@codingame/monaco-vscode-api 36.2.7 → 37.0.0

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

@@ -350,6 +350,9 @@ class TreeRenderer {
         }
     }
     renderTemplate(container) {
+        if (this.renderer.rowClassName) {
+            container.classList.add(this.renderer.rowClassName);
+        }
         const el = append(container, $(".monaco-tl-row"));
         const indent = append(el, $(".monaco-tl-indent"));
         const twistie = append(el, $(".monaco-tl-twistie"));
@@ -380,9 +383,11 @@ class TreeRenderer {
             ...details,
             indent: templateData.indentSize
         });
-        if (typeof details?.height === "number") {
+        if (typeof details?.height === "number" && this.renderedNodes.get(node) === templateData) {
             this.renderedNodes.delete(node);
-            this.renderedElements.delete(node.element);
+            if (this.renderedElements.get(node.element) === node) {
+                this.renderedElements.delete(node.element);
+            }
         }
     }
     disposeTemplate(templateData) {
@@ -1054,7 +1059,7 @@ 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 && node1.sourceNodeEnd === node2.sourceNodeEnd && node1.sourceNodePartiallyVisible === node2.sourceNodePartiallyVisible && node1.hasExplicitHeight === node2.hasExplicitHeight;
 }
 class StickyScrollState {
     constructor(stickyNodes = []) {
@@ -1105,6 +1110,9 @@ class DefaultStickyScrollDelegate {
     }
 }
 class StickyScrollController extends Disposable {
+    get domNode() {
+        return this._widget.domNode;
+    }
     constructor(tree, model, view, renderers, treeDelegate, options = {}) {
         super();
         this.tree = tree;
@@ -1129,6 +1137,14 @@ class StickyScrollController extends Disposable {
         this._register(view.onDidScroll(() => this.update()));
         this._register(view.onDidChangeContentHeight(() => this.update()));
         this._register(tree.onDidChangeCollapseState(() => this.update()));
+        this._register(this._widget.onDidChangeHeight(heightChanges => {
+            for (const {
+                index,
+                height
+            } of heightChanges) {
+                this.view.updateElementHeight(index, height);
+            }
+        }));
         this._register(model.onDidSpliceRenderedNodes(e => {
             const state = this._widget.state;
             if (!state) {
@@ -1206,24 +1222,71 @@ class StickyScrollController extends Disposable {
         if (!nextStickyNode) {
             return undefined;
         }
-        if (nextStickyNode === firstVisibleNodeUnderWidget) {
-            if (!this.nodeIsUncollapsedParent(firstVisibleNodeUnderWidget)) {
-                return undefined;
-            }
-            if (this.nodeTopAlignsWithStickyNodesBottom(firstVisibleNodeUnderWidget, stickyNodesHeight)) {
-                return undefined;
-            }
+        if (nextStickyNode === firstVisibleNodeUnderWidget && !this.nodeIsUncollapsedParent(firstVisibleNodeUnderWidget)) {
+            return undefined;
+        }
+        const sourceRange = this.getStickyScrollNodeSourceRange(nextStickyNode);
+        if (!sourceRange || !Number.isFinite(sourceRange.start) || !Number.isFinite(sourceRange.end) || sourceRange.end <= sourceRange.start) {
+            return undefined;
         }
-        return this.createStickyScrollNode(nextStickyNode, stickyNodesHeight);
+        const sourceNodeTop = this.view.getElementTop(this.getNodeIndex(nextStickyNode));
+        const stickyViewportBottom = this.view.scrollTop + stickyNodesHeight;
+        if (stickyViewportBottom <= sourceNodeTop + sourceRange.start) {
+            return undefined;
+        }
+        const height = this.getStickyScrollNodeHeight(sourceRange, stickyNodesHeight);
+        const sourceNodePartiallyVisible = stickyViewportBottom + height < sourceNodeTop + sourceRange.end;
+        return this.createStickyScrollNode(
+            nextStickyNode,
+            stickyNodesHeight,
+            height,
+            sourceRange.end,
+            sourceNodePartiallyVisible,
+            sourceRange.stickyNodeHeight !== undefined
+        );
     }
-    nodeTopAlignsWithStickyNodesBottom(node, stickyNodesHeight) {
-        const nodeIndex = this.getNodeIndex(node);
-        const elementTop = this.view.getElementTop(nodeIndex);
-        const stickyPosition = stickyNodesHeight;
-        return this.view.scrollTop === elementTop - stickyPosition;
+    getStickyScrollNodeSourceRange(node) {
+        const defaultRange = {
+            start: 0,
+            end: this.getNodeHeight(node)
+        };
+        const sourceRangeProvider = this.tree.options.stickyScrollNodeSourceRangeProvider;
+        if (sourceRangeProvider) {
+            return sourceRangeProvider(node.element, defaultRange);
+        }
+        return defaultRange;
     }
-    createStickyScrollNode(node, currentStickyNodesHeight) {
-        const height = this.treeDelegate.getHeight(node);
+    getStickyScrollNodeHeight(sourceRange, currentStickyNodesHeight) {
+        const height = this.clampNodeHeight(sourceRange.stickyNodeHeight ?? sourceRange.end - sourceRange.start);
+        if (!sourceRange.estimated) {
+            return height;
+        }
+        const availableHeight = Math.max(
+            1,
+            this.view.renderHeight * this.maxWidgetViewRatio - currentStickyNodesHeight
+        );
+        return Math.min(height, availableHeight);
+    }
+    getNodeHeight(node) {
+        const nodeLocation = this.model.getNodeLocation(node);
+        const index = this.model.getListIndex(nodeLocation);
+        if (index >= 0) {
+            return this.view.getElementHeight(index);
+        }
+        return this.treeDelegate.getHeight(node);
+    }
+    clampNodeHeight(height) {
+        const max = this.tree.options.stickyScrollMaxNodeHeight;
+        return max !== undefined ? Math.min(height, max) : height;
+    }
+    createStickyScrollNode(
+        node,
+        currentStickyNodesHeight,
+        height,
+        sourceNodeEnd,
+        sourceNodePartiallyVisible,
+        hasExplicitHeight
+    ) {
         const {
             startIndex,
             endIndex
@@ -1234,7 +1297,10 @@ class StickyScrollController extends Disposable {
             position,
             height,
             startIndex,
-            endIndex
+            endIndex,
+            sourceNodeEnd,
+            sourceNodePartiallyVisible,
+            hasExplicitHeight
         };
     }
     getAncestorUnderPrevious(node, previousAncestor = undefined) {
@@ -1253,19 +1319,8 @@ class StickyScrollController extends Disposable {
         return undefined;
     }
     calculateStickyNodePosition(lastDescendantIndex, stickyRowPositionTop, stickyNodeHeight) {
-        let lastChildRelativeTop = this.view.getRelativeTop(lastDescendantIndex);
-        if (lastChildRelativeTop === null && this.view.firstVisibleIndex === lastDescendantIndex && lastDescendantIndex + 1 < this.view.length) {
-            const nodeHeight = this.treeDelegate.getHeight(this.view.element(lastDescendantIndex));
-            const nextNodeRelativeTop = this.view.getRelativeTop(lastDescendantIndex + 1);
-            lastChildRelativeTop = nextNodeRelativeTop ? nextNodeRelativeTop - nodeHeight / this.view.renderHeight : null;
-        }
-        if (lastChildRelativeTop === null) {
-            return stickyRowPositionTop;
-        }
-        const lastChildNode = this.view.element(lastDescendantIndex);
-        const lastChildHeight = this.treeDelegate.getHeight(lastChildNode);
-        const topOfLastChild = lastChildRelativeTop * this.view.renderHeight;
-        const bottomOfLastChild = topOfLastChild + lastChildHeight;
+        const lastChildHeight = this.view.getElementHeight(lastDescendantIndex);
+        const bottomOfLastChild = this.view.getElementTop(lastDescendantIndex) + lastChildHeight - this.view.scrollTop;
         if (stickyRowPositionTop + stickyNodeHeight > bottomOfLastChild && stickyRowPositionTop <= bottomOfLastChild) {
             return bottomOfLastChild - stickyNodeHeight;
         }
@@ -1326,7 +1381,10 @@ class StickyScrollController extends Disposable {
         }
         let widgetHeight = 0;
         for (let i = 0; i < ancestors.length && i < this.stickyScrollMaxItemCount; i++) {
-            widgetHeight += this.treeDelegate.getHeight(ancestors[i]);
+            const sourceRange = this.getStickyScrollNodeSourceRange(ancestors[i]);
+            if (sourceRange) {
+                widgetHeight += this.getStickyScrollNodeHeight(sourceRange, widgetHeight);
+            }
         }
         return widgetHeight;
     }
@@ -1351,6 +1409,13 @@ class StickyScrollController extends Disposable {
             }
         }
     }
+    refresh() {
+        this.update();
+    }
+    rerender() {
+        this._widget.rerender();
+        this.update();
+    }
     validateStickySettings(options) {
         let stickyScrollMaxItemCount = 7;
         if (typeof options.stickyScrollMaxItemCount === "number") {
@@ -1372,7 +1437,10 @@ class StickyScrollWidget {
         this.treeDelegate = treeDelegate;
         this.accessibilityProvider = accessibilityProvider;
         this._previousElements = [];
+        this._previousElementHeights = [];
         this._previousStateDisposables = ( new DisposableStore());
+        this._onDidChangeHeight = ( new Emitter());
+        this.onDidChangeHeight = this._onDidChangeHeight.event;
         this._rootDomNode = $(".monaco-tree-sticky-container.empty");
         container.appendChild(this._rootDomNode);
         const shadow = $(".monaco-tree-sticky-container-shadow");
@@ -1385,8 +1453,10 @@ class StickyScrollWidget {
         if (!this._previousState) {
             return 0;
         }
-        const lastElement = this._previousState.stickyNodes[this._previousState.count - 1];
-        return lastElement.position + lastElement.height;
+        return this.getRootHeight(this._previousState);
+    }
+    get domNode() {
+        return this._rootDomNode;
     }
     get count() {
         return this._previousState?.count ?? 0;
@@ -1398,14 +1468,17 @@ class StickyScrollWidget {
         const wasVisible = !!this._previousState && this._previousState.count > 0;
         const isVisible = !!state && state.count > 0;
         if ((!wasVisible && !isVisible) || (wasVisible && isVisible && this._previousState.equal(state))) {
+            this.updateSourceNodeVisibility(state);
             return;
         }
         if (wasVisible !== isVisible) {
             this.setVisible(isVisible);
         }
         if (!isVisible) {
+            this.updateSourceNodeVisibility(undefined);
             this._previousState = undefined;
             this._previousElements = [];
+            this._previousElementHeights = [];
             this._previousStateDisposables.clear();
             return;
         }
@@ -1417,7 +1490,25 @@ class StickyScrollWidget {
             this.renderState(state);
         }
         this._previousState = state;
-        this._rootDomNode.style.height = `${lastStickyNode.position + lastStickyNode.height}px`;
+        this.updateSourceNodeVisibility(state);
+        this.updateRootHeight(state);
+    }
+    updateSourceNodeVisibility(state) {
+        let sourceNodePartiallyVisible = false;
+        for (let i = 0; state && i < state.count; i++) {
+            const stickyNode = state.stickyNodes[i];
+            const stickyElement = this._previousElements[i];
+            let nodePartiallyVisible = stickyNode.sourceNodePartiallyVisible;
+            if (stickyElement) {
+                const sourceNodeBottom = this.view.getElementTop(stickyNode.startIndex) + stickyNode.sourceNodeEnd;
+                const stickyElementHeight = this.getRenderedNodeHeight(stickyNode, i);
+                const stickyNodeBottom = this.view.scrollTop + stickyNode.position + stickyElementHeight;
+                nodePartiallyVisible = stickyNodeBottom < sourceNodeBottom;
+            }
+            stickyElement?.classList.toggle("source-node-partially-visible", nodePartiallyVisible);
+            sourceNodePartiallyVisible ||= nodePartiallyVisible;
+        }
+        this._rootDomNode.classList.toggle("source-node-partially-visible", sourceNodePartiallyVisible);
     }
     renderState(state) {
         this._previousStateDisposables.clear();
@@ -1434,24 +1525,87 @@ class StickyScrollWidget {
         }
         this.stickyScrollFocus.updateElements(elements, state);
         this._previousElements = elements;
+        this._previousElementHeights = this.probeDynamicHeights(state, elements);
     }
     rerender() {
         if (this._previousState) {
             this.renderState(this._previousState);
+            this.updateSourceNodeVisibility(this._previousState);
+            this.updateRootHeight(this._previousState);
         }
     }
+    updateRootHeight(state) {
+        this._rootDomNode.style.height = `${this.getRootHeight(state)}px`;
+    }
+    getRootHeight(state) {
+        const lastStickyNode = state.stickyNodes[state.count - 1];
+        const lastStickyElementHeight = this.getRenderedNodeHeight(lastStickyNode, state.count - 1);
+        return Math.max(0, lastStickyNode.position + lastStickyElementHeight);
+    }
+    getRenderedNodeHeight(stickyNode, index) {
+        return Math.min(
+            this._previousElementHeights[index] ?? stickyNode.height,
+            stickyNode.height
+        );
+    }
+    probeDynamicHeights(state, elements) {
+        const heightChanges = [];
+        const elementHeights = ( state.stickyNodes.map(node => node.height));
+        for (let i = 0; i < state.count; i++) {
+            const stickyNode = state.stickyNodes[i];
+            if (!this.treeDelegate.hasDynamicHeight || !this.treeDelegate.hasDynamicHeight(stickyNode.node)) {
+                const measuredHeight = elements[i].offsetHeight;
+                if (measuredHeight > 0) {
+                    elementHeights[i] = measuredHeight;
+                }
+                continue;
+            }
+            const element = elements[i];
+            const previousHeight = element.style.height;
+            element.style.height = "";
+            const measuredHeight = element.offsetHeight;
+            if (measuredHeight <= 0) {
+                element.style.height = previousHeight;
+                continue;
+            }
+            const maxNodeHeight = this.tree.options.stickyScrollMaxNodeHeight;
+            const clampedMeasuredHeight = maxNodeHeight !== undefined ? Math.min(measuredHeight, maxNodeHeight) : measuredHeight;
+            const renderedHeight = stickyNode.hasExplicitHeight ? stickyNode.height : clampedMeasuredHeight;
+            elementHeights[i] = renderedHeight;
+            if (this.tree.options.setRowHeight !== false) {
+                element.style.height = `${renderedHeight}px`;
+            }
+            if (this.tree.options.setRowLineHeight !== false) {
+                element.style.lineHeight = `${renderedHeight}px`;
+            }
+            if (!stickyNode.hasExplicitHeight && clampedMeasuredHeight > this.view.getElementHeight(stickyNode.startIndex)) {
+                heightChanges.push({
+                    index: stickyNode.startIndex,
+                    height: clampedMeasuredHeight
+                });
+            }
+        }
+        if (heightChanges.length > 0) {
+            this._onDidChangeHeight.fire(heightChanges);
+        }
+        return elementHeights;
+    }
     createElement(stickyNode, stickyIndex, stickyNodesTotal) {
         const nodeIndex = stickyNode.startIndex;
         const stickyElement = createElement("div");
         stickyElement.style.top = `${stickyNode.position}px`;
+        const maxNodeHeight = this.tree.options.stickyScrollMaxNodeHeight;
+        const clampedHeight = maxNodeHeight !== undefined ? Math.min(stickyNode.height, maxNodeHeight) : stickyNode.height;
         if (this.tree.options.setRowHeight !== false) {
-            stickyElement.style.height = `${stickyNode.height}px`;
+            stickyElement.style.height = `${clampedHeight}px`;
         }
         if (this.tree.options.setRowLineHeight !== false) {
-            stickyElement.style.lineHeight = `${stickyNode.height}px`;
+            stickyElement.style.lineHeight = `${clampedHeight}px`;
         }
+        stickyElement.style.overflow = "hidden";
         stickyElement.classList.add("monaco-tree-sticky-row");
         stickyElement.classList.add("monaco-list-row");
+        stickyElement.classList.toggle("source-node-partially-visible", stickyNode.sourceNodePartiallyVisible);
         stickyElement.setAttribute("data-index", `${nodeIndex}`);
         stickyElement.setAttribute("data-parity", nodeIndex % 2 === 0 ? "even" : "odd");
         stickyElement.setAttribute("id", this.view.getElementID(nodeIndex));
@@ -1518,7 +1672,6 @@ class StickyScrollWidget {
         if (typeof ariaLevel === "number") {
             container.setAttribute("aria-level", `${ariaLevel}`);
         }
-        container.setAttribute("aria-selected", String(false));
         return result;
     }
     setVisible(visible) {
@@ -1537,6 +1690,7 @@ class StickyScrollWidget {
         return this.stickyScrollFocus.focusedLast();
     }
     dispose() {
+        this._onDidChangeHeight.dispose();
         this.stickyScrollFocus.dispose();
         this._previousStateDisposables.dispose();
         this._rootDomNode.remove();
@@ -2143,6 +2297,9 @@ class AbstractTree {
     get onDidDispose() {
         return this.view.onDidDispose;
     }
+    get stickyScrollDomNode() {
+        return this.stickyScrollController?.domNode;
+    }
     constructor(_user, container, delegate, renderers, _options = {}) {
         this._user = _user;
         this._options = _options;
@@ -2150,6 +2307,8 @@ class AbstractTree {
         this.onDidChangeFindOpenState = Event.None;
         this.onDidChangeStickyScrollFocused = Event.None;
         this.disposables = ( new DisposableStore());
+        this._onDidChangeStickyScrollDomNode = this.disposables.add(( new Emitter()));
+        this.onDidChangeStickyScrollDomNode = this._onDidChangeStickyScrollDomNode.event;
         this.onDidSwapModel = this.disposables.add(( new Emitter()));
         this.onDidChangeModelRelay = this.disposables.add(( new Relay()));
         this.onDidSpliceModelRelay = this.disposables.add(( new Relay()));
@@ -2264,10 +2423,12 @@ class AbstractTree {
                 this._options
             ));
             this.onDidChangeStickyScrollFocused = this.stickyScrollController.onDidChangeHasFocus;
+            this._onDidChangeStickyScrollDomNode.fire(this.stickyScrollController.domNode);
         } else if (this.stickyScrollController && !this._options.enableStickyScroll) {
             this.onDidChangeStickyScrollFocused = Event.None;
             this.stickyScrollController.dispose();
             this.stickyScrollController = undefined;
+            this._onDidChangeStickyScrollDomNode.fire(undefined);
         }
         this.stickyScrollController?.updateOptions(optionsUpdate);
     }
@@ -2311,6 +2472,12 @@ class AbstractTree {
     get renderHeight() {
         return this.view.renderHeight;
     }
+    refreshStickyScroll() {
+        this.stickyScrollController?.refresh();
+    }
+    rerenderStickyScroll() {
+        this.stickyScrollController?.rerender();
+    }
     get firstVisibleElement() {
         let index = this.view.firstVisibleIndex;
         if (this.stickyScrollController) {
@@ -2579,6 +2746,13 @@ class AbstractTree {
         const stickyScrollNode = this.stickyScrollController?.getNode(this.getNode(location));
         return this.view.getRelativeTop(index, stickyScrollNode?.position ?? this.stickyScrollController?.height);
     }
+    getElementTop(location) {
+        const index = this.model.getListIndex(location);
+        if (index === -1) {
+            return undefined;
+        }
+        return this.view.getElementTop(index);
+    }
     getViewState(identityProvider = this.options.identityProvider) {
         if (!identityProvider) {
             throw ( new TreeError(this._user, "Can't get tree view state without an identity provider"));

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

@@ -370,6 +370,7 @@ function asObjectTreeOptions(options) {
                 return options.keyboardNavigationLabelProvider.getKeyboardNavigationLabel(e.element);
             }
         },
+        stickyScrollNodeSourceRangeProvider: options.stickyScrollNodeSourceRangeProvider && ((e, defaultRange) => options.stickyScrollNodeSourceRangeProvider(e.element, defaultRange)),
         sorter: undefined,
         expandOnlyOnTwistieClick: typeof options.expandOnlyOnTwistieClick === "undefined" ? undefined : (typeof options.expandOnlyOnTwistieClick !== "function" ? options.expandOnlyOnTwistieClick : (e => options.expandOnlyOnTwistieClick(e.element))),
         twistieAdditionalCssClass: typeof options.twistieAdditionalCssClass === "undefined" ? undefined : (e => options.twistieAdditionalCssClass(e.element)),

package/vscode/src/vs/base/browser/ui/tree/objectTree.d.ts

@@ -31,6 +31,7 @@ export declare class ObjectTree<T, TFilterData = void> extends AbstractTree<T |
     setChildren(element: T | null, children?: Iterable<IObjectTreeElement<T>>, options?: IObjectTreeSetChildrenOptions<T>): void;
     rerender(element?: T): void;
     updateElementHeight(element: T, height: number | undefined): void;
+    getListRenderCount(element: T | null): number;
     resort(element: T | null, recursive?: boolean): void;
     hasElement(element: T): boolean;
     protected createModel(user: string, options: IObjectTreeOptions<T | null, TFilterData>): ITreeModel<T | null, TFilterData, T | null>;

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

@@ -31,6 +31,9 @@ class ObjectTree extends AbstractTree {
         }
         this.view.updateElementHeight(elementIndex, height);
     }
+    getListRenderCount(element) {
+        return this.model.getListRenderCount(element);
+    }
     resort(element, recursive = true) {
         this.model.resort(element, recursive);
     }
@@ -158,7 +161,10 @@ class CompressibleStickyScrollDelegate {
             startIndex: stickyNodes[0].startIndex,
             endIndex: lastStickyNode.endIndex,
             position: stickyNodes[0].position,
-            height: stickyNodes[0].height
+            height: stickyNodes[0].height,
+            sourceNodeEnd: stickyNodes[0].sourceNodeEnd,
+            sourceNodePartiallyVisible: ( stickyNodes.some(node => node.sourceNodePartiallyVisible)),
+            hasExplicitHeight: stickyNodes[0].hasExplicitHeight
         };
         this.compressedStickyNodes.set(stickyTreeNode, compressedNode);
         return compressedStickyNode;

package/vscode/src/vs/base/browser/ui/tree/tree.d.ts

@@ -130,6 +130,8 @@ export interface ITreeElementRenderDetails extends IListElementRenderDetails {
     readonly indent: number;
 }
 export interface ITreeRenderer<T, TFilterData = void, TTemplateData = void> extends IListRenderer<ITreeNode<T, TFilterData>, TTemplateData> {
+    /** CSS class applied to list rows created for this renderer. */
+    readonly rowClassName?: string;
     renderElement(element: ITreeNode<T, TFilterData>, index: number, templateData: TTemplateData, details?: ITreeElementRenderDetails): void;
     disposeElement?(element: ITreeNode<T, TFilterData>, index: number, templateData: TTemplateData, details?: ITreeElementRenderDetails): void;
     renderTwistie?(element: T, twistieElement: HTMLElement): boolean;

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

@@ -438,7 +438,7 @@ class ArrayQueue {
     }
     takeWhile(predicate) {
         let startIdx = this.firstIdx;
-        while (startIdx < this.items.length && predicate(this.items[startIdx])) {
+        while (startIdx <= this.lastIdx && predicate(this.items[startIdx])) {
             startIdx++;
         }
         const result = startIdx === this.firstIdx ? null : this.items.slice(this.firstIdx, startIdx);
@@ -447,7 +447,7 @@ class ArrayQueue {
     }
     takeFromEndWhile(predicate) {
         let endIdx = this.lastIdx;
-        while (endIdx >= 0 && predicate(this.items[endIdx])) {
+        while (endIdx >= this.firstIdx && predicate(this.items[endIdx])) {
             endIdx--;
         }
         const result = endIdx === this.lastIdx ? null : this.items.slice(endIdx + 1, this.lastIdx + 1);

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

@@ -23,7 +23,6 @@ function softAssert(condition, message = "Soft Assertion Failed") {
 }
 function assertFn(condition) {
     if (!condition()) {
-        debugger;
         condition();
         onUnexpectedError(( new BugIndicatingError("Assertion Failed")));
     }

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

@@ -94,9 +94,8 @@ function raceCancellablePromises(cancellablePromises) {
             }
         });
     };
-    promise.finally(() => {
-        promise.cancel();
-    });
+    const cancel = () => promise.cancel();
+    promise.then(cancel, cancel);
     return promise;
 }
 function raceTimeout(promise, timeout, onTimeout) {

package/vscode/src/vs/base/common/codicons.d.ts

@@ -47,36 +47,6 @@ export declare const codiconsDerived: {
  * In that call a Codicon can be named as default.
  */
 export declare const Codicon: {
-    readonly dialogError: ThemeIcon;
-    readonly dialogWarning: ThemeIcon;
-    readonly dialogInfo: ThemeIcon;
-    readonly dialogClose: ThemeIcon;
-    readonly treeItemExpanded: ThemeIcon;
-    readonly treeFilterOnTypeOn: ThemeIcon;
-    readonly treeFilterOnTypeOff: ThemeIcon;
-    readonly treeFilterClear: ThemeIcon;
-    readonly treeItemLoading: ThemeIcon;
-    readonly menuSelection: ThemeIcon;
-    readonly menuSubmenu: ThemeIcon;
-    readonly menuBarMore: ThemeIcon;
-    readonly scrollbarButtonLeft: ThemeIcon;
-    readonly scrollbarButtonRight: ThemeIcon;
-    readonly scrollbarButtonUp: ThemeIcon;
-    readonly scrollbarButtonDown: ThemeIcon;
-    readonly toolBarMore: ThemeIcon;
-    readonly quickInputBack: ThemeIcon;
-    readonly dropDownButton: ThemeIcon;
-    readonly symbolCustomColor: ThemeIcon;
-    readonly exportIcon: ThemeIcon;
-    readonly workspaceUnspecified: ThemeIcon;
-    readonly newLine: ThemeIcon;
-    readonly thumbsDownFilled: ThemeIcon;
-    readonly thumbsUpFilled: ThemeIcon;
-    readonly gitFetch: ThemeIcon;
-    readonly lightbulbSparkleAutofix: ThemeIcon;
-    readonly debugBreakpointPending: ThemeIcon;
-    readonly chatImport: ThemeIcon;
-    readonly chatExport: ThemeIcon;
     readonly add: ThemeIcon;
     readonly plus: ThemeIcon;
     readonly gistNew: ThemeIcon;
@@ -793,4 +763,75 @@ export declare const Codicon: {
     readonly vscodeOutline: ThemeIcon;
     readonly voiceMode: ThemeIcon;
     readonly voiceModeCompact: ThemeIcon;
+    readonly micDownload: ThemeIcon;
+    readonly micDownloadCompact: ThemeIcon;
+    readonly voiceModeDownload: ThemeIcon;
+    readonly voiceModeDownloadCompact: ThemeIcon;
+    readonly googleGemini: ThemeIcon;
+    readonly kimi: ThemeIcon;
+    readonly microsoft: ThemeIcon;
+    readonly fish1Happy: ThemeIcon;
+    readonly fish1Neutral: ThemeIcon;
+    readonly fish1Sad: ThemeIcon;
+    readonly fish1VerySad: ThemeIcon;
+    readonly fish2Happy: ThemeIcon;
+    readonly fish2Neutral: ThemeIcon;
+    readonly fish2Sad: ThemeIcon;
+    readonly fish2VerySad: ThemeIcon;
+    readonly fish3Happy: ThemeIcon;
+    readonly fish3Neutral: ThemeIcon;
+    readonly fish3Sad: ThemeIcon;
+    readonly fish3VerySad: ThemeIcon;
+    readonly fish4Happy: ThemeIcon;
+    readonly fish4Neutral: ThemeIcon;
+    readonly fish4Sad: ThemeIcon;
+    readonly fish4VerySad: ThemeIcon;
+    readonly personVoice: ThemeIcon;
+    readonly personVoiceCompact: ThemeIcon;
+    readonly personVoiceFilled: ThemeIcon;
+    readonly personVoiceFilledCompact: ThemeIcon;
+    readonly cloudDownloadCompact: ThemeIcon;
+    readonly cloudUploadCompact: ThemeIcon;
+    readonly micCompact: ThemeIcon;
+    readonly arrowUpCompact: ThemeIcon;
+    readonly xai: ThemeIcon;
+    readonly arrowCircleUpSparkle: ThemeIcon;
+    readonly closeSmall: ThemeIcon;
+    readonly bookCompact: ThemeIcon;
+    readonly micOff: ThemeIcon;
+    readonly micOffCompact: ThemeIcon;
+    readonly copilotDot: ThemeIcon;
+    readonly copilotDotCompact: ThemeIcon;
+    readonly layoutDensityCompact: ThemeIcon;
+    readonly layoutDensityDefault: ThemeIcon;
+    readonly dialogError: ThemeIcon;
+    readonly dialogWarning: ThemeIcon;
+    readonly dialogInfo: ThemeIcon;
+    readonly dialogClose: ThemeIcon;
+    readonly treeItemExpanded: ThemeIcon;
+    readonly treeFilterOnTypeOn: ThemeIcon;
+    readonly treeFilterOnTypeOff: ThemeIcon;
+    readonly treeFilterClear: ThemeIcon;
+    readonly treeItemLoading: ThemeIcon;
+    readonly menuSelection: ThemeIcon;
+    readonly menuSubmenu: ThemeIcon;
+    readonly menuBarMore: ThemeIcon;
+    readonly scrollbarButtonLeft: ThemeIcon;
+    readonly scrollbarButtonRight: ThemeIcon;
+    readonly scrollbarButtonUp: ThemeIcon;
+    readonly scrollbarButtonDown: ThemeIcon;
+    readonly toolBarMore: ThemeIcon;
+    readonly quickInputBack: ThemeIcon;
+    readonly dropDownButton: ThemeIcon;
+    readonly symbolCustomColor: ThemeIcon;
+    readonly exportIcon: ThemeIcon;
+    readonly workspaceUnspecified: ThemeIcon;
+    readonly newLine: ThemeIcon;
+    readonly thumbsDownFilled: ThemeIcon;
+    readonly thumbsUpFilled: ThemeIcon;
+    readonly gitFetch: ThemeIcon;
+    readonly lightbulbSparkleAutofix: ThemeIcon;
+    readonly debugBreakpointPending: ThemeIcon;
+    readonly chatImport: ThemeIcon;
+    readonly chatExport: ThemeIcon;
 };