@codingame/monaco-vscode-api 25.1.1 → 26.0.0

package/vscode/src/vs/base/browser/ui/tree/abstractTree.js

@@ -23,6 +23,7 @@ import { Event, Emitter, EventBufferer, Relay } from '../../../common/event.js';
 import { FuzzyScore, fuzzyScore } from '../../../common/filters.js';
 import { KeyCode } from '../../../common/keyCodes.js';
 import { Disposable, DisposableStore, toDisposable, dispose } from '../../../common/lifecycle.js';
+import { isMacintosh } from '../../../common/platform.js';
 import { clamp } from '../../../common/numbers.js';
 import * as tree from './media/tree.css';
 import { localize } from '../../../../nls.js';
@@ -70,16 +71,22 @@ class TreeNodeListDragAndDrop {
         this.dnd.onDragStart?.(asTreeDragAndDropData(data), originalEvent);
     }
     onDragOver(data, targetNode, targetIndex, targetSector, originalEvent, raw = true) {
-        const result = this.dnd.onDragOver(asTreeDragAndDropData(data), targetNode && targetNode.element, targetIndex, targetSector, originalEvent);
+        const result = this.dnd.onDragOver(
+            asTreeDragAndDropData(data),
+            targetNode && targetNode.element,
+            targetIndex,
+            targetSector,
+            originalEvent
+        );
         const didChangeAutoExpandNode = this.autoExpandNode !== targetNode;
         if (didChangeAutoExpandNode) {
             this.autoExpandDisposable.dispose();
             this.autoExpandNode = targetNode;
         }
-        if (typeof targetNode === 'undefined') {
+        if (typeof targetNode === "undefined") {
             return result;
         }
-        if (didChangeAutoExpandNode && typeof result !== 'boolean' && result.autoExpand) {
+        if (didChangeAutoExpandNode && typeof result !== "boolean" && result.autoExpand) {
             this.autoExpandDisposable = disposableTimeout(() => {
                 const model = this.modelProvider();
                 const ref = model.getNodeLocation(targetNode);
@@ -89,11 +96,15 @@ class TreeNodeListDragAndDrop {
                 this.autoExpandNode = undefined;
             }, 500, this.disposables);
         }
-        if (typeof result === 'boolean' || !result.accept || typeof result.bubble === 'undefined' || result.feedback) {
+        if (typeof result === "boolean" || !result.accept || typeof result.bubble === "undefined" || result.feedback) {
             if (!raw) {
-                const accept = typeof result === 'boolean' ? result : result.accept;
-                const effect = typeof result === 'boolean' ? undefined : result.effect;
-                return { accept, effect, feedback: [targetIndex] };
+                const accept = typeof result === "boolean" ? result : result.accept;
+                const effect = typeof result === "boolean" ? undefined : result.effect;
+                return {
+                    accept,
+                    effect,
+                    feedback: [targetIndex]
+                };
             }
             return result;
         }
@@ -109,12 +120,21 @@ class TreeNodeListDragAndDrop {
         const ref = model.getNodeLocation(targetNode);
         const start = model.getListIndex(ref);
         const length = model.getListRenderCount(ref);
-        return { ...result, feedback: range(start, start + length) };
+        return {
+            ...result,
+            feedback: range(start, start + length)
+        };
     }
     drop(data, targetNode, targetIndex, targetSector, originalEvent) {
         this.autoExpandDisposable.dispose();
         this.autoExpandNode = undefined;
-        this.dnd.drop(asTreeDragAndDropData(data), targetNode && targetNode.element, targetIndex, targetSector, originalEvent);
+        this.dnd.drop(
+            asTreeDragAndDropData(data),
+            targetNode && targetNode.element,
+            targetIndex,
+            targetSector,
+            originalEvent
+        );
     }
     onDragEnd(originalEvent) {
         this.dnd.onDragEnd?.(originalEvent);
@@ -130,15 +150,24 @@ function asListOptions(modelProvider, disposableStore, options) {
         identityProvider: options.identityProvider && {
             getId(el) {
                 return options.identityProvider.getId(el.element);
-            }
+            },
+            getGroupId: options.identityProvider.getGroupId ? el => {
+                return options.identityProvider.getGroupId(el.element);
+            } : undefined
         },
         dnd: options.dnd && disposableStore.add(( new TreeNodeListDragAndDrop(modelProvider, options.dnd))),
         multipleSelectionController: options.multipleSelectionController && {
             isSelectionSingleChangeEvent(e) {
-                return options.multipleSelectionController.isSelectionSingleChangeEvent({ ...e, element: e.element });
+                return options.multipleSelectionController.isSelectionSingleChangeEvent({
+                    ...e,
+                    element: e.element
+                });
             },
             isSelectionRangeChangeEvent(e) {
-                return options.multipleSelectionController.isSelectionRangeChangeEvent({ ...e, element: e.element });
+                return options.multipleSelectionController.isSelectionRangeChangeEvent({
+                    ...e,
+                    element: e.element
+                });
             }
         },
         accessibilityProvider: options.accessibilityProvider && {
@@ -153,20 +182,20 @@ function asListOptions(modelProvider, disposableStore, options) {
             getPosInSet(node) {
                 return node.visibleChildIndex + 1;
             },
-            isChecked: options.accessibilityProvider && options.accessibilityProvider.isChecked ? (node) => {
+            isChecked: options.accessibilityProvider && options.accessibilityProvider.isChecked ? node => {
                 return options.accessibilityProvider.isChecked(node.element);
             } : undefined,
-            getRole: options.accessibilityProvider && options.accessibilityProvider.getRole ? (node) => {
+            getRole: options.accessibilityProvider && options.accessibilityProvider.getRole ? node => {
                 return options.accessibilityProvider.getRole(node.element);
-            } : () => 'treeitem',
+            } : () => "treeitem",
             getAriaLabel(e) {
                 return options.accessibilityProvider.getAriaLabel(e.element);
             },
             getWidgetAriaLabel() {
                 return options.accessibilityProvider.getWidgetAriaLabel();
             },
-            getWidgetRole: options.accessibilityProvider && options.accessibilityProvider.getWidgetRole ? () => options.accessibilityProvider.getWidgetRole() : () => 'tree',
-            getAriaLevel: options.accessibilityProvider && options.accessibilityProvider.getAriaLevel ? (node) => options.accessibilityProvider.getAriaLevel(node.element) : (node) => {
+            getWidgetRole: options.accessibilityProvider && options.accessibilityProvider.getWidgetRole ? () => options.accessibilityProvider.getWidgetRole() : () => "tree",
+            getAriaLevel: options.accessibilityProvider && options.accessibilityProvider.getAriaLevel ? node => options.accessibilityProvider.getAriaLevel(node.element) : node => {
                 return node.depth;
             },
             getActiveDescendantId: options.accessibilityProvider.getActiveDescendantId && (node => {
@@ -207,7 +236,7 @@ class AbstractTreeViewState {
             focus: [],
             selection: [],
             expanded: Object.create(null),
-            scrollTop,
+            scrollTop
         }));
     }
     constructor(state) {
@@ -218,8 +247,7 @@ class AbstractTreeViewState {
             for (const id of state.expanded) {
                 this.expanded[id] = 1;
             }
-        }
-        else {
+        } else {
             this.expanded = state.expanded;
         }
         this.expanded = state.expanded;
@@ -230,12 +258,12 @@ class AbstractTreeViewState {
             focus: Array.from(this.focus),
             selection: Array.from(this.selection),
             expanded: this.expanded,
-            scrollTop: this.scrollTop,
+            scrollTop: this.scrollTop
         };
     }
 }
 var RenderIndentGuides;
-(function (RenderIndentGuides) {
+(function(RenderIndentGuides) {
     RenderIndentGuides["None"] = "none";
     RenderIndentGuides["OnHover"] = "onHover";
     RenderIndentGuides["Always"] = "always";
@@ -254,8 +282,17 @@ class EventCollection {
     }
 }
 class TreeRenderer {
-    static { this.DefaultIndent = 8; }
-    constructor(renderer, model, onDidChangeCollapseState, activeNodes, renderedIndentGuides, options = {}) {
+    static {
+        this.DefaultIndent = 8;
+    }
+    constructor(
+        renderer,
+        model,
+        onDidChangeCollapseState,
+        activeNodes,
+        renderedIndentGuides,
+        options = {}
+    ) {
         this.renderer = renderer;
         this.model = model;
         this.activeNodes = activeNodes;
@@ -274,7 +311,7 @@ class TreeRenderer {
         renderer.onDidChangeTwistieState?.(this.onDidChangeTwistieState, this, this.disposables);
     }
     updateOptions(options = {}) {
-        if (typeof options.indent !== 'undefined') {
+        if (typeof options.indent !== "undefined") {
             const indent = clamp(options.indent, 0, 40);
             if (indent !== this.indent) {
                 this.indent = indent;
@@ -284,7 +321,7 @@ class TreeRenderer {
                 }
             }
         }
-        if (typeof options.renderIndentGuides !== 'undefined') {
+        if (typeof options.renderIndentGuides !== "undefined") {
             const shouldRenderIndentGuides = options.renderIndentGuides !== RenderIndentGuides.None;
             if (shouldRenderIndentGuides !== this.shouldRenderIndentGuides) {
                 this.shouldRenderIndentGuides = shouldRenderIndentGuides;
@@ -300,32 +337,45 @@ class TreeRenderer {
                 }
             }
         }
-        if (typeof options.hideTwistiesOfChildlessElements !== 'undefined') {
+        if (typeof options.hideTwistiesOfChildlessElements !== "undefined") {
             this.hideTwistiesOfChildlessElements = options.hideTwistiesOfChildlessElements;
         }
-        if (typeof options.twistieAdditionalCssClass !== 'undefined') {
+        if (typeof options.twistieAdditionalCssClass !== "undefined") {
             this.twistieAdditionalCssClass = options.twistieAdditionalCssClass;
         }
     }
     renderTemplate(container) {
-        const el = append(container, $('.monaco-tl-row'));
-        const indent = append(el, $('.monaco-tl-indent'));
-        const twistie = append(el, $('.monaco-tl-twistie'));
-        const contents = append(el, $('.monaco-tl-contents'));
+        const el = append(container, $(".monaco-tl-row"));
+        const indent = append(el, $(".monaco-tl-indent"));
+        const twistie = append(el, $(".monaco-tl-twistie"));
+        const contents = append(el, $(".monaco-tl-contents"));
         const templateData = this.renderer.renderTemplate(contents);
-        return { container, indent, twistie, indentGuidesDisposable: Disposable.None, indentSize: 0, templateData };
+        return {
+            container,
+            indent,
+            twistie,
+            indentGuidesDisposable: Disposable.None,
+            indentSize: 0,
+            templateData
+        };
     }
     renderElement(node, index, templateData, details) {
         templateData.indentSize = TreeRenderer.DefaultIndent + (node.depth - 1) * this.indent;
         this.renderedNodes.set(node, templateData);
         this.renderedElements.set(node.element, node);
         this.renderTreeElement(node, templateData);
-        this.renderer.renderElement(node, index, templateData.templateData, { ...details, indent: templateData.indentSize });
+        this.renderer.renderElement(node, index, templateData.templateData, {
+            ...details,
+            indent: templateData.indentSize
+        });
     }
     disposeElement(node, index, templateData, details) {
         templateData.indentGuidesDisposable.dispose();
-        this.renderer.disposeElement?.(node, index, templateData.templateData, { ...details, indent: templateData.indentSize });
-        if (typeof details?.height === 'number') {
+        this.renderer.disposeElement?.(node, index, templateData.templateData, {
+            ...details,
+            indent: templateData.indentSize
+        });
+        if (typeof details?.height === "number") {
             this.renderedNodes.delete(node);
             this.renderedElements.delete(node.element);
         }
@@ -353,10 +403,9 @@ class TreeRenderer {
         templateData.twistie.style.paddingLeft = `${templateData.indentSize}px`;
         templateData.indent.style.width = `${templateData.indentSize + this.indent - 16}px`;
         if (node.collapsible) {
-            templateData.container.setAttribute('aria-expanded', String(!node.collapsed));
-        }
-        else {
-            templateData.container.removeAttribute('aria-expanded');
+            templateData.container.setAttribute("aria-expanded", String(!node.collapsed));
+        } else {
+            templateData.container.removeAttribute("aria-expanded");
         }
         templateData.twistie.classList.remove(...ThemeIcon.asClassNameArray(Codicon.treeItemExpanded));
         let twistieRendered = false;
@@ -367,11 +416,10 @@ class TreeRenderer {
             if (!twistieRendered) {
                 templateData.twistie.classList.add(...ThemeIcon.asClassNameArray(Codicon.treeItemExpanded));
             }
-            templateData.twistie.classList.add('collapsible');
-            templateData.twistie.classList.toggle('collapsed', node.collapsed);
-        }
-        else {
-            templateData.twistie.classList.remove('collapsible', 'collapsed');
+            templateData.twistie.classList.add("collapsible");
+            templateData.twistie.classList.toggle("collapsed", node.collapsed);
+        } else {
+            templateData.twistie.classList.remove("collapsible", "collapsed");
         }
         if (this.twistieAdditionalCssClass) {
             const additionalClass = this.twistieAdditionalCssClass(node.element);
@@ -395,14 +443,15 @@ class TreeRenderer {
                 break;
             }
             const parent = this.model.getNode(parentRef);
-            const guide = $('.indent-guide', { style: `width: ${this.indent}px` });
+            const guide = $(".indent-guide", {
+                style: `width: ${this.indent}px`
+            });
             if (( this.activeIndentNodes.has(parent))) {
-                guide.classList.add('active');
+                guide.classList.add("active");
             }
             if (templateData.indent.childElementCount === 0) {
                 templateData.indent.appendChild(guide);
-            }
-            else {
+            } else {
                 templateData.indent.insertBefore(guide, templateData.indent.firstElementChild);
             }
             this.renderedIndentGuides.add(parent, guide);
@@ -422,22 +471,19 @@ class TreeRenderer {
                 const parentRef = this.model.getParentNodeLocation(ref);
                 if (node.collapsible && node.children.length > 0 && !node.collapsed) {
                     set.add(node);
-                }
-                else if (parentRef) {
+                } else if (parentRef) {
                     set.add(this.model.getNode(parentRef));
                 }
-            }
-            catch {
-            }
+            } catch {}
         });
         this.activeIndentNodes.forEach(node => {
             if (!( set.has(node))) {
-                this.renderedIndentGuides.forEach(node, line => line.classList.remove('active'));
+                this.renderedIndentGuides.forEach(node, line => line.classList.remove("active"));
             }
         });
         set.forEach(node => {
             if (!( this.activeIndentNodes.has(node))) {
-                this.renderedIndentGuides.forEach(node, line => line.classList.add('active'));
+                this.renderedIndentGuides.forEach(node, line => line.classList.add("active"));
             }
         });
         this.activeIndentNodes = set;
@@ -461,12 +507,24 @@ function contiguousFuzzyScore(patternLower, wordLower) {
     return score;
 }
 class FindFilter {
-    get totalCount() { return this._totalCount; }
-    get matchCount() { return this._matchCount; }
-    set findMatchType(type) { this._findMatchType = type; }
-    get findMatchType() { return this._findMatchType; }
-    set findMode(mode) { this._findMode = mode; }
-    get findMode() { return this._findMode; }
+    get totalCount() {
+        return this._totalCount;
+    }
+    get matchCount() {
+        return this._matchCount;
+    }
+    set findMatchType(type) {
+        this._findMatchType = type;
+    }
+    get findMatchType() {
+        return this._findMatchType;
+    }
+    set findMode(mode) {
+        this._findMode = mode;
+    }
+    get findMode() {
+        return this._findMode;
+    }
     set pattern(pattern) {
         this._pattern = pattern;
         this._lowercasePattern = pattern.toLowerCase();
@@ -479,21 +537,19 @@ class FindFilter {
         this._matchCount = 0;
         this._findMatchType = TreeFindMatchType.Fuzzy;
         this._findMode = TreeFindMode.Highlight;
-        this._pattern = '';
-        this._lowercasePattern = '';
+        this._pattern = "";
+        this._lowercasePattern = "";
         this.disposables = ( new DisposableStore());
     }
     filter(element, parentVisibility) {
         let visibility = TreeVisibility.Visible;
         if (this._filter) {
             const result = this._filter.filter(element, parentVisibility);
-            if (typeof result === 'boolean') {
+            if (typeof result === "boolean") {
                 visibility = result ? TreeVisibility.Visible : TreeVisibility.Hidden;
-            }
-            else if (isFilterResult(result)) {
+            } else if (isFilterResult(result)) {
                 visibility = getVisibleState(result.visibility);
-            }
-            else {
+            } else {
                 visibility = result;
             }
             if (visibility === TreeVisibility.Hidden) {
@@ -503,42 +559,65 @@ class FindFilter {
         this._totalCount++;
         if (!this._pattern) {
             this._matchCount++;
-            return { data: FuzzyScore.Default, visibility };
+            return {
+                data: FuzzyScore.Default,
+                visibility
+            };
         }
         const label = this._keyboardNavigationLabelProvider.getKeyboardNavigationLabel(element);
         const labels = Array.isArray(label) ? label : [label];
         for (const l of labels) {
             const labelStr = l && ( l.toString());
-            if (typeof labelStr === 'undefined') {
-                return { data: FuzzyScore.Default, visibility };
+            if (typeof labelStr === "undefined") {
+                return {
+                    data: FuzzyScore.Default,
+                    visibility
+                };
             }
             let score;
             if (this._findMatchType === TreeFindMatchType.Contiguous) {
                 score = contiguousFuzzyScore(this._lowercasePattern, labelStr.toLowerCase());
-            }
-            else {
-                score = fuzzyScore(this._pattern, this._lowercasePattern, 0, labelStr, labelStr.toLowerCase(), 0, { firstMatchCanBeWeak: true, boostFullMatch: true });
+            } else {
+                score = fuzzyScore(
+                    this._pattern,
+                    this._lowercasePattern,
+                    0,
+                    labelStr,
+                    labelStr.toLowerCase(),
+                    0,
+                    {
+                        firstMatchCanBeWeak: true,
+                        boostFullMatch: true
+                    }
+                );
             }
             if (score) {
                 this._matchCount++;
-                return labels.length === 1 ?
-                    { data: score, visibility } :
-                    { data: { label: labelStr, score: score }, visibility };
+                return labels.length === 1 ? {
+                    data: score,
+                    visibility
+                } : {
+                    data: {
+                        label: labelStr,
+                        score: score
+                    },
+                    visibility
+                };
             }
         }
         if (this._findMode === TreeFindMode.Filter) {
-            if (typeof this._defaultFindVisibility === 'number') {
+            if (typeof this._defaultFindVisibility === "number") {
                 return this._defaultFindVisibility;
-            }
-            else if (this._defaultFindVisibility) {
+            } else if (this._defaultFindVisibility) {
                 return this._defaultFindVisibility(element);
-            }
-            else {
+            } else {
                 return TreeVisibility.Recurse;
             }
-        }
-        else {
-            return { data: FuzzyScore.Default, visibility };
+        } else {
+            return {
+                data: FuzzyScore.Default,
+                visibility
+            };
         }
     }
     reset() {
@@ -558,14 +637,16 @@ class TreeFindToggle extends Toggle {
             inputActiveOptionBorder: opts.inputActiveOptionBorder,
             inputActiveOptionForeground: opts.inputActiveOptionForeground,
             inputActiveOptionBackground: opts.inputActiveOptionBackground,
-            hoverLifecycleOptions,
+            hoverLifecycleOptions
         });
         this.id = contribution.id;
     }
 }
 class FindToggles {
     constructor(startStates) {
-        this.stateMap = ( new Map(( startStates.map(state => [state.id, { ...state }]))));
+        this.stateMap = ( new Map(( startStates.map(state => [state.id, {
+            ...state
+        }]))));
     }
     states() {
         return Array.from(( this.stateMap.values()));
@@ -596,12 +677,12 @@ const unthemedFindWidgetStyles = {
     listFilterWidgetShadow: undefined
 };
 var TreeFindMode;
-(function (TreeFindMode) {
+(function(TreeFindMode) {
     TreeFindMode[TreeFindMode["Highlight"] = 0] = "Highlight";
     TreeFindMode[TreeFindMode["Filter"] = 1] = "Filter";
 })(TreeFindMode || (TreeFindMode = {}));
 var TreeFindMatchType;
-(function (TreeFindMatchType) {
+(function(TreeFindMatchType) {
     TreeFindMatchType[TreeFindMatchType["Fuzzy"] = 0] = "Fuzzy";
     TreeFindMatchType[TreeFindMatchType["Contiguous"] = 1] = "Contiguous";
 })(TreeFindMatchType || (TreeFindMatchType = {}));
@@ -612,12 +693,19 @@ class FindWidget extends Disposable {
     set value(value) {
         this.findInput.inputBox.value = value;
     }
-    constructor(container, tree, contextViewProvider, placeholder, toggleContributions = [], options) {
+    constructor(
+        container,
+        tree,
+        contextViewProvider,
+        placeholder,
+        toggleContributions = [],
+        options
+    ) {
         super();
         this.tree = tree;
-        this.elements = h('.monaco-tree-type-filter', [
-            h('.monaco-tree-type-filter-input@findInput'),
-            h('.monaco-tree-type-filter-actionbar@actionbar'),
+        this.elements = h(".monaco-tree-type-filter", [
+            h(".monaco-tree-type-filter-input@findInput"),
+            h(".monaco-tree-type-filter-actionbar@actionbar")
         ]);
         this.toggles = [];
         this._onDidDisable = ( new Emitter());
@@ -631,9 +719,14 @@ class FindWidget extends Disposable {
         if (styles.listFilterWidgetShadow) {
             this.elements.root.style.boxShadow = `0 0 8px 2px ${styles.listFilterWidgetShadow}`;
         }
-        const hoverLifecycleOptions = { groupId: 'abstract-tree' };
+        const hoverLifecycleOptions = {
+            groupId: "abstract-tree"
+        };
         this.toggles = ( toggleContributions.map(contribution => this._register(( new TreeFindToggle(contribution, styles.toggleStyles, hoverLifecycleOptions)))));
-        this.onDidToggleChange = Event.any(...( this.toggles.map(toggle => ( Event.map(toggle.onChange, () => ({ id: toggle.id, isChecked: toggle.checked }))))));
+        this.onDidToggleChange = Event.any(...( this.toggles.map(toggle => ( Event.map(toggle.onChange, () => ({
+            id: toggle.id,
+            isChecked: toggle.checked
+        }))))));
         const history = options?.history || [];
         this.findInput = this._register(( new FindInput(this.elements.findInput, contextViewProvider, {
             label: ( localize(32, "Type to search")),
@@ -643,12 +736,12 @@ class FindWidget extends Disposable {
             inputBoxStyles: styles.inputBoxStyles,
             toggleStyles: styles.toggleStyles,
             history: ( new Set(history)),
-            hoverLifecycleOptions,
+            hoverLifecycleOptions
         })));
         this.actionbar = this._register(( new ActionBar(this.elements.actionbar)));
-        const emitter = this._register(( new DomEmitter(this.findInput.inputBox.inputElement, 'keydown')));
+        const emitter = this._register(( new DomEmitter(this.findInput.inputBox.inputElement, "keydown")));
         const onKeyDown = Event.chain(emitter.event, $ => ( $.map(e => ( new StandardKeyboardEvent(e)))));
-        this._register(onKeyDown((e) => {
+        this._register(onKeyDown(e => {
             if (e.equals(KeyCode.Enter)) {
                 e.preventDefault();
                 e.stopPropagation();
@@ -662,8 +755,7 @@ class FindWidget extends Disposable {
                 if (this.findInput.inputBox.isAtLastInHistory() || this.findInput.inputBox.isNowhereInHistory()) {
                     this.findInput.inputBox.addToHistory();
                     this.tree.domFocus();
-                }
-                else {
+                } else {
                     this.findInput.inputBox.showNextValue();
                 }
                 return;
@@ -675,8 +767,11 @@ class FindWidget extends Disposable {
                 return;
             }
         }));
-        const closeAction = this._register(( new Action('close', ( localize(33, "Close")), 'codicon codicon-close', true, () => this.dispose())));
-        this.actionbar.push(closeAction, { icon: true, label: false });
+        const closeAction = this._register(( new Action("close", ( localize(33, "Close")), "codicon codicon-close", true, () => this.dispose())));
+        this.actionbar.push(closeAction, {
+            icon: true,
+            label: false
+        });
         this.onDidChangeValue = this.findInput.onDidChange;
     }
     setToggleState(id, checked) {
@@ -706,19 +801,23 @@ class FindWidget extends Disposable {
     }
     async dispose() {
         this._onDidDisable.fire();
-        this.elements.root.classList.add('disabled');
+        this.elements.root.classList.add("disabled");
         await timeout(300);
         super.dispose();
     }
 }
 var DefaultTreeToggles;
-(function (DefaultTreeToggles) {
+(function(DefaultTreeToggles) {
     DefaultTreeToggles["Mode"] = "mode";
     DefaultTreeToggles["MatchType"] = "matchType";
 })(DefaultTreeToggles || (DefaultTreeToggles = {}));
 class AbstractFindController {
-    get pattern() { return this._pattern; }
-    get placeholder() { return this._placeholder; }
+    get pattern() {
+        return this._pattern;
+    }
+    get placeholder() {
+        return this._placeholder;
+    }
     set placeholder(value) {
         this._placeholder = value;
         this.widget?.setPlaceHolder(value);
@@ -728,8 +827,8 @@ class AbstractFindController {
         this.filter = filter;
         this.contextViewProvider = contextViewProvider;
         this.options = options;
-        this._pattern = '';
-        this.previousPattern = '';
+        this._pattern = "";
+        this.previousPattern = "";
         this._onDidChangePattern = ( new Emitter());
         this.onDidChangePattern = this._onDidChangePattern.event;
         this._onDidChangeOpenState = ( new Emitter());
@@ -748,14 +847,19 @@ class AbstractFindController {
             this.widget.select();
             return;
         }
-        this.tree.updateOptions({ paddingTop: 30 });
+        this.tree.updateOptions({
+            paddingTop: 30
+        });
         this.widget = ( new FindWidget(
             this.tree.getHTMLElement(),
             this.tree,
             this.contextViewProvider,
             this.placeholder,
             this.toggles.states(),
-            { ...this.options, history: this._history }
+            {
+                ...this.options,
+                history: this._history
+            }
         ));
         this.enabledDisposables.add(this.widget);
         this.widget.onDidChangeValue(this.onDidChangeValue, this, this.enabledDisposables);
@@ -770,12 +874,14 @@ class AbstractFindController {
         if (!this.widget) {
             return;
         }
-        this.tree.updateOptions({ paddingTop: 0 });
+        this.tree.updateOptions({
+            paddingTop: 0
+        });
         this._history = this.widget.getHistory();
         this.widget = undefined;
         this.enabledDisposables.clear();
         this.previousPattern = this.pattern;
-        this.onDidChangeValue('');
+        this.onDidChangeValue("");
         this.tree.domFocus();
         this._onDidChangeOpenState.fire(false);
     }
@@ -795,21 +901,23 @@ class AbstractFindController {
     renderMessage(showNotFound, warningMessage) {
         if (showNotFound) {
             if (this.tree.options.showNotFoundMessage ?? true) {
-                this.widget?.showMessage({ type: MessageType.WARNING, content: warningMessage ?? ( localize(34, "No results found.")) });
-            }
-            else {
-                this.widget?.showMessage({ type: MessageType.WARNING });
-            }
-        }
-        else {
+                this.widget?.showMessage({
+                    type: MessageType.WARNING,
+                    content: warningMessage ?? ( localize(34, "No results found."))
+                });
+            } else {
+                this.widget?.showMessage({
+                    type: MessageType.WARNING
+                });
+            }
+        } else {
             this.widget?.clearMessage();
         }
     }
     alertResults(results) {
         if (!results) {
             alert(( localize(35, "No results")));
-        }
-        else {
+        } else {
             alert(( localize(36, "{0} results", results)));
         }
     }
@@ -821,7 +929,9 @@ class AbstractFindController {
     }
 }
 class FindController extends AbstractFindController {
-    get mode() { return this.toggles.get(DefaultTreeToggles.Mode) ? TreeFindMode.Filter : TreeFindMode.Highlight; }
+    get mode() {
+        return this.toggles.get(DefaultTreeToggles.Mode) ? TreeFindMode.Filter : TreeFindMode.Highlight;
+    }
     set mode(mode) {
         if (mode === this.mode) {
             return;
@@ -834,7 +944,9 @@ class FindController extends AbstractFindController {
         this.render();
         this._onDidChangeMode.fire(mode);
     }
-    get matchType() { return this.toggles.get(DefaultTreeToggles.MatchType) ? TreeFindMatchType.Fuzzy : TreeFindMatchType.Contiguous; }
+    get matchType() {
+        return this.toggles.get(DefaultTreeToggles.MatchType) ? TreeFindMatchType.Fuzzy : TreeFindMatchType.Contiguous;
+    }
     set matchType(matchType) {
         if (matchType === this.matchType) {
             return;
@@ -849,19 +961,22 @@ class FindController extends AbstractFindController {
         const defaultFindMode = options.defaultFindMode ?? TreeFindMode.Highlight;
         const defaultFindMatchType = options.defaultFindMatchType ?? TreeFindMatchType.Fuzzy;
         const toggleContributions = [{
-                id: DefaultTreeToggles.Mode,
-                icon: Codicon.listFilter,
-                title: ( localize(38, "Filter")),
-                isChecked: defaultFindMode === TreeFindMode.Filter,
-            }, {
-                id: DefaultTreeToggles.MatchType,
-                icon: Codicon.searchFuzzy,
-                title: ( localize(39, "Fuzzy Match")),
-                isChecked: defaultFindMatchType === TreeFindMatchType.Fuzzy,
-            }];
+            id: DefaultTreeToggles.Mode,
+            icon: Codicon.listFilter,
+            title: ( localize(38, "Filter")),
+            isChecked: defaultFindMode === TreeFindMode.Filter
+        }, {
+            id: DefaultTreeToggles.MatchType,
+            icon: Codicon.searchFuzzy,
+            title: ( localize(39, "Fuzzy Match")),
+            isChecked: defaultFindMatchType === TreeFindMatchType.Fuzzy
+        }];
         filter.findMatchType = defaultFindMatchType;
         filter.findMode = defaultFindMode;
-        super(tree, filter, contextViewProvider, { ...options, toggles: toggleContributions });
+        super(tree, filter, contextViewProvider, {
+            ...options,
+            toggles: toggleContributions
+        });
         this.filter = filter;
         this._onDidChangeMode = ( new Emitter());
         this.onDidChangeMode = this._onDidChangeMode.event;
@@ -889,7 +1004,7 @@ class FindController extends AbstractFindController {
     applyPattern(pattern) {
         this.tree.refilter();
         if (pattern) {
-            this.tree.focusNext(0, true, undefined, (node) => !FuzzyScore.isDefault(node.filterData));
+            this.tree.focusNext(0, true, undefined, node => !FuzzyScore.isDefault(node.filterData));
         }
         const focus = this.tree.getFocus();
         if (focus.length > 0) {
@@ -912,8 +1027,7 @@ class FindController extends AbstractFindController {
     onDidToggleChange(e) {
         if (e.id === DefaultTreeToggles.Mode) {
             this.mode = e.isChecked ? TreeFindMode.Filter : TreeFindMode.Highlight;
-        }
-        else if (e.id === DefaultTreeToggles.MatchType) {
+        } else if (e.id === DefaultTreeToggles.MatchType) {
             this.matchType = e.isChecked ? TreeFindMatchType.Fuzzy : TreeFindMatchType.Contiguous;
         }
     }
@@ -930,16 +1044,15 @@ function stickyScrollNodeStateEquals(node1, node2) {
     return node1.position === node2.position && stickyScrollNodeEquals(node1, node2);
 }
 function stickyScrollNodeEquals(node1, node2) {
-    return node1.node.element === node2.node.element &&
-        node1.startIndex === node2.startIndex &&
-        node1.height === node2.height &&
-        node1.endIndex === node2.endIndex;
+    return node1.node.element === node2.node.element && node1.startIndex === node2.startIndex && node1.height === node2.height && node1.endIndex === node2.endIndex;
 }
 class StickyScrollState {
     constructor(stickyNodes = []) {
         this.stickyNodes = stickyNodes;
     }
-    get count() { return this.stickyNodes.length; }
+    get count() {
+        return this.stickyNodes.length;
+    }
     equal(state) {
         return equals(this.stickyNodes, state.stickyNodes, stickyScrollNodeStateEquals);
     }
@@ -1006,7 +1119,7 @@ class StickyScrollController extends Disposable {
         this._register(view.onDidScroll(() => this.update()));
         this._register(view.onDidChangeContentHeight(() => this.update()));
         this._register(tree.onDidChangeCollapseState(() => this.update()));
-        this._register(model.onDidSpliceRenderedNodes((e) => {
+        this._register(model.onDidSpliceRenderedNodes(e => {
             const state = this._widget.state;
             if (!state) {
                 return;
@@ -1039,8 +1152,7 @@ class StickyScrollController extends Disposable {
         let index;
         if (height === 0) {
             index = this.view.firstVisibleIndex;
-        }
-        else {
+        } else {
             index = this.view.indexAt(height + this.view.scrollTop);
         }
         if (index < 0 || index >= this.view.length) {
@@ -1102,9 +1214,18 @@ class StickyScrollController extends Disposable {
     }
     createStickyScrollNode(node, currentStickyNodesHeight) {
         const height = this.treeDelegate.getHeight(node);
-        const { startIndex, endIndex } = this.getNodeRange(node);
+        const {
+            startIndex,
+            endIndex
+        } = this.getNodeRange(node);
         const position = this.calculateStickyNodePosition(endIndex, currentStickyNodesHeight, height);
-        return { node, position, height, startIndex, endIndex };
+        return {
+            node,
+            position,
+            height,
+            startIndex,
+            endIndex
+        };
     }
     getAncestorUnderPrevious(node, previousAncestor = undefined) {
         let currentAncestor = node;
@@ -1155,7 +1276,7 @@ class StickyScrollController extends Disposable {
         }
         const lastConstrainedStickyNode = constrainedStickyNodes[constrainedStickyNodes.length - 1];
         if (constrainedStickyNodes.length > this.stickyScrollMaxItemCount || lastConstrainedStickyNode.position + lastConstrainedStickyNode.height > maximumStickyWidgetHeight) {
-            throw ( new Error('stickyScrollDelegate violates constraints'));
+            throw ( new Error("stickyScrollDelegate violates constraints"));
         }
         return constrainedStickyNodes;
     }
@@ -1177,11 +1298,14 @@ class StickyScrollController extends Disposable {
         const nodeLocation = this.model.getNodeLocation(node);
         const startIndex = this.model.getListIndex(nodeLocation);
         if (startIndex < 0) {
-            throw ( new Error('Node not found in tree'));
+            throw ( new Error("Node not found in tree"));
         }
         const renderCount = this.model.getListRenderCount(nodeLocation);
         const endIndex = startIndex + renderCount - 1;
-        return { startIndex, endIndex };
+        return {
+            startIndex,
+            endIndex
+        };
     }
     nodePositionTopBelowWidget(node) {
         const ancestors = [];
@@ -1219,14 +1343,18 @@ class StickyScrollController extends Disposable {
     }
     validateStickySettings(options) {
         let stickyScrollMaxItemCount = 7;
-        if (typeof options.stickyScrollMaxItemCount === 'number') {
+        if (typeof options.stickyScrollMaxItemCount === "number") {
             stickyScrollMaxItemCount = Math.max(options.stickyScrollMaxItemCount, 1);
         }
-        return { stickyScrollMaxItemCount };
+        return {
+            stickyScrollMaxItemCount
+        };
     }
 }
 class StickyScrollWidget {
-    get state() { return this._previousState; }
+    get state() {
+        return this._previousState;
+    }
     constructor(container, view, tree, treeRenderers, treeDelegate, accessibilityProvider) {
         this.view = view;
         this.tree = tree;
@@ -1235,9 +1363,9 @@ class StickyScrollWidget {
         this.accessibilityProvider = accessibilityProvider;
         this._previousElements = [];
         this._previousStateDisposables = ( new DisposableStore());
-        this._rootDomNode = $('.monaco-tree-sticky-container.empty');
+        this._rootDomNode = $(".monaco-tree-sticky-container.empty");
         container.appendChild(this._rootDomNode);
-        const shadow = $('.monaco-tree-sticky-container-shadow');
+        const shadow = $(".monaco-tree-sticky-container-shadow");
         this._rootDomNode.appendChild(shadow);
         this.stickyScrollFocus = ( new StickyScrollFocus(this._rootDomNode, view));
         this.onDidChangeHasFocus = this.stickyScrollFocus.onDidChangeHasFocus;
@@ -1286,7 +1414,10 @@ class StickyScrollWidget {
         const elements = Array(state.count);
         for (let stickyIndex = state.count - 1; stickyIndex >= 0; stickyIndex--) {
             const stickyNode = state.stickyNodes[stickyIndex];
-            const { element, disposable } = this.createElement(stickyNode, stickyIndex, state.count);
+            const {
+                element,
+                disposable
+            } = this.createElement(stickyNode, stickyIndex, state.count);
             elements[stickyIndex] = element;
             this._rootDomNode.appendChild(element);
             this._previousStateDisposables.add(disposable);
@@ -1301,7 +1432,7 @@ class StickyScrollWidget {
     }
     createElement(stickyNode, stickyIndex, stickyNodesTotal) {
         const nodeIndex = stickyNode.startIndex;
-        const stickyElement = createElement('div');
+        const stickyElement = createElement("div");
         stickyElement.style.top = `${stickyNode.position}px`;
         if (this.tree.options.setRowHeight !== false) {
             stickyElement.style.height = `${stickyNode.height}px`;
@@ -1309,14 +1440,14 @@ class StickyScrollWidget {
         if (this.tree.options.setRowLineHeight !== false) {
             stickyElement.style.lineHeight = `${stickyNode.height}px`;
         }
-        stickyElement.classList.add('monaco-tree-sticky-row');
-        stickyElement.classList.add('monaco-list-row');
-        stickyElement.setAttribute('data-index', `${nodeIndex}`);
-        stickyElement.setAttribute('data-parity', nodeIndex % 2 === 0 ? 'even' : 'odd');
-        stickyElement.setAttribute('id', this.view.getElementID(nodeIndex));
+        stickyElement.classList.add("monaco-tree-sticky-row");
+        stickyElement.classList.add("monaco-list-row");
+        stickyElement.setAttribute("data-index", `${nodeIndex}`);
+        stickyElement.setAttribute("data-parity", nodeIndex % 2 === 0 ? "even" : "odd");
+        stickyElement.setAttribute("id", this.view.getElementID(nodeIndex));
         const accessibilityDisposable = this.setAccessibilityAttributes(stickyElement, stickyNode.node.element, stickyIndex, stickyNodesTotal);
         const nodeTemplateId = this.treeDelegate.getTemplateId(stickyNode.node);
-        const renderer = this.treeRenderers.find((renderer) => renderer.templateId === nodeTemplateId);
+        const renderer = this.treeRenderers.find(renderer => renderer.templateId === nodeTemplateId);
         if (!renderer) {
             throw ( new Error(`No renderer found for template id ${nodeTemplateId}`));
         }
@@ -1325,52 +1456,63 @@ class StickyScrollWidget {
             nodeCopy = ( new Proxy(stickyNode.node, {}));
         }
         const templateData = renderer.renderTemplate(stickyElement);
-        renderer.renderElement(nodeCopy, stickyNode.startIndex, templateData, { height: stickyNode.height });
+        renderer.renderElement(nodeCopy, stickyNode.startIndex, templateData, {
+            height: stickyNode.height
+        });
         const disposable = toDisposable(() => {
             accessibilityDisposable.dispose();
-            renderer.disposeElement(nodeCopy, stickyNode.startIndex, templateData, { height: stickyNode.height });
+            renderer.disposeElement(nodeCopy, stickyNode.startIndex, templateData, {
+                height: stickyNode.height
+            });
             renderer.disposeTemplate(templateData);
             stickyElement.remove();
         });
-        return { element: stickyElement, disposable };
+        return {
+            element: stickyElement,
+            disposable
+        };
     }
     setAccessibilityAttributes(container, element, stickyIndex, stickyNodesTotal) {
         if (!this.accessibilityProvider) {
             return Disposable.None;
         }
         if (this.accessibilityProvider.getSetSize) {
-            container.setAttribute('aria-setsize', String(this.accessibilityProvider.getSetSize(element, stickyIndex, stickyNodesTotal)));
+            container.setAttribute("aria-setsize", String(
+                this.accessibilityProvider.getSetSize(element, stickyIndex, stickyNodesTotal)
+            ));
         }
         if (this.accessibilityProvider.getPosInSet) {
-            container.setAttribute('aria-posinset', String(this.accessibilityProvider.getPosInSet(element, stickyIndex)));
+            container.setAttribute(
+                "aria-posinset",
+                String(this.accessibilityProvider.getPosInSet(element, stickyIndex))
+            );
         }
         if (this.accessibilityProvider.getRole) {
-            container.setAttribute('role', this.accessibilityProvider.getRole(element) ?? 'treeitem');
+            container.setAttribute("role", this.accessibilityProvider.getRole(element) ?? "treeitem");
         }
         const ariaLabel = this.accessibilityProvider.getAriaLabel(element);
-        const observable = (ariaLabel && typeof ariaLabel !== 'string') ? ariaLabel : constObservable(ariaLabel);
+        const observable = (ariaLabel && typeof ariaLabel !== "string") ? ariaLabel : constObservable(ariaLabel);
         const result = autorun(reader => {
             const value = reader.readObservable(observable);
             if (value) {
-                container.setAttribute('aria-label', value);
-            }
-            else {
-                container.removeAttribute('aria-label');
+                container.setAttribute("aria-label", value);
+            } else {
+                container.removeAttribute("aria-label");
             }
         });
-        if (typeof ariaLabel === 'string') ;
-        else if (ariaLabel) {
-            container.setAttribute('aria-label', ariaLabel.get());
+        if (typeof ariaLabel === "string")
+            ; else if (ariaLabel) {
+            container.setAttribute("aria-label", ariaLabel.get());
         }
         const ariaLevel = this.accessibilityProvider.getAriaLevel && this.accessibilityProvider.getAriaLevel(element);
-        if (typeof ariaLevel === 'number') {
-            container.setAttribute('aria-level', `${ariaLevel}`);
+        if (typeof ariaLevel === "number") {
+            container.setAttribute("aria-level", `${ariaLevel}`);
         }
-        container.setAttribute('aria-selected', String(false));
+        container.setAttribute("aria-selected", String(false));
         return result;
     }
     setVisible(visible) {
-        this._rootDomNode.classList.toggle('empty', !visible);
+        this._rootDomNode.classList.toggle("empty", !visible);
         if (!visible) {
             this.stickyScrollFocus.updateElements([], undefined);
         }
@@ -1391,7 +1533,9 @@ class StickyScrollWidget {
     }
 }
 class StickyScrollFocus extends Disposable {
-    get domHasFocus() { return this._domHasFocus; }
+    get domHasFocus() {
+        return this._domHasFocus;
+    }
     set domHasFocus(hasFocus) {
         if (hasFocus !== this._domHasFocus) {
             this._onDidChangeHasFocus.fire(hasFocus);
@@ -1409,12 +1553,12 @@ class StickyScrollFocus extends Disposable {
         this._onContextMenu = ( new Emitter());
         this.onContextMenu = this._onContextMenu.event;
         this._domHasFocus = false;
-        this._register(addDisposableListener(this.container, 'focus', () => this.onFocus()));
-        this._register(addDisposableListener(this.container, 'blur', () => this.onBlur()));
+        this._register(addDisposableListener(this.container, "focus", () => this.onFocus()));
+        this._register(addDisposableListener(this.container, "blur", () => this.onBlur()));
         this._register(this.view.onDidFocus(() => this.toggleStickyScrollFocused(false)));
-        this._register(this.view.onKeyDown((e) => this.onKeyDown(e)));
-        this._register(this.view.onMouseDown((e) => this.onMouseDown(e)));
-        this._register(this.view.onContextMenu((e) => this.handleContextMenu(e)));
+        this._register(this.view.onKeyDown(e => this.onKeyDown(e)));
+        this._register(this.view.onMouseDown(e => this.onMouseDown(e)));
+        this._register(this.view.onContextMenu(e => this.handleContextMenu(e)));
     }
     handleContextMenu(e) {
         const target = e.browserEvent.target;
@@ -1426,12 +1570,12 @@ class StickyScrollFocus extends Disposable {
         }
         if (!isKeyboardEvent(e.browserEvent)) {
             if (!this.state) {
-                throw ( new Error('Context menu should not be triggered when state is undefined'));
+                throw ( new Error("Context menu should not be triggered when state is undefined"));
             }
             const stickyIndex = this.state.stickyNodes.findIndex(stickyNode => stickyNode.node.element === e.element?.element);
             if (stickyIndex === -1) {
                 throw ( new Error(
-                    'Context menu should not be triggered when element is not in sticky scroll widget'
+                    "Context menu should not be triggered when element is not in sticky scroll widget"
                 ));
             }
             this.container.focus();
@@ -1440,29 +1584,33 @@ class StickyScrollFocus extends Disposable {
         }
         if (!this.state || this.focusedIndex < 0) {
             throw ( new Error(
-                'Context menu key should not be triggered when focus is not in sticky scroll widget'
+                "Context menu key should not be triggered when focus is not in sticky scroll widget"
             ));
         }
         const stickyNode = this.state.stickyNodes[this.focusedIndex];
         const element = stickyNode.node.element;
         const anchor = this.elements[this.focusedIndex];
-        this._onContextMenu.fire({ element, anchor, browserEvent: e.browserEvent, isStickyScroll: true });
+        this._onContextMenu.fire({
+            element,
+            anchor,
+            browserEvent: e.browserEvent,
+            isStickyScroll: true
+        });
     }
     onKeyDown(e) {
         if (this.domHasFocus && this.state) {
-            if (e.key === 'ArrowUp') {
+            if (e.key === "ArrowUp") {
                 this.setFocusedElement(Math.max(0, this.focusedIndex - 1));
                 e.preventDefault();
                 e.stopPropagation();
             }
-            else if (e.key === 'ArrowDown' || e.key === 'ArrowRight') {
+            else if (e.key === "ArrowDown" || e.key === "ArrowRight") {
                 if (this.focusedIndex >= this.state.count - 1) {
                     const nodeIndexToFocus = this.state.stickyNodes[this.state.count - 1].startIndex + 1;
                     this.view.domFocus();
                     this.view.setFocus([nodeIndexToFocus]);
                     this.scrollNodeUnderWidget(nodeIndexToFocus, this.state);
-                }
-                else {
+                } else {
                     this.setFocusedElement(this.focusedIndex + 1);
                 }
                 e.preventDefault();
@@ -1480,10 +1628,10 @@ class StickyScrollFocus extends Disposable {
     }
     updateElements(elements, state) {
         if (state && state.count === 0) {
-            throw ( new Error('Sticky scroll state must be undefined when there are no sticky nodes'));
+            throw ( new Error("Sticky scroll state must be undefined when there are no sticky nodes"));
         }
         if (state && state.count !== elements.length) {
-            throw ( new Error('Sticky scroll focus received illigel state'));
+            throw ( new Error("Sticky scroll focus received illigel state"));
         }
         const previousIndex = this.focusedIndex;
         this.removeFocus();
@@ -1492,8 +1640,7 @@ class StickyScrollFocus extends Disposable {
         if (state) {
             const newFocusedIndex = clamp(previousIndex, 0, state.count - 1);
             this.setFocus(newFocusedIndex);
-        }
-        else {
+        } else {
             if (this.domHasFocus) {
                 this.view.domFocus();
             }
@@ -1503,7 +1650,7 @@ class StickyScrollFocus extends Disposable {
     setFocusedElement(stickyIndex) {
         const state = this.state;
         if (!state) {
-            throw ( new Error('Cannot set focus when state is undefined'));
+            throw ( new Error("Cannot set focus when state is undefined"));
         }
         this.setFocus(stickyIndex);
         if (stickyIndex < state.count - 1) {
@@ -1529,7 +1676,7 @@ class StickyScrollFocus extends Disposable {
     }
     domFocus() {
         if (!this.state) {
-            throw ( new Error('Cannot focus when state is undefined'));
+            throw ( new Error("Cannot focus when state is undefined"));
         }
         this.container.focus();
     }
@@ -1537,7 +1684,7 @@ class StickyScrollFocus extends Disposable {
         if (!this.state) {
             return false;
         }
-        return this.view.getHTMLElement().classList.contains('sticky-scroll-focused');
+        return this.view.getHTMLElement().classList.contains("sticky-scroll-focused");
     }
     removeFocus() {
         if (this.focusedIndex === -1) {
@@ -1548,13 +1695,13 @@ class StickyScrollFocus extends Disposable {
     }
     setFocus(newFocusIndex) {
         if (0 > newFocusIndex) {
-            throw ( new Error('addFocus() can not remove focus'));
+            throw ( new Error("addFocus() can not remove focus"));
         }
         if (!this.state && newFocusIndex >= 0) {
-            throw ( new Error('Cannot set focus index when state is undefined'));
+            throw ( new Error("Cannot set focus index when state is undefined"));
         }
         if (this.state && newFocusIndex >= this.state.count) {
-            throw ( new Error('Cannot set focus index to an index that does not exist'));
+            throw ( new Error("Cannot set focus index to an index that does not exist"));
         }
         const oldIndex = this.focusedIndex;
         if (oldIndex >= 0) {
@@ -1576,17 +1723,17 @@ class StickyScrollFocus extends Disposable {
         this.toggleElementActiveFocus(this.elements[this.focusedIndex], focused);
     }
     toggleElementActiveFocus(element, focused) {
-        element.classList.toggle('focused', focused);
+        element.classList.toggle("focused", focused);
     }
     toggleElementPassiveFocus(element, focused) {
-        element.classList.toggle('passive-focused', focused);
+        element.classList.toggle("passive-focused", focused);
     }
     toggleStickyScrollFocused(focused) {
-        this.view.getHTMLElement().classList.toggle('sticky-scroll-focused', focused);
+        this.view.getHTMLElement().classList.toggle("sticky-scroll-focused", focused);
     }
     onFocus() {
         if (!this.state || this.elements.length === 0) {
-            throw ( new Error('Cannot focus when state is undefined or elements are empty'));
+            throw ( new Error("Cannot focus when state is undefined or elements are empty"));
         }
         this.domHasFocus = true;
         this.toggleStickyScrollFocused(true);
@@ -1607,13 +1754,11 @@ class StickyScrollFocus extends Disposable {
 }
 function asTreeMouseEvent(event) {
     let target = TreeMouseEventTarget.Unknown;
-    if (hasParentWithClass(event.browserEvent.target, 'monaco-tl-twistie', 'monaco-tl-row')) {
+    if (hasParentWithClass(event.browserEvent.target, "monaco-tl-twistie", "monaco-tl-row")) {
         target = TreeMouseEventTarget.Twistie;
-    }
-    else if (hasParentWithClass(event.browserEvent.target, 'monaco-tl-contents', 'monaco-tl-row')) {
+    } else if (hasParentWithClass(event.browserEvent.target, "monaco-tl-contents", "monaco-tl-row")) {
         target = TreeMouseEventTarget.Element;
-    }
-    else if (hasParentWithClass(event.browserEvent.target, 'monaco-tree-type-filter', 'monaco-list')) {
+    } else if (hasParentWithClass(event.browserEvent.target, "monaco-tree-type-filter", "monaco-list")) {
         target = TreeMouseEventTarget.Filter;
     }
     return {
@@ -1662,7 +1807,12 @@ class Trait {
         this._nodeSet = undefined;
         if (!silent) {
             const that = this;
-            this._onDidChange.fire({ get elements() { return that.get(); }, browserEvent });
+            this._onDidChange.fire({
+                get elements() {
+                    return that.get();
+                },
+                browserEvent
+            });
         }
     }
     get() {
@@ -1677,19 +1827,24 @@ class Trait {
     has(node) {
         return ( this.nodeSet.has(node));
     }
-    onDidModelSplice({ insertedNodes, deletedNodes }) {
+    onDidModelSplice(
+        {
+            insertedNodes,
+            deletedNodes
+        }
+    ) {
         if (!this.identityProvider) {
             const set = this.createNodeSet();
-            const visit = (node) => set.delete(node);
+            const visit = node => set.delete(node);
             deletedNodes.forEach(node => dfs(node, visit));
             this.set([...( set.values())]);
             return;
         }
         const deletedNodesIdSet = ( new Set());
-        const deletedNodesVisitor = (node) => deletedNodesIdSet.add(( this.identityProvider.getId(node.element).toString()));
+        const deletedNodesVisitor = node => deletedNodesIdSet.add(( this.identityProvider.getId(node.element).toString()));
         deletedNodes.forEach(node => dfs(node, deletedNodesVisitor));
         const insertedNodesMap = ( new Map());
-        const insertedNodesVisitor = (node) => insertedNodesMap.set(( this.identityProvider.getId(node.element).toString()), node);
+        const insertedNodesVisitor = node => insertedNodesMap.set(( this.identityProvider.getId(node.element).toString()), node);
         insertedNodes.forEach(node => dfs(node, insertedNodesVisitor));
         const nodes = [];
         for (const node of this.nodes) {
@@ -1697,8 +1852,7 @@ class Trait {
             const wasDeleted = ( deletedNodesIdSet.has(id));
             if (!wasDeleted) {
                 nodes.push(node);
-            }
-            else {
+            } else {
                 const insertedNode = insertedNodesMap.get(id);
                 if (insertedNode && insertedNode.visible) {
                     nodes.push(insertedNode);
@@ -1728,9 +1882,7 @@ class TreeNodeListMouseController extends MouseController {
         this.stickyScrollProvider = stickyScrollProvider;
     }
     onViewPointer(e) {
-        if (isButton(e.browserEvent.target) ||
-            isEditableElement(e.browserEvent.target) ||
-            isMonacoEditor(e.browserEvent.target)) {
+        if (isButton(e.browserEvent.target) || isEditableElement(e.browserEvent.target) || isMonacoEditor(e.browserEvent.target)) {
             return;
         }
         if (e.browserEvent.isHandledByList) {
@@ -1744,17 +1896,14 @@ class TreeNodeListMouseController extends MouseController {
             return super.onViewPointer(e);
         }
         const target = e.browserEvent.target;
-        const onTwistie = target.classList.contains('monaco-tl-twistie')
-            || (target.classList.contains('monaco-icon-label') && target.classList.contains('folder-icon') && e.browserEvent.offsetX < 16);
+        const onTwistie = target.classList.contains("monaco-tl-twistie") || (target.classList.contains("monaco-icon-label") && target.classList.contains("folder-icon") && e.browserEvent.offsetX < 16);
         const isStickyElement = isStickyScrollElement(e.browserEvent.target);
         let expandOnlyOnTwistieClick = false;
         if (isStickyElement) {
             expandOnlyOnTwistieClick = true;
-        }
-        else if (typeof this.tree.expandOnlyOnTwistieClick === 'function') {
+        } else if (typeof this.tree.expandOnlyOnTwistieClick === "function") {
             expandOnlyOnTwistieClick = this.tree.expandOnlyOnTwistieClick(node.element);
-        }
-        else {
+        } else {
             expandOnlyOnTwistieClick = !!this.tree.expandOnlyOnTwistieClick;
         }
         if (!isStickyElement) {
@@ -1764,8 +1913,7 @@ class TreeNodeListMouseController extends MouseController {
             if (!this.tree.expandOnDoubleClick && e.browserEvent.detail === 2) {
                 return super.onViewPointer(e);
             }
-        }
-        else {
+        } else {
             this.handleStickyScrollMouseEvent(e, node);
         }
         if (node.collapsible && (!isStickyElement || onTwistie)) {
@@ -1788,7 +1936,7 @@ class TreeNodeListMouseController extends MouseController {
         }
         const stickyScrollController = this.stickyScrollProvider();
         if (!stickyScrollController) {
-            throw ( new Error('Sticky scroll controller not found'));
+            throw ( new Error("Sticky scroll controller not found"));
         }
         const nodeIndex = this.list.indexOf(node);
         const elementScrollTop = this.list.getElementTop(nodeIndex);
@@ -1799,7 +1947,7 @@ class TreeNodeListMouseController extends MouseController {
         this.list.setSelection([nodeIndex]);
     }
     onDoubleClick(e) {
-        const onTwistie = e.browserEvent.target.classList.contains('monaco-tl-twistie');
+        const onTwistie = e.browserEvent.target.classList.contains("monaco-tl-twistie");
         if (onTwistie || !this.tree.expandOnDoubleClick) {
             return;
         }
@@ -1824,7 +1972,16 @@ class TreeNodeListMouseController extends MouseController {
     }
 }
 class TreeNodeList extends List {
-    constructor(user, container, virtualDelegate, renderers, focusTrait, selectionTrait, anchorTrait, options) {
+    constructor(
+        user,
+        container,
+        virtualDelegate,
+        renderers,
+        focusTrait,
+        selectionTrait,
+        anchorTrait,
+        options
+    ) {
         super(user, container, virtualDelegate, renderers, options);
         this.focusTrait = focusTrait;
         this.selectionTrait = selectionTrait;
@@ -1858,7 +2015,7 @@ class TreeNodeList extends List {
         if (additionalSelection.length > 0) {
             super.setSelection(distinct([...super.getSelection(), ...additionalSelection]));
         }
-        if (typeof anchor === 'number') {
+        if (typeof anchor === "number") {
             super.setAnchor(anchor);
         }
     }
@@ -1877,52 +2034,105 @@ class TreeNodeList extends List {
     setAnchor(index, fromAPI = false) {
         super.setAnchor(index);
         if (!fromAPI) {
-            if (typeof index === 'undefined') {
+            if (typeof index === "undefined") {
                 this.anchorTrait.set([]);
-            }
-            else {
+            } else {
                 this.anchorTrait.set([this.element(index)]);
             }
         }
     }
 }
 var AbstractTreePart;
-(function (AbstractTreePart) {
+(function(AbstractTreePart) {
     AbstractTreePart[AbstractTreePart["Tree"] = 0] = "Tree";
     AbstractTreePart[AbstractTreePart["StickyScroll"] = 1] = "StickyScroll";
 })(AbstractTreePart || (AbstractTreePart = {}));
 class AbstractTree {
-    get onDidScroll() { return this.view.onDidScroll; }
-    get onDidChangeFocus() { return this.eventBufferer.wrapEvent(this.focus.onDidChange); }
-    get onDidChangeSelection() { return this.eventBufferer.wrapEvent(this.selection.onDidChange); }
-    get onMouseClick() { return ( Event.map(this.view.onMouseClick, asTreeMouseEvent)); }
-    get onMouseDblClick() { return Event.filter(( Event.map(this.view.onMouseDblClick, asTreeMouseEvent)), e => e.target !== TreeMouseEventTarget.Filter); }
-    get onMouseMiddleClick() { return Event.filter(( Event.map(this.view.onMouseMiddleClick, asTreeMouseEvent)), e => e.target !== TreeMouseEventTarget.Filter); }
-    get onMouseOver() { return ( Event.map(this.view.onMouseOver, asTreeMouseEvent)); }
-    get onMouseOut() { return ( Event.map(this.view.onMouseOut, asTreeMouseEvent)); }
-    get onContextMenu() { return Event.any(Event.filter(( Event.map(this.view.onContextMenu, asTreeContextMenuEvent)), e => !e.isStickyScroll), this.stickyScrollController?.onContextMenu ?? Event.None); }
-    get onTap() { return ( Event.map(this.view.onTap, asTreeMouseEvent)); }
-    get onPointer() { return ( Event.map(this.view.onPointer, asTreeMouseEvent)); }
-    get onKeyDown() { return this.view.onKeyDown; }
-    get onKeyUp() { return this.view.onKeyUp; }
-    get onKeyPress() { return this.view.onKeyPress; }
-    get onDidFocus() { return this.view.onDidFocus; }
-    get onDidBlur() { return this.view.onDidBlur; }
-    get onDidChangeModel() { return Event.any(this.onDidChangeModelRelay.event, this.onDidSwapModel.event); }
-    get onDidChangeCollapseState() { return this.onDidChangeCollapseStateRelay.event; }
-    get onDidChangeRenderNodeCount() { return this.onDidChangeRenderNodeCountRelay.event; }
-    get findMode() { return this.findController?.mode ?? TreeFindMode.Highlight; }
-    set findMode(findMode) { if (this.findController) {
-        this.findController.mode = findMode;
-    } }
-    get findMatchType() { return this.findController?.matchType ?? TreeFindMatchType.Fuzzy; }
-    set findMatchType(findFuzzy) { if (this.findController) {
-        this.findController.matchType = findFuzzy;
-    } }
-    get onDidChangeFindPattern() { return this.findController ? this.findController.onDidChangePattern : Event.None; }
-    get expandOnDoubleClick() { return typeof this._options.expandOnDoubleClick === 'undefined' ? true : this._options.expandOnDoubleClick; }
-    get expandOnlyOnTwistieClick() { return typeof this._options.expandOnlyOnTwistieClick === 'undefined' ? true : this._options.expandOnlyOnTwistieClick; }
-    get onDidDispose() { return this.view.onDidDispose; }
+    get onDidScroll() {
+        return this.view.onDidScroll;
+    }
+    get onDidChangeFocus() {
+        return this.eventBufferer.wrapEvent(this.focus.onDidChange);
+    }
+    get onDidChangeSelection() {
+        return this.eventBufferer.wrapEvent(this.selection.onDidChange);
+    }
+    get onMouseClick() {
+        return ( Event.map(this.view.onMouseClick, asTreeMouseEvent));
+    }
+    get onMouseDblClick() {
+        return Event.filter(( Event.map(this.view.onMouseDblClick, asTreeMouseEvent)), e => e.target !== TreeMouseEventTarget.Filter);
+    }
+    get onMouseMiddleClick() {
+        return Event.filter(( Event.map(this.view.onMouseMiddleClick, asTreeMouseEvent)), e => e.target !== TreeMouseEventTarget.Filter);
+    }
+    get onMouseOver() {
+        return ( Event.map(this.view.onMouseOver, asTreeMouseEvent));
+    }
+    get onMouseOut() {
+        return ( Event.map(this.view.onMouseOut, asTreeMouseEvent));
+    }
+    get onContextMenu() {
+        return Event.any(Event.filter(( Event.map(this.view.onContextMenu, asTreeContextMenuEvent)), e => !e.isStickyScroll), this.stickyScrollController?.onContextMenu ?? Event.None);
+    }
+    get onTap() {
+        return ( Event.map(this.view.onTap, asTreeMouseEvent));
+    }
+    get onPointer() {
+        return ( Event.map(this.view.onPointer, asTreeMouseEvent));
+    }
+    get onKeyDown() {
+        return this.view.onKeyDown;
+    }
+    get onKeyUp() {
+        return this.view.onKeyUp;
+    }
+    get onKeyPress() {
+        return this.view.onKeyPress;
+    }
+    get onDidFocus() {
+        return this.view.onDidFocus;
+    }
+    get onDidBlur() {
+        return this.view.onDidBlur;
+    }
+    get onDidChangeModel() {
+        return Event.any(this.onDidChangeModelRelay.event, this.onDidSwapModel.event);
+    }
+    get onDidChangeCollapseState() {
+        return this.onDidChangeCollapseStateRelay.event;
+    }
+    get onDidChangeRenderNodeCount() {
+        return this.onDidChangeRenderNodeCountRelay.event;
+    }
+    get findMode() {
+        return this.findController?.mode ?? TreeFindMode.Highlight;
+    }
+    set findMode(findMode) {
+        if (this.findController) {
+            this.findController.mode = findMode;
+        }
+    }
+    get findMatchType() {
+        return this.findController?.matchType ?? TreeFindMatchType.Fuzzy;
+    }
+    set findMatchType(findFuzzy) {
+        if (this.findController) {
+            this.findController.matchType = findFuzzy;
+        }
+    }
+    get onDidChangeFindPattern() {
+        return this.findController ? this.findController.onDidChangePattern : Event.None;
+    }
+    get expandOnDoubleClick() {
+        return typeof this._options.expandOnDoubleClick === "undefined" ? true : this._options.expandOnDoubleClick;
+    }
+    get expandOnlyOnTwistieClick() {
+        return typeof this._options.expandOnlyOnTwistieClick === "undefined" ? true : this._options.expandOnlyOnTwistieClick;
+    }
+    get onDidDispose() {
+        return this.view.onDidDispose;
+    }
     constructor(_user, container, delegate, renderers, _options = {}) {
         this._user = _user;
         this._options = _options;
@@ -1947,7 +2157,10 @@ class AbstractTree {
                 _options.filter,
                 _options.defaultFindVisibility
             ));
-            _options = { ..._options, filter: this.findFilter };
+            _options = {
+                ..._options,
+                filter: this.findFilter
+            };
             this.disposables.add(this.findFilter);
         }
         this.model = this.createModel(_user, _options);
@@ -1976,12 +2189,15 @@ class AbstractTree {
             this.focus,
             this.selection,
             this.anchor,
-            { ...asListOptions(() => this.model, this.disposables, _options), tree: this, stickyScrollProvider: () => this.stickyScrollController }
+            {
+                ...asListOptions(() => this.model, this.disposables, _options),
+                tree: this,
+                stickyScrollProvider: () => this.stickyScrollController
+            }
         ));
         this.setupModel(this.model);
         if (_options.keyboardSupport !== false) {
-            const onKeyDown = Event.chain(this.view.onKeyDown, $ => ( $.filter(e => !isEditableElement(e.target))
-                .map(e => ( new StandardKeyboardEvent(e)))));
+            const onKeyDown = Event.chain(this.view.onKeyDown, $ => ( $.filter(e => !isEditableElement(e.target)).map(e => ( new StandardKeyboardEvent(e)))));
             Event.chain(onKeyDown, $ => $.filter(e => e.keyCode === KeyCode.LeftArrow))(this.onLeftArrow, this, this.disposables);
             Event.chain(onKeyDown, $ => $.filter(e => e.keyCode === KeyCode.RightArrow))(this.onRightArrow, this, this.disposables);
             Event.chain(onKeyDown, $ => $.filter(e => e.keyCode === KeyCode.Space))(this.onSpace, this, this.disposables);
@@ -1991,15 +2207,14 @@ class AbstractTree {
                 styles: _options.findWidgetStyles,
                 defaultFindMode: _options.defaultFindMode,
                 defaultFindMatchType: _options.defaultFindMatchType,
-                showNotFoundMessage: _options.showNotFoundMessage,
+                showNotFoundMessage: _options.showNotFoundMessage
             };
             this.findController = this.disposables.add(( new FindController(this, this.findFilter, _options.contextViewProvider, findOptions)));
             this.focusNavigationFilter = node => this.findController.shouldAllowFocus(node);
             this.onDidChangeFindOpenState = this.findController.onDidChangeOpenState;
             this.onDidChangeFindMode = this.findController.onDidChangeMode;
             this.onDidChangeFindMatchType = this.findController.onDidChangeMatchType;
-        }
-        else {
+        } else {
             this.onDidChangeFindMode = Event.None;
             this.onDidChangeFindMatchType = Event.None;
         }
@@ -2008,10 +2223,13 @@ class AbstractTree {
             this.onDidChangeStickyScrollFocused = this.stickyScrollController.onDidChangeHasFocus;
         }
         this.styleElement = createStyleSheet(this.view.getHTMLElement());
-        this.getHTMLElement().classList.toggle('always', this._options.renderIndentGuides === RenderIndentGuides.Always);
+        this.getHTMLElement().classList.toggle("always", this._options.renderIndentGuides === RenderIndentGuides.Always);
     }
     updateOptions(optionsUpdate = {}) {
-        this._options = { ...this._options, ...optionsUpdate };
+        this._options = {
+            ...this._options,
+            ...optionsUpdate
+        };
         for (const renderer of this.renderers) {
             renderer.updateOptions(optionsUpdate);
         }
@@ -2019,7 +2237,7 @@ class AbstractTree {
         this.findController?.updateOptions(optionsUpdate);
         this.updateStickyScroll(optionsUpdate);
         this._onDidUpdateOptions.fire(this._options);
-        this.getHTMLElement().classList.toggle('always', this._options.renderIndentGuides === RenderIndentGuides.Always);
+        this.getHTMLElement().classList.toggle("always", this._options.renderIndentGuides === RenderIndentGuides.Always);
     }
     get options() {
         return this._options;
@@ -2035,8 +2253,7 @@ class AbstractTree {
                 this._options
             ));
             this.onDidChangeStickyScrollFocused = this.stickyScrollController.onDidChangeHasFocus;
-        }
-        else if (this.stickyScrollController && !this._options.enableStickyScroll) {
+        } else if (this.stickyScrollController && !this._options.enableStickyScroll) {
             this.onDidChangeStickyScrollFocused = Event.None;
             this.stickyScrollController.dispose();
             this.stickyScrollController = undefined;
@@ -2111,8 +2328,7 @@ class AbstractTree {
     domFocus() {
         if (this.stickyScrollController?.focusedLast()) {
             this.stickyScrollController.domFocus();
-        }
-        else {
+        } else {
             this.view.domFocus();
         }
     }
@@ -2126,37 +2342,70 @@ class AbstractTree {
         const suffix = `.${this.view.domId}`;
         const content = [];
         if (styles.treeIndentGuidesStroke) {
-            content.push(`.monaco-list${suffix}:hover .monaco-tl-indent > .indent-guide, .monaco-list${suffix}.always .monaco-tl-indent > .indent-guide  { opacity: 1; border-color: ${styles.treeInactiveIndentGuidesStroke}; }`);
-            content.push(`.monaco-list${suffix} .monaco-tl-indent > .indent-guide.active { opacity: 1; border-color: ${styles.treeIndentGuidesStroke}; }`);
+            content.push(
+                `.monaco-list${suffix}:hover .monaco-tl-indent > .indent-guide, .monaco-list${suffix}.always .monaco-tl-indent > .indent-guide  { opacity: 1; border-color: ${styles.treeInactiveIndentGuidesStroke}; }`
+            );
+            content.push(
+                `.monaco-list${suffix} .monaco-tl-indent > .indent-guide.active { opacity: 1; border-color: ${styles.treeIndentGuidesStroke}; }`
+            );
         }
         const stickyScrollBackground = styles.treeStickyScrollBackground ?? styles.listBackground;
         if (stickyScrollBackground) {
-            content.push(`.monaco-list${suffix} .monaco-scrollable-element .monaco-tree-sticky-container { background-color: ${stickyScrollBackground}; }`);
-            content.push(`.monaco-list${suffix} .monaco-scrollable-element .monaco-tree-sticky-container .monaco-tree-sticky-row { background-color: ${stickyScrollBackground}; }`);
+            content.push(
+                `.monaco-list${suffix} .monaco-scrollable-element .monaco-tree-sticky-container { background-color: ${stickyScrollBackground}; }`
+            );
+            content.push(
+                `.monaco-list${suffix} .monaco-scrollable-element .monaco-tree-sticky-container .monaco-tree-sticky-row { background-color: ${stickyScrollBackground}; }`
+            );
         }
         if (styles.treeStickyScrollBorder) {
-            content.push(`.monaco-list${suffix} .monaco-scrollable-element .monaco-tree-sticky-container { border-bottom: 1px solid ${styles.treeStickyScrollBorder}; }`);
+            content.push(
+                `.monaco-list${suffix} .monaco-scrollable-element .monaco-tree-sticky-container { border-bottom: 1px solid ${styles.treeStickyScrollBorder}; }`
+            );
         }
         if (styles.treeStickyScrollShadow) {
-            content.push(`.monaco-list${suffix} .monaco-scrollable-element .monaco-tree-sticky-container .monaco-tree-sticky-container-shadow { box-shadow: ${styles.treeStickyScrollShadow} 0 6px 6px -6px inset; height: 3px; }`);
+            content.push(
+                `.monaco-list${suffix} .monaco-scrollable-element .monaco-tree-sticky-container .monaco-tree-sticky-container-shadow { box-shadow: ${styles.treeStickyScrollShadow} 0 6px 6px -6px inset; height: 3px; }`
+            );
         }
         if (styles.listFocusForeground) {
-            content.push(`.monaco-list${suffix}.sticky-scroll-focused .monaco-scrollable-element .monaco-tree-sticky-container:focus .monaco-list-row.focused { color: ${styles.listFocusForeground}; }`);
-            content.push(`.monaco-list${suffix}:not(.sticky-scroll-focused) .monaco-scrollable-element .monaco-tree-sticky-container .monaco-list-row.focused { color: inherit; }`);
-        }
-        const focusAndSelectionOutline = asCssValueWithDefault(styles.listFocusAndSelectionOutline, asCssValueWithDefault(styles.listSelectionOutline, styles.listFocusOutline ?? ''));
+            content.push(
+                `.monaco-list${suffix}.sticky-scroll-focused .monaco-scrollable-element .monaco-tree-sticky-container:focus .monaco-list-row.focused { color: ${styles.listFocusForeground}; }`
+            );
+            content.push(
+                `.monaco-list${suffix}:not(.sticky-scroll-focused) .monaco-scrollable-element .monaco-tree-sticky-container .monaco-list-row.focused { color: inherit; }`
+            );
+        }
+        const focusAndSelectionOutline = asCssValueWithDefault(
+            styles.listFocusAndSelectionOutline,
+            asCssValueWithDefault(styles.listSelectionOutline, styles.listFocusOutline ?? "")
+        );
         if (focusAndSelectionOutline) {
-            content.push(`.monaco-list${suffix}.sticky-scroll-focused .monaco-scrollable-element .monaco-tree-sticky-container:focus .monaco-list-row.focused.selected { outline: 1px solid ${focusAndSelectionOutline}; outline-offset: -1px;}`);
-            content.push(`.monaco-list${suffix}:not(.sticky-scroll-focused) .monaco-scrollable-element .monaco-tree-sticky-container .monaco-list-row.focused.selected { outline: inherit;}`);
+            content.push(
+                `.monaco-list${suffix}.sticky-scroll-focused .monaco-scrollable-element .monaco-tree-sticky-container:focus .monaco-list-row.focused.selected { outline: 1px solid ${focusAndSelectionOutline}; outline-offset: -1px;}`
+            );
+            content.push(
+                `.monaco-list${suffix}:not(.sticky-scroll-focused) .monaco-scrollable-element .monaco-tree-sticky-container .monaco-list-row.focused.selected { outline: inherit;}`
+            );
         }
         if (styles.listFocusOutline) {
-            content.push(`.monaco-list${suffix}.sticky-scroll-focused .monaco-scrollable-element .monaco-tree-sticky-container:focus .monaco-list-row.focused { outline: 1px solid ${styles.listFocusOutline}; outline-offset: -1px; }`);
-            content.push(`.monaco-list${suffix}:not(.sticky-scroll-focused) .monaco-scrollable-element .monaco-tree-sticky-container .monaco-list-row.focused { outline: inherit; }`);
-            content.push(`.context-menu-visible .monaco-list${suffix}.last-focused.sticky-scroll-focused .monaco-scrollable-element .monaco-tree-sticky-container .monaco-list-row.passive-focused { outline: 1px solid ${styles.listFocusOutline}; outline-offset: -1px; }`);
-            content.push(`.context-menu-visible .monaco-list${suffix}.last-focused.sticky-scroll-focused .monaco-list-rows .monaco-list-row.focused { outline: inherit; }`);
-            content.push(`.context-menu-visible .monaco-list${suffix}.last-focused:not(.sticky-scroll-focused) .monaco-tree-sticky-container .monaco-list-rows .monaco-list-row.focused { outline: inherit; }`);
-        }
-        this.styleElement.textContent = content.join('\n');
+            content.push(
+                `.monaco-list${suffix}.sticky-scroll-focused .monaco-scrollable-element .monaco-tree-sticky-container:focus .monaco-list-row.focused { outline: 1px solid ${styles.listFocusOutline}; outline-offset: -1px; }`
+            );
+            content.push(
+                `.monaco-list${suffix}:not(.sticky-scroll-focused) .monaco-scrollable-element .monaco-tree-sticky-container .monaco-list-row.focused { outline: inherit; }`
+            );
+            content.push(
+                `.context-menu-visible .monaco-list${suffix}.last-focused.sticky-scroll-focused .monaco-scrollable-element .monaco-tree-sticky-container .monaco-list-row.passive-focused { outline: 1px solid ${styles.listFocusOutline}; outline-offset: -1px; }`
+            );
+            content.push(
+                `.context-menu-visible .monaco-list${suffix}.last-focused.sticky-scroll-focused .monaco-list-rows .monaco-list-row.focused { outline: inherit; }`
+            );
+            content.push(
+                `.context-menu-visible .monaco-list${suffix}.last-focused:not(.sticky-scroll-focused) .monaco-tree-sticky-container .monaco-list-rows .monaco-list-row.focused { outline: inherit; }`
+            );
+        }
+        this.styleElement.textContent = content.join("\n");
         this.view.style(styles);
     }
     getParentElement(location) {
@@ -2214,7 +2463,7 @@ class AbstractTree {
         this.model.refilter();
     }
     setAnchor(element) {
-        if (typeof element === 'undefined') {
+        if (typeof element === "undefined") {
             return this.view.setAnchor(undefined);
         }
         this.eventBufferer.bufferEvents(() => {
@@ -2248,22 +2497,44 @@ class AbstractTree {
             this.view.setFocus(indexes, browserEvent, true);
         });
     }
-    focusNext(n = 1, loop = false, browserEvent, filter = (isKeyboardEvent(browserEvent) && browserEvent.altKey) ? undefined : this.focusNavigationFilter) {
+    focusNext(
+        n = 1,
+        loop = false,
+        browserEvent,
+        filter = (isKeyboardEvent(browserEvent) && browserEvent.altKey) ? undefined : this.focusNavigationFilter
+    ) {
         this.view.focusNext(n, loop, browserEvent, filter);
     }
-    focusPrevious(n = 1, loop = false, browserEvent, filter = (isKeyboardEvent(browserEvent) && browserEvent.altKey) ? undefined : this.focusNavigationFilter) {
+    focusPrevious(
+        n = 1,
+        loop = false,
+        browserEvent,
+        filter = (isKeyboardEvent(browserEvent) && browserEvent.altKey) ? undefined : this.focusNavigationFilter
+    ) {
         this.view.focusPrevious(n, loop, browserEvent, filter);
     }
-    focusNextPage(browserEvent, filter = (isKeyboardEvent(browserEvent) && browserEvent.altKey) ? undefined : this.focusNavigationFilter) {
+    focusNextPage(
+        browserEvent,
+        filter = (isKeyboardEvent(browserEvent) && browserEvent.altKey) ? undefined : this.focusNavigationFilter
+    ) {
         return this.view.focusNextPage(browserEvent, filter);
     }
-    focusPreviousPage(browserEvent, filter = (isKeyboardEvent(browserEvent) && browserEvent.altKey) ? undefined : this.focusNavigationFilter) {
+    focusPreviousPage(
+        browserEvent,
+        filter = (isKeyboardEvent(browserEvent) && browserEvent.altKey) ? undefined : this.focusNavigationFilter
+    ) {
         return this.view.focusPreviousPage(browserEvent, filter, () => this.stickyScrollController?.height ?? 0);
     }
-    focusLast(browserEvent, filter = (isKeyboardEvent(browserEvent) && browserEvent.altKey) ? undefined : this.focusNavigationFilter) {
+    focusLast(
+        browserEvent,
+        filter = (isKeyboardEvent(browserEvent) && browserEvent.altKey) ? undefined : this.focusNavigationFilter
+    ) {
         this.view.focusLast(browserEvent, filter);
     }
-    focusFirst(browserEvent, filter = (isKeyboardEvent(browserEvent) && browserEvent.altKey) ? undefined : this.focusNavigationFilter) {
+    focusFirst(
+        browserEvent,
+        filter = (isKeyboardEvent(browserEvent) && browserEvent.altKey) ? undefined : this.focusNavigationFilter
+    ) {
         this.view.focusFirst(browserEvent, filter);
     }
     getFocus() {
@@ -2284,8 +2555,7 @@ class AbstractTree {
         }
         if (!this.stickyScrollController) {
             this.view.reveal(index, relativeTop);
-        }
-        else {
+        } else {
             const paddingTop = this.stickyScrollController.nodePositionTopBelowWidget(this.getNode(location));
             this.view.reveal(index, relativeTop, paddingTop);
         }
@@ -2300,9 +2570,9 @@ class AbstractTree {
     }
     getViewState(identityProvider = this.options.identityProvider) {
         if (!identityProvider) {
-            throw ( new TreeError(this._user, 'Can\'t get tree view state without an identity provider'));
+            throw ( new TreeError(this._user, "Can't get tree view state without an identity provider"));
         }
-        const getId = (element) => ( identityProvider.getId(element).toString());
+        const getId = element => ( identityProvider.getId(element).toString());
         const state = AbstractTreeViewState.empty(this.scrollTop);
         for (const focus of this.getFocus()) {
             state.focus.add(getId(focus));
@@ -2375,7 +2645,13 @@ class AbstractTree {
     }
     setupModel(model) {
         this.modelDisposables.clear();
-        this.modelDisposables.add(model.onDidSpliceRenderedNodes(({ start, deleteCount, elements }) => this.view.splice(start, deleteCount, elements)));
+        this.modelDisposables.add(model.onDidSpliceRenderedNodes((
+            {
+                start,
+                deleteCount,
+                elements
+            }
+        ) => this.view.splice(start, deleteCount, elements)));
         const onDidModelSplice = Event.forEach(model.onDidSpliceModel, e => {
             this.eventBufferer.bufferEvents(() => {
                 this.focus.onDidModelSplice(e);
@@ -2385,23 +2661,36 @@ class AbstractTree {
         onDidModelSplice(() => null, null, this.modelDisposables);
         const activeNodesEmitter = this.modelDisposables.add(( new Emitter()));
         const activeNodesDebounce = this.modelDisposables.add(( new Delayer(0)));
-        this.modelDisposables.add(Event.any(onDidModelSplice, this.focus.onDidChange, this.selection.onDidChange)(() => {
-            activeNodesDebounce.trigger(() => {
-                const set = ( new Set());
-                for (const node of this.focus.getNodes()) {
-                    set.add(node);
-                }
-                for (const node of this.selection.getNodes()) {
-                    set.add(node);
-                }
-                activeNodesEmitter.fire([...( set.values())]);
-            });
-        }));
+        this.modelDisposables.add(
+            Event.any(onDidModelSplice, this.focus.onDidChange, this.selection.onDidChange)(() => {
+                activeNodesDebounce.trigger(() => {
+                    const set = ( new Set());
+                    for (const node of this.focus.getNodes()) {
+                        set.add(node);
+                    }
+                    for (const node of this.selection.getNodes()) {
+                        set.add(node);
+                    }
+                    activeNodesEmitter.fire([...( set.values())]);
+                });
+            })
+        );
         this.onDidChangeActiveNodesRelay.input = activeNodesEmitter.event;
         this.onDidChangeModelRelay.input = Event.signal(model.onDidSpliceModel);
         this.onDidChangeCollapseStateRelay.input = model.onDidChangeCollapseState;
         this.onDidChangeRenderNodeCountRelay.input = model.onDidChangeRenderNodeCount;
         this.onDidSpliceModelRelay.input = model.onDidSpliceModel;
+        if (isMacintosh) {
+            this.modelDisposables.add(model.onDidChangeCollapseState(e => {
+                const {
+                    node,
+                    deep
+                } = e;
+                if (node.collapsible && !deep && this.isDOMFocused()) {
+                    alert(node.collapsed ? ( localize(40, "collapsed")) : ( localize(41, "expanded")));
+                }
+            }));
+        }
     }
     navigate(start) {
         return ( new TreeNavigator(this.view, this.model, start));
@@ -2422,8 +2711,7 @@ class TreeNavigator {
         this.model = model;
         if (start) {
             this.index = this.model.getListIndex(start);
-        }
-        else {
+        } else {
             this.index = -1;
         }
     }