@codingame/monaco-vscode-api 13.1.7 → 14.0.0

package/vscode/src/vs/base/browser/ui/list/listView.d.ts

@@ -41,10 +41,12 @@ export interface IListViewOptions<T> extends IListViewOptionsUpdate {
     readonly setRowHeight?: boolean;
     readonly supportDynamicHeights?: boolean;
     readonly mouseSupport?: boolean;
+    readonly userSelection?: boolean;
     readonly accessibilityProvider?: IListViewAccessibilityProvider<T>;
     readonly transformOptimization?: boolean;
     readonly alwaysConsumeMouseWheel?: boolean;
     readonly initialSize?: Dimension;
+    readonly scrollToActiveElement?: boolean;
 }
 export declare class ElementsDragAndDropData<T, TContext = void> implements IDragAndDropData {
     readonly elements: T[];
@@ -155,6 +157,9 @@ export declare class ListView<T> implements IListView<T> {
     private currentDragFeedbackPosition;
     private currentDragFeedbackDisposable;
     private onDragLeaveTimeout;
+    private currentSelectionDisposable;
+    private currentSelectionBounds;
+    private activeElement;
     private readonly disposables;
     private readonly _onDidChangeContentHeight;
     private readonly _onDidChangeContentWidth;
@@ -170,6 +175,8 @@ export declare class ListView<T> implements IListView<T> {
     private get horizontalScrolling();
     private set horizontalScrolling(value);
     constructor(container: HTMLElement, virtualDelegate: IListVirtualDelegate<T>, renderers: IListRenderer<any, any>[], options?: IListViewOptions<T>);
+    private _setupFocusObserver;
+    private _scrollToActiveElement;
     updateOptions(options: IListViewOptionsUpdate): void;
     delegateScrollFromMouseWheelEvent(browserEvent: IMouseWheelEvent): void;
     delegateVerticalScrollbarPointerDown(browserEvent: PointerEvent): void;
@@ -225,6 +232,8 @@ export declare class ListView<T> implements IListView<T> {
     private onScroll;
     private onTouchChange;
     private onDragStart;
+    private onPotentialSelectionStart;
+    private getIndexOfListElement;
     private onDragOver;
     private onDragLeave;
     private onDrop;
@@ -235,6 +244,7 @@ export declare class ListView<T> implements IListView<T> {
     private teardownDragAndDropScrollTopAnimation;
     private getTargetSector;
     private getItemIndexFromEventTarget;
+    private getVisibleRange;
     protected getRenderRange(renderTop: number, renderHeight: number): IRange;
     protected _rerender(renderTop: number, renderHeight: number, inSmoothScrolling?: boolean): void;
     private probeDynamicHeight;

package/vscode/src/vs/base/browser/ui/list/listView.js

@@ -1,11 +1,11 @@
 
 import { __decorate } from '../../../../../../../external/tslib/tslib.es6.js';
 import { DataTransfers } from '../../dnd.js';
-import { getContentWidth, scheduleAtNextAnimationFrame, getWindow, addDisposableListener, getContentHeight, $, getTopLeftOffset, animate, isHTMLElement, isSVGElement, isAncestor } from '../../dom.js';
+import { getContentWidth, scheduleAtNextAnimationFrame, getWindow, addDisposableListener, getActiveElement, getContentHeight, $, getDocument, getTopLeftOffset, animate, isHTMLElement, isSVGElement, isAncestor } from '../../dom.js';
 import { DomEmitter } from '../../event.js';
 import { Gesture, EventType } from '../../touch.js';
 import { SmoothScrollableElement } from '../scrollbar/scrollableElement.js';
-import { equals, distinct } from '../../../common/arrays.js';
+import { equals, splice, distinct } from '../../../common/arrays.js';
 import { Delayer, disposableTimeout } from '../../../common/async.js';
 import { memoize } from '../../../common/decorators.js';
 import { Emitter, Event } from '../../../common/event.js';
@@ -176,6 +176,7 @@ class ListView {
         this.canDrop = false;
         this.currentDragFeedbackDisposable = Disposable.None;
         this.onDragLeaveTimeout = Disposable.None;
+        this.currentSelectionDisposable = Disposable.None;
         this.disposables = ( new DisposableStore());
         this._onDidChangeContentHeight = ( new Emitter());
         this._onDidChangeContentWidth = ( new Emitter());
@@ -230,16 +231,49 @@ class ListView {
         container.appendChild(this.domNode);
         this.scrollableElement.onScroll(this.onScroll, this, this.disposables);
         this.disposables.add(addDisposableListener(this.rowsContainer, EventType.Change, e => this.onTouchChange(e)));
-        this.disposables.add(addDisposableListener(this.scrollableElement.getDomNode(), 'scroll', e => e.target.scrollTop = 0));
+        this.disposables.add(addDisposableListener(this.scrollableElement.getDomNode(), 'scroll', e => {
+            const element = e.target;
+            const scrollValue = element.scrollTop;
+            element.scrollTop = 0;
+            if (options.scrollToActiveElement) {
+                this.setScrollTop(this.scrollTop + scrollValue);
+            }
+        }));
         this.disposables.add(addDisposableListener(this.domNode, 'dragover', e => this.onDragOver(this.toDragEvent(e))));
         this.disposables.add(addDisposableListener(this.domNode, 'drop', e => this.onDrop(this.toDragEvent(e))));
         this.disposables.add(addDisposableListener(this.domNode, 'dragleave', e => this.onDragLeave(this.toDragEvent(e))));
         this.disposables.add(addDisposableListener(this.domNode, 'dragend', e => this.onDragEnd(e)));
+        if (options.userSelection) {
+            if (options.dnd) {
+                throw ( new Error('DND and user selection cannot be used simultaneously'));
+            }
+            this.disposables.add(addDisposableListener(this.domNode, 'mousedown', e => this.onPotentialSelectionStart(e)));
+        }
         this.setRowLineHeight = options.setRowLineHeight ?? DefaultOptions.setRowLineHeight;
         this.setRowHeight = options.setRowHeight ?? DefaultOptions.setRowHeight;
         this.supportDynamicHeights = options.supportDynamicHeights ?? DefaultOptions.supportDynamicHeights;
         this.dnd = options.dnd ?? this.disposables.add(DefaultOptions.dnd);
         this.layout(options.initialSize?.height, options.initialSize?.width);
+        if (options.scrollToActiveElement) {
+            this._setupFocusObserver(container);
+        }
+    }
+    _setupFocusObserver(container) {
+        this.disposables.add(addDisposableListener(container, 'focus', () => {
+            const element = getActiveElement();
+            if (this.activeElement !== element && element !== null) {
+                this.activeElement = element;
+                this._scrollToActiveElement(this.activeElement, container);
+            }
+        }, true));
+    }
+    _scrollToActiveElement(element, container) {
+        const containerRect = container.getBoundingClientRect();
+        const elementRect = element.getBoundingClientRect();
+        const topOffset = elementRect.top - containerRect.top;
+        if (topOffset < 0) {
+            this.setScrollTop(this.scrollTop + topOffset);
+        }
     }
     updateOptions(options) {
         if (options.paddingBottom !== undefined) {
@@ -320,6 +354,9 @@ class ListView {
         if (this.supportDynamicHeights) {
             this._rerender(this.lastRenderTop, this.lastRenderHeight);
         }
+        else {
+            this._onDidChangeContentHeight.fire(this.contentHeight);
+        }
     }
     createRangeMap(paddingTop) {
         return ( new RangeMap(paddingTop));
@@ -388,7 +425,7 @@ class ListView {
         }
         else {
             this.rangeMap.splice(start, deleteCount, inserted);
-            deleted = this.items.splice(start, deleteCount, ...inserted);
+            deleted = splice(this.items, start, deleteCount, inserted);
         }
         const delta = elements.length - deleteCount;
         const renderRange = this.getRenderRange(this.lastRenderTop, this.lastRenderHeight);
@@ -486,7 +523,7 @@ class ListView {
         return scrollDimensions.height;
     }
     get firstVisibleIndex() {
-        const range = this.getRenderRange(this.lastRenderTop, this.lastRenderHeight);
+        const range = this.getVisibleRange(this.lastRenderTop, this.lastRenderHeight);
         return range.start;
     }
     get firstMostlyVisibleIndex() {
@@ -796,6 +833,57 @@ class ListView {
         StaticDND.CurrentDragAndDropData = ( new ExternalElementsDragAndDropData(elements));
         this.dnd.onDragStart?.(this.currentDragData, event);
     }
+    onPotentialSelectionStart(e) {
+        this.currentSelectionDisposable.dispose();
+        const doc = getDocument(this.domNode);
+        const selectionStore = this.currentSelectionDisposable = ( new DisposableStore());
+        const movementStore = selectionStore.add(( new DisposableStore()));
+        movementStore.add(addDisposableListener(this.domNode, 'selectstart', () => {
+            movementStore.add(addDisposableListener(doc, 'mousemove', e => {
+                if (doc.getSelection()?.isCollapsed === false) {
+                    this.setupDragAndDropScrollTopAnimation(e);
+                }
+            }));
+            selectionStore.add(toDisposable(() => {
+                const previousRenderRange = this.getRenderRange(this.lastRenderTop, this.lastRenderHeight);
+                this.currentSelectionBounds = undefined;
+                this.render(previousRenderRange, this.lastRenderTop, this.lastRenderHeight, undefined, undefined);
+            }));
+            selectionStore.add(addDisposableListener(doc, 'selectionchange', () => {
+                const selection = doc.getSelection();
+                if (!selection) {
+                    return;
+                }
+                let start = this.getIndexOfListElement(selection.anchorNode);
+                let end = this.getIndexOfListElement(selection.focusNode);
+                if (start !== undefined && end !== undefined) {
+                    if (end < start) {
+                        [start, end] = [end, start];
+                    }
+                    this.currentSelectionBounds = { start, end };
+                }
+            }));
+        }));
+        movementStore.add(addDisposableListener(doc, 'mouseup', () => {
+            movementStore.dispose();
+            this.teardownDragAndDropScrollTopAnimation();
+            if (doc.getSelection()?.isCollapsed !== false) {
+                selectionStore.dispose();
+            }
+        }));
+    }
+    getIndexOfListElement(element) {
+        if (!element || !this.domNode.contains(element)) {
+            return undefined;
+        }
+        while (element && element !== this.domNode) {
+            if (element.dataset?.index) {
+                return Number(element.dataset.index);
+            }
+            element = element.parentElement;
+        }
+        return undefined;
+    }
     onDragOver(event) {
         event.browserEvent.preventDefault();
         this.onDragLeaveTimeout.dispose();
@@ -975,12 +1063,20 @@ class ListView {
         }
         return undefined;
     }
-    getRenderRange(renderTop, renderHeight) {
+    getVisibleRange(renderTop, renderHeight) {
         return {
             start: this.rangeMap.indexAt(renderTop),
             end: this.rangeMap.indexAfter(renderTop + renderHeight - 1)
         };
     }
+    getRenderRange(renderTop, renderHeight) {
+        const range = this.getVisibleRange(renderTop, renderHeight);
+        if (this.currentSelectionBounds) {
+            range.start = Math.min(range.start, this.currentSelectionBounds.start);
+            range.end = Math.max(range.end, this.currentSelectionBounds.end + 1);
+        }
+        return range;
+    }
     _rerender(renderTop, renderHeight, inSmoothScrolling) {
         const previousRenderRange = this.getRenderRange(renderTop, renderHeight);
         let anchorElementIndex;

package/vscode/src/vs/base/browser/ui/list/listWidget.d.ts

@@ -89,6 +89,7 @@ export interface IListOptions<T> extends IListOptionsUpdate {
     readonly setRowHeight?: boolean;
     readonly supportDynamicHeights?: boolean;
     readonly mouseSupport?: boolean;
+    readonly userSelection?: boolean;
     readonly horizontalScrolling?: boolean;
     readonly scrollByPage?: boolean;
     readonly transformOptimization?: boolean;

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

@@ -637,7 +637,6 @@ class SubmenuMenuActionViewItem extends BaseMenuActionViewItem {
             this.submenuContainer.classList.add('menubar-menu-items-holder', 'context-view');
             const computedStyles = getWindow(this.parentData.parent.domNode).getComputedStyle(this.parentData.parent.domNode);
             const paddingTop = parseFloat(computedStyles.paddingTop || '0') || 0;
-            this.submenuContainer.style.zIndex = '1';
             this.submenuContainer.style.position = 'fixed';
             this.submenuContainer.style.top = '0';
             this.submenuContainer.style.left = '0';
@@ -1078,6 +1077,10 @@ ${formatRule(Codicon.menuSubmenu)}
 				height: 3px;
 				width: 3px;
 			}
+			/* Fix for https://github.com/microsoft/vscode/issues/103170 */
+			.monaco-menu .action-item .monaco-submenu {
+				z-index: 1;
+			}
 		`;
         const scrollbarShadowColor = style.scrollbarShadow;
         if (scrollbarShadowColor) {

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

@@ -163,7 +163,7 @@ interface IAbstractFindControllerOptions extends IFindWidgetOptions {
     toggles?: ITreeFindToggleContribution[];
     showNotFoundMessage?: boolean;
 }
-interface IFindControllerOptions extends IAbstractFindControllerOptions {
+export interface IFindControllerOptions extends IAbstractFindControllerOptions {
     defaultFindMode?: TreeFindMode;
     defaultFindMatchType?: TreeFindMatchType;
 }

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

@@ -13,7 +13,7 @@ import { Toggle, unthemedToggleStyles } from '../toggle/toggle.js';
 import { isFilterResult, getVisibleState } from './indexTreeModel.js';
 import { TreeDragOverBubble, TreeVisibility, TreeMouseEventTarget, TreeError } from './tree.js';
 import { Action } from '../../../common/actions.js';
-import { range, equals, distinct } from '../../../common/arrays.js';
+import { range, equals, distinct, insertInto } from '../../../common/arrays.js';
 import { disposableTimeout, timeout, Delayer } from '../../../common/async.js';
 import { Codicon } from '../../../common/codicons.js';
 import { ThemeIcon } from '../../../common/themables.js';
@@ -877,7 +877,7 @@ class FindController extends AbstractFindController {
     applyPattern(pattern) {
         this.tree.refilter();
         if (pattern) {
-            this.tree.focusNext(0, true, undefined, (node) => this.shouldAllowFocus(node));
+            this.tree.focusNext(0, true, undefined, (node) => !FuzzyScore.isDefault(node.filterData));
         }
         const focus = this.tree.getFocus();
         if (focus.length > 0) {
@@ -2297,13 +2297,13 @@ class AbstractTree {
             state.selection.add(getId(selection));
         }
         const root = this.model.getNode();
-        const queue = [root];
-        while (queue.length > 0) {
-            const node = queue.shift();
+        const stack = [root];
+        while (stack.length > 0) {
+            const node = stack.pop();
             if (node !== root && node.collapsible) {
                 state.expanded[getId(node.element)] = node.collapsed ? 0 : 1;
             }
-            queue.push(...node.children);
+            insertInto(stack, stack.length, node.children);
         }
         return state;
     }

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

@@ -104,7 +104,7 @@ export declare class AsyncDataTree<TInput, T, TFilterData = void> implements IDi
     get onDidDispose(): Event<void>;
     constructor(user: string, container: HTMLElement, delegate: IListVirtualDelegate<T>, renderers: ITreeRenderer<T, TFilterData, any>[], dataSource: IAsyncDataSource<TInput, T>, options?: IAsyncDataTreeOptions<T, TFilterData>);
     protected createTree(user: string, container: HTMLElement, delegate: IListVirtualDelegate<T>, renderers: ITreeRenderer<T, TFilterData, any>[], options: IAsyncDataTreeOptions<T, TFilterData>): ObjectTree<IAsyncDataTreeNode<TInput, T>, TFilterData>;
-    updateOptions(options?: IAsyncDataTreeOptionsUpdate): void;
+    updateOptions(optionsUpdate?: IAsyncDataTreeOptionsUpdate): void;
     get options(): IAsyncDataTreeOptions<T, TFilterData>;
     getHTMLElement(): HTMLElement;
     get contentHeight(): number;
@@ -199,7 +199,6 @@ export declare class CompressibleAsyncDataTree<TInput, T, TFilterData = void> ex
     getCompressedTreeNode(e: T | TInput): ICompressedTreeNode<IAsyncDataTreeNode<TInput, T>> | null;
     protected createTree(user: string, container: HTMLElement, delegate: IListVirtualDelegate<T>, renderers: ICompressibleTreeRenderer<T, TFilterData, any>[], options: ICompressibleAsyncDataTreeOptions<T, TFilterData>): ObjectTree<IAsyncDataTreeNode<TInput, T>, TFilterData>;
     protected asTreeElement(node: IAsyncDataTreeNode<TInput, T>, viewStateContext?: IAsyncDataTreeViewStateContext<TInput, T>): ICompressedTreeElement<IAsyncDataTreeNode<TInput, T>>;
-    updateOptions(options?: ICompressibleAsyncDataTreeOptionsUpdate): void;
     getViewState(): IAsyncDataTreeViewState;
     protected render(node: IAsyncDataTreeNode<TInput, T>, viewStateContext?: IAsyncDataTreeViewStateContext<TInput, T>, options?: IAsyncDataTreeUpdateChildrenOptions<T>): void;
     protected processChildren(children: Iterable<T>): Iterable<T>;

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

@@ -14,7 +14,7 @@ import { toDisposable, DisposableStore, dispose } from '../../../common/lifecycl
 import { isIterable } from '../../../common/types.js';
 import { CancellationTokenSource } from '../../../common/cancellation.js';
 import { FuzzyScore } from '../../../common/filters.js';
-import { splice } from '../../../common/arrays.js';
+import { splice, insertInto } from '../../../common/arrays.js';
 import { localize } from '../../../../nls.js';
 
 function createAsyncDataTreeNode(props) {
@@ -416,7 +416,12 @@ class AsyncDataTree {
         this.nodes.set(null, this.root);
         this.tree.onDidChangeCollapseState(this._onDidChangeCollapseState, this, this.disposables);
         if (asyncFindEnabled) {
-            const findOptions = { styles: options.findWidgetStyles, showNotFoundMessage: options.showNotFoundMessage };
+            const findOptions = {
+                styles: options.findWidgetStyles,
+                showNotFoundMessage: options.showNotFoundMessage,
+                defaultFindMatchType: options.defaultFindMatchType,
+                defaultFindMode: options.defaultFindMode,
+            };
             this.findController = this.disposables.add(( new AsyncFindController(
                 this.tree,
                 options.findProvider,
@@ -447,8 +452,16 @@ class AsyncDataTree {
             objectTreeOptions
         ));
     }
-    updateOptions(options = {}) {
-        this.tree.updateOptions(options);
+    updateOptions(optionsUpdate = {}) {
+        if (this.findController) {
+            if (optionsUpdate.defaultFindMode !== undefined) {
+                this.findController.mode = optionsUpdate.defaultFindMode;
+            }
+            if (optionsUpdate.defaultFindMatchType !== undefined) {
+                this.findController.matchType = optionsUpdate.defaultFindMatchType;
+            }
+        }
+        this.tree.updateOptions(optionsUpdate);
     }
     get options() {
         return this.tree.options;
@@ -991,7 +1004,7 @@ class AsyncDataTree {
             if (node !== root && node.collapsible && !node.collapsed) {
                 expanded.push(getId(node.element.element));
             }
-            stack.push(...node.children);
+            insertInto(stack, stack.length, node.children);
         }
         return { focus, selection, expanded, scrollTop: this.scrollTop };
     }
@@ -1109,9 +1122,6 @@ class CompressibleAsyncDataTree extends AsyncDataTree {
             ...super.asTreeElement(node, viewStateContext)
         };
     }
-    updateOptions(options = {}) {
-        this.tree.updateOptions(options);
-    }
     getViewState() {
         if (!this.identityProvider) {
             throw ( new TreeError(this.user, 'Can\'t get tree view state without an identity provider'));

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

@@ -1,6 +1,6 @@
 
 import { TreeVisibility, TreeError } from './tree.js';
-import { splice, tail2 } from '../../../common/arrays.js';
+import { splice, tail } from '../../../common/arrays.js';
 import { Delayer } from '../../../common/async.js';
 import { MicrotaskDelay } from '../../../common/symbols.js';
 import { LcsDiff } from '../../../common/diff/diff.js';
@@ -510,7 +510,7 @@ class IndexTreeModel {
             return [];
         }
         else {
-            return tail2(location)[0];
+            return tail(location)[0];
         }
     }
     getFirstElementChild(location) {

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

@@ -21,7 +21,7 @@ export type WorkbenchActionExecutedClassification = {
         purpose: "FeatureInsight";
         comment: "Optional details about how the action was run, e.g which keybinding was used.";
     };
-    owner: "bpasero";
+    owner: "isidorn";
     comment: "Provides insight into actions that are executed within the workbench.";
 };
 export type WorkbenchActionExecutedEvent = {

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

@@ -1,7 +1,6 @@
 import { CancellationToken } from "./cancellation.js";
 import { ISplice } from "./sequence.js";
-export declare function tail<T>(array: ArrayLike<T>, n?: number): T | undefined;
-export declare function tail2<T>(arr: T[]): [
+export declare function tail<T>(arr: T[]): [
     T[],
     T
 ];

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

@@ -1,7 +1,7 @@
 
 import { findFirstIdxMonotonousOrArrLen } from './arraysFind.js';
 
-function tail2(arr) {
+function tail(arr) {
     if (arr.length === 0) {
         throw ( new Error('Invalid tail call'));
     }
@@ -544,4 +544,4 @@ 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, tail2, tieBreakComparators, top, uniqueFilter };
+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, tieBreakComparators, top, uniqueFilter };

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

@@ -1,6 +1,6 @@
 export declare function ok(value?: unknown, message?: string): void;
 export declare function assertNever(value: never, message?: string): never;
-export declare function assert(condition: boolean, message?: string): asserts condition;
+export declare function assert(condition: boolean, messageOrError?: string | Error): asserts condition;
 export declare function softAssert(condition: boolean): void;
 export declare function assertFn(condition: () => boolean): void;
 export declare function checkAdjacentItems<T>(items: readonly T[], predicate: (item1: T, item2: T) => boolean): boolean;

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

@@ -9,9 +9,12 @@ function ok(value, message) {
 function assertNever(value, message = 'Unreachable') {
     throw ( new Error(message));
 }
-function assert(condition, message = 'unexpected state') {
+function assert(condition, messageOrError = 'unexpected state') {
     if (!condition) {
-        throw ( new BugIndicatingError(`Assertion Failed: ${message}`));
+        const errorToThrow = typeof messageOrError === 'string'
+            ? ( new BugIndicatingError(`Assertion Failed: ${messageOrError}`))
+            : messageOrError;
+        throw errorToThrow;
     }
 }
 function softAssert(condition) {

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

@@ -334,7 +334,7 @@ function disposableTimeout(handler, timeout = 0, store) {
     }, timeout);
     const disposable = toDisposable(() => {
         clearTimeout(timer);
-        store?.deleteAndLeak(disposable);
+        store?.delete(disposable);
     });
     store?.add(disposable);
     return disposable;
@@ -446,6 +446,20 @@ class Queue extends Limiter {
         super(1);
     }
 }
+class LimitedQueue {
+    constructor() {
+        this.sequentializer = ( new TaskSequentializer());
+        this.tasks = 0;
+    }
+    queue(factory) {
+        if (!this.sequentializer.isRunning()) {
+            return this.sequentializer.run(this.tasks++, factory());
+        }
+        return this.sequentializer.queue(() => {
+            return this.sequentializer.run(this.tasks++, factory());
+        });
+    }
+}
 class ResourceQueue {
     constructor() {
         this.queues = ( new Map());
@@ -1161,4 +1175,4 @@ class AsyncIterableSource {
     }
 }
 
-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 };
+export { AbstractIdleValue, AsyncIterableObject, AsyncIterableSource, AutoOpenBarrier, Barrier, CancelableAsyncIterableObject, DeferredPromise, Delayer, GlobalIdleValue, IntervalCounter, IntervalTimer, LazyStatefulPromise, LimitedQueue, 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/codicons.d.ts

@@ -636,4 +636,5 @@ export declare const Codicon: {
     readonly python: ThemeIcon;
     readonly copilotLarge: ThemeIcon;
     readonly copilotWarningLarge: ThemeIcon;
+    readonly keyboardTab: ThemeIcon;
 };

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

@@ -576,4 +576,5 @@ export declare const codiconsLibrary: {
     readonly python: import("./themables.js").ThemeIcon;
     readonly copilotLarge: import("./themables.js").ThemeIcon;
     readonly copilotWarningLarge: import("./themables.js").ThemeIcon;
+    readonly keyboardTab: import("./themables.js").ThemeIcon;
 };

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

@@ -579,6 +579,7 @@ const codiconsLibrary = {
     python: register('python', 0xec39),
     copilotLarge: register('copilot-large', 0xec3a),
     copilotWarningLarge: register('copilot-warning-large', 0xec3b),
+    keyboardTab: register('keyboard-tab', 0xec3c),
 };
 
 export { codiconsLibrary };

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

@@ -62,8 +62,8 @@ export declare class Color {
     private static _flatten;
     private _toString?;
     toString(): string;
-    private _toNumber24Bit?;
-    toNumber24Bit(): number;
+    private _toNumber32Bit?;
+    toNumber32Bit(): number;
     static getLighterColor(of: Color, relative: Color, factor?: number): Color;
     static getDarkerColor(of: Color, relative: Color, factor?: number): Color;
     static readonly white: Color;

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

@@ -357,14 +357,14 @@ class Color {
         }
         return this._toString;
     }
-    toNumber24Bit() {
-        if (!this._toNumber24Bit) {
-            this._toNumber24Bit = (this.rgba.r  << 24 |
+    toNumber32Bit() {
+        if (!this._toNumber32Bit) {
+            this._toNumber32Bit = (this.rgba.r  << 24 |
                 this.rgba.g  << 16 |
                 this.rgba.b  << 8 |
                 this.rgba.a * 0xFF << 0) >>> 0;
         }
-        return this._toNumber24Bit;
+        return this._toNumber32Bit;
     }
     static getLighterColor(of, relative, factor) {
         if (of.isLighterThan(relative)) {

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

@@ -4,3 +4,4 @@ export interface IDebounceReducer<T> {
 }
 export declare function debounce<T>(delay: number, reducer?: IDebounceReducer<T>, initialValueProvider?: () => T): MethodDecorator;
 export declare function throttle<T>(delay: number, reducer?: IDebounceReducer<T>, initialValueProvider?: () => T): MethodDecorator;
+export { cancelPreviousCalls } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/base/common/decorators/cancelPreviousCalls";

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

@@ -1,4 +1,6 @@
 
+import './lifecycle.js';
+import './cancellation.js';
 
 function createDecorator(mapFn) {
     return (_target, key, descriptor) => {

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

@@ -28,6 +28,8 @@ export interface SerializedError {
     readonly message: string;
     readonly stack: string;
     readonly noTelemetry: boolean;
+    readonly code?: string;
+    readonly cause?: SerializedError;
 }
 export declare function transformErrorForSerialization(error: Error): SerializedError;
 export declare function transformErrorForSerialization(error: any): any;

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

@@ -65,14 +65,16 @@ function onUnexpectedExternalError(e) {
 }
 function transformErrorForSerialization(error) {
     if (error instanceof Error) {
-        const { name, message } = error;
+        const { name, message, cause } = error;
         const stack = error.stacktrace || error.stack;
         return {
             $isError: true,
             name,
             message,
             stack,
-            noTelemetry: ErrorNoTelemetry.isErrorNoTelemetry(error)
+            noTelemetry: ErrorNoTelemetry.isErrorNoTelemetry(error),
+            cause: cause ? transformErrorForSerialization(cause) : undefined,
+            code: error.code
         };
     }
     return error;
@@ -88,6 +90,12 @@ function transformErrorFromSerialization(data) {
     }
     error.message = data.message;
     error.stack = data.stack;
+    if (data.code) {
+        error.code = data.code;
+    }
+    if (data.cause) {
+        error.cause = transformErrorFromSerialization(data.cause);
+    }
     return error;
 }
 const canceledName = 'Canceled';

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

@@ -47,13 +47,13 @@ export declare namespace Event {
         removeEventListener(event: string | symbol, listener: Function): void;
     }
     function fromDOMEventEmitter<T>(emitter: DOMEventEmitter, eventName: string, map?: (...args: any[]) => T): Event<T>;
-    function toPromise<T>(event: Event<T>): Promise<T>;
+    function toPromise<T>(event: Event<T>, disposables?: IDisposable[] | DisposableStore): Promise<T>;
     function fromPromise<T>(promise: Promise<T>): Event<T | undefined>;
     function forward<T>(from: Event<T>, to: Emitter<T>): IDisposable;
     function runAndSubscribe<T>(event: Event<T>, handler: (e: T) => unknown, initial: T): IDisposable;
     function runAndSubscribe<T>(event: Event<T>, handler: (e: T | undefined) => unknown): IDisposable;
-    function fromObservable<T>(obs: IObservable<T, any>, store?: DisposableStore): Event<T>;
-    function fromObservableLight(observable: IObservable<any>): Event<void>;
+    function fromObservable<T>(obs: IObservable<T>, store?: DisposableStore): Event<T>;
+    function fromObservableLight(observable: IObservable<unknown>): Event<void>;
 }
 export interface EmitterOptions {
     onWillAddFirstListener?: Function;

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

@@ -305,8 +305,8 @@ var Event;
         return result.event;
     }
     Event.fromDOMEventEmitter = fromDOMEventEmitter;
-    function toPromise(event) {
-        return ( new Promise(resolve => once(event)(resolve)));
+    function toPromise(event, disposables) {
+        return ( new Promise(resolve => once(event)(resolve, null, disposables)));
     }
     Event.toPromise = toPromise;
     function fromPromise(promise) {