@codingame/monaco-vscode-api 17.2.1 → 18.0.1

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

@@ -2,7 +2,7 @@ import { IIdentityProvider, IKeyboardNavigationLabelProvider, IListVirtualDelega
 import { AbstractTree, IAbstractTreeOptions, IAbstractTreeOptionsUpdate } from "./abstractTree.js";
 import { CompressibleObjectTreeModel, ElementMapper, ICompressedTreeElement, ICompressedTreeNode } from "./compressedObjectTreeModel.js";
 import { IObjectTreeModel } from "./objectTreeModel.js";
-import { ICollapseStateChangeEvent, IObjectTreeElement, ITreeModel, ITreeNode, ITreeRenderer, ITreeSorter } from "./tree.js";
+import { ICollapseStateChangeEvent, IObjectTreeElement, ITreeElementRenderDetails, ITreeModel, ITreeNode, ITreeRenderer, ITreeSorter } from "./tree.js";
 import { Event } from "../../../common/event.js";
 export interface IObjectTreeOptions<T, TFilterData = void> extends IAbstractTreeOptions<T, TFilterData> {
     readonly sorter?: ITreeSorter<T>;
@@ -27,8 +27,8 @@ interface ICompressedTreeNodeProvider<T, TFilterData> {
     getCompressedTreeNode(location: T | null): ITreeNode<ICompressedTreeNode<T> | null, TFilterData>;
 }
 export interface ICompressibleTreeRenderer<T, TFilterData = void, TTemplateData = void> extends ITreeRenderer<T, TFilterData, TTemplateData> {
-    renderCompressedElements(node: ITreeNode<ICompressedTreeNode<T>, TFilterData>, index: number, templateData: TTemplateData, height: number | undefined): void;
-    disposeCompressedElements?(node: ITreeNode<ICompressedTreeNode<T>, TFilterData>, index: number, templateData: TTemplateData, height: number | undefined): void;
+    renderCompressedElements(node: ITreeNode<ICompressedTreeNode<T>, TFilterData>, index: number, templateData: TTemplateData, details?: ITreeElementRenderDetails): void;
+    disposeCompressedElements?(node: ITreeNode<ICompressedTreeNode<T>, TFilterData>, index: number, templateData: TTemplateData, details?: ITreeElementRenderDetails): void;
 }
 export interface ICompressibleKeyboardNavigationLabelProvider<T> extends IKeyboardNavigationLabelProvider<T> {
     getCompressedNodeKeyboardNavigationLabel(elements: T[]): {

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

@@ -56,36 +56,33 @@ class CompressibleRenderer {
         const data = this.renderer.renderTemplate(container);
         return { compressedTreeNode: undefined, data };
     }
-    renderElement(node, index, templateData, height) {
+    renderElement(node, index, templateData, details) {
         let compressedTreeNode = this.stickyScrollDelegate.getCompressedNode(node);
         if (!compressedTreeNode) {
             compressedTreeNode = this.compressedTreeNodeProvider.getCompressedTreeNode(node.element);
         }
         if (compressedTreeNode.element.elements.length === 1) {
             templateData.compressedTreeNode = undefined;
-            this.renderer.renderElement(node, index, templateData.data, height);
+            this.renderer.renderElement(node, index, templateData.data, details);
         }
         else {
             templateData.compressedTreeNode = compressedTreeNode;
-            this.renderer.renderCompressedElements(compressedTreeNode, index, templateData.data, height);
+            this.renderer.renderCompressedElements(compressedTreeNode, index, templateData.data, details);
         }
     }
-    disposeElement(node, index, templateData, height) {
+    disposeElement(node, index, templateData, details) {
         if (templateData.compressedTreeNode) {
-            this.renderer.disposeCompressedElements?.(templateData.compressedTreeNode, index, templateData.data, height);
+            this.renderer.disposeCompressedElements?.(templateData.compressedTreeNode, index, templateData.data, details);
         }
         else {
-            this.renderer.disposeElement?.(node, index, templateData.data, height);
+            this.renderer.disposeElement?.(node, index, templateData.data, details);
         }
     }
     disposeTemplate(templateData) {
         this.renderer.disposeTemplate(templateData.data);
     }
     renderTwistie(element, twistieElement) {
-        if (this.renderer.renderTwistie) {
-            return this.renderer.renderTwistie(element, twistieElement);
-        }
-        return false;
+        return this.renderer.renderTwistie?.(element, twistieElement) ?? false;
     }
 }
 CompressibleRenderer.__decorator = ( __decorate([

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

@@ -1,6 +1,6 @@
 import { IDragAndDropData } from "../../dnd.js";
 import { IMouseEvent } from "../../mouseEvent.js";
-import { IListDragAndDrop, IListDragOverReaction, IListRenderer } from "../list/list.js";
+import { IListDragAndDrop, IListDragOverReaction, IListElementRenderDetails, IListRenderer } from "../list/list.js";
 import { ListViewTargetSector } from "../list/listView.js";
 import { Event } from "../../../common/event.js";
 export declare enum TreeVisibility {
@@ -83,7 +83,12 @@ export interface ITreeModel<T, TFilterData, TRef> {
     rerender(location: TRef): void;
     refilter(): void;
 }
+export interface ITreeElementRenderDetails extends IListElementRenderDetails {
+    readonly indent: number;
+}
 export interface ITreeRenderer<T, TFilterData = void, TTemplateData = void> extends IListRenderer<ITreeNode<T, TFilterData>, TTemplateData> {
+    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;
     onDidChangeTwistieState?: Event<T>;
 }

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

@@ -96,10 +96,7 @@ function whenESMWorkerReady(worker) {
     }));
 }
 function isPromiseLike(obj) {
-    if (typeof obj.then === 'function') {
-        return true;
-    }
-    return false;
+    return !!obj && typeof obj.then === 'function';
 }
 class WebWorker extends Disposable {
     static { this.LAST_WORKER_ID = 0; }

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

@@ -25,7 +25,7 @@ export declare function topAsync<T>(array: T[], compare: (a: T, b: T) => number,
 export declare function coalesce<T>(array: ReadonlyArray<T | undefined | null>): T[];
 export declare function coalesceInPlace<T>(array: Array<T | undefined | null>): asserts array is Array<T>;
 export declare function move(array: unknown[], from: number, to: number): void;
-export declare function isFalsyOrEmpty(obj: any): boolean;
+export declare function isFalsyOrEmpty(obj: unknown): boolean;
 export declare function isNonEmptyArray<T>(obj: T[] | undefined | null): obj is T[];
 export declare function isNonEmptyArray<T>(obj: readonly T[] | undefined | null): obj is readonly T[];
 export declare function distinct<T>(array: ReadonlyArray<T>, keyFn?: (value: T) => unknown): T[];
@@ -105,4 +105,6 @@ export declare class Permutation {
     inverse(): Permutation;
 }
 export declare function findAsync<T>(array: readonly T[], predicate: (element: T, index: number) => Promise<boolean>): Promise<T | undefined>;
+export declare function sum(array: readonly number[]): number;
+export declare function sumBy<T>(array: readonly T[], selector: (value: T) => number): number;
 export {};

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

@@ -1,5 +1,6 @@
 
 import { findFirstIdxMonotonousOrArrLen } from './arraysFind.js';
+import './errors.js';
 
 function tail(arr) {
     if (arr.length === 0) {
@@ -562,5 +563,8 @@ async function findAsync(array, predicate) {
     )));
     return results.find(r => r.ok)?.element;
 }
+function sumBy(array, selector) {
+    return array.reduce((acc, value) => acc + selector(value), 0);
+}
 
-export { ArrayQueue, CallbackIterable, CompareResult, Permutation, arrayInsert, asArray, binarySearch, binarySearch2, booleanComparator, coalesce, coalesceInPlace, commonPrefixLength, compareBy, compareUndefinedSmallest, concatArrays, delta, distinct, equals, findAsync, forEachAdjacent, forEachWithNeighbors, groupAdjacentBy, groupBy, index, insert, insertInto, isFalsyOrEmpty, isNonEmptyArray, mapArrayOrNot, move, numberComparator, pick, pushMany, pushToEnd, pushToStart, quickSelect, range, remove, removeFastWithoutKeepingOrder, reverseOrder, shuffle, sortedDiff, splice, tail, tieBreakComparators, top, uniqueFilter };
+export { ArrayQueue, CallbackIterable, CompareResult, Permutation, arrayInsert, asArray, binarySearch, binarySearch2, booleanComparator, coalesce, coalesceInPlace, commonPrefixLength, compareBy, compareUndefinedSmallest, concatArrays, delta, distinct, equals, findAsync, forEachAdjacent, forEachWithNeighbors, groupAdjacentBy, groupBy, index, insert, insertInto, isFalsyOrEmpty, isNonEmptyArray, mapArrayOrNot, move, numberComparator, pick, pushMany, pushToEnd, pushToStart, quickSelect, range, remove, removeFastWithoutKeepingOrder, reverseOrder, shuffle, sortedDiff, splice, sumBy, tail, tieBreakComparators, top, uniqueFilter };

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

@@ -12,7 +12,8 @@ export declare function createCancelablePromise<T>(callback: (token: Cancellatio
 export declare function raceCancellation<T>(promise: Promise<T>, token: CancellationToken): Promise<T | undefined>;
 export declare function raceCancellation<T>(promise: Promise<T>, token: CancellationToken, defaultValue: T): Promise<T>;
 export declare function raceCancellationError<T>(promise: Promise<T>, token: CancellationToken): Promise<T>;
-export declare function raceCancellablePromises<T>(cancellablePromises: CancelablePromise<T>[]): Promise<T>;
+export declare function notCancellablePromise<T>(promise: CancelablePromise<T>): Promise<T>;
+export declare function raceCancellablePromises<T>(cancellablePromises: (CancelablePromise<T> | Promise<T>)[]): CancelablePromise<T>;
 export declare function raceTimeout<T>(promise: Promise<T>, timeout: number, onTimeout?: () => void): Promise<T | undefined>;
 export declare function raceFilter<T>(promises: Promise<T>[], filter: (result: T) => boolean): Promise<T | undefined>;
 export declare function asPromise<T>(callback: () => T | Thenable<T>): Promise<T>;
@@ -129,6 +130,16 @@ export declare class ResourceQueue implements IDisposable {
     private releaseDrainers;
     dispose(): void;
 }
+export type Task<T = void> = () => (Promise<T> | T);
+export declare class TaskQueue {
+    private _runningTask;
+    private _pendingTasks;
+    schedule<T>(task: Task<T>): Promise<T>;
+    scheduleSkipIfCleared<T>(task: Task<T>): Promise<T | undefined>;
+    private _runIfNotRunning;
+    private _processQueue;
+    clearPending(): void;
+}
 export declare class TimeoutTimer implements IDisposable {
     private _token;
     private _isDisposed;
@@ -270,6 +281,7 @@ export declare class DeferredPromise<T> {
     constructor();
     complete(value: T): Promise<void>;
     error(err: unknown): Promise<void>;
+    settleWith(promise: Promise<T>): Promise<void>;
     cancel(): Promise<void>;
 }
 export declare namespace Promises {
@@ -301,7 +313,7 @@ export interface AsyncIterableEmitter<T> {
     reject(error: Error): void;
 }
 export interface AsyncIterableExecutor<T> {
-    (emitter: AsyncIterableEmitter<T>): void | Promise<void>;
+    (emitter: AsyncIterableEmitter<T>): unknown | Promise<unknown>;
 }
 export declare class AsyncIterableObject<T> implements AsyncIterable<T> {
     static fromArray<T>(items: T[]): AsyncIterableObject<T>;
@@ -339,11 +351,14 @@ export declare class AsyncIterableSource<T> {
     private readonly _deferred;
     private readonly _asyncIterable;
     private _errorFn;
-    private _emitFn;
+    private _emitOneFn;
+    private _emitManyFn;
     constructor(onReturn?: () => Promise<void> | void);
     get asyncIterable(): AsyncIterableObject<T>;
     resolve(): void;
     reject(error: Error): void;
     emitOne(item: T): void;
+    emitMany(items: T[]): void;
 }
+export declare function cancellableIterable<T>(iterableOrIterator: AsyncIterator<T> | AsyncIterable<T>, token: CancellationToken): AsyncIterableIterator<T>;
 export {};

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

@@ -70,22 +70,28 @@ function raceCancellationError(promise, token) {
         promise.then(resolve, reject).finally(() => ref.dispose());
     }));
 }
-async function raceCancellablePromises(cancellablePromises) {
+function notCancellablePromise(promise) {
+    return ( new Promise((resolve, reject) => {
+        promise.then(resolve, reject);
+    }));
+}
+function raceCancellablePromises(cancellablePromises) {
     let resolvedPromiseIndex = -1;
     const promises = ( cancellablePromises.map(
         (promise, index) => promise.then(result => { resolvedPromiseIndex = index; return result; })
     ));
-    try {
-        const result = await Promise.race(promises);
-        return result;
-    }
-    finally {
+    const promise = Promise.race(promises);
+    promise.cancel = () => {
         cancellablePromises.forEach((cancellablePromise, index) => {
-            if (index !== resolvedPromiseIndex) {
+            if (index !== resolvedPromiseIndex && cancellablePromise.cancel) {
                 cancellablePromise.cancel();
             }
         });
-    }
+    };
+    promise.finally(() => {
+        promise.cancel();
+    });
+    return promise;
 }
 function raceTimeout(promise, timeout, onTimeout) {
     let promiseResolve = undefined;
@@ -456,20 +462,6 @@ 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());
@@ -542,10 +534,69 @@ class ResourceQueue {
         this.drainListeners?.dispose();
     }
 }
+class TaskQueue {
+    constructor() {
+        this._runningTask = undefined;
+        this._pendingTasks = [];
+    }
+    schedule(task) {
+        const deferred = ( new DeferredPromise());
+        this._pendingTasks.push({ task, deferred, setUndefinedWhenCleared: false });
+        this._runIfNotRunning();
+        return deferred.p;
+    }
+    scheduleSkipIfCleared(task) {
+        const deferred = ( new DeferredPromise());
+        this._pendingTasks.push({ task, deferred, setUndefinedWhenCleared: true });
+        this._runIfNotRunning();
+        return deferred.p;
+    }
+    _runIfNotRunning() {
+        if (this._runningTask === undefined) {
+            this._processQueue();
+        }
+    }
+    async _processQueue() {
+        if (this._pendingTasks.length === 0) {
+            return;
+        }
+        const next = this._pendingTasks.shift();
+        if (!next) {
+            return;
+        }
+        if (this._runningTask) {
+            throw ( new BugIndicatingError());
+        }
+        this._runningTask = next.task;
+        try {
+            const result = await next.task();
+            next.deferred.complete(result);
+        }
+        catch (e) {
+            next.deferred.error(e);
+        }
+        finally {
+            this._runningTask = undefined;
+            this._processQueue();
+        }
+    }
+    clearPending() {
+        const tasks = this._pendingTasks;
+        this._pendingTasks = [];
+        for (const task of tasks) {
+            if (task.setUndefinedWhenCleared) {
+                task.deferred.complete(undefined);
+            }
+            else {
+                task.deferred.error(( new CancellationError()));
+            }
+        }
+    }
+}
 class TimeoutTimer {
     constructor(runner, timeout) {
         this._isDisposed = false;
-        this._token = -1;
+        this._token = undefined;
         if (typeof runner === 'function' && typeof timeout === 'number') {
             this.setIfNotSet(runner, timeout);
         }
@@ -555,9 +606,9 @@ class TimeoutTimer {
         this._isDisposed = true;
     }
     cancel() {
-        if (this._token !== -1) {
+        if (this._token !== undefined) {
             clearTimeout(this._token);
-            this._token = -1;
+            this._token = undefined;
         }
     }
     cancelAndSet(runner, timeout) {
@@ -566,7 +617,7 @@ class TimeoutTimer {
         }
         this.cancel();
         this._token = setTimeout(() => {
-            this._token = -1;
+            this._token = undefined;
             runner();
         }, timeout);
     }
@@ -574,11 +625,11 @@ class TimeoutTimer {
         if (this._isDisposed) {
             throw ( new BugIndicatingError(`Calling 'setIfNotSet' on a disposed TimeoutTimer`));
         }
-        if (this._token !== -1) {
+        if (this._token !== undefined) {
             return;
         }
         this._token = setTimeout(() => {
-            this._token = -1;
+            this._token = undefined;
             runner();
         }, timeout);
     }
@@ -612,7 +663,7 @@ class IntervalTimer {
 }
 class RunOnceScheduler {
     constructor(runner, delay) {
-        this.timeoutToken = -1;
+        this.timeoutToken = undefined;
         this.runner = runner;
         this.timeout = delay;
         this.timeoutHandler = this.onTimeout.bind(this);
@@ -624,7 +675,7 @@ class RunOnceScheduler {
     cancel() {
         if (this.isScheduled()) {
             clearTimeout(this.timeoutToken);
-            this.timeoutToken = -1;
+            this.timeoutToken = undefined;
         }
     }
     schedule(delay = this.timeout) {
@@ -638,7 +689,7 @@ class RunOnceScheduler {
         this.timeout = value;
     }
     isScheduled() {
-        return this.timeoutToken !== -1;
+        return this.timeoutToken !== undefined;
     }
     flush() {
         if (this.isScheduled()) {
@@ -647,7 +698,7 @@ class RunOnceScheduler {
         }
     }
     onTimeout() {
-        this.timeoutToken = -1;
+        this.timeoutToken = undefined;
         if (this.runner) {
             this.doRun();
         }
@@ -882,6 +933,9 @@ class DeferredPromise {
             resolve();
         }));
     }
+    settleWith(promise) {
+        return promise.then(value => this.complete(value), error => this.error(error));
+    }
     cancel() {
         return this.error(( new CancellationError()));
     }
@@ -1153,20 +1207,29 @@ class AsyncIterableSource {
                 emitter.emitMany(earlyItems);
             }
             this._errorFn = (error) => emitter.reject(error);
-            this._emitFn = (item) => emitter.emitOne(item);
+            this._emitOneFn = (item) => emitter.emitOne(item);
+            this._emitManyFn = (items) => emitter.emitMany(items);
             return this._deferred.p;
         }, onReturn));
         let earlyError;
         let earlyItems;
-        this._emitFn = (item) => {
+        this._errorFn = (error) => {
+            if (!earlyError) {
+                earlyError = error;
+            }
+        };
+        this._emitOneFn = (item) => {
             if (!earlyItems) {
                 earlyItems = [];
             }
             earlyItems.push(item);
         };
-        this._errorFn = (error) => {
-            if (!earlyError) {
-                earlyError = error;
+        this._emitManyFn = (items) => {
+            if (!earlyItems) {
+                earlyItems = items.slice();
+            }
+            else {
+                items.forEach(item => earlyItems.push(item));
             }
         };
     }
@@ -1181,8 +1244,11 @@ class AsyncIterableSource {
         this._deferred.complete();
     }
     emitOne(item) {
-        this._emitFn(item);
+        this._emitOneFn(item);
+    }
+    emitMany(items) {
+        this._emitManyFn(items);
     }
 }
 
-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 };
+export { AbstractIdleValue, AsyncIterableObject, AsyncIterableSource, AutoOpenBarrier, Barrier, CancelableAsyncIterableObject, DeferredPromise, Delayer, GlobalIdleValue, IntervalCounter, IntervalTimer, LazyStatefulPromise, Limiter, Promises, Queue, ResourceQueue, RunOnceScheduler, RunOnceWorker, Sequencer, SequencerByKey, StatefulPromise, TaskQueue, TaskSequentializer, ThrottledDelayer, Throttler, TimeoutTimer, _runWhenIdle, asPromise, createCancelableAsyncIterable, createCancelablePromise, disposableTimeout, first, isThenable, notCancellablePromise, promiseWithResolvers, raceCancellablePromises, raceCancellation, raceCancellationError, raceTimeout, retry, runWhenGlobalIdle, sequence, timeout };

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

@@ -55,3 +55,5 @@ export declare function prefixedBufferReadable(prefix: VSBuffer, readable: VSBuf
 export declare function prefixedBufferStream(prefix: VSBuffer, stream: VSBufferReadableStream): VSBufferReadableStream;
 export declare function decodeBase64(encoded: string): VSBuffer;
 export declare function encodeBase64({ buffer }: VSBuffer, padded?: boolean, urlSafe?: boolean): string;
+export declare function encodeHex({ buffer }: VSBuffer): string;
+export declare function decodeHex(hex: string): VSBuffer;

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

@@ -330,5 +330,40 @@ function encodeBase64({ buffer }, padded = true, urlSafe = false) {
     }
     return output;
 }
+const hexChars = '0123456789abcdef';
+function encodeHex({ buffer }) {
+    let result = '';
+    for (let i = 0; i < buffer.length; i++) {
+        const byte = buffer[i];
+        result += hexChars[byte >>> 4];
+        result += hexChars[byte & 0x0f];
+    }
+    return result;
+}
+function decodeHex(hex) {
+    if (hex.length % 2 !== 0) {
+        throw ( new SyntaxError('Hex string must have an even length'));
+    }
+    const out = ( new Uint8Array(hex.length >> 1));
+    for (let i = 0; i < hex.length;) {
+        out[i >> 1] = (decodeHexChar(hex, i++) << 4) | decodeHexChar(hex, i++);
+    }
+    return VSBuffer.wrap(out);
+}
+function decodeHexChar(str, position) {
+    const s = str.charCodeAt(position);
+    if (s >= 48 && s <= 57) {
+        return s - 48;
+    }
+    else if (s >= 97 && s <= 102) {
+        return s - 87;
+    }
+    else if (s >= 65 && s <= 70) {
+        return s - 55;
+    }
+    else {
+        throw ( new SyntaxError(`Invalid hex character at position ${position}`));
+    }
+}
 
-export { VSBuffer, binaryIndexOf, bufferToReadable, bufferToStream, bufferedStreamToBuffer, decodeBase64, encodeBase64, newWriteableBufferStream, prefixedBufferReadable, prefixedBufferStream, readUInt16LE, readUInt32BE, readUInt32LE, readUInt8, readableToBuffer, streamToBuffer, writeUInt16LE, writeUInt32BE, writeUInt32LE, writeUInt8 };
+export { VSBuffer, binaryIndexOf, bufferToReadable, bufferToStream, bufferedStreamToBuffer, decodeBase64, decodeHex, encodeBase64, encodeHex, newWriteableBufferStream, prefixedBufferReadable, prefixedBufferStream, readUInt16LE, readUInt32BE, readUInt32LE, readUInt8, readableToBuffer, streamToBuffer, writeUInt16LE, writeUInt32BE, writeUInt32LE, writeUInt8 };

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

@@ -647,4 +647,9 @@ export declare const Codicon: {
     readonly keyboardTabAbove: ThemeIcon;
     readonly keyboardTabBelow: ThemeIcon;
     readonly gitPullRequestDone: ThemeIcon;
+    readonly mcp: ThemeIcon;
+    readonly extensionsLarge: ThemeIcon;
+    readonly layoutPanelDock: ThemeIcon;
+    readonly layoutSidebarLeftDock: ThemeIcon;
+    readonly layoutSidebarRightDock: ThemeIcon;
 };

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

@@ -587,4 +587,9 @@ export declare const codiconsLibrary: {
     readonly keyboardTabAbove: import("./themables.js").ThemeIcon;
     readonly keyboardTabBelow: import("./themables.js").ThemeIcon;
     readonly gitPullRequestDone: import("./themables.js").ThemeIcon;
+    readonly mcp: import("./themables.js").ThemeIcon;
+    readonly extensionsLarge: import("./themables.js").ThemeIcon;
+    readonly layoutPanelDock: import("./themables.js").ThemeIcon;
+    readonly layoutSidebarLeftDock: import("./themables.js").ThemeIcon;
+    readonly layoutSidebarRightDock: import("./themables.js").ThemeIcon;
 };

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

@@ -590,6 +590,11 @@ const codiconsLibrary = {
     keyboardTabAbove: register('keyboard-tab-above', 0xec44),
     keyboardTabBelow: register('keyboard-tab-below', 0xec45),
     gitPullRequestDone: register('git-pull-request-done', 0xec46),
+    mcp: register('mcp', 0xec47),
+    extensionsLarge: register('extensions-large', 0xec48),
+    layoutPanelDock: register('layout-panel-dock', 0xec49),
+    layoutSidebarLeftDock: register('layout-sidebar-left-dock', 0xec4a),
+    layoutSidebarRightDock: register('layout-sidebar-right-dock', 0xec4b),
 };
 
 export { codiconsLibrary };

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

@@ -1,22 +1,23 @@
 
+import { safeIntl } from './date.js';
 import { Lazy } from './lazy.js';
 import { sep } from './path.js';
 
 const intlFileNameCollatorBaseNumeric = ( new Lazy(() => {
-    const collator = new Intl.Collator(undefined, { numeric: true, sensitivity: 'base' });
+    const collator = safeIntl.Collator(undefined, { numeric: true, sensitivity: 'base' }).value;
     return {
         collator,
         collatorIsNumeric: collator.resolvedOptions().numeric
     };
 }));
 const intlFileNameCollatorNumeric = ( new Lazy(() => {
-    const collator = new Intl.Collator(undefined, { numeric: true });
+    const collator = safeIntl.Collator(undefined, { numeric: true }).value;
     return {
         collator
     };
 }));
 const intlFileNameCollatorNumericCaseInsensitive = ( new Lazy(() => {
-    const collator = new Intl.Collator(undefined, { numeric: true, sensitivity: 'accent' });
+    const collator = safeIntl.Collator(undefined, { numeric: true, sensitivity: 'accent' }).value;
     return {
         collator
     };

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

@@ -1,10 +1,12 @@
+import { Lazy } from "./lazy.js";
 export declare function fromNow(date: number | Date, appendAgoLabel?: boolean, useFullTimeWords?: boolean, disallowNow?: boolean): string;
 export declare function fromNowByDay(date: number | Date, appendAgoLabel?: boolean, useFullTimeWords?: boolean): string;
 export declare function getDurationString(ms: number, useFullTimeWords?: boolean): string;
 export declare function toLocalISOString(date: Date): string;
 export declare const safeIntl: {
-    DateTimeFormat(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): Intl.DateTimeFormat;
-    Collator(locales?: Intl.LocalesArgument, options?: Intl.CollatorOptions): Intl.Collator;
-    Segmenter(locales?: Intl.LocalesArgument, options?: Intl.SegmenterOptions): Intl.Segmenter;
-    Locale(tag: Intl.Locale | string, options?: Intl.LocaleOptions): Intl.Locale;
+    DateTimeFormat(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): Lazy<Intl.DateTimeFormat>;
+    Collator(locales?: Intl.LocalesArgument, options?: Intl.CollatorOptions): Lazy<Intl.Collator>;
+    Segmenter(locales?: Intl.LocalesArgument, options?: Intl.SegmenterOptions): Lazy<Intl.Segmenter>;
+    Locale(tag: Intl.Locale | string, options?: Intl.LocaleOptions): Lazy<Intl.Locale>;
+    NumberFormat(locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): Lazy<Intl.NumberFormat>;
 };