@codingame/monaco-vscode-api 31.0.1 → 32.0.0

package/vscode/src/vs/base/browser/dom.d.ts

@@ -520,13 +520,53 @@ export declare class DragAndDropObserver extends Disposable {
     private registerListeners;
 }
 /**
- * A wrapper around ResizeObserver that is disposable.
+ * A wrapper around `ResizeObserver` that is disposable.
+ *
+ * Behavior is intentionally identical to using `new ResizeObserver(callback)`
+ * directly: the user-supplied callback runs synchronously inside the
+ * browser's resize-observation phase, with the entries the browser delivered.
+ * The wrapper adds three things on top:
+ *
+ * 1. Lifetime management: `dispose()` disconnects the underlying observer.
+ * 2. Auxiliary-window support: pass `targetWindow` so the observer is
+ *    constructed in the realm of the element being observed.
+ * 3. Attribution for the
+ *    `ResizeObserver loop completed with undelivered notifications` warning:
+ *    each instance carries a stable `name`, and just before invoking the
+ *    user callback we publish that name to a module-level slot. The warning
+ *    is delivered as a stackless `ErrorEvent` on `window` after callbacks
+ *    run, so error telemetry can swap in the most-recently-invoked
+ *    observer's name to pinpoint the offending consumer (see
+ *    {@link getRecentDisposableResizeObserverAttributionForLoopError}).
+ *
+ * @param name Stable identifier used in attribution. Prefer something that
+ * survives minification and refactors (e.g. the consumer class + purpose)
+ * since callstacks change across releases.
+ * @param callback Invoked synchronously when the browser delivers resize
+ * notifications, with the same entries the native `ResizeObserver` would
+ * have delivered.
+ * @param targetWindow The window whose `ResizeObserver` constructor should
+ * be used. Defaults to `mainWindow`. Pass the containing window when
+ * creating an observer for elements that live in an auxiliary window.
+ * @param options Optional configuration. `resizeObserverCtor` is a test
+ * seam that defaults to `targetWindow.ResizeObserver`.
  */
 export declare class DisposableResizeObserver extends Disposable {
     private readonly observer;
-    constructor(callback: ResizeObserverCallback);
+    readonly name: string;
+    constructor(name: string, callback: ResizeObserverCallback, targetWindow?: CodeWindow, options?: {
+        resizeObserverCtor?: typeof ResizeObserver;
+    });
     observe(target: Element, options?: ResizeObserverOptions): IDisposable;
 }
+/**
+ * If `message` looks like the ResizeObserver loop warning, return an
+ * attribution string built from the most recently invoked
+ * `DisposableResizeObserver` so error telemetry can replace its synthetic,
+ * stackless callstack with the offending observer's `name`. Returns
+ * `undefined` for unrelated messages or when no observer has fired yet.
+ */
+export declare function getRecentDisposableResizeObserverAttributionForLoopError(message: string | undefined | null): string | undefined;
 type HTMLElementAttributeKeys<T> = Partial<{
     [K in keyof T]: T[K] extends Function ? never : T[K] extends object ? HTMLElementAttributeKeys<T[K]> : T[K];
 }>;

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

