@codingame/monaco-vscode-api 10.1.3 → 11.0.0

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

@@ -1,23 +1,24 @@
-import { isEditableElement, createStyleSheet, isActiveElement, asCssValueWithDefault, isKeyboardEvent, append, $, clearNode, addDisposableListener, hasParentWithClass, h, getWindow } from '../../dom.js';
+import { append, $, clearNode, h, getWindow, addDisposableListener, isKeyboardEvent, hasParentWithClass, isEditableElement, createStyleSheet, isActiveElement } from '../../dom.js';
+import { asCssValueWithDefault } from '../../cssValue.js';
 import { DomEmitter } from '../../event.js';
 import { StandardKeyboardEvent } from '../../keyboardEvent.js';
 import { ActionBar } from '../actionbar/actionbar.js';
 import { FindInput } from '../findinput/findInput.js';
 import { unthemedInboxStyles } from '../inputbox/inputBox.js';
 import { ElementsDragAndDropData } from '../list/listView.js';
-import { isStickyScrollContainer, isStickyScrollElement, List, MouseController, isButton, isMonacoEditor, isMonacoCustomToggle, isActionItem } from '../list/listWidget.js';
+import { isStickyScrollContainer, isStickyScrollElement, MouseController, isButton, isMonacoEditor, isMonacoCustomToggle, isActionItem, List } from '../list/listWidget.js';
 import { Toggle, unthemedToggleStyles } from '../toggle/toggle.js';
 import { isFilterResult, getVisibleState } from './indexTreeModel.js';
 import { TreeMouseEventTarget, TreeError } from './tree.js';
 import { Action } from '../../../common/actions.js';
-import { equals, distinct, range } from '../../../common/arrays.js';
-import { Delayer, disposableTimeout, timeout } from '../../../common/async.js';
+import { range, equals, distinct } from '../../../common/arrays.js';
+import { disposableTimeout, timeout, Delayer } from '../../../common/async.js';
 import { Codicon } from '../../../common/codicons.js';
 import { ThemeIcon } from '../../../common/themables.js';
 import { SetMap } from '../../../common/map.js';
-import { Event, EventBufferer, Emitter, Relay } from '../../../common/event.js';
+import { Event, Emitter, EventBufferer, Relay } from '../../../common/event.js';
 import { FuzzyScore, fuzzyScore } from '../../../common/filters.js';
-import { DisposableStore, dispose, Disposable, toDisposable } from '../../../common/lifecycle.js';
+import { Disposable, DisposableStore, toDisposable, dispose } from '../../../common/lifecycle.js';
 import { clamp } from '../../../common/numbers.js';
 import { isNumber } from '../../../common/types.js';
 import './media/tree.css.js';
@@ -28,6 +29,7 @@ import '../../../common/observableInternal/derived.js';
 import '../../../common/cancellation.js';
 import { constObservable } from '../../../common/observableInternal/utils.js';
 import { alert } from '../aria/aria.js';
