@codingame/monaco-vscode-api 2.0.3-improve-modularity.1 → 2.1.0-update-vscode-1.86.1

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

@@ -101,7 +101,8 @@ function asTreeContextMenuEvent(e) {
     return {
         browserEvent: e.browserEvent,
         element: e.element && e.element.element,
-        anchor: e.anchor
+        anchor: e.anchor,
+        isStickyScroll: e.isStickyScroll
     };
 }
 class AsyncDataTreeElementsDragAndDropData extends ElementsDragAndDropData {
@@ -138,11 +139,11 @@ class AsyncDataTreeNodeListDragAndDrop {
     onDragStart(data, originalEvent) {
         this.dnd.onDragStart?.(asAsyncDataTreeDragAndDropData(data), originalEvent);
     }
-    onDragOver(data, targetNode, targetIndex, originalEvent, raw = true) {
-        return this.dnd.onDragOver(asAsyncDataTreeDragAndDropData(data), targetNode && targetNode.element, targetIndex, originalEvent);
+    onDragOver(data, targetNode, targetIndex, targetSector, originalEvent, raw = true) {
+        return this.dnd.onDragOver(asAsyncDataTreeDragAndDropData(data), targetNode && targetNode.element, targetIndex, targetSector, originalEvent);
     }
-    drop(data, targetNode, targetIndex, originalEvent) {
-        this.dnd.drop(asAsyncDataTreeDragAndDropData(data), targetNode && targetNode.element, targetIndex, originalEvent);
+    drop(data, targetNode, targetIndex, targetSector, originalEvent) {
+        this.dnd.drop(asAsyncDataTreeDragAndDropData(data), targetNode && targetNode.element, targetIndex, targetSector, originalEvent);
     }
     onDragEnd(originalEvent) {
         this.dnd.onDragEnd?.(originalEvent);
@@ -242,8 +243,11 @@ class AsyncDataTree {
     get onDidChangeCollapseState() { return this.tree.onDidChangeCollapseState; }
     get onDidUpdateOptions() { return this.tree.onDidUpdateOptions; }
     get onDidChangeFindOpenState() { return this.tree.onDidChangeFindOpenState; }
+    get onDidChangeStickyScrollFocused() { return this.tree.onDidChangeStickyScrollFocused; }
     get findMode() { return this.tree.findMode; }
     set findMode(mode) { this.tree.findMode = mode; }
+    get findMatchType() { return this.tree.findMatchType; }
+    set findMatchType(matchType) { this.tree.findMatchType = matchType; }
     get expandOnlyOnTwistieClick() {
         if (typeof this.tree.expandOnlyOnTwistieClick === 'boolean') {
             return this.tree.expandOnlyOnTwistieClick;
@@ -268,6 +272,7 @@ class AsyncDataTree {
         this.getDefaultCollapseState = e => options.collapseByDefault ? (options.collapseByDefault(e) ? ObjectTreeElementCollapseState.PreserveOrCollapsed : ObjectTreeElementCollapseState.PreserveOrExpanded) : undefined;
         this.tree = this.createTree(user, container, delegate, renderers, options);
         this.onDidChangeFindMode = this.tree.onDidChangeFindMode;
+        this.onDidChangeFindMatchType = this.tree.onDidChangeFindMatchType;
         this.root = createAsyncDataTreeNode({
             element: undefined,
             parent: null,
@@ -534,6 +539,13 @@ class AsyncDataTree {
         const nodes = this.tree.getFocus();
         return ( nodes.map(n => n.element));
     }
+    getStickyScrollFocus() {
+        const nodes = this.tree.getStickyScrollFocus();
+        return ( nodes.map(n => n.element));
+    }
+    getFocusedPart() {
+        return this.tree.getFocusedPart();
+    }
     reveal(element, relativeTop) {
         this.tree.reveal(this.getDataNode(element), relativeTop);
     }
@@ -558,6 +570,9 @@ class AsyncDataTree {
     }
     async refreshAndRenderNode(node, recursive, viewStateContext, options) {
         await this.refreshNode(node, recursive, viewStateContext);
+        if (this.disposables.isDisposed) {
+            return;
+        }
         this.render(node, viewStateContext, options);
     }
     async refreshNode(node, recursive, viewStateContext) {
@@ -942,7 +957,7 @@ class CompressibleAsyncDataTree extends AsyncDataTree {
         }
         return { focus, selection, expanded, scrollTop: this.scrollTop };
     }
-    render(node, viewStateContext) {
+    render(node, viewStateContext, options) {
         if (!this.identityProvider) {
             return super.render(node, viewStateContext);
         }
@@ -962,7 +977,7 @@ class CompressibleAsyncDataTree extends AsyncDataTree {
         };
         const oldSelection = getUncompressedIds(this.tree.getSelection());
         const oldFocus = getUncompressedIds(this.tree.getFocus());
-        super.render(node, viewStateContext);
+        super.render(node, viewStateContext, options);
         const selection = this.getSelection();
         let didChangeSelection = false;
         const focus = this.getFocus();

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

@@ -106,7 +106,6 @@ class IndexTreeModel {
             el => this.createTreeNode(el, parentNode, parentNode.visible ? 1  : 0 , revealed, treeListElementsToInsert, onDidCreateNode)
         ));
         const lastIndex = location[location.length - 1];
-        const lastHadChildren = parentNode.children.length > 0;
         let visibleChildStartIndex = 0;
         for (let i = lastIndex; i >= 0 && i < parentNode.children.length; i--) {
             const child = parentNode.children[i];
@@ -163,10 +162,6 @@ class IndexTreeModel {
             deletedNodes.forEach(visit);
         }
         this._onDidSplice.fire({ insertedNodes: nodesToInsert, deletedNodes });
-        const currentlyHasChildren = parentNode.children.length > 0;
-        if (lastHadChildren !== currentlyHasChildren) {
-            this.setCollapsible(location.slice(0, -1), currentlyHasChildren);
-        }
         let node = parentNode;
         while (node) {
             if (node.visibility === 2 ) {

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 .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%}";
+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}";
 n(css,{});
 export { css, css as default };

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

@@ -37,8 +37,9 @@ class CompressibleRenderer {
     get compressedTreeNodeProvider() {
         return this._compressedTreeNodeProvider();
     }
-    constructor(_compressedTreeNodeProvider, renderer) {
+    constructor(_compressedTreeNodeProvider, stickyScrollDelegate, renderer) {
         this._compressedTreeNodeProvider = _compressedTreeNodeProvider;
+        this.stickyScrollDelegate = stickyScrollDelegate;
         this.renderer = renderer;
         this.templateId = renderer.templateId;
         if (renderer.onDidChangeTwistieState) {
@@ -50,7 +51,10 @@ class CompressibleRenderer {
         return { compressedTreeNode: undefined, data };
     }
     renderElement(node, index, templateData, height) {
-        const compressedTreeNode = this.compressedTreeNodeProvider.getCompressedTreeNode(node.element);
+        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);
@@ -81,6 +85,67 @@ class CompressibleRenderer {
 CompressibleRenderer.__decorator = ( __decorate([
     memoize
 ], CompressibleRenderer.prototype, "compressedTreeNodeProvider", null));
+class CompressibleStickyScrollDelegate {
+    constructor(modelProvider) {
+        this.modelProvider = modelProvider;
+        this.compressedStickyNodes = ( new Map());
+    }
+    getCompressedNode(node) {
+        return this.compressedStickyNodes.get(node);
+    }
+    constrainStickyScrollNodes(stickyNodes, stickyScrollMaxItemCount, maxWidgetHeight) {
+        this.compressedStickyNodes.clear();
+        if (stickyNodes.length === 0) {
+            return [];
+        }
+        for (let i = 0; i < stickyNodes.length; i++) {
+            const stickyNode = stickyNodes[i];
+            const stickyNodeBottom = stickyNode.position + stickyNode.height;
+            const followingReachesMaxHeight = i + 1 < stickyNodes.length && stickyNodeBottom + stickyNodes[i + 1].height > maxWidgetHeight;
+            if (followingReachesMaxHeight || i >= stickyScrollMaxItemCount - 1 && stickyScrollMaxItemCount < stickyNodes.length) {
+                const uncompressedStickyNodes = stickyNodes.slice(0, i);
+                const overflowingStickyNodes = stickyNodes.slice(i);
+                const compressedStickyNode = this.compressStickyNodes(overflowingStickyNodes);
+                return [...uncompressedStickyNodes, compressedStickyNode];
+            }
+        }
+        return stickyNodes;
+    }
+    compressStickyNodes(stickyNodes) {
+        if (stickyNodes.length === 0) {
+            throw new Error('Can\'t compress empty sticky nodes');
+        }
+        if (!this.modelProvider().isCompressionEnabled()) {
+            return stickyNodes[0];
+        }
+        const elements = [];
+        for (const stickyNode of stickyNodes) {
+            const compressedNode = this.modelProvider().getCompressedTreeNode(stickyNode.node.element);
+            if (compressedNode.element) {
+                if (compressedNode.element.incompressible) {
+                    break;
+                }
+                elements.push(...compressedNode.element.elements);
+            }
+        }
+        if (elements.length < 2) {
+            return stickyNodes[0];
+        }
+        const lastStickyNode = stickyNodes[stickyNodes.length - 1];
+        const compressedElement = { elements, incompressible: false };
+        const compressedNode = { ...lastStickyNode.node, children: [], element: compressedElement };
+        const stickyTreeNode = ( new Proxy(stickyNodes[0].node, {}));
+        const compressedStickyNode = {
+            node: stickyTreeNode,
+            startIndex: stickyNodes[0].startIndex,
+            endIndex: lastStickyNode.endIndex,
+            position: stickyNodes[0].position,
+            height: stickyNodes[0].height,
+        };
+        this.compressedStickyNodes.set(stickyTreeNode, compressedNode);
+        return compressedStickyNode;
+    }
+}
 function asObjectTreeOptions(compressedTreeNodeProvider, options) {
     return options && {
         ...options,
@@ -106,8 +171,9 @@ function asObjectTreeOptions(compressedTreeNodeProvider, options) {
 class CompressibleObjectTree extends ObjectTree {
     constructor(user, container, delegate, renderers, options = {}) {
         const compressedTreeNodeProvider = () => this;
-        const compressibleRenderers = ( renderers.map(r => ( new CompressibleRenderer(compressedTreeNodeProvider, r))));
-        super(user, container, delegate, compressibleRenderers, asObjectTreeOptions(compressedTreeNodeProvider, options));
+        const stickyScrollDelegate = ( new CompressibleStickyScrollDelegate(() => this.model));
+        const compressibleRenderers = ( renderers.map(r => ( new CompressibleRenderer(compressedTreeNodeProvider, stickyScrollDelegate, r))));
+        super(user, container, delegate, compressibleRenderers, { ...asObjectTreeOptions(compressedTreeNodeProvider, options), stickyScrollDelegate });
     }
     setChildren(element, children = Iterable.empty(), options) {
         this.model.setChildren(element, children, options);

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

@@ -7,6 +7,11 @@ function ok(value, message) {
 function assertNever(value, message = 'Unreachable') {
     throw new Error(message);
 }
+function softAssert(condition) {
+    if (!condition) {
+        onUnexpectedError(( new BugIndicatingError('Assertion Failed')));
+    }
+}
 function assertFn(condition) {
     if (!condition()) {
         debugger;
@@ -26,4 +31,4 @@ function checkAdjacentItems(items, predicate) {
     }
     return true;
 }
-export { assertFn, assertNever, checkAdjacentItems, ok };
+export { assertFn, assertNever, checkAdjacentItems, ok, softAssert };

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

@@ -14,7 +14,6 @@ function createCancelablePromise(callback) {
     const promise = ( new Promise((resolve, reject) => {
         const subscription = source.token.onCancellationRequested(() => {
             subscription.dispose();
-            source.dispose();
             reject(( new CancellationError()));
         });
         Promise.resolve(thenable).then(value => {
@@ -30,6 +29,7 @@ function createCancelablePromise(callback) {
     return new (class {
         cancel() {
             source.cancel();
+            source.dispose();
         }
         then(resolve, reject) {
             return promise.then(resolve, reject);
@@ -367,11 +367,17 @@ function first(promiseFactories, shouldStop = t => !!t, defaultValue = null) {
 class Limiter {
     constructor(maxDegreeOfParalellism) {
         this._size = 0;
+        this._isDisposed = false;
         this.maxDegreeOfParalellism = maxDegreeOfParalellism;
         this.outstandingPromises = [];
         this.runningPromises = 0;
         this._onDrained = ( new Emitter());
     }
+    whenIdle() {
+        return this.size > 0
+            ? Event.toPromise(this.onDrained)
+            : Promise.resolve();
+    }
     get onDrained() {
         return this._onDrained.event;
     }
@@ -379,6 +385,9 @@ class Limiter {
         return this._size;
     }
     queue(factory) {
+        if (this._isDisposed) {
+            throw new Error('Object has been disposed');
+        }
         this._size++;
         return ( new Promise((c, e) => {
             this.outstandingPromises.push({ factory, c, e });
@@ -395,16 +404,28 @@ class Limiter {
         }
     }
     consumed() {
-        this._size--;
+        if (this._isDisposed) {
+            return;
+        }
         this.runningPromises--;
+        if (--this._size === 0) {
+            this._onDrained.fire();
+        }
         if (this.outstandingPromises.length > 0) {
             this.consume();
         }
-        else {
-            this._onDrained.fire();
+    }
+    clear() {
+        if (this._isDisposed) {
+            throw new Error('Object has been disposed');
         }
+        this.outstandingPromises.length = 0;
+        this._size = this.runningPromises;
     }
     dispose() {
+        this._isDisposed = true;
+        this.outstandingPromises.length = 0;
+        this._size = 0;
         this._onDrained.dispose();
     }
 }
@@ -436,7 +457,11 @@ class ResourceQueue {
         }
         return true;
     }
-    queueFor(resource, extUri$1 = extUri) {
+    queueSize(resource, extUri$1 = extUri) {
+        const key = extUri$1.getComparisonKey(resource);
+        return this.queues.get(key)?.size ?? 0;
+    }
+    queueFor(resource, factory, extUri$1 = extUri) {
         const key = extUri$1.getComparisonKey(resource);
         let queue = this.queues.get(key);
         if (!queue) {
@@ -458,7 +483,7 @@ class ResourceQueue {
             this.drainListeners.set(drainListenerId, drainListener);
             this.queues.set(key, queue);
         }
-        return queue;
+        return queue.queue(factory);
     }
     onDidQueueDrain() {
         if (!this.isDrained()) {

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

@@ -68,6 +68,7 @@ const Codicon = {
     closeDirty: register('close-dirty', 0xea71),
     debugBreakpoint: register('debug-breakpoint', 0xea71),
     debugBreakpointDisabled: register('debug-breakpoint-disabled', 0xea71),
+    debugBreakpointPending: register('debug-breakpoint-pending', 0xebd9),
     debugHint: register('debug-hint', 0xea71),
     primitiveSquare: register('primitive-square', 0xea72),
     edit: register('edit', 0xea73),
@@ -561,6 +562,10 @@ const Codicon = {
     sparkleFilled: register('sparkle-filled', 0xec21),
     diffSingle: register('diff-single', 0xec22),
     diffMultiple: register('diff-multiple', 0xec23),
+    surroundWith: register('surround-with', 0xec24),
+    gitStash: register('git-stash', 0xec26),
+    gitStashApply: register('git-stash-apply', 0xec27),
+    gitStashPop: register('git-stash-pop', 0xec28),
     dialogError: register('dialog-error', 'error'),
     dialogWarning: register('dialog-warning', 'warning'),
     dialogInfo: register('dialog-info', 'info'),

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

@@ -238,11 +238,6 @@ declare namespace Event {
      */
     function runAndSubscribe<T>(event: Event<T>, handler: (e: T) => any, initial: T): IDisposable;
     function runAndSubscribe<T>(event: Event<T>, handler: (e: T | undefined) => any): IDisposable;
-    /**
-     * Adds a listener to an event and calls the listener immediately with undefined as the event object. A new
-     * {@link DisposableStore} is passed to the listener which is disposed when the returned disposable is disposed.
-     */
-    function runAndSubscribeWithStore<T>(event: Event<T>, handler: (e: T | undefined, disposableStore: DisposableStore) => any): IDisposable;
     /**
      * Creates an event emitter that is fired when the observable changes.
      * Each listeners subscribes to the emitter.

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

@@ -319,21 +319,6 @@ var Event;
         return event(e => handler(e));
     }
     Event.runAndSubscribe = runAndSubscribe;
-    function runAndSubscribeWithStore(event, handler) {
-        let store = null;
-        function run(e) {
-            store?.dispose();
-            store = ( new DisposableStore());
-            handler(e, store);
-        }
-        run(undefined);
-        const disposable = event(e => run(e));
-        return toDisposable(() => {
-            disposable.dispose();
-            store?.dispose();
-        });
-    }
-    Event.runAndSubscribeWithStore = runAndSubscribeWithStore;
     class EmitterObserver {
         constructor(_observable, store) {
             this._observable = _observable;

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

@@ -2,22 +2,5 @@ interface IMatch {
     start: number;
     end: number;
 }
-/**
- * An array representing a fuzzy match.
- *
- * 0. the score
- * 1. the offset at which matching started
- * 2. `<match_pos_N>`
- * 3. `<match_pos_1>`
- * 4. `<match_pos_0>` etc
- */
-type FuzzyScore = [score: number, wordStart: number, ...matches: number[]];
-declare namespace FuzzyScore {
-    /**
-     * No matches and value `-100`
-     */
-    const Default: FuzzyScore;
-    function isDefault(score?: FuzzyScore): score is [-100, 0];
-}
 
-export { FuzzyScore, type IMatch };
+export type { IMatch };

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

@@ -32,11 +32,7 @@ class MarkdownString {
         return this;
     }
     appendCodeblock(langId, code) {
-        this.value += '\n```';
-        this.value += langId;
-        this.value += '\n';
-        this.value += code;
-        this.value += '\n```\n';
+        this.value += `\n${appendEscapedMarkdownCodeBlockFence(code, langId)}\n`;
         return this;
     }
     appendLink(target, label, title) {
@@ -102,6 +98,16 @@ function markdownStringEqual(a, b) {
 function escapeMarkdownSyntaxTokens(text) {
     return text.replace(/[\\`*_{}[\]()#+\-!~]/g, '\\$&');
 }
+function appendEscapedMarkdownCodeBlockFence(code, langId) {
+    const longestFenceLength = code.match(/^`+/gm)?.reduce((a, b) => (a.length > b.length ? a : b)).length ??
+        0;
+    const desiredFenceLength = longestFenceLength >= 3 ? longestFenceLength + 1 : 3;
+    return [
+        `${'`'.repeat(desiredFenceLength)}${langId}`,
+        code,
+        `${'`'.repeat(desiredFenceLength)}`,
+    ].join('\n');
+}
 function escapeDoubleQuotes(input) {
     return input.replace(/"/g, '"');
 }
@@ -132,4 +138,4 @@ function parseHrefAndDimensions(href) {
     }
     return { href, dimensions };
 }
-export { MarkdownString, escapeDoubleQuotes, escapeMarkdownSyntaxTokens, isEmptyMarkdownString, isMarkdownString, markdownStringEqual, parseHrefAndDimensions, removeMarkdownEscapes };
+export { MarkdownString, appendEscapedMarkdownCodeBlockFence, escapeDoubleQuotes, escapeMarkdownSyntaxTokens, isEmptyMarkdownString, isMarkdownString, markdownStringEqual, parseHrefAndDimensions, removeMarkdownEscapes };

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

@@ -118,5 +118,13 @@ var Iterable;
         return [consumed, { [Symbol.iterator]() { return iterator; } }];
     }
     Iterable.consume = consume;
+    async function asyncToArray(iterable) {
+        const result = [];
+        for await (const item of iterable) {
+            result.push(item);
+        }
+        return Promise.resolve(result);
+    }
+    Iterable.asyncToArray = asyncToArray;
 })(Iterable || (Iterable = {})));
 export { Iterable };

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

@@ -243,7 +243,8 @@ function splitRecentLabel(recentLabel) {
         const lastIndexOfSquareBracket = recentLabel.lastIndexOf(' [', recentLabel.length - 2);
         if (lastIndexOfSquareBracket !== -1) {
             const split = splitName(recentLabel.substring(0, lastIndexOfSquareBracket));
-            return { name: split.name, parentPath: split.parentPath + recentLabel.substring(lastIndexOfSquareBracket) };
+            const remoteNameWithSpace = recentLabel.substring(lastIndexOfSquareBracket);
+            return { name: split.name + remoteNameWithSpace, parentPath: split.parentPath };
         }
     }
     return splitName(recentLabel);

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

@@ -603,4 +603,23 @@ class SetMap {
         return values;
     }
 }
-export { BidirectionalMap, CounterSet, LRUCache, LinkedMap, ResourceMap, ResourceSet, SetMap, getOrSet };
+function mapsStrictEqualIgnoreOrder(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (a.size !== b.size) {
+        return false;
+    }
+    for (const [key, value] of a) {
+        if (!( b.has(key)) || b.get(key) !== value) {
+            return false;
+        }
+    }
+    for (const [key] of b) {
+        if (!( a.has(key))) {
+            return false;
+        }
+    }
+    return true;
+}
+export { BidirectionalMap, CounterSet, LRUCache, LinkedMap, ResourceMap, ResourceSet, SetMap, getOrSet, mapsStrictEqualIgnoreOrder };

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

@@ -54,6 +54,10 @@ interface IObservable<T, TChange = unknown> {
      * Makes sure this value is computed eagerly.
      */
     recomputeInitiallyAndOnChange(store: DisposableStore, handleValue?: (value: T) => void): IObservable<T>;
+    /**
+     * Makes sure this value is cached.
+     */
+    keepObserved(store: DisposableStore): IObservable<T>;
     /**
      * A human-readable name for debugging purposes.
      */

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

@@ -2,6 +2,10 @@ let _recomputeInitiallyAndOnChange;
 function _setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange) {
     _recomputeInitiallyAndOnChange = recomputeInitiallyAndOnChange;
 }
+let _keepObserved;
+function _setKeepObserved(keepObserved) {
+    _keepObserved = keepObserved;
+}
 let _derived;
 function _setDerivedOpts(derived) {
     _derived = derived;
@@ -45,6 +49,10 @@ class ConvenientObservable {
         store.add(_recomputeInitiallyAndOnChange(this, handleValue));
         return this;
     }
+    keepObserved(store) {
+        store.add(_keepObserved(this));
+        return this;
+    }
 }
 class BaseObservable extends ConvenientObservable {
     constructor() {
@@ -137,24 +145,24 @@ class TransactionImpl {
 }
 const countPerName = ( new Map());
 const cachedDebugName = ( new WeakMap());
-function getDebugName(obj, debugNameFn, fn, owner, self) {
-    const cached = cachedDebugName.get(obj);
+function getDebugName(self, debugNameFn, fn, owner) {
+    const cached = cachedDebugName.get(self);
     if (cached) {
         return cached;
     }
-    const dbgName = computeDebugName(obj, debugNameFn, fn, owner, self);
+    const dbgName = computeDebugName(self, debugNameFn, fn, owner);
     if (dbgName) {
         let count = countPerName.get(dbgName) ?? 0;
         count++;
         countPerName.set(dbgName, count);
         const result = count === 1 ? dbgName : `${dbgName}#${count}`;
-        cachedDebugName.set(obj, result);
+        cachedDebugName.set(self, result);
         return result;
     }
     return undefined;
 }
-function computeDebugName(obj, debugNameFn, fn, owner, self) {
-    const cached = cachedDebugName.get(obj);
+function computeDebugName(self, debugNameFn, fn, owner) {
+    const cached = cachedDebugName.get(self);
     if (cached) {
         return cached;
     }
@@ -225,7 +233,7 @@ function observableValue(nameOrOwner, initialValue) {
 }
 class ObservableValue extends BaseObservable {
     get debugName() {
-        return getDebugName(this, this._debugName, undefined, this._owner, this) ?? 'ObservableValue';
+        return getDebugName(this, this._debugName, undefined, this._owner) ?? 'ObservableValue';
     }
     constructor(_owner, _debugName, initialValue) {
         super();
@@ -286,4 +294,4 @@ class DisposableObservableValue extends ObservableValue {
         this._value?.dispose();
     }
 }
-export { BaseObservable, ConvenientObservable, DisposableObservableValue, ObservableValue, TransactionImpl, _setDerivedOpts, _setRecomputeInitiallyAndOnChange, asyncTransaction, disposableObservableValue, getDebugName, getFunctionName, globalTransaction, observableValue, subtransaction, transaction };
+export { BaseObservable, ConvenientObservable, DisposableObservableValue, ObservableValue, TransactionImpl, _setDerivedOpts, _setKeepObserved, _setRecomputeInitiallyAndOnChange, asyncTransaction, disposableObservableValue, getDebugName, getFunctionName, globalTransaction, observableValue, subtransaction, transaction };

package/vscode/src/vs/base/common/observableInternal/derived.js

@@ -1,4 +1,4 @@
-import { BugIndicatingError } from '../errors.js';
+import { assertFn } from '../assert.js';
 import { DisposableStore } from '../lifecycle.js';
 import { getFunctionName, BaseObservable, getDebugName, _setDerivedOpts } from './base.js';
 const defaultEqualityComparer = (a, b) => a === b;
@@ -31,7 +31,7 @@ function derivedOpts(options, computeFn) {
         computeFn,
         undefined,
         undefined,
-        undefined,
+        options.onLastObserverRemoved,
         options.equalityComparer ?? defaultEqualityComparer
     ));
 }
@@ -87,7 +87,7 @@ function derivedDisposable(computeFnOrOwner, computeFnOrUndefined) {
 _setDerivedOpts(derivedOpts);
 class Derived extends BaseObservable {
     get debugName() {
-        return getDebugName(this, this._debugName, this._computeFn, this._owner, this) ?? '(anonymous)';
+        return getDebugName(this, this._debugName, this._computeFn, this._owner) ?? '(anonymous)';
     }
     constructor(_owner, _debugName, _computeFn, createChangeSummary, _handleChange, _handleLastObserverRemoved = undefined, _equalityComparator) {
         super();
@@ -195,9 +195,7 @@ class Derived extends BaseObservable {
                 r.endUpdate(this);
             }
         }
-        if (this.updateCount < 0) {
-            throw new BugIndicatingError();
-        }
+        assertFn(() => this.updateCount >= 0);
     }
     handlePossibleChange(observable) {
         if (this.state === 3  && ( this.dependencies.has(observable)) && !( this.dependenciesToBeRemoved.has(observable))) {