@codingame/monaco-vscode-api 4.5.2 → 5.0.0

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

@@ -1,6 +1,7 @@
 import { show, hide } from '../../dom.js';
+import { getProgressAcccessibilitySignalScheduler } from './progressAccessibilitySignal.js';
 import { RunOnceScheduler } from '../../../common/async.js';
-import { Disposable } from '../../../common/lifecycle.js';
+import { Disposable, MutableDisposable } from '../../../common/lifecycle.js';
 import { isNumber } from '../../../common/types.js';
 import './progressbar.css.js';
 const CSS_DONE = 'done';
@@ -10,8 +11,10 @@ const CSS_INFINITE_LONG_RUNNING = 'infinite-long-running';
 const CSS_DISCRETE = 'discrete';
 class ProgressBar extends Disposable {
     static { this.LONG_RUNNING_INFINITE_THRESHOLD = 10000; }
+    static { this.PROGRESS_SIGNAL_DEFAULT_DELAY = 3000; }
     constructor(container, options) {
         super();
+        this.progressSignal = this._register(( new MutableDisposable()));
         this.workedVal = 0;
         this.showDelayedScheduler = this._register(( new RunOnceScheduler(() => show(this.element), 0)));
         this.longRunningScheduler = this._register(( new RunOnceScheduler(
@@ -38,6 +41,7 @@ class ProgressBar extends Disposable {
         this.workedVal = 0;
         this.totalWork = undefined;
         this.longRunningScheduler.cancel();
+        this.progressSignal.clear();
     }
     done() {
         return this.doDone(true);
@@ -110,6 +114,7 @@ class ProgressBar extends Disposable {
     }
     show(delay) {
         this.showDelayedScheduler.cancel();
+        this.progressSignal.value = getProgressAcccessibilitySignalScheduler(ProgressBar.PROGRESS_SIGNAL_DEFAULT_DELAY);
         if (typeof delay === 'number') {
             this.showDelayedScheduler.schedule(delay);
         }
@@ -120,6 +125,7 @@ class ProgressBar extends Disposable {
     hide() {
         hide(this.element);
         this.showDelayedScheduler.cancel();
+        this.progressSignal.clear();
     }
 }
 export { ProgressBar };

package/vscode/src/vs/base/browser/ui/selectBox/selectBoxCustom.js

@@ -2,8 +2,8 @@ import { $ as $$1, append, createStyleSheet, addDisposableListener, addStandardD
 import { DomEmitter } from '../../event.js';
 import { StandardKeyboardEvent } from '../../keyboardEvent.js';
 import { renderMarkdown } from '../../markdownRenderer.js';
+import { getBaseLayerHoverDelegate } from '../hover/hoverDelegate2.js';
 import { getDefaultHoverDelegate } from '../hover/hoverDelegateFactory.js';
-import { setupCustomHover } from '../hover/updatableHoverWidget.js';
 import { List } from '../list/listWidget.js';
 import { equals } from '../../../common/arrays.js';
 import { Emitter, Event } from '../../../common/event.js';
@@ -84,7 +84,7 @@ class SelectBoxList extends Disposable {
     }
     setTitle(title) {
         if (!this._hover && title) {
-            this._hover = this._register(setupCustomHover(getDefaultHoverDelegate('mouse'), this.selectElement, title));
+            this._hover = this._register(getBaseLayerHoverDelegate().setupUpdatableHover(getDefaultHoverDelegate('mouse'), this.selectElement, title));
         }
         else if (this._hover) {
             this._hover.update(title);

package/vscode/src/vs/base/browser/ui/table/tableWidget.js

@@ -1,6 +1,6 @@
 import { append, $, clearNode, createStyleSheet, getContentHeight, getContentWidth } from '../../dom.js';
+import { getBaseLayerHoverDelegate } from '../hover/hoverDelegate2.js';
 import { getDefaultHoverDelegate } from '../hover/hoverDelegateFactory.js';
-import { setupCustomHover } from '../hover/updatableHoverWidget.js';
 import { List, unthemedListStyles } from '../list/listWidget.js';
 import { SplitView } from '../splitview/splitview.js';
 import { Event, Emitter } from '../../../common/event.js';
@@ -88,7 +88,7 @@ class ColumnHeader extends Disposable {
         this.onDidLayout = this._onDidLayout.event;
         this.element = $('.monaco-table-th', { 'data-col-index': index }, column.label);
         if (column.tooltip) {
-            this._register(setupCustomHover(getDefaultHoverDelegate('mouse'), this.element, column.tooltip));
+            this._register(getBaseLayerHoverDelegate().setupUpdatableHover(getDefaultHoverDelegate('mouse'), this.element, column.tooltip));
         }
     }
     layout(size) {

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

@@ -5,8 +5,8 @@ import { ThemeIcon } from '../../../common/themables.js';
 import { Emitter } from '../../../common/event.js';
 import './toggle.css.js';
 import { isActiveElement, $, addDisposableListener, EventType } from '../../dom.js';
-import { setupCustomHover } from '../hover/updatableHoverWidget.js';
 import { getDefaultHoverDelegate } from '../hover/hoverDelegateFactory.js';
+import { getBaseLayerHoverDelegate } from '../hover/hoverDelegate2.js';
 const unthemedToggleStyles = {
     inputActiveOptionBorder: '#007ACC00',
     inputActiveOptionForeground: '#FFFFFF',
@@ -77,7 +77,7 @@ class Toggle extends Widget {
             classes.push('checked');
         }
         this.domNode = document.createElement('div');
-        this._hover = this._register(setupCustomHover(opts.hoverDelegate ?? getDefaultHoverDelegate('mouse'), this.domNode, this._opts.title));
+        this._hover = this._register(getBaseLayerHoverDelegate().setupUpdatableHover(opts.hoverDelegate ?? getDefaultHoverDelegate('mouse'), this.domNode, this._opts.title));
         this.domNode.classList.add(...classes);
         if (!this._opts.notFocusable) {
             this.domNode.tabIndex = 0;
@@ -149,6 +149,12 @@ class Toggle extends Widget {
         this._hover.update(newTitle);
         this.domNode.setAttribute('aria-label', newTitle);
     }
+    set visible(visible) {
+        this.domNode.style.display = visible ? '' : 'none';
+    }
+    get visible() {
+        return this.domNode.style.display !== 'none';
+    }
 }
 class Checkbox extends Widget {
     constructor(title, isChecked, styles) {

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

@@ -40,7 +40,7 @@ declare class ToolBar extends Disposable {
     private readonly element;
     private _onDidChangeDropdownVisibility;
     readonly onDidChangeDropdownVisibility: Event<boolean>;
-    private disposables;
+    private readonly disposables;
     constructor(container: HTMLElement, contextMenuProvider: IContextMenuProvider, options?: IToolBarOptions);
     set actionRunner(actionRunner: IActionRunner);
     get actionRunner(): IActionRunner;

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

@@ -1733,7 +1733,7 @@ class TreeNodeListMouseController extends MouseController {
             const recursive = e.browserEvent.altKey;
             this.tree.setFocus([location]);
             this.tree.toggleCollapsed(location, recursive);
-            if (expandOnlyOnTwistieClick && onTwistie) {
+            if (onTwistie) {
                 e.browserEvent.isHandledByList = true;
                 return;
             }
@@ -2108,9 +2108,16 @@ class AbstractTree {
             content.push(`.monaco-list${suffix}:hover .monaco-tl-indent > .indent-guide, .monaco-list${suffix}.always .monaco-tl-indent > .indent-guide  { border-color: ${styles.treeInactiveIndentGuidesStroke}; }`);
             content.push(`.monaco-list${suffix} .monaco-tl-indent > .indent-guide.active { border-color: ${styles.treeIndentGuidesStroke}; }`);
         }
-        if (styles.listBackground) {
-            content.push(`.monaco-list${suffix} .monaco-scrollable-element .monaco-tree-sticky-container { background-color: ${styles.listBackground}; }`);
-            content.push(`.monaco-list${suffix} .monaco-scrollable-element .monaco-tree-sticky-container .monaco-tree-sticky-row { background-color: ${styles.listBackground}; }`);
+        const stickyScrollBackground = styles.treeStickyScrollBackground ?? styles.listBackground;
+        if (stickyScrollBackground) {
+            content.push(`.monaco-list${suffix} .monaco-scrollable-element .monaco-tree-sticky-container { background-color: ${stickyScrollBackground}; }`);
+            content.push(`.monaco-list${suffix} .monaco-scrollable-element .monaco-tree-sticky-container .monaco-tree-sticky-row { background-color: ${stickyScrollBackground}; }`);
+        }
+        if (styles.treeStickyScrollBorder) {
+            content.push(`.monaco-list${suffix} .monaco-scrollable-element .monaco-tree-sticky-container { border-bottom: 1px solid ${styles.treeStickyScrollBorder}; }`);
+        }
+        if (styles.treeStickyScrollShadow) {
+            content.push(`.monaco-list${suffix} .monaco-scrollable-element .monaco-tree-sticky-container .monaco-tree-sticky-container-shadow { box-shadow: ${styles.treeStickyScrollShadow} 0 6px 6px -6px inset; height: 3px; }`);
         }
         if (styles.listFocusForeground) {
             content.push(`.monaco-list${suffix}.sticky-scroll-focused .monaco-scrollable-element .monaco-tree-sticky-container:focus .monaco-list-row.focused { color: ${styles.listFocusForeground}; }`);

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

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

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

@@ -115,14 +115,16 @@ class CompressibleStickyScrollDelegate {
         if (stickyNodes.length === 0) {
             throw ( new Error('Can\'t compress empty sticky nodes'));
         }
-        if (!this.modelProvider().isCompressionEnabled()) {
+        const compressionModel = this.modelProvider();
+        if (!compressionModel.isCompressionEnabled()) {
             return stickyNodes[0];
         }
         const elements = [];
-        for (const stickyNode of stickyNodes) {
-            const compressedNode = this.modelProvider().getCompressedTreeNode(stickyNode.node.element);
+        for (let i = 0; i < stickyNodes.length; i++) {
+            const stickyNode = stickyNodes[i];
+            const compressedNode = compressionModel.getCompressedTreeNode(stickyNode.node.element);
             if (compressedNode.element) {
-                if (compressedNode.element.incompressible) {
+                if (i !== 0 && compressedNode.element.incompressible) {
                     break;
                 }
                 elements.push(...compressedNode.element.elements);

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

@@ -1,4 +1,4 @@
-function findLast(array, predicate, fromIdx) {
+function findLast(array, predicate) {
     const idx = findLastIdx(array, predicate);
     if (idx === -1) {
         return undefined;
@@ -74,7 +74,7 @@ class MonotonousArray {
         return idx === -1 ? undefined : this._array[idx];
     }
 }
-function findFirstMaxBy(array, comparator) {
+function findFirstMax(array, comparator) {
     if (array.length === 0) {
         return undefined;
     }
@@ -87,7 +87,7 @@ function findFirstMaxBy(array, comparator) {
     }
     return max;
 }
-function findLastMaxBy(array, comparator) {
+function findLastMax(array, comparator) {
     if (array.length === 0) {
         return undefined;
     }
@@ -100,10 +100,10 @@ function findLastMaxBy(array, comparator) {
     }
     return max;
 }
-function findFirstMinBy(array, comparator) {
-    return findFirstMaxBy(array, (a, b) => -comparator(a, b));
+function findFirstMin(array, comparator) {
+    return findFirstMax(array, (a, b) => -comparator(a, b));
 }
-function findMaxIdxBy(array, comparator) {
+function findMaxIdx(array, comparator) {
     if (array.length === 0) {
         return -1;
     }
@@ -125,4 +125,4 @@ function mapFindFirst(items, mapFn) {
     }
     return undefined;
 }
-export { MonotonousArray, findFirstIdxMonotonousOrArrLen, findFirstMaxBy, findFirstMinBy, findFirstMonotonous, findLast, findLastIdx, findLastIdxMonotonous, findLastMaxBy, findLastMonotonous, findMaxIdxBy, mapFindFirst };
+export { MonotonousArray, findFirstIdxMonotonousOrArrLen, findFirstMax, findFirstMin, findFirstMonotonous, findLast, findLastIdx, findLastIdxMonotonous, findLastMax, findLastMonotonous, findMaxIdx, mapFindFirst };

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

@@ -939,10 +939,11 @@ class AsyncIterableObject {
         }));
     }
     static { this.EMPTY = AsyncIterableObject.fromArray([]); }
-    constructor(executor) {
+    constructor(executor, onReturn) {
         this._state = 0 ;
         this._results = [];
         this._error = null;
+        this._onReturn = onReturn;
         this._onStateChanged = ( new Emitter());
         queueMicrotask(async () => {
             const writer = {
@@ -980,6 +981,10 @@ class AsyncIterableObject {
                     }
                     await Event.toPromise(this._onStateChanged.event);
                 } while (true);
+            },
+            return: async () => {
+                this._onReturn?.();
+                return { done: true, value: undefined };
             }
         };
     }
@@ -1087,7 +1092,7 @@ function createCancelableAsyncIterable(callback) {
     }));
 }
 class AsyncIterableSource {
-    constructor() {
+    constructor(onReturn) {
         this._deferred = ( new DeferredPromise());
         this._asyncIterable = ( new AsyncIterableObject(emitter => {
             if (earlyError) {
@@ -1100,7 +1105,7 @@ class AsyncIterableSource {
             this._errorFn = (error) => emitter.reject(error);
             this._emitFn = (item) => emitter.emitOne(item);
             return this._deferred.p;
-        }));
+        }, onReturn));
         let earlyError;
         let earlyItems;
         this._emitFn = (item) => {

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

@@ -21,18 +21,27 @@ class Cache {
         return this.result;
     }
 }
+function identity(t) {
+    return t;
+}
 class LRUCachedFunction {
-    constructor(fn, _computeKey = JSON.stringify) {
-        this.fn = fn;
-        this._computeKey = _computeKey;
+    constructor(arg1, arg2) {
         this.lastCache = undefined;
         this.lastArgKey = undefined;
+        if (typeof arg1 === 'function') {
+            this._fn = arg1;
+            this._computeKey = identity;
+        }
+        else {
+            this._fn = arg2;
+            this._computeKey = arg1.getCacheKey;
+        }
     }
     get(arg) {
         const key = this._computeKey(arg);
         if (this.lastArgKey !== key) {
             this.lastArgKey = key;
-            this.lastCache = this.fn(arg);
+            this.lastCache = this._fn(arg);
         }
         return this.lastCache;
     }
@@ -41,17 +50,27 @@ class CachedFunction {
     get cachedValues() {
         return this._map;
     }
-    constructor(fn) {
-        this.fn = fn;
+    constructor(arg1, arg2) {
         this._map = ( new Map());
+        this._map2 = ( new Map());
+        if (typeof arg1 === 'function') {
+            this._fn = arg1;
+            this._computeKey = identity;
+        }
+        else {
+            this._fn = arg2;
+            this._computeKey = arg1.getCacheKey;
+        }
     }
     get(arg) {
-        if (( this._map.has(arg))) {
-            return this._map.get(arg);
+        const key = this._computeKey(arg);
+        if (( this._map2.has(key))) {
+            return this._map2.get(key);
         }
-        const value = this.fn(arg);
+        const value = this._fn(arg);
         this._map.set(arg, value);
+        this._map2.set(key, value);
         return value;
     }
 }
-export { Cache, CachedFunction, LRUCachedFunction };
+export { Cache, CachedFunction, LRUCachedFunction, identity };

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

@@ -94,4 +94,9 @@ class CancellationTokenSource {
         }
     }
 }
-export { CancellationToken, CancellationTokenSource };
+function cancelOnDispose(store) {
+    const source = ( new CancellationTokenSource());
+    store.add({ dispose() { source.cancel(); } });
+    return source.token;
+}
+export { CancellationToken, CancellationTokenSource, cancelOnDispose };

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

@@ -602,6 +602,9 @@ declare const Codicon: {
     readonly foldVertical: ThemeIcon;
     readonly mapVerticalFilled: ThemeIcon;
     readonly foldVerticalFilled: ThemeIcon;
+    readonly goToSearch: ThemeIcon;
+    readonly percentage: ThemeIcon;
+    readonly sortPercentage: ThemeIcon;
 };
 
 export { Codicon };

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

@@ -566,5 +566,8 @@ const codiconsLibrary = {
     foldVertical: register('fold-vertical', 0xec30),
     mapVerticalFilled: register('map-vertical-filled', 0xec31),
     foldVerticalFilled: register('fold-vertical-filled', 0xec31),
+    goToSearch: register('go-to-search', 0xec32),
+    percentage: register('percentage', 0xec33),
+    sortPercentage: register('sort-percentage', 0xec33),
 };
 export { codiconsLibrary };

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

@@ -0,0 +1,48 @@
+import { BugIndicatingError } from './errors.js';
+class ReentrancyBarrier {
+    constructor() {
+        this._isOccupied = false;
+    }
+    runExclusivelyOrSkip(runner) {
+        if (this._isOccupied) {
+            return;
+        }
+        this._isOccupied = true;
+        try {
+            runner();
+        }
+        finally {
+            this._isOccupied = false;
+        }
+    }
+    runExclusivelyOrThrow(runner) {
+        if (this._isOccupied) {
+            throw ( new BugIndicatingError(`ReentrancyBarrier: reentrant call detected!`));
+        }
+        this._isOccupied = true;
+        try {
+            runner();
+        }
+        finally {
+            this._isOccupied = false;
+        }
+    }
+    get isOccupied() {
+        return this._isOccupied;
+    }
+    makeExclusiveOrSkip(fn) {
+        return ((...args) => {
+            if (this._isOccupied) {
+                return;
+            }
+            this._isOccupied = true;
+            try {
+                return fn(...args);
+            }
+            finally {
+                this._isOccupied = false;
+            }
+        });
+    }
+}
+export { ReentrancyBarrier };

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

@@ -0,0 +1,44 @@
+import { equals } from './arrays.js';
+const strictEquals = (a, b) => a === b;
+function itemsEquals(itemEquals = strictEquals) {
+    return (a, b) => equals(a, b, itemEquals);
+}
+function itemEquals() {
+    return (a, b) => a.equals(b);
+}
+function equalsIfDefined(v1, v2, equals) {
+    if (!v1 || !v2) {
+        return v1 === v2;
+    }
+    return equals(v1, v2);
+}
+function getStructuralKey(t) {
+    return JSON.stringify(toNormalizedJsonStructure(t));
+}
+let objectId = 0;
+const objIds = ( new WeakMap());
+function toNormalizedJsonStructure(t) {
+    if (Array.isArray(t)) {
+        return ( t.map(toNormalizedJsonStructure));
+    }
+    if (t && typeof t === 'object') {
+        if (Object.getPrototypeOf(t) === Object.prototype) {
+            const tObj = t;
+            const res = Object.create(null);
+            for (const key of ( Object.keys(tObj)).sort()) {
+                res[key] = toNormalizedJsonStructure(tObj[key]);
+            }
+            return res;
+        }
+        else {
+            let objId = objIds.get(t);
+            if (objId === undefined) {
+                objId = objectId++;
+                objIds.set(t, objId);
+            }
+            return objId + '----2b76a038c20c4bcc';
+        }
+    }
+    return t;
+}
+export { equalsIfDefined, getStructuralKey, itemEquals, itemsEquals, strictEquals };

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

@@ -383,5 +383,15 @@ interface IWaitUntil {
 interface IDynamicListEventMultiplexer<TEventType> extends IDisposable {
     readonly event: Event<TEventType>;
 }
+declare class DynamicListEventMultiplexer<TItem, TEventType> implements IDynamicListEventMultiplexer<TEventType> {
+    private readonly _store;
+    readonly event: Event<TEventType>;
+    constructor(items: TItem[], onAddItem: Event<TItem>, onRemoveItem: Event<TItem>, getEvent: (item: TItem) => Event<TEventType>);
+    dispose(): void;
+}
+interface IValueWithChangeEvent<T> {
+    readonly onDidChange: Event<void>;
+    get value(): T;
+}
 
-export { Emitter, type EmitterOptions, Event, type EventDeliveryQueue, type IDynamicListEventMultiplexer, type IWaitUntil };
+export { DynamicListEventMultiplexer, Emitter, type EmitterOptions, Event, type EventDeliveryQueue, type IDynamicListEventMultiplexer, type IValueWithChangeEvent, type IWaitUntil };

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

@@ -926,4 +926,29 @@ class Relay {
         this.emitter.dispose();
     }
 }
-export { AsyncEmitter, DebounceEmitter, DynamicListEventMultiplexer, Emitter, Event, EventBufferer, EventMultiplexer, EventProfiling, MicrotaskEmitter, PauseableEmitter, Relay, createEventDeliveryQueue, setGlobalLeakWarningThreshold };
+class ValueWithChangeEvent {
+    static const(value) {
+        return ( new ConstValueWithChangeEvent(value));
+    }
+    constructor(_value) {
+        this._value = _value;
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+    }
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        if (value !== this._value) {
+            this._value = value;
+            this._onDidChange.fire(undefined);
+        }
+    }
+}
+class ConstValueWithChangeEvent {
+    constructor(value) {
+        this.value = value;
+        this.onDidChange = Event.None;
+    }
+}
+export { AsyncEmitter, DebounceEmitter, DynamicListEventMultiplexer, Emitter, Event, EventBufferer, EventMultiplexer, EventProfiling, MicrotaskEmitter, PauseableEmitter, Relay, ValueWithChangeEvent, createEventDeliveryQueue, setGlobalLeakWarningThreshold };

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

@@ -26,7 +26,7 @@ function setProperty(text, originalPath, value, formattingOptions, getInsertionI
     }
     if (!parent) {
         if (value === undefined) {
-            throw ( new Error('Can not delete in empty document'));
+            return [];
         }
         return withFormatting(text, { offset: root ? root.offset : 0, length: root ? root.length : 0, content: JSON.stringify(value) }, formattingOptions);
     }

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

@@ -145,7 +145,7 @@ function markAsSingleton(singleton) {
     return singleton;
 }
 function isDisposable(thing) {
-    return typeof thing.dispose === 'function' && thing.dispose.length === 0;
+    return typeof thing === 'object' && thing !== null && typeof thing.dispose === 'function' && thing.dispose.length === 0;
 }
 function dispose(arg) {
     if (Iterable.is(arg)) {

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

@@ -336,6 +336,28 @@ class LinkedMap {
         }
         this._state++;
     }
+    trimNew(newSize) {
+        if (newSize >= this.size) {
+            return;
+        }
+        if (newSize === 0) {
+            this.clear();
+            return;
+        }
+        let current = this._tail;
+        let currentSize = this.size;
+        while (current && currentSize > newSize) {
+            this._map.delete(current.key);
+            current = current.previous;
+            currentSize--;
+        }
+        this._tail = current;
+        this._size = currentSize;
+        if (current) {
+            current.next = undefined;
+        }
+        this._state++;
+    }
     addItemFirst(item) {
         if (!this._head && !this._tail) {
             this._tail = item;
@@ -458,7 +480,7 @@ class LinkedMap {
         }
     }
 }
-class LRUCache extends LinkedMap {
+class Cache extends LinkedMap {
     constructor(limit, ratio = 1) {
         super();
         this._limit = limit;
@@ -486,15 +508,42 @@ class LRUCache extends LinkedMap {
     }
     set(key, value) {
         super.set(key, value, 2 );
-        this.checkTrim();
         return this;
     }
     checkTrim() {
         if (this.size > this._limit) {
-            this.trimOld(Math.round(this._limit * this._ratio));
+            this.trim(Math.round(this._limit * this._ratio));
         }
     }
 }
+class LRUCache extends Cache {
+    constructor(limit, ratio = 1) {
+        super(limit, ratio);
+    }
+    trim(newSize) {
+        this.trimOld(newSize);
+    }
+    set(key, value) {
+        super.set(key, value);
+        this.checkTrim();
+        return this;
+    }
+}
+class MRUCache extends Cache {
+    constructor(limit, ratio = 1) {
+        super(limit, ratio);
+    }
+    trim(newSize) {
+        this.trimNew(newSize);
+    }
+    set(key, value) {
+        if (this._limit <= this.size && !( this.has(key))) {
+            this.trim(Math.round(this._limit * this._ratio) - 1);
+        }
+        super.set(key, value);
+        return this;
+    }
+}
 class CounterSet {
     constructor() {
         this.map = ( new Map());
@@ -622,4 +671,4 @@ function mapsStrictEqualIgnoreOrder(a, b) {
     }
     return true;
 }
-export { BidirectionalMap, CounterSet, LRUCache, LinkedMap, ResourceMap, ResourceSet, SetMap, getOrSet, mapsStrictEqualIgnoreOrder };
+export { BidirectionalMap, CounterSet, LRUCache, LinkedMap, MRUCache, ResourceMap, ResourceSet, SetMap, getOrSet, mapsStrictEqualIgnoreOrder };

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

@@ -32,6 +32,7 @@ var Schemas;
     Schemas.vscodeWorkspaceTrust = 'vscode-workspace-trust';
     Schemas.vscodeTerminal = 'vscode-terminal';
     Schemas.vscodeChatCodeBlock = 'vscode-chat-code-block';
+    Schemas.vscodeChatCodeCompreBlock = 'vscode-chat-code-compare-block';
     Schemas.vscodeChatSesssion = 'vscode-chat-editor';
     Schemas.webviewPanel = 'webview-panel';
     Schemas.vscodeWebview = 'vscode-webview';
@@ -40,6 +41,7 @@ var Schemas;
     Schemas.tmp = 'tmp';
     Schemas.vsls = 'vsls';
     Schemas.vscodeSourceControl = 'vscode-scm';
+    Schemas.commentsInput = 'comment';
     Schemas.codeSetting = 'code-setting';
 })(Schemas || (Schemas = {})));
 function matchesScheme(target, scheme) {

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

@@ -149,6 +149,9 @@ function safeStringify(obj) {
                 seen.add(value);
             }
         }
+        if (typeof value === 'bigint') {
+            return `[BigInt ${( value.toString())}]`;
+        }
         return value;
     });
 }