+
 class TreeElementsDragAndDropData extends ElementsDragAndDropData {
     set context(context) {
         this.data.context = context;
@@ -441,6 +443,17 @@ class TreeRenderer {
         dispose(this.disposables);
     }
 }
+function contiguousFuzzyScore(patternLower, wordLower) {
+    const index = wordLower.toLowerCase().indexOf(patternLower);
+    let score;
+    if (index > -1) {
+        score = [Number.MAX_SAFE_INTEGER, 0];
+        for (let i = patternLower.length; i > 0; i--) {
+            score.push(index + i - 1);
+        }
+    }
+    return score;
+}
 class FindFilter {
     get totalCount() { return this._totalCount; }
     get matchCount() { return this._matchCount; }
@@ -490,13 +503,7 @@ class FindFilter {
             }
             let score;
             if (this.tree.findMatchType === TreeFindMatchType.Contiguous) {
-                const index = labelStr.toLowerCase().indexOf(this._lowercasePattern);
-                if (index > -1) {
-                    score = [Number.MAX_SAFE_INTEGER, 0];
-                    for (let i = this._lowercasePattern.length; i > 0; i--) {
-                        score.push(index + i - 1);
-                    }
-                }
+                score = contiguousFuzzyScore(this._lowercasePattern, labelStr.toLowerCase());
             }
             else {
                 score = fuzzyScore(this._pattern, this._lowercasePattern, 0, labelStr, labelStr.toLowerCase(), 0, { firstMatchCanBeWeak: true, boostFullMatch: true });
@@ -627,7 +634,7 @@ class FindWidget extends Disposable {
             toggle => ( (Event.map(toggle.onChange, () => ({ id: toggle.id, isChecked: toggle.checked }))))
         ))));
         this.findInput = this._register(( (new FindInput(this.elements.findInput, contextViewProvider, {
-            label: ( localize(4946, "Type to search")),
+            label: ( localize(4547, "Type to search")),
             placeholder,
             additionalToggles: this.toggles,
             showCommonFindToggles: false,
@@ -665,7 +672,7 @@ class FindWidget extends Disposable {
                 return;
             }
         }));
-        const closeAction = this._register(( (new Action('close', ( localize(4947, "Close")), 'codicon codicon-close', true, () => this.dispose()))));
+        const closeAction = this._register(( (new Action('close', ( localize(4548, "Close")), 'codicon codicon-close', true, () => this.dispose()))));
         this.actionbar.push(closeAction, { icon: true, label: false });
         const onGrabMouseDown = this._register(( (new DomEmitter(this.elements.grab, 'mousedown'))));
         this._register(onGrabMouseDown.event(e => {
@@ -799,7 +806,7 @@ class AbstractFindController {
         this.enabledDisposables = ( (new DisposableStore()));
         this.disposables = ( (new DisposableStore()));
         this.toggles = ( (new FindToggles(options.toggles ?? [])));
-        this._placeholder = options.placeholder ?? ( localize(4946, "Type to search"));
+        this._placeholder = options.placeholder ?? ( localize(4547, "Type to search"));
     }
     isOpened() {
         return !!this.widget;
@@ -856,7 +863,7 @@ class AbstractFindController {
     renderMessage(showNotFound) {
         if (showNotFound) {
             if (this.tree.options.showNotFoundMessage ?? true) {
-                this.widget?.showMessage({ type: 2 , content: ( localize(4948, "No results found.")) });
+                this.widget?.showMessage({ type: 2 , content: ( localize(4549, "No results found.")) });
             }
             else {
                 this.widget?.showMessage({ type: 2  });
@@ -868,10 +875,10 @@ class AbstractFindController {
     }
     alertResults(results) {
         if (!results) {
-            alert(( localize(4949, "No results")));
+            alert(( localize(4550, "No results")));
         }
         else {
-            alert(( localize(4950, "{0} results", results)));
+            alert(( localize(4551, "{0} results", results)));
         }
     }
     layout(width) {
@@ -893,7 +900,7 @@ class FindController extends AbstractFindController {
         }
         const isFilterMode = mode === TreeFindMode.Filter;
         this.updateToggleState(DefaultTreeToggles.Mode, isFilterMode);
-        this.placeholder = isFilterMode ? ( localize(4951, "Type to filter")) : ( localize(4946, "Type to search"));
+        this.placeholder = isFilterMode ? ( localize(4552, "Type to filter")) : ( localize(4547, "Type to search"));
         this.tree.refilter();
         this.render();
         this._onDidChangeMode.fire(mode);
@@ -914,12 +921,12 @@ class FindController extends AbstractFindController {
         const toggleContributions = [{
                 id: DefaultTreeToggles.Mode,
                 icon: Codicon.listFilter,
-                title: ( localize(4952, "Filter")),
+                title: ( localize(4553, "Filter")),
                 isChecked: defaultFindMode === TreeFindMode.Filter,
             }, {
                 id: DefaultTreeToggles.MatchType,
                 icon: Codicon.searchFuzzy,
-                title: ( localize(4953, "Fuzzy Match")),
+                title: ( localize(4554, "Fuzzy Match")),
                 isChecked: defaultFindMatchType === TreeFindMatchType.Fuzzy,
             }];
         super(tree, filter, contextViewProvider, { ...options, toggles: toggleContributions });
@@ -1003,6 +1010,11 @@ class StickyScrollState {
     equal(state) {
         return equals(this.stickyNodes, state.stickyNodes, stickyScrollNodeStateEquals);
     }
+    contains(element) {
+        return (
+             (this.stickyNodes.some(node => node.node.element === element.element))
+        );
+    }
     lastNodePartiallyVisible() {
         if (this.count === 0) {
             return false;
@@ -1062,6 +1074,26 @@ 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) => {
+            const state = this._widget.state;
+            if (!state) {
+                return;
+            }
+            const hasRemovedStickyNode = e.deleteCount > 0 && ( (state.stickyNodes.some(
+                stickyNode => !( (this.model.has(this.model.getNodeLocation(stickyNode.node))))
+            )));
+            if (hasRemovedStickyNode) {
+                this.update();
+                return;
+            }
+            const shouldRerenderStickyNodes = ( (state.stickyNodes.some(stickyNode => {
+                const listIndex = this.model.getListIndex(this.model.getNodeLocation(stickyNode.node));
+                return listIndex >= e.start && listIndex < e.start + e.deleteCount && state.contains(stickyNode.node);
+            })));
+            if (shouldRerenderStickyNodes) {
+                this._widget.rerender();
+            }
+        }));
         this.update();
     }
     get height() {
@@ -1265,6 +1297,7 @@ class StickyScrollController extends Disposable {
     }
 }
 class StickyScrollWidget {
+    get state() { return this._previousState; }
     constructor(container, view, tree, treeRenderers, treeDelegate, accessibilityProvider) {
         this.view = view;
         this.tree = tree;
@@ -1314,21 +1347,29 @@ class StickyScrollWidget {
             this._previousElements[this._previousState.count - 1].style.top = `${lastStickyNode.position}px`;
         }
         else {
-            this._previousStateDisposables.clear();
-            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);
-                elements[stickyIndex] = element;
-                this._rootDomNode.appendChild(element);
-                this._previousStateDisposables.add(disposable);
-            }
-            this.stickyScrollFocus.updateElements(elements, state);
-            this._previousElements = elements;
+            this.renderState(state);
         }
         this._previousState = state;
         this._rootDomNode.style.height = `${lastStickyNode.position + lastStickyNode.height}px`;
     }
+    renderState(state) {
+        this._previousStateDisposables.clear();
+        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);
+            elements[stickyIndex] = element;
+            this._rootDomNode.appendChild(element);
+            this._previousStateDisposables.add(disposable);
+        }
+        this.stickyScrollFocus.updateElements(elements, state);
+        this._previousElements = elements;
+    }
+    rerender() {
+        if (this._previousState) {
+            this.renderState(this._previousState);
+        }
+    }
     createElement(stickyNode, stickyIndex, stickyNodesTotal) {
         const nodeIndex = stickyNode.startIndex;
         const stickyElement = document.createElement('div');
@@ -2504,4 +2545,5 @@ class TreeNavigator {
         return this.current();
     }
 }
-export { AbstractFindController, AbstractTree, AbstractTreeViewState, ComposedTreeDelegate, FindToggles, RenderIndentGuides, TreeFindMatchType, TreeFindMode, TreeRenderer };
+
+export { AbstractFindController, AbstractTree, AbstractTreeViewState, ComposedTreeDelegate, FindToggles, RenderIndentGuides, TreeFindMatchType, TreeFindMode, TreeRenderer, contiguousFuzzyScore };

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

@@ -2,8 +2,8 @@ import { ElementsDragAndDropData } from '../list/listView.js';
 import { AbstractFindController, ComposedTreeDelegate } from './abstractTree.js';
 import { isFilterResult, getVisibleState } from './indexTreeModel.js';
 import { ObjectTree, CompressibleObjectTree } from './objectTree.js';
-import { WeakMapper, ObjectTreeElementCollapseState, TreeError } from './tree.js';
-import { Promises, timeout, createCancelablePromise, TimeoutTimer } from '../../../common/async.js';
+import { TreeError, ObjectTreeElementCollapseState, WeakMapper } from './tree.js';
+import { TimeoutTimer, Promises, timeout, createCancelablePromise } from '../../../common/async.js';
 import { Codicon } from '../../../common/codicons.js';
 import { ThemeIcon } from '../../../common/themables.js';
 import { isCancellationError, onUnexpectedError } from '../../../common/errors.js';
@@ -12,7 +12,8 @@ import { Iterable } from '../../../common/iterator.js';
 import { DisposableStore, dispose } from '../../../common/lifecycle.js';
 import { isNumber, isIterable } from '../../../common/types.js';
 import { CancellationTokenSource } from '../../../common/cancellation.js';
-import { FuzzyScore, fuzzyScore } from '../../../common/filters.js';
+import { FuzzyScore } from '../../../common/filters.js';
+
 function createAsyncDataTreeNode(props) {
     return {
         ...props,
@@ -188,6 +189,9 @@ class AsyncFindTree {
     get totalNodes() {
         return this.cachedNodes.size;
     }
+    get results() {
+        return [...this._results];
+    }
     constructor(dataSource, identityProvider, sorter) {
         this.dataSource = dataSource;
         this.identityProvider = identityProvider;
@@ -195,11 +199,14 @@ class AsyncFindTree {
         this.cachedNodes = ( new Map());
         this.root = ( new AsyncFindTreeNode(undefined, '_AsyncFindTreeRoot_', this.sorter));
         this._totalLeafs = 0;
+        this._results = [];
         if (!dataSource.getParent) {
             throw ( new Error('Data source must implement `getParent`'));
         }
     }
-    add(element) {
+    add(result) {
+        this._results.push(result);
+        const element = result.element;
         const elementId = ( this.identityProvider.getId(element).toString());
         if (( this.cachedNodes.has(elementId))) {
             return;
@@ -229,20 +236,17 @@ class AsyncFindTree {
     }
 }
 class AsyncFindFilter {
-    get pattern() {
-        return this._pattern;
-    }
-    set pattern(pattern) {
-        this._pattern = pattern;
-        this._lowercasePattern = pattern.toLowerCase();
-    }
-    constructor(keyboardNavigationLabelProvider, _filter) {
-        this.keyboardNavigationLabelProvider = keyboardNavigationLabelProvider;
+    constructor(_filter) {
         this._filter = _filter;
-        this._pattern = '';
-        this._lowercasePattern = '';
+        this.pattern = '';
+        this.findFilterData = ( new Map());
         this.disposables = ( new DisposableStore());
     }
+    setFindResults(findResults) {
+        this.findFilterData = ( new Map(( findResults.
+            filter(result => result.filterdata !== undefined).
+            map(result => [result.element, result.filterdata]))));
+    }
     filter(element, parentVisibility) {
         let visibility = 1 ;
         if (this._filter) {
@@ -260,22 +264,9 @@ class AsyncFindFilter {
                 return false;
             }
         }
-        if (!this._pattern) {
-            return { data: FuzzyScore.Default, visibility };
-        }
-        const label = this.keyboardNavigationLabelProvider.getKeyboardNavigationLabel(element.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 };
-            }
-            const score = fuzzyScore(this._pattern, this._lowercasePattern, 0, labelStr, labelStr.toLowerCase(), 0, { firstMatchCanBeWeak: true, boostFullMatch: true });
-            if (score) {
-                return labels.length === 1 ?
-                    { data: score, visibility } :
-                    { data: { label: labelStr, score: score }, visibility };
-            }
+        const filterData = this.findFilterData.get(element.element);
+        if (filterData !== undefined) {
+            return { data: filterData, visibility };
         }
         return { data: FuzzyScore.Default, visibility };
     }
@@ -375,6 +366,7 @@ class AsyncFindController extends AbstractFindController {
                 return;
             }
             else {
+                this.filter.setFindResults([]);
                 this.tree.setChildren(null, []);
             }
         }, 600);
@@ -386,6 +378,7 @@ class AsyncFindController extends AbstractFindController {
         }
         this.schedule(() => {
             this.setFindModeActive(true);
+            this.filter.setFindResults(findTree.results);
             this.tree.setChildren(null, rootChildren);
             this.renderMessage(rootChildren.length === 0);
             this.alertResults(findTree.totalLeafs);
@@ -575,7 +568,7 @@ class AsyncDataTree {
         this.nodes.set(null, this.root);
         this.tree.onDidChangeCollapseState(this._onDidChangeCollapseState, this, this.disposables);
         if (asyncFindEnabled) {
-            const findFilter = this.disposables.add(( new AsyncFindFilter(options.keyboardNavigationLabelProvider, this.tree.options.filter)));
+            const findFilter = this.disposables.add(( new AsyncFindFilter(this.tree.options.filter)));
             const findOptions = { styles: options.findWidgetStyles, showNotFoundMessage: options.showNotFoundMessage };
             this.findController = this.disposables.add(( new AsyncFindController(
                 user,
@@ -899,7 +892,11 @@ class AsyncDataTree {
         }
         const node = this.nodes.get((element === this.root.element ? null : element));
         if (!node) {
-            throw ( new TreeError(this.user, `Data tree node not found: ${element}`));
+            const nodeIdentity = this.identityProvider?.getId(element).toString();
+            throw ( new TreeError(
+                this.user,
+                `Data tree node not found${nodeIdentity ? `: ${nodeIdentity}` : ''}`
+            ));
         }
         return node;
     }
@@ -1404,4 +1401,5 @@ class AsyncDataTreeNavigator {
         return this.current();
     }
 }
+
 export { AsyncDataTree, CompressibleAsyncDataTree };

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

@@ -1,9 +1,10 @@
 import { getVisibleState, isFilterResult } from './indexTreeModel.js';
 import { ObjectTreeModel } from './objectTreeModel.js';
-import { WeakMapper, TreeError } from './tree.js';
+import { TreeError, WeakMapper } from './tree.js';
 import { equals } from '../../../common/arrays.js';
 import { Event } from '../../../common/event.js';
 import { Iterable } from '../../../common/iterator.js';
+
 function noCompress(element) {
     const elements = [element.element];
     const incompressible = element.incompressible || false;
@@ -380,4 +381,5 @@ class CompressibleObjectTreeModel {
         return this.model.getNode(location);
     }
 }
+
 export { CompressedObjectTreeModel, CompressibleObjectTreeModel, DefaultElementMapper, compress, decompress };

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

@@ -2,6 +2,7 @@ import { AbstractTree } from './abstractTree.js';
 import { ObjectTreeModel } from './objectTreeModel.js';
 import { TreeError } from './tree.js';
 import { Iterable } from '../../../common/iterator.js';
+
 class DataTree extends AbstractTree {
     constructor(user, container, delegate, renderers, dataSource, options = {}) {
         super(user, container, delegate, renderers, options);
@@ -110,4 +111,5 @@ class DataTree extends AbstractTree {
         return ( new ObjectTreeModel(user, options));
     }
 }
+
 export { DataTree };

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

@@ -5,6 +5,7 @@ import { MicrotaskDelay } from '../../../common/symbols.js';
 import { LcsDiff } from '../../../common/diff/diff.js';
 import { EventBufferer, Emitter } from '../../../common/event.js';
 import { Iterable } from '../../../common/iterator.js';
+
 function isFilterResult(obj) {
     return typeof obj === 'object' && 'visibility' in obj && 'data' in obj;
 }
@@ -151,11 +152,6 @@ class IndexTreeModel {
             }
         }
         parentNode.visibleChildrenCount += insertedVisibleChildrenCount - deletedVisibleChildrenCount;
-        if (revealed && visible) {
-            const visibleDeleteCount = deletedNodes.reduce((r, node) => r + (node.visible ? node.renderNodeCount : 0), 0);
-            this._updateAncestorsRenderNodeCount(parentNode, renderNodeCount - visibleDeleteCount);
-            this._onDidSpliceRenderedNodes.fire({ start: listIndex, deleteCount: visibleDeleteCount, elements: treeListElementsToInsert });
-        }
         if (deletedNodes.length > 0 && onDidDeleteNode) {
             const visit = (node) => {
                 onDidDeleteNode(node);
@@ -163,6 +159,11 @@ class IndexTreeModel {
             };
             deletedNodes.forEach(visit);
         }
+        if (revealed && visible) {
+            const visibleDeleteCount = deletedNodes.reduce((r, node) => r + (node.visible ? node.renderNodeCount : 0), 0);
+            this._updateAncestorsRenderNodeCount(parentNode, renderNodeCount - visibleDeleteCount);
+            this._onDidSpliceRenderedNodes.fire({ start: listIndex, deleteCount: visibleDeleteCount, elements: treeListElementsToInsert });
+        }
         this._onDidSpliceModel.fire({ insertedNodes: nodesToInsert, deletedNodes });
         let node = parentNode;
         while (node) {
@@ -532,4 +533,5 @@ class IndexTreeModel {
         return this._getLastElementAncestor(node.children[node.children.length - 1]);
     }
 }
+
 export { IndexTreeModel, getVisibleState, isFilterResult };

package/vscode/src/vs/base/browser/ui/tree/media/tree.css.js

@@ -1,4 +1,6 @@
 import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+
 var css = ".monaco-tl-row{align-items:center;display:flex;height:100%;position:relative}.monaco-tl-row.disabled{cursor:default}.monaco-tl-indent{height:100%;left:16px;pointer-events:none;position:absolute;top:0}.hide-arrows .monaco-tl-indent{left:12px}.monaco-tl-indent>.indent-guide{border-left:1px solid transparent;box-sizing:border-box;display:inline-block;height:100%}.monaco-workbench:not(.reduce-motion) .monaco-tl-indent>.indent-guide{transition:border-color .1s linear}.monaco-tl-contents,.monaco-tl-twistie{height:100%}.monaco-tl-twistie{align-items:center;display:flex!important;flex-shrink:0;font-size:10px;justify-content:center;padding-right:6px;text-align:right;transform:translateX(3px);width:16px}.monaco-tl-contents{flex:1;overflow:hidden}.monaco-tl-twistie:before{border-radius:20px}.monaco-tl-twistie.collapsed:before{transform:rotate(-90deg)}.monaco-tl-twistie.codicon-tree-item-loading:before{animation:codicon-spin 1.25s steps(30) infinite}.monaco-tree-type-filter{border:1px solid var(--vscode-widget-border);border-bottom-left-radius:4px;border-bottom-right-radius:4px;display:flex;margin:0 6px;max-width:200px;padding:3px;position:absolute;top:0;z-index:100}.monaco-workbench:not(.reduce-motion) .monaco-tree-type-filter{transition:top .3s}.monaco-tree-type-filter.disabled{top:-40px!important}.monaco-tree-type-filter-grab{align-items:center;cursor:grab;display:flex!important;justify-content:center;margin-right:2px}.monaco-tree-type-filter-grab.grabbing{cursor:grabbing}.monaco-tree-type-filter-input{flex:1}.monaco-tree-type-filter-input .monaco-inputbox{height:23px}.monaco-tree-type-filter-input .monaco-inputbox>.ibwrapper>.input,.monaco-tree-type-filter-input .monaco-inputbox>.ibwrapper>.mirror{padding:2px 4px}.monaco-tree-type-filter-input .monaco-findInput>.controls{top:2px}.monaco-tree-type-filter-actionbar{margin-left:4px}.monaco-tree-type-filter-actionbar .monaco-action-bar .action-label{padding:2px}.monaco-list .monaco-scrollable-element .monaco-tree-sticky-container{background-color:var(--vscode-sideBar-background);height:0;left:0;position:absolute;top:0;width:100%;z-index:13}.monaco-list .monaco-scrollable-element .monaco-tree-sticky-container .monaco-tree-sticky-row.monaco-list-row{background-color:var(--vscode-sideBar-background);opacity:1!important;overflow:hidden;position:absolute;width:100%}.monaco-list .monaco-scrollable-element .monaco-tree-sticky-container .monaco-tree-sticky-row:hover{background-color:var(--vscode-list-hoverBackground)!important;cursor:pointer}.monaco-list .monaco-scrollable-element .monaco-tree-sticky-container.empty,.monaco-list .monaco-scrollable-element .monaco-tree-sticky-container.empty .monaco-tree-sticky-container-shadow{display:none}.monaco-list .monaco-scrollable-element .monaco-tree-sticky-container .monaco-tree-sticky-container-shadow{bottom:-3px;height:0;left:0;position:absolute;width:100%}.monaco-list .monaco-scrollable-element .monaco-tree-sticky-container[tabindex=\"0\"]:focus{outline:none}";
 n(css,{});
+
 export { css, css as default };

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

@@ -4,6 +4,7 @@ import { CompressibleObjectTreeModel } from './compressedObjectTreeModel.js';
 import { ObjectTreeModel } from './objectTreeModel.js';
 import { memoize } from '../../../common/decorators.js';
 import { Iterable } from '../../../common/iterator.js';
+
 class ObjectTree extends AbstractTree {
     get onDidChangeCollapseState() { return this.model.onDidChangeCollapseState; }
     constructor(user, container, delegate, renderers, options = {}) {
@@ -197,4 +198,5 @@ class CompressibleObjectTree extends ObjectTree {
         return this.model.getCompressedTreeNode(element);
     }
 }
+
 export { CompressibleObjectTree, ObjectTree };

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

@@ -1,6 +1,7 @@
 import { IndexTreeModel } from './indexTreeModel.js';
-import { TreeError, ObjectTreeElementCollapseState } from './tree.js';
+import { ObjectTreeElementCollapseState, TreeError } from './tree.js';
 import { Iterable } from '../../../common/iterator.js';
+
 class ObjectTreeModel {
     get size() { return this.nodes.size; }
     constructor(user, options = {}) {
@@ -216,4 +217,5 @@ class ObjectTreeModel {
         return this.model.getNodeLocation(node);
     }
 }
+
 export { ObjectTreeModel };

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

@@ -31,4 +31,5 @@ class WeakMapper {
         return result;
     }
 }
+
 export { ObjectTreeElementCollapseState, TreeError, TreeMouseEventTarget, WeakMapper };

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

@@ -1,8 +1,9 @@
 import { Action } from '../../../common/actions.js';
 import { localize } from '../../../../nls.js';
+
 class CollapseAllAction extends Action {
     constructor(viewer, enabled) {
-        super('vs.tree.collapse', ( localize(11359, "Collapse All")), 'collapse-all', enabled);
+        super('vs.tree.collapse', ( localize(11479, "Collapse All")), 'collapse-all', enabled);
         this.viewer = viewer;
     }
     async run() {
@@ -11,4 +12,5 @@ class CollapseAllAction extends Action {
         this.viewer.setFocus([]);
     }
 }
+
 export { CollapseAllAction };

package/vscode/src/vs/base/browser/ui/widget.js

@@ -1,8 +1,9 @@
-import { addDisposableListener, getWindow, EventType } from '../dom.js';
+import { addDisposableListener, EventType, getWindow } from '../dom.js';
 import { StandardKeyboardEvent } from '../keyboardEvent.js';
 import { StandardMouseEvent } from '../mouseEvent.js';
 import { Gesture } from '../touch.js';
 import { Disposable } from '../../common/lifecycle.js';
+
 class Widget extends Disposable {
     onclick(domNode, listener) {
         this._register(addDisposableListener(domNode, EventType.CLICK, (e) => listener(( new StandardMouseEvent(getWindow(domNode), e)))));
@@ -38,4 +39,5 @@ class Widget extends Disposable {
         return Gesture.ignoreTarget(domNode);
     }
 }
+
 export { Widget };

package/vscode/src/vs/base/browser/window.js

@@ -14,4 +14,5 @@ function isAuxiliaryWindow(obj) {
     const candidate = obj;
     return typeof candidate?.vscodeWindowId === 'number';
 }
+
 export { ensureCodeWindow, isAuxiliaryWindow, mainWindow };

package/vscode/src/vs/base/common/actions.js

@@ -1,6 +1,7 @@
 import { Emitter } from './event.js';
 import { Disposable } from './lifecycle.js';
 import { localize } from '../../nls.js';
+
 class Action extends Disposable {
     constructor(id, label = '', cssClass = '', enabled = true, actionCallback) {
         super();
@@ -149,7 +150,7 @@ class SubmenuAction {
 class EmptySubmenuAction extends Action {
     static { this.ID = 'vs.actions.empty'; }
     constructor() {
-        super(EmptySubmenuAction.ID, ( localize(1631, '(empty)')), undefined, false);
+        super(EmptySubmenuAction.ID, ( localize(1627, '(empty)')), undefined, false);
     }
 }
 function toAction(props) {
@@ -163,4 +164,5 @@ function toAction(props) {
         run: async (...args) => props.run(...args),
     };
 }
+
 export { Action, ActionRunner, EmptySubmenuAction, Separator, SubmenuAction, toAction };

package/vscode/src/vs/base/common/arrays.js

@@ -1,4 +1,5 @@
 import { findFirstIdxMonotonousOrArrLen } from './arraysFind.js';
+
 function tail(array, n = 0) {
     return array[array.length - (1 + n)];
 }
@@ -544,4 +545,5 @@ async function findAsync(array, predicate) {
     )));
     return results.find(r => r.ok)?.element;
 }
+
 export { ArrayQueue, CallbackIterable, CompareResult, Permutation, arrayInsert, asArray, binarySearch, binarySearch2, booleanComparator, coalesce, coalesceInPlace, commonPrefixLength, compareBy, delta, distinct, equals, findAsync, forEachAdjacent, forEachWithNeighbors, groupAdjacentBy, groupBy, index, insert, insertInto, isFalsyOrEmpty, isNonEmptyArray, mapArrayOrNot, move, numberComparator, pushMany, pushToEnd, pushToStart, quickSelect, range, remove, removeFastWithoutKeepingOrder, reverseOrder, shuffle, sortedDiff, splice, tail, tail2, tieBreakComparators, top, uniqueFilter };

package/vscode/src/vs/base/common/arraysFind.js

@@ -125,4 +125,5 @@ function mapFindFirst(items, mapFn) {
     }
     return undefined;
 }
+
 export { MonotonousArray, findFirstIdxMonotonousOrArrLen, findFirstMax, findFirstMin, findFirstMonotonous, findLast, findLastIdx, findLastIdxMonotonous, findLastMax, findLastMonotonous, findMaxIdx, mapFindFirst };

package/vscode/src/vs/base/common/assert.js

@@ -1,4 +1,5 @@
-import { onUnexpectedError, BugIndicatingError } from './errors.js';
+import { BugIndicatingError, onUnexpectedError } from './errors.js';
+
 function ok(value, message) {
     if (!value) {
         throw ( new Error(message ? `Assertion failed (${message})` : 'Assertion Failed'));
@@ -36,4 +37,5 @@ function checkAdjacentItems(items, predicate) {
     }
     return true;
 }
+
 export { assert, assertFn, assertNever, checkAdjacentItems, ok, softAssert };

package/vscode/src/vs/base/common/async.js

@@ -6,6 +6,7 @@ import { extUri } from './resources.js';
 import { setTimeout0 } from './platform.js';
 import { MicrotaskDelay } from './symbols.js';
 import { Lazy } from './lazy.js';
+
 function isThenable(obj) {
     return !!obj && typeof obj.then === 'function';
 }
@@ -655,7 +656,7 @@ let runWhenGlobalIdle;
 let _runWhenIdle;
 (function () {
     if (typeof globalThis.requestIdleCallback !== 'function' || typeof globalThis.cancelIdleCallback !== 'function') {
-        _runWhenIdle = (_targetWindow, runner) => {
+        _runWhenIdle = (_targetWindow, runner, timeout) => {
             setTimeout0(() => {
                 if (disposed) {
                     return;
@@ -695,7 +696,7 @@ let _runWhenIdle;
             };
         };
     }
-    runWhenGlobalIdle = (runner) => _runWhenIdle(globalThis, runner);
+    runWhenGlobalIdle = (runner, timeout) => _runWhenIdle(globalThis, runner, timeout);
 })();
 class AbstractIdleValue {
     constructor(targetWindow, executor) {
@@ -937,7 +938,7 @@ class AsyncIterableObject {
             emitter.emitMany(await promise);
         }));
     }
-    static fromPromises(promises) {
+    static fromPromisesResolveOrder(promises) {
         return ( new AsyncIterableObject(async (emitter) => {
             await Promise.all(( promises.map(async (p) => emitter.emitOne(await p))));
         }));
@@ -1147,4 +1148,5 @@ class AsyncIterableSource {
         this._emitFn(item);
     }
 }
+
 export { AbstractIdleValue, AsyncIterableObject, AsyncIterableSource, AutoOpenBarrier, Barrier, CancelableAsyncIterableObject, DeferredPromise, Delayer, GlobalIdleValue, IntervalCounter, IntervalTimer, LazyStatefulPromise, Limiter, Promises, Queue, ResourceQueue, RunOnceScheduler, RunOnceWorker, Sequencer, SequencerByKey, StatefulPromise, TaskSequentializer, ThrottledDelayer, Throttler, TimeoutTimer, _runWhenIdle, asPromise, createCancelableAsyncIterable, createCancelablePromise, disposableTimeout, first, isThenable, promiseWithResolvers, raceCancellablePromises, raceCancellation, raceCancellationError, raceTimeout, retry, runWhenGlobalIdle, sequence, timeout };

package/vscode/src/vs/base/common/buffer.js

@@ -1,5 +1,6 @@
 import { Lazy } from './lazy.js';
-import { consumeReadable, toReadable, consumeStream, toStream, prefixedStream, newWriteableStream, prefixedReadable } from './stream.js';
+import { consumeReadable, toReadable, consumeStream, toStream, newWriteableStream, prefixedReadable, prefixedStream } from './stream.js';
+
 const hasBuffer = (typeof Buffer !== 'undefined');
 const indexOfTable = ( new Lazy(() => ( new Uint8Array(256))));
 let textEncoder;
@@ -319,4 +320,5 @@ function encodeBase64({ buffer }, padded = true, urlSafe = false) {
     }
     return output;
 }
+
 export { VSBuffer, binaryIndexOf, bufferToReadable, bufferToStream, bufferedStreamToBuffer, decodeBase64, encodeBase64, newWriteableBufferStream, prefixedBufferReadable, prefixedBufferStream, readUInt16LE, readUInt32BE, readUInt32LE, readUInt8, readableToBuffer, streamToBuffer, writeUInt16LE, writeUInt32BE, writeUInt32LE, writeUInt8 };