@@ -1358,9 +1358,23 @@ class DragAndDropObserver extends Disposable {
     }
 }
 class DisposableResizeObserver extends Disposable {
-    constructor(callback) {
+    constructor(name, callback, targetWindow = mainWindow, options) {
         super();
-        this.observer = new mainWindow.ResizeObserver(callback);
+        this.name = name;
+        const ctor = options?.resizeObserverCtor ?? targetWindow.ResizeObserver;
+        this.observer = ( new ctor((entries, observer) => {
+            _lastInvokedDisposableResizeObserver = this;
+            setTimeout(() => {
+                if (_lastInvokedDisposableResizeObserver === this) {
+                    _lastInvokedDisposableResizeObserver = undefined;
+                }
+            }, 0);
+            try {
+                callback(entries, observer);
+            } catch (e) {
+                onUnexpectedError(e);
+            }
+        }));
         this._register(toDisposable(() => this.observer.disconnect()));
     }
     observe(target, options) {
@@ -1368,6 +1382,17 @@ class DisposableResizeObserver extends Disposable {
         return toDisposable(() => this.observer.unobserve(target));
     }
 }
+let _lastInvokedDisposableResizeObserver;
+function getRecentDisposableResizeObserverAttributionForLoopError(message) {
+    if (typeof message !== "string" || !message.includes("ResizeObserver loop")) {
+        return undefined;
+    }
+    const observer = _lastInvokedDisposableResizeObserver;
+    if (!observer) {
+        return undefined;
+    }
+    return `[DisposableResizeObserver(${observer.name})] ${message}`;
+}
 const H_REGEX = /(?<tag>[\w\-]+)?(?:#(?<id>[\w\-]+))?(?<class>(?:\.(?:[\w\-]+))*)(?:@(?<name>(?:[\w\_])+))?/;
 function h(tag, ...args) {
     let attributes;
@@ -1871,4 +1896,4 @@ if (!customElements.get("connection-observer")) {
     customElements.define("connection-observer", ConnectionObserverElement);
 }
 
-export { $, AnimationFrameScheduler, ConnectionObserverElement, DetectedFullscreenMode, Dimension, DisposableResizeObserver, DragAndDropObserver, EventHelper, EventType, LiveElement, ModifierKeyEmitter, Namespace, ObserverNode, ObserverNodeWithElement, SafeTriangle, WindowIdleValue, WindowIntervalTimer, addDisposableGenericMouseDownListener, addDisposableGenericMouseMoveListener, addDisposableGenericMouseUpListener, addDisposableListener, addDisposableThrottledListener, addStandardDisposableGenericMouseDownListener, addStandardDisposableGenericMouseUpListener, addStandardDisposableListener, after, animate, append, clearNode, computeScreenAwareSize, copyAttributes, createDocumentFragment, createElement, createElementNS, createLinkElement, createMetaElement, createTextNode, detectFullscreen, disposableWindowInterval, finalHandler, findParentWithClass, getActiveDocument, getActiveElement, getActiveWindow, getClientArea, getComputedStyle, getContentHeight, getContentWidth, getDocument, getDomNodePagePosition, getDomNodeZoomLevel, getExternalFocusWindow, getFullscreenElement, getLargestChildWidth, getRootContainer, getShadowRoot, getTopLeftOffset, getTotalHeight, getTotalScrollWidth, getTotalWidth, getWindow, getWindowById, getWindowId, getWindows, getWindowsCount, h, hasAppFocus, hasExternalFocus, hasParentWithClass, hide, isActiveDocument, isActiveElement, isAncestor, isAncestorOfActiveElement, isAncestorUsingFlowTo, isDragEvent, isEditableElement, isElement, isEventLike, isHTMLAnchorElement, isHTMLButtonElement, isHTMLDivElement, isHTMLElement, isHTMLIframeElement, isHTMLInputElement, isHTMLTextAreaElement, isInShadowDOM, isKeyboardEvent, isMouseEvent, isPointerEvent, isSVGElement, isShadowRoot, measure, modify, n, onDidRegisterWindow, onDidUnregisterWindow, onWillUnregisterWindow, position, prepend, registerWindow, reset, restoreParentsScrollTop, runAtThisOrScheduleAtNextAnimationFrame, runWhenWindowIdle, saveParentsScrollTop, scheduleAtNextAnimationFrame, setParentFlowTo, setVisibility, sharedMutationObserver, show, size, svgElem, trackActiveElement, trackAttributes, trackFocus, triggerDownload, triggerUpload, windowOpenNoOpener, windowOpenPopup, windowOpenWithSuccess };
+export { $, AnimationFrameScheduler, ConnectionObserverElement, DetectedFullscreenMode, Dimension, DisposableResizeObserver, DragAndDropObserver, EventHelper, EventType, LiveElement, ModifierKeyEmitter, Namespace, ObserverNode, ObserverNodeWithElement, SafeTriangle, WindowIdleValue, WindowIntervalTimer, addDisposableGenericMouseDownListener, addDisposableGenericMouseMoveListener, addDisposableGenericMouseUpListener, addDisposableListener, addDisposableThrottledListener, addStandardDisposableGenericMouseDownListener, addStandardDisposableGenericMouseUpListener, addStandardDisposableListener, after, animate, append, clearNode, computeScreenAwareSize, copyAttributes, createDocumentFragment, createElement, createElementNS, createLinkElement, createMetaElement, createTextNode, detectFullscreen, disposableWindowInterval, finalHandler, findParentWithClass, getActiveDocument, getActiveElement, getActiveWindow, getClientArea, getComputedStyle, getContentHeight, getContentWidth, getDocument, getDomNodePagePosition, getDomNodeZoomLevel, getExternalFocusWindow, getFullscreenElement, getLargestChildWidth, getRecentDisposableResizeObserverAttributionForLoopError, getRootContainer, getShadowRoot, getTopLeftOffset, getTotalHeight, getTotalScrollWidth, getTotalWidth, getWindow, getWindowById, getWindowId, getWindows, getWindowsCount, h, hasAppFocus, hasExternalFocus, hasParentWithClass, hide, isActiveDocument, isActiveElement, isAncestor, isAncestorOfActiveElement, isAncestorUsingFlowTo, isDragEvent, isEditableElement, isElement, isEventLike, isHTMLAnchorElement, isHTMLButtonElement, isHTMLDivElement, isHTMLElement, isHTMLIframeElement, isHTMLInputElement, isHTMLTextAreaElement, isInShadowDOM, isKeyboardEvent, isMouseEvent, isPointerEvent, isSVGElement, isShadowRoot, measure, modify, n, onDidRegisterWindow, onDidUnregisterWindow, onWillUnregisterWindow, position, prepend, registerWindow, reset, restoreParentsScrollTop, runAtThisOrScheduleAtNextAnimationFrame, runWhenWindowIdle, saveParentsScrollTop, scheduleAtNextAnimationFrame, setParentFlowTo, setVisibility, sharedMutationObserver, show, size, svgElem, trackActiveElement, trackAttributes, trackFocus, triggerDownload, triggerUpload, windowOpenNoOpener, windowOpenPopup, windowOpenWithSuccess };

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

@@ -22,14 +22,8 @@ class StandardMouseEvent {
         this.shiftKey = e.shiftKey;
         this.altKey = e.altKey;
         this.metaKey = e.metaKey;
-        if (typeof e.pageX === 'number') {
-            this.posx = e.pageX;
-            this.posy = e.pageY;
-        }
-        else {
-            this.posx = e.clientX + this.target.ownerDocument.body.scrollLeft + this.target.ownerDocument.documentElement.scrollLeft;
-            this.posy = e.clientY + this.target.ownerDocument.body.scrollTop + this.target.ownerDocument.documentElement.scrollTop;
-        }
+        this.posx = e.pageX;
+        this.posy = e.pageY;
         const iframeOffsets = IframeUtils.getPositionOfChildWindowRelativeToAncestorWindow(targetWindow, e.view);
         this.posx -= iframeOffsets.left;
         this.posy -= iframeOffsets.top;

package/vscode/src/vs/base/browser/overlayLayoutElement.d.ts

@@ -1,11 +1,10 @@
-import { IDimension, IDomPosition } from "./dom.js";
 import { IDisposable } from "../common/lifecycle.js";
 /**
  * Positions an element over another element anywhere in the dom using absolute positioning.
  *
  * This is useful for cases where a dom node cannot be re-parented without losing its state, such as a iframe.
  *
- * Call {@link layoutOverAnchorElement} each time the layout is recalculated. When the
+ * Call {@link setAnchorElement} each time the layout is recalculated. When the
  * same anchor element is passed again the call is a no-op (the browser keeps them in sync).
  */
 export declare class OverlayLayoutElement implements IDisposable {
@@ -33,12 +32,16 @@ export declare class OverlayLayoutElement implements IDisposable {
     /**
      * Position the content over `anchorElement`.
      *
-     * For legacy browser support this should be called each time the layout is recalculated.
+     * This only needs to be called when the anchor element or the clipping container changes.
      */
-    layoutOverAnchorElement(anchorElement: HTMLElement, options?: {
+    setAnchorElement(anchorElement: HTMLElement, options?: {
         readonly clippingContainer?: HTMLElement;
-        readonly fallbackDimension?: IDimension;
-        readonly fallbackPosition?: IDomPosition;
     }): void;
+    /**
+     * Walk up from the anchor element to find the nearest ancestor with an explicit
+     * z-index and place the overlay one level above it. This ensures the overlay sits
+     * above modal layers or other stacking contexts.
+     */
+    private _updateZIndex;
     private _updateClipping;
 }

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

@@ -1,38 +1,34 @@
 
-import { createElement, setParentFlowTo } from './dom.js';
-import { Lazy } from '../common/lazy.js';
+import { createElement, setParentFlowTo, getComputedStyle } from './dom.js';
 import { generateUuid } from '../common/uuid.js';
 
-const supportsAnchorPositioning = ( new Lazy(() => CSS.supports("(top: anchor(top))")));
 function getOrCreateAnchorName(element) {
-    const existing = element.style.getPropertyValue("anchor-name");
+    const existing = element.style.getPropertyValue('anchor-name');
     if (existing) {
         return existing;
     }
     const name = `--overlay-anchor-${generateUuid()}`;
-    element.style.setProperty("anchor-name", name);
+    element.style.setProperty('anchor-name', name);
     return name;
 }
 class OverlayLayoutElement {
     constructor() {
-        this.content = createElement("div");
-        this.content.style.position = "absolute";
-        this.content.style.overflow = "hidden";
-        this._root = createElement("div");
+        this.content = createElement('div');
+        this.content.style.position = 'absolute';
+        this.content.style.overflow = 'hidden';
+        this._root = createElement('div');
         this._root.appendChild(this.content);
         this.reapplyLayoutStyles();
     }
     reapplyLayoutStyles() {
-        if (supportsAnchorPositioning.value) {
-            this.content.style.position = "fixed";
-            this.content.style.top = "anchor(top)";
-            this.content.style.left = "anchor(left)";
-            this.content.style.width = "anchor-size(width)";
-            this.content.style.height = "anchor-size(height)";
-            this.content.style.pointerEvents = "auto";
-        }
-        this._root.style.position = "absolute";
-        this._root.style.pointerEvents = "none";
+        this.content.style.position = 'fixed';
+        this.content.style.top = 'anchor(top)';
+        this.content.style.left = 'anchor(left)';
+        this.content.style.width = 'anchor-size(width)';
+        this.content.style.height = 'anchor-size(height)';
+        this.content.style.pointerEvents = 'auto';
+        this._root.style.position = 'absolute';
+        this._root.style.pointerEvents = 'none';
     }
     dispose() {
         this.root.remove();
@@ -40,82 +36,51 @@ class OverlayLayoutElement {
     get root() {
         return this._root;
     }
-    layoutOverAnchorElement(anchorElement, options) {
-        if (supportsAnchorPositioning.value) {
-            if (this._currentAnchor?.element !== anchorElement) {
-                const name = getOrCreateAnchorName(anchorElement);
-                this.content.style.setProperty("position-anchor", name);
-                setParentFlowTo(this.content, anchorElement);
-                this._currentAnchor = {
-                    element: anchorElement,
-                    name
-                };
-            }
-        } else {
-            const cs = this.content.style;
-            if (options?.fallbackPosition) {
-                cs.top = `${options.fallbackPosition.top}px`;
-                cs.left = `${options.fallbackPosition.left}px`;
-            } else {
-                const anchorRect = anchorElement.getBoundingClientRect();
-                const parentRect = this.content.parentElement.getBoundingClientRect();
-                const parentBorderTop = (parentRect.height - this.content.parentElement.clientHeight) / 2.0;
-                const parentBorderLeft = (parentRect.width - this.content.parentElement.clientWidth) / 2.0;
-                cs.top = `${anchorRect.top - parentRect.top - parentBorderTop}px`;
-                cs.left = `${anchorRect.left - parentRect.left - parentBorderLeft}px`;
-            }
+    setAnchorElement(anchorElement, options) {
+        if (this._currentAnchor?.element !== anchorElement) {
+            const name = getOrCreateAnchorName(anchorElement);
+            this.content.style.setProperty('position-anchor', name);
             setParentFlowTo(this.content, anchorElement);
-            const anchorRect = anchorElement.getBoundingClientRect();
-            cs.width = `${options?.fallbackDimension ? options.fallbackDimension.width : anchorRect.width}px`;
-            cs.height = `${options?.fallbackDimension ? options.fallbackDimension.height : anchorRect.height}px`;
+            this._currentAnchor = { element: anchorElement, name };
         }
-        this._updateClipping(anchorElement, options?.clippingContainer);
+        this._updateClipping(options?.clippingContainer);
+        this._updateZIndex(anchorElement);
     }
-    _updateClipping(anchorElement, clippingContainer) {
-        if (supportsAnchorPositioning.value) {
-            if (this._clippingAnchor?.element === clippingContainer) {
-                return;
-            }
-            this._root.style.removeProperty("position-anchor");
-            const ws = this._root.style;
-            if (clippingContainer) {
-                const name = getOrCreateAnchorName(clippingContainer);
-                ws.clipPath = "content-box";
-                ws.setProperty("position-anchor", name);
-                ws.setProperty("top", "anchor(top)");
-                ws.setProperty("left", "anchor(left)");
-                ws.setProperty("width", `anchor-size(width)`);
-                ws.setProperty("height", `anchor-size(height)`);
-                this._clippingAnchor = {
-                    element: clippingContainer,
-                    name
-                };
-            } else {
-                ws.clipPath = "";
-                ws.setProperty("top", "0");
-                ws.setProperty("left", "0");
-                ws.setProperty("right", "0");
-                ws.setProperty("bottom", "0");
-                this._clippingAnchor = undefined;
-            }
-        } else {
-            if (clippingContainer) {
-                const anchorRect = anchorElement.getBoundingClientRect();
-                const clipRect = clippingContainer.getBoundingClientRect();
-                const top = Math.max(clipRect.top - anchorRect.top, 0);
-                const right = Math.max(anchorRect.width - (anchorRect.right - clipRect.right), 0);
-                const bottom = Math.max(anchorRect.height - (anchorRect.bottom - clipRect.bottom), 0);
-                const left = Math.max(clipRect.left - anchorRect.left, 0);
-                this.content.style.clipPath = `polygon(${left}px ${top}px, ${right}px ${top}px, ${right}px ${bottom}px, ${left}px ${bottom}px)`;
-                this._clippingAnchor = {
-                    element: clippingContainer,
-                    name: ""
-                };
-            } else {
-                this.content.style.clipPath = "";
-                this._clippingAnchor = undefined;
+    _updateZIndex(anchorElement) {
+        let zIndex = '';
+        for (let el = anchorElement; el; el = el.parentElement) {
+            const computed = getComputedStyle(el).zIndex;
+            if (computed && computed !== 'auto') {
+                zIndex = String(Number(computed) + 1);
+                break;
             }
         }
+        this.content.style.zIndex = zIndex;
+    }
+    _updateClipping(clippingContainer) {
+        if (this._clippingAnchor?.element === clippingContainer) {
+            return;
+        }
+        this._root.style.removeProperty('position-anchor');
+        const ws = this._root.style;
+        if (clippingContainer) {
+            const name = getOrCreateAnchorName(clippingContainer);
+            ws.clipPath = 'content-box';
+            ws.setProperty('position-anchor', name);
+            ws.setProperty('top', 'anchor(top)');
+            ws.setProperty('left', 'anchor(left)');
+            ws.setProperty('width', `anchor-size(width)`);
+            ws.setProperty('height', `anchor-size(height)`);
+            this._clippingAnchor = { element: clippingContainer, name };
+        }
+        else {
+            ws.clipPath = '';
+            ws.setProperty('top', '0');
+            ws.setProperty('left', '0');
+            ws.setProperty('right', '0');
+            ws.setProperty('bottom', '0');
+            this._clippingAnchor = undefined;
+        }
     }
 }
 

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

@@ -54,14 +54,15 @@ export declare class ActionBar extends Disposable implements IActionRunner {
     private _context;
     private readonly _orientation;
     private readonly _triggerKeys;
-    viewItems: IActionViewItem[];
+    private _viewItems;
+    get viewItems(): readonly IActionViewItem[];
     private readonly viewItemDisposables;
     private previouslyFocusedItem?;
     protected focusedItem?: number;
     private focusTracker;
     private triggerKeyDown;
     private focusable;
-    domNode: HTMLElement;
+    readonly domNode: HTMLElement;
     protected readonly actionsList: HTMLElement;
     private readonly _onDidBlur;
     get onDidBlur(): import("../../../common/event.js").Event<void>;

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

@@ -18,6 +18,9 @@ var ActionsOrientation;
     ActionsOrientation[ActionsOrientation["VERTICAL"] = 1] = "VERTICAL";
 })(ActionsOrientation || (ActionsOrientation = {}));
 class ActionBar extends Disposable {
+    get viewItems() {
+        return this._viewItems;
+    }
     get onDidBlur() {
         return this._onDidBlur.event;
     }
@@ -59,7 +62,7 @@ class ActionBar extends Disposable {
         }
         this._actionRunnerDisposables.add(this._actionRunner.onDidRun(e => this._onDidRun.fire(e)));
         this._actionRunnerDisposables.add(this._actionRunner.onWillRun(e => this._onWillRun.fire(e)));
-        this.viewItems = [];
+        this._viewItems = [];
         this.focusedItem = undefined;
         this.domNode = createElement("div");
         this.domNode.className = "monaco-action-bar";
@@ -262,10 +265,10 @@ class ActionBar extends Disposable {
             item.render(actionViewItemElement);
             if (index === null || index < 0 || index >= this.actionsList.children.length) {
                 this.actionsList.appendChild(actionViewItemElement);
-                this.viewItems.push(item);
+                this._viewItems.push(item);
             } else {
                 this.actionsList.insertBefore(actionViewItemElement, this.actionsList.children[index]);
-                this.viewItems.splice(index, 0, item);
+                this._viewItems.splice(index, 0, item);
                 index++;
             }
         });
@@ -299,28 +302,16 @@ class ActionBar extends Disposable {
         this.refreshRole();
     }
     getWidth(index) {
-        if (index >= 0 && index < this.actionsList.children.length) {
-            const item = this.actionsList.children.item(index);
-            if (item) {
-                return item.clientWidth;
-            }
-        }
-        return 0;
+        return this.actionsList.children.item(index)?.clientWidth ?? 0;
     }
     getHeight(index) {
-        if (index >= 0 && index < this.actionsList.children.length) {
-            const item = this.actionsList.children.item(index);
-            if (item) {
-                return item.clientHeight;
-            }
-        }
-        return 0;
+        return this.actionsList.children.item(index)?.clientHeight ?? 0;
     }
     pull(index) {
         if (index >= 0 && index < this.viewItems.length) {
             this.actionsList.childNodes[index].remove();
             this.viewItemDisposables.deleteAndDispose(this.viewItems[index]);
-            dispose(this.viewItems.splice(index, 1));
+            dispose(this._viewItems.splice(index, 1));
             this.refreshRole();
         }
     }
@@ -328,7 +319,7 @@ class ActionBar extends Disposable {
         if (this.isEmpty()) {
             return;
         }
-        this.viewItems = dispose(this.viewItems);
+        this._viewItems = dispose(this._viewItems);
         this.viewItemDisposables.clearAndDisposeAll();
         clearNode(this.actionsList);
         this.refreshRole();
@@ -462,7 +453,7 @@ class ActionBar extends Disposable {
     }
     dispose() {
         this._context = undefined;
-        this.viewItems = dispose(this.viewItems);
+        this._viewItems = dispose(this._viewItems);
         this.getContainer().remove();
         super.dispose();
     }

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

@@ -38,6 +38,8 @@ export interface IButton extends IDisposable {
     set icon(value: ThemeIcon);
     set enabled(value: boolean);
     set checked(value: boolean);
+    setTitle(title: string): void;
+    setAriaLabel(ariaLabel: string): void;
     focus(): void;
     hasFocus(): boolean;
 }
@@ -72,6 +74,7 @@ export declare class Button extends Disposable implements IButton {
     set checked(value: boolean);
     get checked(): boolean;
     setTitle(title: string): void;
+    setAriaLabel(ariaLabel: string): void;
     focus(): void;
     hasFocus(): boolean;
 }
@@ -102,6 +105,8 @@ export declare class ButtonWithDropdown extends Disposable implements IButton {
     get enabled(): boolean;
     set checked(value: boolean);
     get checked(): boolean;
+    setTitle(title: string): void;
+    setAriaLabel(ariaLabel: string): void;
     focus(): void;
     hasFocus(): boolean;
 }
@@ -119,6 +124,8 @@ export declare class ButtonWithDescription implements IButtonWithDescription {
     set enabled(enabled: boolean);
     set checked(value: boolean);
     get checked(): boolean;
+    setTitle(title: string): void;
+    setAriaLabel(ariaLabel: string): void;
     focus(): void;
     hasFocus(): boolean;
     dispose(): void;

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

@@ -278,6 +278,9 @@ class Button extends Disposable {
             this._hover.update(title);
         }
     }
+    setAriaLabel(ariaLabel) {
+        this._element.setAttribute("aria-label", ariaLabel);
+    }
     focus() {
         this._element.focus();
     }
@@ -365,6 +368,12 @@ class ButtonWithDropdown extends Disposable {
     get checked() {
         return this.primaryButton.checked;
     }
+    setTitle(title) {
+        this.primaryButton.setTitle(title);
+    }
+    setAriaLabel(ariaLabel) {
+        this.primaryButton.setAriaLabel(ariaLabel);
+    }
     focus() {
         this.primaryButton.focus();
     }
@@ -407,6 +416,12 @@ class ButtonWithDescription {
     get checked() {
         return this._button.checked;
     }
+    setTitle(title) {
+        this._button.setTitle(title);
+    }
+    setAriaLabel(ariaLabel) {
+        this._button.setAriaLabel(ariaLabel);
+    }
     focus() {
         this._button.focus();
     }

package/vscode/src/vs/base/browser/ui/findinput/replaceInput.d.ts

@@ -68,5 +68,4 @@ export declare class ReplaceInput extends Widget {
     clearMessage(): void;
     private clearValidation;
     set width(newWidth: number);
-    dispose(): void;
 }

package/vscode/src/vs/base/browser/ui/findinput/replaceInput.js

@@ -214,9 +214,6 @@ class ReplaceInput extends Widget {
         this.inputBox.paddingRight = this.cachedOptionsWidth;
         this.domNode.style.width = newWidth + "px";
     }
-    dispose() {
-        super.dispose();
-    }
 }
 
 export { ReplaceInput };

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

@@ -100,7 +100,7 @@ class ToolBar extends Disposable {
             this.element.classList.toggle("responsive-all", this.options.responsiveBehavior.kind === "all");
             this.element.classList.toggle("responsive-last", this.options.responsiveBehavior.kind === "last");
             this.element.style.setProperty(ACTION_MIN_WIDTH_VAR, `${this.getConfiguredActionMinWidth()}px`);
-            const observer = this._store.add(( new DisposableResizeObserver(() => {
+            const observer = this._store.add(( new DisposableResizeObserver("Toolbar.actionsUpdate", () => {
                 this.updateActions(this.element.getBoundingClientRect().width);
             })));
             observer.observe(this.element);

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

@@ -34,6 +34,7 @@ export declare function raceCancellation<T>(promise: Promise<T>, token: Cancella
  * @see {@link raceCancellation}
  */
 export declare function raceCancellationError<T>(promise: Promise<T>, token: CancellationToken): Promise<T>;
+export declare function rejectIfNotCanceled(err: unknown): undefined;
 /**
  * Wraps a cancellable promise such that it is no cancellable. Can be used to
  * avoid issues with shared promises that would normally be returned as
@@ -775,4 +776,5 @@ export declare class AsyncReader<T> {
     peekTimeout(timeoutMs: number): Promise<T | typeof AsyncReaderEndOfStream | undefined>;
     private _extendBuffer;
 }
+export declare function createTimeout(ms: number, cb: () => void): IDisposable;
 export {};

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

@@ -1,6 +1,6 @@
 
 import { CancellationTokenSource } from './cancellation.js';
-import { CancellationError, BugIndicatingError } from './errors.js';
+import { CancellationError, isCancellationError, BugIndicatingError } from './errors.js';
 import { Emitter, Event } from './event.js';
 import { isDisposable, toDisposable, DisposableMap } from './lifecycle.js';
 import { extUri } from './resources.js';
@@ -69,6 +69,12 @@ function raceCancellationError(promise, token) {
         promise.then(resolve, reject).finally(() => ref.dispose());
     }));
 }
+function rejectIfNotCanceled(err) {
+    if (isCancellationError(err)) {
+        return undefined;
+    }
+    return Promise.reject(err);
+}
 function notCancellablePromise(promise) {
     return ( new Promise((resolve, reject) => {
         promise.then(resolve, reject);
@@ -1511,4 +1517,4 @@ class CancelableAsyncIterableProducer extends AsyncIterableProducer {
     }
 }
 
-export { AbstractIdleValue, AsyncIterableObject, AsyncIterableProducer, AsyncIterableSource, AutoOpenBarrier, Barrier, CancelableAsyncIterableProducer, DeferredPromise, Delayer, GlobalIdleValue, IntervalCounter, IntervalTimer, LazyStatefulPromise, Limiter, Promises, Queue, ResourceQueue, RunOnceScheduler, RunOnceWorker, Sequencer, SequencerByKey, StatefulPromise, TaskQueue, TaskSequentializer, ThrottledDelayer, Throttler, TimeoutTimer, _runWhenIdle, asPromise, createCancelableAsyncIterableProducer, createCancelablePromise, disposableTimeout, first, isThenable, notCancellablePromise, promiseWithResolvers, raceCancellablePromises, raceCancellation, raceCancellationError, raceTimeout, retry, runWhenGlobalIdle, sequence, timeout };
+export { AbstractIdleValue, AsyncIterableObject, AsyncIterableProducer, AsyncIterableSource, AutoOpenBarrier, Barrier, CancelableAsyncIterableProducer, DeferredPromise, Delayer, GlobalIdleValue, IntervalCounter, IntervalTimer, LazyStatefulPromise, Limiter, Promises, Queue, ResourceQueue, RunOnceScheduler, RunOnceWorker, Sequencer, SequencerByKey, StatefulPromise, TaskQueue, TaskSequentializer, ThrottledDelayer, Throttler, TimeoutTimer, _runWhenIdle, asPromise, createCancelableAsyncIterableProducer, createCancelablePromise, disposableTimeout, first, isThenable, notCancellablePromise, promiseWithResolvers, raceCancellablePromises, raceCancellation, raceCancellationError, raceTimeout, rejectIfNotCanceled, retry, runWhenGlobalIdle, sequence, timeout };

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

@@ -725,4 +725,5 @@ export declare const Codicon: {
     readonly openInWindow: ThemeIcon;
     readonly newSession: ThemeIcon;
     readonly terminalSecure: ThemeIcon;
+    readonly shareWindow: ThemeIcon;
 };

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

@@ -647,4 +647,7 @@ export declare const codiconsLibrary: {
     readonly openInWindow: import("./themables.js").ThemeIcon;
     readonly newSession: import("./themables.js").ThemeIcon;
     readonly terminalSecure: import("./themables.js").ThemeIcon;
+    readonly chatImport: import("./themables.js").ThemeIcon;
+    readonly chatExport: import("./themables.js").ThemeIcon;
+    readonly shareWindow: import("./themables.js").ThemeIcon;
 };

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

@@ -650,6 +650,9 @@ const codiconsLibrary = {
     openInWindow: register('open-in-window', 0xec83),
     newSession: register('new-session', 0xec84),
     terminalSecure: register('terminal-secure', 0xec85),
+    chatImport: register('chat-import', 0xec86),
+    chatExport: register('chat-export', 0xec87),
+    shareWindow: register('share-window', 0xec88),
 };
 
 export { codiconsLibrary };

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

@@ -330,6 +330,11 @@ export interface EmitterOptions {
      * @see setGlobalLeakWarningThreshold
      */
     leakWarningThreshold?: number;
+    /**
+     * Human-readable name for the emitter, included in leak warning error
+     * messages to help identify which emitter is leaking in telemetry.
+     */
+    leakWarningName?: string;
     /**
      * Pass in a delivery queue, which is useful for ensuring
      * in order event delivery across multiple emitters.
@@ -364,14 +369,15 @@ export declare class ListenerLeakError extends Error {
     /**
      * The detailed message including listener count and most frequent stack.
      * Available locally for debugging but intentionally not used as the error
-     * `message` so that all leak errors group under the same title in telemetry.
+     * `message`. When `emitterName` is provided, errors group by emitter name
+     * and kind in telemetry; otherwise they group by kind alone.
      */
     readonly details: string;
-    constructor(kind: "dominated" | "popular", details: string, stack: string, listenerCount: number);
+    constructor(kind: "dominated" | "popular", details: string, stack: string, listenerCount: number, emitterName?: string);
     static is(err: unknown): err is ListenerLeakError;
 }
 export declare class ListenerRefusalError extends ListenerLeakError {
-    constructor(kind: "dominated" | "popular", details: string, stack: string, listenerCount: number);
+    constructor(kind: "dominated" | "popular", details: string, stack: string, listenerCount: number, emitterName?: string);
 }
 declare class UniqueContainer<T> {
     readonly value: T;