@codingame/monaco-vscode-api 30.0.1 → 31.0.0

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

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

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

@@ -1,4 +1,9 @@
 export declare namespace inputLatency {
+    /**
+     * Observable that increments each time a new input latency sample is recorded.
+     * Consumers can use `debouncedObservable` to batch-report after a period of inactivity.
+     */
+    const sampleCount: import("../common/observable.js").ISettableObservable<number, void>;
     /**
      * Record the start of the keydown event.
      */

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

@@ -1,4 +1,6 @@
 
+import '../common/observableInternal/index.js';
+import { observableValue } from '../common/observableInternal/observables/observableValue.js';
 
 var inputLatency;
 (function (inputLatency) {
@@ -7,6 +9,7 @@ var inputLatency;
     const totalRenderTime = { ...totalKeydownTime };
     const totalInputLatencyTime = { ...totalKeydownTime };
     let measurementsCount = 0;
+    inputLatency.sampleCount = observableValue('inputLatency.sampleCount', 0);
     let EventPhase;
     (function (EventPhase) {
         EventPhase[EventPhase["Before"] = 0] = "Before";
@@ -89,6 +92,7 @@ var inputLatency;
             addMeasure('render', totalRenderTime);
             addMeasure('inputlatency', totalInputLatencyTime);
             measurementsCount++;
+            inputLatency.sampleCount.set(inputLatency.sampleCount.get() + 1, undefined);
             reset();
         }
     }

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

@@ -75,6 +75,7 @@ export declare class FindInput extends Widget {
     setFocusInputOnOptionClick(value: boolean): void;
     setEnabled(enabled: boolean): void;
     setAdditionalToggles(toggles: Toggle[] | undefined): void;
+    protected getToggleDomNodes(): HTMLElement[];
     setActions(actions: ReadonlyArray<IAction> | undefined, actionViewItemProvider?: IActionViewItemProvider): void;
     private updateInputBoxPadding;
     clear(): void;

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

@@ -128,9 +128,9 @@ class FindInput extends Widget {
             this._register(this.caseSensitive.onKeyDown(e => {
                 this._onCaseSensitiveKeyDown.fire(e);
             }));
-            const indexes = [this.caseSensitive.domNode, this.wholeWords.domNode, this.regex.domNode];
             this.onkeydown(this.domNode, event => {
                 if (event.equals(KeyCode.LeftArrow) || event.equals(KeyCode.RightArrow) || event.equals(KeyCode.Escape)) {
+                    const indexes = this.getToggleDomNodes();
                     const index = indexes.indexOf(getActiveElement(this.domNode.ownerDocument));
                     if (index >= 0) {
                         let newIndex = -1;
@@ -249,6 +249,22 @@ class FindInput extends Widget {
         }
         this.updateInputBoxPadding();
     }
+    getToggleDomNodes() {
+        const nodes = [];
+        if (this.caseSensitive) {
+            nodes.push(this.caseSensitive.domNode);
+        }
+        if (this.wholeWords) {
+            nodes.push(this.wholeWords.domNode);
+        }
+        if (this.regex) {
+            nodes.push(this.regex.domNode);
+        }
+        for (const toggle of this.additionalToggles) {
+            nodes.push(toggle.domNode);
+        }
+        return nodes;
+    }
     setActions(actions, actionViewItemProvider) {
         this.inputBox.setActions(actions, actionViewItemProvider);
     }

package/vscode/src/vs/base/browser/ui/scrollbar/media/scrollbars.css

@@ -27,6 +27,11 @@
 	transition: opacity 800ms linear;
 }
 
+.disable-animations .monaco-scrollable-element > .visible,
+.disable-animations .monaco-scrollable-element > .invisible.fade {
+	transition: none;
+}
+
 /* Scrollable Content Inset Shadow */
 .monaco-scrollable-element > .shadow {
 	position: absolute;

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

@@ -168,6 +168,7 @@ interface IAbstractFindControllerOptions extends IFindWidgetOptions {
     placeholder?: string;
     toggles?: ITreeFindToggleContribution[];
     showNotFoundMessage?: boolean;
+    findWidgetContainer?: HTMLElement;
 }
 export interface IFindControllerOptions extends IAbstractFindControllerOptions {
     defaultFindMode?: TreeFindMode;
@@ -299,6 +300,7 @@ export interface IAbstractTreeOptions<T, TFilterData = void> extends IAbstractTr
     readonly paddingBottom?: number;
     readonly findWidgetEnabled?: boolean;
     readonly findWidgetStyles?: IFindWidgetStyles;
+    readonly findWidgetContainer?: HTMLElement;
     readonly defaultFindVisibility?: TreeVisibility | ((e: T) => TreeVisibility);
     readonly stickyScrollDelegate?: IStickyScrollDelegate<T, TFilterData>;
     readonly disableExpandOnSpacebar?: boolean;

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

@@ -852,11 +852,14 @@ class AbstractFindController {
             this.widget.select();
             return;
         }
-        this.tree.updateOptions({
-            paddingTop: 30
-        });
+        const widgetContainer = this.options.findWidgetContainer ?? this.tree.getHTMLElement();
+        if (!this.options.findWidgetContainer) {
+            this.tree.updateOptions({
+                paddingTop: 30
+            });
+        }
         this.widget = ( new FindWidget(
-            this.tree.getHTMLElement(),
+            widgetContainer,
             this.tree,
             this.contextViewProvider,
             this.placeholder,
@@ -879,9 +882,11 @@ class AbstractFindController {
         if (!this.widget) {
             return;
         }
-        this.tree.updateOptions({
-            paddingTop: 0
-        });
+        if (!this.options.findWidgetContainer) {
+            this.tree.updateOptions({
+                paddingTop: 0
+            });
+        }
         this._history = this.widget.getHistory();
         this.widget = undefined;
         this.enabledDisposables.clear();
@@ -2212,7 +2217,8 @@ class AbstractTree {
                 styles: _options.findWidgetStyles,
                 defaultFindMode: _options.defaultFindMode,
                 defaultFindMatchType: _options.defaultFindMatchType,
-                showNotFoundMessage: _options.showNotFoundMessage
+                showNotFoundMessage: _options.showNotFoundMessage,
+                findWidgetContainer: _options.findWidgetContainer
             };
             this.findController = this.disposables.add(( new FindController(this, this.findFilter, _options.contextViewProvider, findOptions)));
             this.focusNavigationFilter = node => this.findController.shouldAllowFocus(node);

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

@@ -472,6 +472,7 @@ type IdleApi = Pick<typeof globalThis, "requestIdleCallback" | "cancelIdleCallba
  */
 export declare let runWhenGlobalIdle: (callback: (idle: IdleDeadline) => void, timeout?: number) => IDisposable;
 export declare let _runWhenIdle: (targetWindow: IdleApi, callback: (idle: IdleDeadline) => void, timeout?: number) => IDisposable;
+export declare function installFakeRunWhenIdle(fakeImpl: typeof _runWhenIdle): IDisposable;
 export declare abstract class AbstractIdleValue<T> {
     private readonly _executor;
     private readonly _handle;

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

@@ -18,6 +18,7 @@ export interface ILegacyQuotaSnapshotData {
 }
 export interface IEntitlementsData extends ILegacyQuotaSnapshotData {
     readonly access_type_sku: string;
+    readonly chat_enabled: boolean;
     readonly assigned_date: string;
     readonly can_signup_for_limited: boolean;
     readonly copilot_plan: string;

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

@@ -359,22 +359,19 @@ declare class Stacktrace {
     print(): void;
 }
 export declare class ListenerLeakError extends Error {
+    readonly kind: string;
+    readonly listenerCount: number;
     /**
      * The detailed message including listener count and most frequent stack.
      * Available locally for debugging but intentionally not used as the error
      * `message` so that all leak errors group under the same title in telemetry.
      */
     readonly details: string;
-    constructor(kind: "dominated" | "popular", details: string, stack: string);
+    constructor(kind: "dominated" | "popular", details: string, stack: string, listenerCount: number);
+    static is(err: unknown): err is ListenerLeakError;
 }
-export declare class ListenerRefusalError extends Error {
-    /**
-     * The detailed message including listener count and most frequent stack.
-     * Available locally for debugging but intentionally not used as the error
-     * `message` so that all leak errors group under the same title in telemetry.
-     */
-    readonly details: string;
-    constructor(kind: "dominated" | "popular", details: string, stack: string);
+export declare class ListenerRefusalError extends ListenerLeakError {
+    constructor(kind: "dominated" | "popular", details: string, stack: string, listenerCount: number);
 }
 declare class UniqueContainer<T> {
     readonly value: T;

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

@@ -602,7 +602,7 @@ class LeakageMonitor {
             console.warn(message);
             console.warn(topStack);
             const kind = topCount / listenerCount > 0.3 ? "dominated" : "popular";
-            const error = ( new ListenerLeakError(kind, message, topStack));
+            const error = ( new ListenerLeakError(kind, message, topStack, listenerCount));
             this._errorHandler(error);
         }
         return () => {
@@ -638,19 +638,22 @@ class Stacktrace {
     }
 }
 class ListenerLeakError extends Error {
-    constructor(kind, details, stack) {
+    constructor(kind, details, stack, listenerCount) {
         super(`potential listener LEAK detected, ${kind}`);
         this.name = "ListenerLeakError";
+        this.kind = kind;
+        this.listenerCount = listenerCount;
         this.details = details;
         this.stack = stack;
     }
+    static is(err) {
+        return err instanceof ListenerLeakError || (err instanceof Error && typeof err.kind === "string" && typeof err.listenerCount === "number");
+    }
 }
-class ListenerRefusalError extends Error {
-    constructor(kind, details, stack) {
-        super(`potential listener LEAK detected, ${kind} (REFUSED to add)`);
+class ListenerRefusalError extends ListenerLeakError {
+    constructor(kind, details, stack, listenerCount) {
+        super(kind, details, stack, listenerCount);
         this.name = "ListenerRefusalError";
-        this.details = details;
-        this.stack = stack;
     }
 }
 let id = 0;
@@ -708,7 +711,8 @@ class Emitter {
                 const error = ( new ListenerRefusalError(
                     kind,
                     `${message}. HINT: Stack shows most frequent listener (${tuple[1]}-times)`,
-                    tuple[0]
+                    tuple[0],
+                    this._size
                 ));
                 const errorHandler = this._options?.onListenerError || onUnexpectedError;
                 errorHandler(error);

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

@@ -49,6 +49,16 @@ export declare function escapeMarkdownSyntaxTokens(text: string): string;
  * @see https://github.com/microsoft/vscode/issues/193746
  */
 export declare function appendEscapedMarkdownCodeBlockFence(code: string, langId: string): string;
+/**
+ * Wraps arbitrary text in a markdown inline code span using a backtick fence
+ * long enough to safely contain any backtick sequences present in the text.
+ *
+ * Backticks inside an inline code span cannot be backslash-escaped per the
+ * CommonMark spec — the only safe way is to choose a delimiter run longer
+ * than any run of backticks in the content (and pad with spaces if the
+ * content begins or ends with a backtick).
+ */
+export declare function appendEscapedMarkdownInlineCode(text: string): string;
 export declare function escapeDoubleQuotes(input: string): string;
 export declare function removeMarkdownEscapes(text: string): string;
 export declare function parseHrefAndDimensions(href: string): {

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

@@ -111,6 +111,13 @@ function appendEscapedMarkdownCodeBlockFence(code, langId) {
         `${"`".repeat(desiredFenceLength)}`
     ].join("\n");
 }
+function appendEscapedMarkdownInlineCode(text) {
+    const longestBacktickRun = Math.max(0, ...( (text.match(/`+/g) ?? []).map(m => m.length)));
+    const fence = "`".repeat(longestBacktickRun + 1);
+    const needsSpace = text.startsWith("`") || text.endsWith("`");
+    const content = needsSpace ? ` ${text} ` : text;
+    return `${fence}${content}${fence}`;
+}
 function escapeDoubleQuotes(input) {
     return input.replace(/"/g, """);
 }
@@ -159,4 +166,4 @@ function createCommandUri(commandId, ...commandArgs) {
     }));
 }
 
-export { MarkdownString, MarkdownStringTextNewlineStyle, appendEscapedMarkdownCodeBlockFence, createCommandUri, createMarkdownCommandLink, createMarkdownLink, escapeDoubleQuotes, escapeMarkdownSyntaxTokens, isEmptyMarkdownString, isMarkdownString, markdownStringEqual, parseHrefAndDimensions, removeMarkdownEscapes };
+export { MarkdownString, MarkdownStringTextNewlineStyle, appendEscapedMarkdownCodeBlockFence, appendEscapedMarkdownInlineCode, createCommandUri, createMarkdownCommandLink, createMarkdownLink, escapeDoubleQuotes, escapeMarkdownSyntaxTokens, isEmptyMarkdownString, isMarkdownString, markdownStringEqual, parseHrefAndDimensions, removeMarkdownEscapes };

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

@@ -43,7 +43,7 @@ export declare function getPathLabel(resource: URI, formatting: IPathLabelFormat
 export declare function normalizeDriveLetter(path: string, isWindowsOS?: boolean): string;
 export declare function tildify(path: string, userHome: string, os?: OperatingSystem): string;
 export declare function untildify(path: string, userHome: string): string;
-export declare function shorten(paths: string[], pathSeparator?: string): string[];
+export declare function shorten(paths: string[], defaultPathSeparator?: string): string[];
 export interface ISeparator {
     label: string;
 }

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

@@ -107,11 +107,13 @@ function untildify(path, userHome) {
 }
 const ellipsis = "…";
 const unc = "\\\\";
+const urlSchemaRegexp = /^[^:/\\?#]+?:\/\//;
 const home = "~";
-function shorten(paths, pathSeparator = sep) {
+function shorten(paths, defaultPathSeparator = sep) {
     const shortenedPaths = ( new Array(paths.length));
     let match = false;
     for (let pathIndex = 0; pathIndex < paths.length; pathIndex++) {
+        let pathSeparator = defaultPathSeparator;
         const originalPath = paths[pathIndex];
         if (originalPath === "") {
             shortenedPaths[pathIndex] = `.${pathSeparator}`;
@@ -124,7 +126,11 @@ function shorten(paths, pathSeparator = sep) {
         match = true;
         let prefix = "";
         let trimmedPath = originalPath;
-        if (trimmedPath.indexOf(unc) === 0) {
+        if (urlSchemaRegexp.test(trimmedPath)) {
+            prefix = trimmedPath.substr(0, trimmedPath.indexOf("//") + 2);
+            trimmedPath = trimmedPath.substr(trimmedPath.indexOf("//") + 2);
+            pathSeparator = "/";
+        } else if (trimmedPath.indexOf(unc) === 0) {
             prefix = trimmedPath.substr(0, trimmedPath.indexOf(unc) + unc.length);
             trimmedPath = trimmedPath.substr(trimmedPath.indexOf(unc) + unc.length);
         } else if (trimmedPath.indexOf(pathSeparator) === 0) {
@@ -165,7 +171,11 @@ function shorten(paths, pathSeparator = sep) {
                     }
                     result = result + subpath;
                     if (start + subpathLength < segments.length) {
-                        result = result + pathSeparator + ellipsis;
+                        if (start + subpathLength === segments.length - 1 && segments[segments.length - 1] === "") {
+                            result = result + pathSeparator;
+                        } else {
+                            result = result + pathSeparator + ellipsis;
+                        }
                     }
                     shortenedPaths[pathIndex] = result;
                 }

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

@@ -6,7 +6,7 @@ export { derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedW
 export { type IDerivedReader } from "./observables/derivedImpl.js";
 export { ObservableLazy, ObservableLazyPromise, ObservablePromise, PromiseResult, } from "./utils/promise.js";
 export { derivedWithCancellationToken, waitForState } from "./utils/utilsCancellation.js";
-export { debouncedObservable, debouncedObservable2, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, mapObservableArrayCached, observableFromPromise, recomputeInitiallyAndOnChange, signalFromObservable, wasEventTriggeredRecently, isObservable, } from "./utils/utils.js";
+export { debouncedObservable, debouncedObservable2, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, mapObservableArrayCached, observableFromPromise, recomputeInitiallyAndOnChange, signalFromObservable, throttledObservable, wasEventTriggeredRecently, isObservable, } from "./utils/utils.js";
 export { type DebugOwner } from "./debugName.js";
 export { type IChangeContext, type IChangeTracker, recordChanges, recordChangesLazy } from "./changeTracker.js";
 export { constObservable } from "./observables/constObservable.js";

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

@@ -10,7 +10,7 @@ import './reactions/autorunImpl.js';
 export { derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithSetter } from './observables/derived.js';
 import '../cancellation.js';
 import './observables/derivedImpl.js';
-export { debouncedObservable, debouncedObservable2, derivedObservableWithCache, derivedObservableWithWritableCache, isObservable, keepObserved, mapObservableArrayCached, observableFromPromise, recomputeInitiallyAndOnChange, wasEventTriggeredRecently } from './utils/utils.js';
+export { debouncedObservable, debouncedObservable2, derivedObservableWithCache, derivedObservableWithWritableCache, isObservable, keepObserved, mapObservableArrayCached, observableFromPromise, recomputeInitiallyAndOnChange, throttledObservable, wasEventTriggeredRecently } from './utils/utils.js';
 export { observableFromEvent, observableFromEventOpts } from './observables/observableFromEvent.js';
 import { logObservableToConsole } from './logging/consoleObservableLogger.js';
 import { DevToolsLogger } from './logging/debugger/devToolsLogger.js';

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

@@ -10,6 +10,12 @@ export declare function signalFromObservable<T>(owner: DebugOwner | undefined, o
  * Creates an observable that debounces the input observable.
  */
 export declare function debouncedObservable<T>(observable: IObservable<T>, debounceMs: number | ((lastValue: T | undefined, newValue: T) => number), debugLocation?: DebugLocation): IObservable<T>;
+/**
+ * Creates an observable that throttles the input observable.
+ * Unlike {@link debouncedObservable}, the timer starts on the first change
+ * and is not reset by subsequent changes, preventing starvation.
+ */
+export declare function throttledObservable<T>(observable: IObservable<T>, throttleMs: number, debugLocation?: DebugLocation): IObservable<T>;
 /**
  * Creates an observable that debounces the input observable.
  */

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

@@ -61,6 +61,43 @@ function debouncedObservable(observable, debounceMs, debugLocation = DebugLocati
         }
     }, debugLocation);
 }
+function throttledObservable(observable, throttleMs, debugLocation = DebugLocation.ofCaller()) {
+    let hasValue = false;
+    let lastValue;
+    let timeout = undefined;
+    return observableFromEvent(undefined, cb => {
+        const d = autorun(reader => {
+            const value = observable.read(reader);
+            if (!hasValue) {
+                hasValue = true;
+                lastValue = value;
+            } else if (!timeout) {
+                timeout = setTimeout(() => {
+                    timeout = undefined;
+                    lastValue = observable.read(undefined);
+                    cb();
+                }, throttleMs);
+            }
+        });
+        return {
+            dispose() {
+                d.dispose();
+                if (timeout) {
+                    clearTimeout(timeout);
+                    timeout = undefined;
+                }
+                hasValue = false;
+                lastValue = undefined;
+            }
+        };
+    }, () => {
+        if (hasValue) {
+            return lastValue;
+        } else {
+            return observable.get();
+        }
+    }, debugLocation);
+}
 function debouncedObservable2(observable, debounceMs, debugLocation = DebugLocation.ofCaller()) {
     const s = observableSignal("handleTimeout");
     let currentValue = undefined;
@@ -239,4 +276,4 @@ function isObservable(obj) {
     return !!obj && obj.read !== undefined && obj.reportChanges !== undefined;
 }
 
-export { KeepAliveObserver, debouncedObservable, debouncedObservable2, derivedObservableWithCache, derivedObservableWithWritableCache, isObservable, keepObserved, mapObservableArrayCached, observableFromPromise, recomputeInitiallyAndOnChange, wasEventTriggeredRecently };
+export { KeepAliveObserver, debouncedObservable, debouncedObservable2, derivedObservableWithCache, derivedObservableWithWritableCache, isObservable, keepObserved, mapObservableArrayCached, observableFromPromise, recomputeInitiallyAndOnChange, throttledObservable, wasEventTriggeredRecently };

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

@@ -2,9 +2,10 @@ export declare const mark: (name: string, markOptions?: {
     startTime?: number;
 }) => void;
 /**
- * Clears all marks whose name starts with the given prefix.
+ * Clears performance marks. If a name is given, only marks with that exact
+ * name are removed. If no name is given, all marks are removed.
  */
-export declare const clearMarks: (prefix: string) => void;
+export declare const clearMarks: (name?: string) => void;
 export interface PerformanceMark {
     readonly name: string;
     readonly startTime: number;