@codingame/monaco-vscode-api 4.5.1 → 5.0.0

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

@@ -5,14 +5,14 @@ import { renderMarkdownAsPlaintext } from '../../../../base/browser/markdownRend
 import { ActionBar } from '../../../../base/browser/ui/actionbar/actionbar.js';
 import { ActionViewItem } from '../../../../base/browser/ui/actionbar/actionViewItems.js';
 import { CollapseAllAction } from '../../../../base/browser/ui/tree/treeDefaults.js';
-import { ActionRunner } from '../../../../base/common/actions.js';
+import { ActionRunner, Separator } from '../../../../base/common/actions.js';
 import { timeout } from '../../../../base/common/async.js';
 import { CancellationToken, CancellationTokenSource } from '../../../../base/common/cancellation.js';
 import { Codicon } from '../../../../base/common/codicons.js';
 import { isCancellationError } from '../../../../base/common/errors.js';
 import { Emitter, Event } from '../../../../base/common/event.js';
 import { createMatches } from '../../../../base/common/filters.js';
-import { isMarkdownString } from '../../../../base/common/htmlContent.js';
+import { MarkdownString, isMarkdownString } from '../../../../base/common/htmlContent.js';
 import { Disposable, DisposableStore, toDisposable, MutableDisposable } from '../../../../base/common/lifecycle.js';
 import { Mimes } from '../../../../base/common/mime.js';
 import { Schemas } from '../../../../base/common/network.js';
@@ -51,8 +51,7 @@ import { ThemeIcon } from '../../../../base/common/themables.js';
 import { fillEditorsDragData } from '../../dnd.js';
 import { ResourceLabels } from '../../labels.js';
 import { API_OPEN_EDITOR_COMMAND_ID, API_OPEN_DIFF_EDITOR_COMMAND_ID } from '../editor/editorCommands.js';
-import { ViewPane } from './viewPane.js';
-import { PANEL_BACKGROUND, SIDE_BAR_BACKGROUND } from '../../../common/theme.js';
+import { ViewPane, getLocationBasedViewColors } from './viewPane.js';
 import { ResolvableTreeItem, TreeItemCollapsibleState, Extensions } from '../../../common/views.js';
 import { IViewDescriptorService } from '../../../common/views.service.js';
 import { NumberBadge } from '../../../services/activity/common/activity.js';
@@ -69,11 +68,16 @@ import { TelemetryTrustedValue } from '../../../../platform/telemetry/common/tel
 import { ITreeViewsDnDService } from '../../../../editor/common/services/treeViewsDndService.js';
 import { DraggedTreeItemsIdentifier } from '../../../../editor/common/services/treeViewsDnd.js';
 import { MarkdownRenderer } from '../../../../editor/browser/widget/markdownRenderer/browser/markdownRenderer.js';
+import { parseLinkedText } from '../../../../base/common/linkedText.js';
+import { Button } from '../../../../base/browser/ui/button/button.js';
+import { defaultButtonStyles } from '../../../../platform/theme/browser/defaultStyles.js';
+import { IAccessibleViewInformationService } from '../../../services/accessibility/common/accessibleViewInformationService.service.js';
 var TreeRenderer_1;
+const _moduleId = "vs/workbench/browser/parts/views/treeView";
 let TreeViewPane = class TreeViewPane extends ViewPane {
-    constructor(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, notificationService) {
-        super({ ...options, titleMenuId: MenuId.ViewTitle, donotForwardArgs: false }, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
-        const { treeView } = ( Registry.as(Extensions.ViewsRegistry)).getView(options.id);
+    constructor(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, notificationService, hoverService, accessibleViewService) {
+        super({ ...options, titleMenuId: MenuId.ViewTitle, donotForwardArgs: false }, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, 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)));
@@ -91,7 +95,7 @@ let TreeViewPane = class TreeViewPane extends ViewPane {
         if (options.titleDescription !== this.treeView.description) {
             this.updateTitleDescription(this.treeView.description);
         }
-        this._actionRunner = ( new MultipleSelectionActionRunner(notificationService, () => this.treeView.getSelection()));
+        this._actionRunner = ( (new MultipleSelectionActionRunner(notificationService, () => this.treeView.getSelection())));
         this.updateTreeVisibility();
     }
     focus() {
@@ -129,18 +133,20 @@ let TreeViewPane = class TreeViewPane extends ViewPane {
         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, ITelemetryService)),
-    ( __param(10, INotificationService))
-], 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, ITelemetryService))),
+    ( (__param(10, INotificationService))),
+    ( (__param(11, IHoverService))),
+    ( (__param(12, IAccessibleViewInformationService)))
+], TreeViewPane)));
 class Root {
     constructor() {
         this.label = { label: 'root' };
@@ -162,18 +168,18 @@ function isTreeCommandEnabled(treeCommand, contextKeyService) {
     return true;
 }
 function isRenderedMessageValue(messageValue) {
-    return !!messageValue && typeof messageValue !== 'string' && 'element' in messageValue && 'dispose' in messageValue;
+    return !!messageValue && typeof messageValue !== 'string' && 'element' in messageValue && 'disposables' in messageValue;
 }
 const noDataProviderMessage = ( localizeWithPath(
-    'vs/workbench/browser/parts/views/treeView',
-    'no-dataprovider',
+    _moduleId,
+    0,
     "There is no data provider registered that can provide view data."
 ));
-const RawCustomTreeViewContextKey = ( new RawContextKey('customTreeView', false));
+const RawCustomTreeViewContextKey = ( (new RawContextKey('customTreeView', false)));
 class Tree extends WorkbenchAsyncDataTree {
 }
 let AbstractTreeView = class AbstractTreeView extends Disposable {
-    constructor(id, _title, themeService, instantiationService, commandService, configurationService, progressService, contextMenuService, keybindingService, notificationService, viewDescriptorService, hoverService, contextKeyService, activityService, logService) {
+    constructor(id, _title, themeService, instantiationService, commandService, configurationService, progressService, contextMenuService, keybindingService, notificationService, viewDescriptorService, hoverService, contextKeyService, activityService, logService, openerService) {
         super();
         this.id = id;
         this._title = _title;
@@ -190,6 +196,7 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
         this.contextKeyService = contextKeyService;
         this.activityService = activityService;
         this.logService = logService;
+        this.openerService = openerService;
         this.isVisible = false;
         this._hasIconForParentNode = false;
         this._hasIconForLeafNode = false;
@@ -198,31 +205,33 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
         this._manuallyManageCheckboxes = false;
         this.elementsToRefresh = [];
         this.lastSelection = [];
-        this._onDidExpandItem = this._register(( new Emitter()));
+        this._onDidExpandItem = this._register(( (new Emitter())));
         this.onDidExpandItem = this._onDidExpandItem.event;
-        this._onDidCollapseItem = this._register(( new Emitter()));
+        this._onDidCollapseItem = this._register(( (new Emitter())));
         this.onDidCollapseItem = this._onDidCollapseItem.event;
-        this._onDidChangeSelectionAndFocus = this._register(( new Emitter()));
+        this._onDidChangeSelectionAndFocus = this._register(( (new Emitter())));
         this.onDidChangeSelectionAndFocus = this._onDidChangeSelectionAndFocus.event;
-        this._onDidChangeVisibility = this._register(( new Emitter()));
+        this._onDidChangeVisibility = this._register(( (new Emitter())));
         this.onDidChangeVisibility = this._onDidChangeVisibility.event;
-        this._onDidChangeActions = this._register(( new Emitter()));
+        this._onDidChangeActions = this._register(( (new Emitter())));
         this.onDidChangeActions = this._onDidChangeActions.event;
-        this._onDidChangeWelcomeState = this._register(( new Emitter()));
+        this._onDidChangeWelcomeState = this._register(( (new Emitter())));
         this.onDidChangeWelcomeState = this._onDidChangeWelcomeState.event;
-        this._onDidChangeTitle = this._register(( new Emitter()));
+        this._onDidChangeTitle = this._register(( (new Emitter())));
         this.onDidChangeTitle = this._onDidChangeTitle.event;
-        this._onDidChangeDescription = this._register(( new Emitter()));
+        this._onDidChangeDescription = this._register(( (new Emitter())));
         this.onDidChangeDescription = this._onDidChangeDescription.event;
-        this._onDidChangeCheckboxState = this._register(( new Emitter()));
+        this._onDidChangeCheckboxState = this._register(( (new Emitter())));
         this.onDidChangeCheckboxState = this._onDidChangeCheckboxState.event;
-        this._onDidCompleteRefresh = this._register(( new Emitter()));
+        this._onDidCompleteRefresh = this._register(( (new Emitter())));
         this._isInitialized = false;
-        this._activity = this._register(( new MutableDisposable()));
+        this._activity = this._register(( (new MutableDisposable())));
+        this.activated = false;
+        this.treeDisposables = this._register(( (new DisposableStore())));
         this._height = 0;
         this._width = 0;
         this.refreshing = false;
-        this.root = ( new Root());
+        this.root = ( (new Root()));
         this.lastActive = this.root;
     }
     initialize() {
@@ -245,8 +254,8 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
             }
         }));
         this._register(this.viewDescriptorService.onDidChangeLocation(({ views, from, to }) => {
-            if (( views.some(v => v.id === this.id))) {
-                this.tree?.updateOptions({ overrideStyles: { listBackground: this.viewLocation === 1  ? PANEL_BACKGROUND : SIDE_BAR_BACKGROUND } });
+            if (( (views.some(v => v.id === this.id)))) {
+                this.tree?.updateOptions({ overrideStyles: getLocationBasedViewColors(this.viewLocation).listOverrideStyles });
             }
         }));
         this.registerActions();
@@ -276,7 +285,7 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
             this._dataProvider = new (class {
                 constructor() {
                     this._isEmpty = true;
-                    this._onDidChangeEmpty = ( new Emitter());
+                    this._onDidChangeEmpty = ( (new Emitter()));
                     this.onDidChangeEmpty = this._onDidChangeEmpty.event;
                 }
                 get isTreeEmpty() {
@@ -324,6 +333,8 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
         }
         else {
             this._dataProvider = undefined;
+            this.treeDisposables.clear();
+            this.activated = false;
             this.updateMessage();
         }
         this._onDidChangeWelcomeState.fire();
@@ -361,11 +372,14 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
         this._badge = badge;
         if (badge) {
             const activity = {
-                badge: ( new NumberBadge(badge.value, () => badge.tooltip)),
+                badge: ( (new NumberBadge(badge.value, () => badge.tooltip))),
                 priority: 50
             };
             this._activity.value = this.activityService.showViewActivity(this.id, activity);
         }
+        else {
+            this._activity.clear();
+        }
     }
     get canSelectMany() {
         return this._canSelectMany;
@@ -394,12 +408,12 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
     }
     initializeShowCollapseAllAction(startingValue = false) {
         if (!this.collapseAllContext) {
-            this.collapseAllContextKey = ( new RawContextKey(`treeView.${this.id}.enableCollapseAll`, startingValue, ( localizeWithPath(
-                'vs/workbench/browser/parts/views/treeView',
-                'treeView.enableCollapseAll',
+            this.collapseAllContextKey = ( (new RawContextKey(`treeView.${this.id}.enableCollapseAll`, startingValue, ( localizeWithPath(
+                _moduleId,
+                1,
                 "Whether the the tree view with id {0} enables collapse all.",
                 this.id
-            ))));
+            )))));
             this.collapseAllContext = this.collapseAllContextKey.bindTo(this.contextKeyService);
         }
         return true;
@@ -414,12 +428,12 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
     }
     initializeShowRefreshAction(startingValue = false) {
         if (!this.refreshContext) {
-            this.refreshContextKey = ( new RawContextKey(`treeView.${this.id}.enableRefresh`, startingValue, ( localizeWithPath(
-                'vs/workbench/browser/parts/views/treeView',
-                'treeView.enableRefresh',
+            this.refreshContextKey = ( (new RawContextKey(`treeView.${this.id}.enableRefresh`, startingValue, ( localizeWithPath(
+                _moduleId,
+                2,
                 "Whether the tree view with id {0} enables refresh.",
                 this.id
-            ))));
+            )))));
             this.refreshContext = this.refreshContextKey.bindTo(this.contextKeyService);
         }
     }
@@ -437,10 +451,13 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
             constructor() {
                 super({
                     id: `workbench.actions.treeView.${that.id}.refresh`,
-                    title: ( localizeWithPath('vs/workbench/browser/parts/views/treeView', 'refresh', "Refresh")),
+                    title: ( localizeWithPath(_moduleId, 3, "Refresh")),
                     menu: {
                         id: MenuId.ViewTitle,
-                        when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', that.id)), that.refreshContextKey)),
+                        when: ( (ContextKeyExpr.and(
+                             (ContextKeyExpr.equals('view', that.id)),
+                            that.refreshContextKey
+                        ))),
                         group: 'navigation',
                         order: Number.MAX_SAFE_INTEGER - 1,
                     },
@@ -455,10 +472,13 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
             constructor() {
                 super({
                     id: `workbench.actions.treeView.${that.id}.collapseAll`,
-                    title: ( localizeWithPath('vs/workbench/browser/parts/views/treeView', 'collapseAll', "Collapse All")),
+                    title: ( localizeWithPath(_moduleId, 4, "Collapse All")),
                     menu: {
                         id: MenuId.ViewTitle,
-                        when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', that.id)), that.collapseAllContextKey)),
+                        when: ( (ContextKeyExpr.and(
+                             (ContextKeyExpr.equals('view', that.id)),
+                            that.collapseAllContextKey
+                        ))),
                         group: 'navigation',
                         order: Number.MAX_SAFE_INTEGER,
                     },
@@ -468,7 +488,7 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
             }
             async run() {
                 if (that.tree) {
-                    return ( new CollapseAllAction(that.tree, true)).run();
+                    return ( (new CollapseAllAction(that.tree, true))).run();
                 }
             }
         }));
@@ -531,17 +551,18 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
         this._register(focusTracker.onDidBlur(() => this.focused = false));
     }
     createTree() {
+        this.treeDisposables.clear();
         const actionViewItemProvider = createActionViewItem.bind(undefined, this.instantiationService);
-        const treeMenus = this._register(this.instantiationService.createInstance(TreeMenus, this.id));
-        this.treeLabels = this._register(this.instantiationService.createInstance(ResourceLabels, this));
+        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 aligner = ( new Aligner(this.themeService));
-        const checkboxStateHandler = this._register(( new CheckboxStateHandler()));
+        const aligner = ( (new Aligner(this.themeService)));
+        const checkboxStateHandler = this.treeDisposables.add(( (new CheckboxStateHandler())));
         const renderer = this.instantiationService.createInstance(TreeRenderer, this.id, treeMenus, this.treeLabels, actionViewItemProvider, aligner, checkboxStateHandler, () => this.manuallyManageCheckboxes);
-        this._register(renderer.onDidChangeCheckboxState(e => this._onDidChangeCheckboxState.fire(e)));
+        this.treeDisposables.add(renderer.onDidChangeCheckboxState(e => this._onDidChangeCheckboxState.fire(e)));
         const widgetAriaLabel = this._title;
-        this.tree = this._register(this.instantiationService.createInstance(Tree, this.id, this.treeContainer, ( new TreeViewDelegate()), [renderer], dataSource, {
-            identityProvider: ( new TreeViewIdentityProvider()),
+        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) {
@@ -584,31 +605,30 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
             },
             multipleSelectionSupport: this.canSelectMany,
             dnd: this.treeViewDnd,
-            overrideStyles: {
-                listBackground: this.viewLocation === 1  ? PANEL_BACKGROUND : SIDE_BAR_BACKGROUND
-            }
+            overrideStyles: getLocationBasedViewColors(this.viewLocation).listOverrideStyles
         }));
+        this.treeDisposables.add(this.tree);
         treeMenus.setContextKeyService(this.tree.contextKeyService);
         aligner.tree = this.tree;
-        const actionRunner = ( new MultipleSelectionActionRunner(this.notificationService, () => this.tree.getSelection()));
+        const actionRunner = ( (new MultipleSelectionActionRunner(this.notificationService, () => this.tree.getSelection())));
         renderer.actionRunner = actionRunner;
         this.tree.contextKeyService.createKey(this.id, true);
         const customTreeKey = RawCustomTreeViewContextKey.bindTo(this.tree.contextKeyService);
         customTreeKey.set(true);
-        this._register(this.tree.onContextMenu(e => this.onContextMenu(treeMenus, e, actionRunner)));
-        this._register(this.tree.onDidChangeSelection(e => {
+        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._register(this.tree.onDidChangeFocus(e => {
+        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._register(this.tree.onDidChangeCollapseState(e => {
+        this.treeDisposables.add(this.tree.onDidChangeCollapseState(e => {
             if (!e.node.element) {
                 return;
             }
@@ -621,7 +641,7 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
             }
         }));
         this.tree.setInput(this.root).then(() => this.updateContentAreas());
-        this._register(this.tree.onDidOpen(async (e) => {
+        this.treeDisposables.add(this.tree.onDidOpen(async (e) => {
             if (!e.browserEvent) {
                 return;
             }
@@ -643,7 +663,7 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
                 }
             }
         }));
-        this._register(treeMenus.onDidChange((changed) => {
+        this.treeDisposables.add(treeMenus.onDidChange((changed) => {
             if (this.tree?.hasNode(changed)) {
                 this.tree?.rerender(changed);
             }
@@ -669,7 +689,11 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
         event.preventDefault();
         event.stopPropagation();
         this.tree.setFocus([node]);
-        const actions = treeMenus.getResourceContextActions(node);
+        let selected = this.canSelectMany ? this.getSelection() : [];
+        if (!selected.find(item => item.handle === node.handle)) {
+            selected = [node];
+        }
+        const actions = treeMenus.getResourceContextActions(selected);
         if (!actions.length) {
             return;
         }
@@ -679,7 +703,9 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
             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;
             },
@@ -704,14 +730,65 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
         }
         this.updateContentAreas();
     }
+    processMessage(message, disposables) {
+        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') {
+                const node = linkedText.nodes[0];
+                const buttonContainer = document.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 });
+                }, null, disposables);
+                disposables.add(button);
+                hasFoundButton = true;
+                result.push(buttonContainer);
+            }
+            else {
+                hasFoundButton = false;
+                const rendered = this.markdownRenderer.render(( (new MarkdownString(
+                    line,
+                    { isTrusted: message.isTrusted, supportThemeIcons: message.supportThemeIcons, supportHtml: message.supportHtml }
+                ))));
+                result.push(rendered.element);
+                disposables.add(rendered);
+            }
+        }
+        const container = document.createElement('div');
+        container.classList.add('rendered-message');
+        for (const child of result) {
+            if (child instanceof HTMLElement) {
+                container.appendChild(child);
+            }
+            else {
+                container.appendChild(child.element);
+            }
+        }
+        return container;
+    }
     showMessage(message) {
         if (isRenderedMessageValue(this._messageValue)) {
-            this._messageValue.dispose();
+            this._messageValue.disposables.dispose();
         }
         if (isMarkdownString(message) && !this.markdownRenderer) {
             this.markdownRenderer = this.instantiationService.createInstance(MarkdownRenderer, {});
         }
-        this._messageValue = isMarkdownString(message) ? this.markdownRenderer.render(message) : message;
+        if (isMarkdownString(message)) {
+            const disposables = ( (new DisposableStore()));
+            const renderedMessage = this.processMessage(message, disposables);
+            this._messageValue = { element: renderedMessage, disposables };
+        }
+        else {
+            this._messageValue = message;
+        }
         if (!this.messageElement) {
             return;
         }
@@ -769,10 +846,10 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
             }
             else {
                 if (this.elementsToRefresh.length) {
-                    const seen = ( new Set());
+                    const seen = ( (new Set()));
                     this.elementsToRefresh.forEach(element => seen.add(element.handle));
                     for (const element of elements) {
-                        if (!( seen.has(element.handle))) {
+                        if (!( (seen.has(element.handle)))) {
                             this.elementsToRefresh.push(element);
                         }
                     }
@@ -829,13 +906,13 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
             this.refreshing = true;
             const oldSelection = tree.getSelection();
             try {
-                await Promise.all(( elements.map(element => tree.updateChildren(element, true, true))));
+                await Promise.all(( (elements.map(element => tree.updateChildren(element, true, true)))));
             }
             catch (e) {
                 this.logService.error(e);
             }
             const newSelection = tree.getSelection();
-            if (oldSelection.length !== newSelection.length || ( oldSelection.some((value, index) => value.handle !== newSelection[index].handle))) {
+            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 });
             }
@@ -850,12 +927,12 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
     }
     initializeCollapseAllToggle() {
         if (!this.collapseAllToggleContext) {
-            this.collapseAllToggleContextKey = ( new RawContextKey(`treeView.${this.id}.toggleCollapseAll`, false, ( localizeWithPath(
-                'vs/workbench/browser/parts/views/treeView',
-                'treeView.toggleCollapseAll',
+            this.collapseAllToggleContextKey = ( (new RawContextKey(`treeView.${this.id}.toggleCollapseAll`, false, ( localizeWithPath(
+                _moduleId,
+                5,
                 "Whether collapse all is toggled for the tree view with id {0}.",
                 this.id
-            ))));
+            )))));
             this.collapseAllToggleContext = this.collapseAllToggleContextKey.bindTo(this.contextKeyService);
         }
     }
@@ -863,7 +940,7 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
         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.root.children.some(value => value.collapsibleState !== TreeItemCollapsibleState.None))));
         }
     }
     updateContentAreas() {
@@ -886,21 +963,22 @@ let AbstractTreeView = class AbstractTreeView extends Disposable {
         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))
-], 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)))
+], AbstractTreeView)));
 class TreeViewIdentityProvider {
     getId(element) {
         return element.handle;
@@ -941,7 +1019,7 @@ 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, treeViewsService, contextKeyService, instantiationService) {
+    constructor(treeViewId, menus, labels, actionViewItemProvider, aligner, checkboxStateHandler, manuallyManageCheckboxes, themeService, configurationService, labelService, treeViewsService, contextKeyService, hoverService, instantiationService) {
         super();
         this.treeViewId = treeViewId;
         this.menus = menus;
@@ -955,10 +1033,11 @@ let TreeRenderer = class TreeRenderer extends Disposable {
         this.labelService = labelService;
         this.treeViewsService = treeViewsService;
         this.contextKeyService = contextKeyService;
-        this._onDidChangeCheckboxState = this._register(( new Emitter()));
+        this.hoverService = hoverService;
+        this._onDidChangeCheckboxState = this._register(( (new Emitter())));
         this.onDidChangeCheckboxState = this._onDidChangeCheckboxState.event;
         this._hasCheckbox = false;
-        this._renderedElements = ( new Map());
+        this._renderedElements = ( (new Map()));
         this._hoverDelegate = this._register(instantiationService.createInstance(WorkbenchHoverDelegate, 'mouse', false, {}));
         this._register(this.themeService.onDidFileIconThemeChange(() => this.rerender()));
         this._register(this.themeService.onDidColorThemeChange(() => this.rerender()));
@@ -978,10 +1057,10 @@ let TreeRenderer = class TreeRenderer extends Disposable {
         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, {
+        const actionBar = ( (new ActionBar(actionsContainer, {
             actionViewItemProvider: this.actionViewItemProvider
-        }));
-        return { resourceLabel, icon, checkboxContainer, actionBar, container, elementDisposable: ( new DisposableStore()) };
+        })));
+        return { resourceLabel, icon, checkboxContainer, actionBar, container, elementDisposable: ( (new DisposableStore())) };
     }
     getHover(label, resource, node) {
         if (!(node instanceof ResolvableTreeItem) || !node.hasResolve) {
@@ -1004,9 +1083,11 @@ let TreeRenderer = class TreeRenderer extends Disposable {
         return {
             markdown: typeof node.tooltip === 'string' ? node.tooltip :
                 (token) => {
-                    return ( new Promise((resolve) => {
-                        node.resolve(token).then(() => resolve(node.tooltip));
-                    }));
+                    return (
+                         (new Promise((resolve) => {
+                            node.resolve(token).then(() => resolve(node.tooltip));
+                        }))
+                    );
                 },
             markdownNotSupportedFallback: resource ? undefined : (label ?? '')
         };
@@ -1017,7 +1098,7 @@ let TreeRenderer = class TreeRenderer extends Disposable {
         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 label = treeItemLabel ? treeItemLabel.label : undefined;
-        const matches = (treeItemLabel && treeItemLabel.highlights && label) ? ( treeItemLabel.highlights.map(([start, end]) => {
+        const matches = (treeItemLabel && treeItemLabel.highlights && label) ? ( (treeItemLabel.highlights.map(([start, end]) => {
             if (start < 0) {
                 start = label.length + start;
             }
@@ -1033,7 +1114,7 @@ let TreeRenderer = class TreeRenderer extends Disposable {
                 end = swap;
             }
             return ({ start, end });
-        })) : undefined;
+        }))) : undefined;
         const icon = this.themeService.getColorTheme().type === ColorScheme.LIGHT ? node.icon : node.iconDark;
         const iconUrl = icon ? URI.revive(icon) : undefined;
         const title = this.getHover(label, resource, node);
@@ -1046,7 +1127,7 @@ let TreeRenderer = class TreeRenderer extends Disposable {
         this.renderCheckbox(node, templateData);
         if (resource) {
             const fileDecorations = this.configurationService.getValue('explorer.decorations');
-            const labelResource = resource ? resource : ( URI.parse('missing:_icon_resource'));
+            const labelResource = resource ? resource : ( (URI.parse('missing:_icon_resource')));
             templateData.resourceLabel.setResource({ name: label, description, resource: labelResource }, {
                 fileKind: this.getFileKind(node),
                 title,
@@ -1093,7 +1174,7 @@ let TreeRenderer = class TreeRenderer extends Disposable {
             }
         }
         templateData.actionBar.context = { $treeViewId: this.treeViewId, $treeItemHandle: node.handle };
-        const menuActions = this.menus.getResourceActions(node, templateData.elementDisposable);
+        const menuActions = this.menus.getResourceActions([node], templateData.elementDisposable);
         templateData.actionBar.push(menuActions.actions, { icon: true, label: false });
         if (this._actionRunner) {
             templateData.actionBar.actionRunner = this._actionRunner;
@@ -1104,7 +1185,7 @@ let TreeRenderer = class TreeRenderer extends Disposable {
         this._renderedElements.set(element.element.handle, [...renderedItems, { original: element, rendered: templateData }]);
     }
     rerender() {
-        const keys = ( new Set(( this._renderedElements.keys())));
+        const keys = ( (new Set( (this._renderedElements.keys()))));
         for (const key of keys) {
             const values = this._renderedElements.get(key) ?? [];
             for (const value of values) {
@@ -1120,11 +1201,12 @@ let TreeRenderer = class TreeRenderer extends Disposable {
                 this.rerender();
             }
             if (!templateData.checkbox) {
-                const checkbox = ( new TreeItemCheckbox(
+                const checkbox = ( (new TreeItemCheckbox(
                     templateData.checkboxContainer,
                     this.checkboxStateHandler,
-                    this._hoverDelegate
-                ));
+                    this._hoverDelegate,
+                    this.hoverService
+                )));
                 templateData.checkbox = checkbox;
             }
             templateData.checkbox.render(node);
@@ -1183,10 +1265,10 @@ let TreeRenderer = class TreeRenderer extends Disposable {
                         }
                     }
                     checkChildren(item);
-                    const visitedParents = ( new Set());
+                    const visitedParents = ( (new Set()));
                     function checkParents(currentItem) {
                         if (currentItem.parent && (currentItem.parent.checkbox !== undefined) && currentItem.parent.children) {
-                            if (( visitedParents.has(currentItem.parent))) {
+                            if (( (visitedParents.has(currentItem.parent)))) {
                                 return;
                             }
                             else {
@@ -1252,14 +1334,15 @@ let TreeRenderer = class TreeRenderer extends Disposable {
         templateData.elementDisposable.dispose();
     }
 };
-TreeRenderer = TreeRenderer_1 = ( __decorate([
-    ( __param(7, IThemeService)),
-    ( __param(8, IConfigurationService)),
-    ( __param(9, ILabelService)),
-    ( __param(10, ITreeViewsService)),
-    ( __param(11, IContextKeyService)),
-    ( __param(12, IInstantiationService))
-], TreeRenderer));
+TreeRenderer = TreeRenderer_1 = ( (__decorate([
+    ( (__param(7, IThemeService))),
+    ( (__param(8, IConfigurationService))),
+    ( (__param(9, ILabelService))),
+    ( (__param(10, ITreeViewsService))),
+    ( (__param(11, IContextKeyService))),
+    ( (__param(12, IHoverService))),
+    ( (__param(13, IInstantiationService)))
+], TreeRenderer)));
 class Aligner extends Disposable {
     constructor(themeService) {
         super();
@@ -1278,9 +1361,9 @@ class Aligner extends Disposable {
         if (this._tree) {
             const parent = this._tree.getParentElement(treeItem) || this._tree.getInput();
             if (this.hasIcon(parent)) {
-                return !!parent.children && ( parent.children.some(
+                return !!parent.children && ( (parent.children.some(
                     c => c.collapsibleState !== TreeItemCollapsibleState.None && !this.hasIcon(c)
-                ));
+                )));
             }
             return !!parent.children && parent.children.every(c => c.collapsibleState === TreeItemCollapsibleState.None || !this.hasIcon(c));
         }
@@ -1311,8 +1394,8 @@ class MultipleSelectionActionRunner extends ActionRunner {
         this._register(this.onDidRun(e => {
             if (e.error && !isCancellationError(e.error)) {
                 notificationService.error(( localizeWithPath(
-                    'vs/workbench/browser/parts/views/treeView',
-                    'command-error',
+                    _moduleId,
+                    6,
                     'Error running command {1}: {0}. This is likely caused by the extension that contributes {1}.',
                     e.error.message,
                     e.action.id
@@ -1325,14 +1408,14 @@ class MultipleSelectionActionRunner extends ActionRunner {
         let selectionHandleArgs = undefined;
         let actionInSelected = false;
         if (selection.length > 1) {
-            selectionHandleArgs = ( selection.map(selected => {
+            selectionHandleArgs = ( (selection.map(selected => {
                 if ((selected.handle === context.$treeItemHandle) || context.$selectedTreeItems) {
                     actionInSelected = true;
                 }
                 return { $treeViewId: context.$treeViewId, $treeItemHandle: selected.handle };
-            }));
+            })));
         }
-        if (!actionInSelected) {
+        if (!actionInSelected && selectionHandleArgs) {
             selectionHandleArgs = undefined;
         }
         await action.run(context, selectionHandleArgs);
@@ -1342,60 +1425,110 @@ let TreeMenus = class TreeMenus {
     constructor(id, menuService) {
         this.id = id;
         this.menuService = menuService;
-        this._onDidChange = ( new Emitter());
+        this._onDidChange = ( (new Emitter()));
         this.onDidChange = this._onDidChange.event;
     }
-    getResourceActions(element, disposableStore) {
-        const actions = this.getActions(MenuId.ViewItemContext, element, disposableStore);
-        return { menu: actions.menu, actions: actions.primary };
+    getResourceActions(elements, disposableStore) {
+        const actions = this.getActions(MenuId.ViewItemContext, elements, disposableStore);
+        return { actions: actions.primary };
     }
-    getResourceContextActions(element) {
-        return this.getActions(MenuId.ViewItemContext, element).secondary;
+    getResourceContextActions(elements) {
+        return this.getActions(MenuId.ViewItemContext, elements).secondary;
     }
     setContextKeyService(service) {
         this.contextKeyService = service;
     }
-    getActions(menuId, element, listen) {
+    filterNonUniversalActions(groups, newActions) {
+        const newActionsSet = ( (new Set( (newActions.map(a => a.id)))));
+        for (const group of groups) {
+            const actions = ( (group.keys()));
+            for (const action of actions) {
+                if (!( (newActionsSet.has(action)))) {
+                    group.delete(action);
+                }
+            }
+        }
+    }
+    buildMenu(groups) {
+        const result = [];
+        for (const group of groups) {
+            if (group.size > 0) {
+                if (result.length) {
+                    result.push(( (new Separator())));
+                }
+                result.push(...( (group.values())));
+            }
+        }
+        return result;
+    }
+    createGroups(actions) {
+        const groups = [];
+        let group = ( (new Map()));
+        for (const action of actions) {
+            if (action instanceof Separator) {
+                groups.push(group);
+                group = ( (new Map()));
+            }
+            else {
+                group.set(action.id, action);
+            }
+        }
+        groups.push(group);
+        return groups;
+    }
+    getActions(menuId, elements, listen) {
         if (!this.contextKeyService) {
             return { primary: [], secondary: [] };
         }
-        const contextKeyService = this.contextKeyService.createOverlay([
-            ['view', this.id],
-            ['viewItem', element.contextValue]
-        ]);
-        const menu = this.menuService.createMenu(menuId, contextKeyService);
-        const primary = [];
-        const secondary = [];
-        const result = { primary, secondary, menu };
-        createAndFillInContextMenuActions(menu, { shouldForwardArgs: true }, result, 'inline');
-        if (listen) {
-            listen.add(menu.onDidChange(() => this._onDidChange.fire(element)));
-            listen.add(menu);
-        }
-        else {
-            menu.dispose();
+        let primaryGroups = [];
+        let secondaryGroups = [];
+        for (let i = 0; i < elements.length; i++) {
+            const element = elements[i];
+            const contextKeyService = this.contextKeyService.createOverlay([
+                ['view', this.id],
+                ['viewItem', element.contextValue]
+            ]);
+            const menu = this.menuService.createMenu(menuId, contextKeyService);
+            const primary = [];
+            const secondary = [];
+            const result = { primary, secondary, menu };
+            createAndFillInContextMenuActions(menu, { shouldForwardArgs: true }, result, 'inline');
+            if (i === 0) {
+                primaryGroups = this.createGroups(result.primary);
+                secondaryGroups = this.createGroups(result.secondary);
+            }
+            else {
+                this.filterNonUniversalActions(primaryGroups, result.primary);
+                this.filterNonUniversalActions(secondaryGroups, result.secondary);
+            }
+            if (listen && elements.length === 1) {
+                listen.add(menu.onDidChange(() => this._onDidChange.fire(element)));
+                listen.add(menu);
+            }
+            else {
+                menu.dispose();
+            }
         }
-        return result;
+        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) {
-        super(id, title, themeService, instantiationService, commandService, configurationService, progressService, contextMenuService, keybindingService, notificationService, viewDescriptorService, hoverService, contextKeyService, activityService, logService);
+    constructor(id, title, extensionId, themeService, instantiationService, commandService, configurationService, progressService, contextMenuService, keybindingService, notificationService, viewDescriptorService, contextKeyService, hoverService, extensionService, activityService, telemetryService, logService, openerService) {
+        super(id, title, themeService, instantiationService, commandService, configurationService, progressService, contextMenuService, keybindingService, notificationService, viewDescriptorService, hoverService, contextKeyService, activityService, logService, openerService);
         this.extensionId = extensionId;
         this.extensionService = extensionService;
         this.telemetryService = telemetryService;
-        this.activated = false;
     }
     activate() {
         if (!this.activated) {
             this.telemetryService.publicLog2('Extension:ViewActivate', {
-                extensionId: ( new TelemetryTrustedValue(this.extensionId)),
+                extensionId: ( (new TelemetryTrustedValue(this.extensionId))),
                 id: this.id,
             });
             this.createTree();
@@ -1408,28 +1541,25 @@ let CustomTreeView = class CustomTreeView extends AbstractTreeView {
         }
     }
 };
-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))
-], 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)))
+], CustomTreeView)));
 class TreeView extends AbstractTreeView {
-    constructor() {
-        super(...arguments);
-        this.activated = false;
-    }
     activate() {
         if (!this.activated) {
             this.createTree();
@@ -1471,9 +1601,9 @@ let CustomTreeViewDragAndDrop = class CustomTreeViewDragAndDrop {
             return;
         }
         const uuid = generateUuid();
-        this.dragCancellationToken = ( new CancellationTokenSource());
+        this.dragCancellationToken = ( (new CancellationTokenSource()));
         this.treeViewsDragAndDropService.addDragOperationTransfer(uuid, this.handleDragAndLog(this.dndController, itemHandles, uuid, this.dragCancellationToken.token));
-        this.treeItemsTransfer.setData([( new DraggedTreeItemsIdentifier(uuid))], DraggedTreeItemsIdentifier.prototype);
+        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, '');
@@ -1485,7 +1615,7 @@ let CustomTreeViewDragAndDrop = class CustomTreeViewDragAndDrop {
     addResourceInfoToTransfer(originalEvent, resources) {
         if (resources.length && originalEvent.dataTransfer) {
             this.instantiationService.invokeFunction(accessor => fillEditorsDragData(accessor, resources, originalEvent));
-            const fileResources = ( resources.filter(s => s.scheme === Schemas.file).map(r => r.fsPath));
+            const fileResources = ( (resources.filter(s => s.scheme === Schemas.file).map(r => r.fsPath)));
             if (fileResources.length) {
                 originalEvent.dataTransfer.setData(CodeDataTransfers.FILES, JSON.stringify(fileResources));
             }
@@ -1520,7 +1650,7 @@ let CustomTreeViewDragAndDrop = class CustomTreeViewDragAndDrop {
     }
     onDragOver(data, targetElement, targetIndex, targetSector, originalEvent) {
         const dataTransfer = toExternalVSDataTransfer(originalEvent.dataTransfer);
-        const types = ( new Set(Array.from(dataTransfer, x => x[0])));
+        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()) {
@@ -1534,14 +1664,14 @@ let CustomTreeViewDragAndDrop = class CustomTreeViewDragAndDrop {
         if (!dndController || !originalEvent.dataTransfer || (dndController.dropMimeTypes.length === 0)) {
             return false;
         }
-        const dragContainersSupportedType = ( Array.from(types).some((value, index) => {
+        const dragContainersSupportedType = ( (Array.from(types).some((value, index) => {
             if (value === this.treeMimeType) {
                 return true;
             }
             else {
                 return dndController.dropMimeTypes.indexOf(value) >= 0;
             }
-        }));
+        })));
         if (dragContainersSupportedType) {
             return { accept: true, bubble: 0 , autoExpand: true };
         }
@@ -1551,7 +1681,7 @@ let CustomTreeViewDragAndDrop = class CustomTreeViewDragAndDrop {
         if (!this.dndController) {
             return null;
         }
-        return element.resourceUri ? ( URI.revive(element.resourceUri).toString()) : element.handle;
+        return element.resourceUri ? ( (URI.revive(element.resourceUri).toString())) : element.handle;
     }
     getDragLabel(elements) {
         if (!this.dndController) {
@@ -1574,7 +1704,7 @@ let CustomTreeViewDragAndDrop = class CustomTreeViewDragAndDrop {
             willDropUuid = this.treeItemsTransfer.getData(DraggedTreeItemsIdentifier.prototype)[0].identifier;
         }
         const originalDataTransfer = toExternalVSDataTransfer(originalEvent.dataTransfer, true);
-        const outDataTransfer = ( new VSDataTransfer());
+        const outDataTransfer = ( (new VSDataTransfer()));
         for (const [type, item] of originalDataTransfer) {
             if (type === this.treeMimeType || dndController.dropMimeTypes.includes(type) || (item.asFile() && dndController.dropMimeTypes.includes(DataTransfers.FILES.toLowerCase()))) {
                 outDataTransfer.append(type, item);
@@ -1602,10 +1732,10 @@ let CustomTreeViewDragAndDrop = class CustomTreeViewDragAndDrop {
     }
     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)));
 export { CustomTreeView, CustomTreeViewDragAndDrop, RawCustomTreeViewContextKey, TreeView, TreeViewPane };