@codingame/monaco-vscode-api 21.5.1 → 22.0.0

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

@@ -1,7 +1,6 @@
 
-import { toDisposable, DisposableStore } from '../common/lifecycle.js';
 import { Schemas } from '../common/network.js';
-import { createElement } from './dom.js';
+import { reset } from './dom.js';
 import dompurify from 'dompurify';
 
 const basicMarkupHtmlTags = ( Object.freeze([
@@ -47,6 +46,7 @@ const basicMarkupHtmlTags = ( Object.freeze([
     'rp',
     'rt',
     'ruby',
+    's',
     'samp',
     'small',
     'small',
@@ -92,19 +92,28 @@ const defaultAllowedAttrs = ( Object.freeze([
     'height',
     'align',
 ]));
-function addDompurifyHook(hook, cb) {
-    dompurify.addHook(hook, cb);
-    return toDisposable(() => dompurify.removeHook(hook));
-}
-function hookDomPurifyHrefAndSrcSanitizer(allowedLinkProtocols, allowedMediaProtocols) {
-    const anchor = createElement('a');
-    function validateLink(value, allowedProtocols) {
-        if (allowedProtocols === '*') {
+const fakeRelativeUrlProtocol = 'vscode-relative-path';
+function validateLink(value, allowedProtocols) {
+    if (allowedProtocols.override === '*') {
+        return true;
+    }
+    try {
+        const url = ( new URL(value, fakeRelativeUrlProtocol + '://'));
+        if (allowedProtocols.override.includes(url.protocol.replace(/:$/, ''))) {
             return true;
         }
-        anchor.href = value;
-        return allowedProtocols.includes(anchor.protocol.replace(/:$/, ''));
+        if (allowedProtocols.allowRelativePaths
+            && url.protocol === fakeRelativeUrlProtocol + ':'
+            && !value.trim().toLowerCase().startsWith(fakeRelativeUrlProtocol)) {
+            return true;
+        }
+        return false;
     }
+    catch (e) {
+        return false;
+    }
+}
+function hookDomPurifyHrefAndSrcSanitizer(allowedLinkProtocols, allowedMediaProtocols) {
     dompurify.addHook('afterSanitizeAttributes', (node) => {
         for (const attr of ['href', 'src']) {
             if (node.hasAttribute(attr)) {
@@ -122,18 +131,16 @@ function hookDomPurifyHrefAndSrcSanitizer(allowedLinkProtocols, allowedMediaProt
             }
         }
     });
-    return toDisposable(() => dompurify.removeHook('afterSanitizeAttributes'));
 }
 const defaultDomPurifyConfig = ( Object.freeze({
     ALLOWED_TAGS: [...basicMarkupHtmlTags],
     ALLOWED_ATTR: [...defaultAllowedAttrs],
-    RETURN_DOM: false,
-    RETURN_DOM_FRAGMENT: false,
-    RETURN_TRUSTED_TYPE: true,
     ALLOW_UNKNOWN_PROTOCOLS: true,
 }));
 function sanitizeHtml(untrusted, config) {
-    const store = ( new DisposableStore());
+    return doSanitizeHtml(untrusted, config, 'trusted');
+}
+function doSanitizeHtml(untrusted, config, outputType) {
     try {
         const resolvedConfig = { ...defaultDomPurifyConfig };
         if (config?.allowedTags) {
@@ -173,12 +180,18 @@ function sanitizeHtml(untrusted, config) {
             }
         }
         resolvedConfig.ALLOWED_ATTR = Array.from(allowedAttrNames);
-        store.add(hookDomPurifyHrefAndSrcSanitizer(config?.allowedLinkProtocols?.override ?? [Schemas.http, Schemas.https], config?.allowedMediaProtocols?.override ?? [Schemas.http, Schemas.https]));
+        hookDomPurifyHrefAndSrcSanitizer({
+            override: config?.allowedLinkProtocols?.override ?? [Schemas.http, Schemas.https],
+            allowRelativePaths: config?.allowRelativeLinkPaths ?? false
+        }, {
+            override: config?.allowedMediaProtocols?.override ?? [Schemas.http, Schemas.https],
+            allowRelativePaths: config?.allowRelativeMediaPaths ?? false
+        });
         if (config?.replaceWithPlaintext) {
-            store.add(addDompurifyHook('uponSanitizeElement', replaceWithPlainTextHook));
+            dompurify.addHook('uponSanitizeElement', replaceWithPlainTextHook);
         }
         if (allowedAttrPredicates.size) {
-            store.add(addDompurifyHook('uponSanitizeAttribute', (node, e) => {
+            dompurify.addHook('uponSanitizeAttribute', (node, e) => {
                 const predicate = allowedAttrPredicates.get(e.attrName);
                 if (predicate) {
                     const result = predicate.shouldKeep(node, e);
@@ -193,15 +206,23 @@ function sanitizeHtml(untrusted, config) {
                 else {
                     e.keepAttr = ( allowedAttrNames.has(e.attrName));
                 }
-            }));
+            });
+        }
+        if (outputType === 'dom') {
+            return dompurify.sanitize(untrusted, {
+                ...resolvedConfig,
+                RETURN_DOM_FRAGMENT: true
+            });
+        }
+        else {
+            return dompurify.sanitize(untrusted, {
+                ...resolvedConfig,
+                RETURN_TRUSTED_TYPE: true
+            });
         }
-        return dompurify.sanitize(untrusted, {
-            ...resolvedConfig,
-            RETURN_TRUSTED_TYPE: true
-        });
     }
     finally {
-        store.dispose();
+        dompurify.removeAllHooks();
     }
 }
 const selfClosingTags = ['area', 'base', 'br', 'col', 'command', 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'meta', 'param', 'source', 'track', 'wbr'];
@@ -248,7 +269,8 @@ function convertTagToPlaintext(element) {
     return fragment;
 }
 function safeSetInnerHtml(node, untrusted, config) {
-    node.innerHTML = sanitizeHtml(untrusted, config);
+    const fragment = doSanitizeHtml(untrusted, config, 'dom');
+    reset(node, fragment);
 }
 
 export { basicMarkupHtmlTags, convertTagToPlaintext, defaultAllowedAttrs, safeSetInnerHtml, sanitizeHtml };

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

@@ -1,6 +1,7 @@
 
 import { toDisposable, DisposableStore } from '../common/lifecycle.js';
 import '../common/observableInternal/index.js';
+import { isFirefox } from './browser.js';
 import { isShadowRoot, createElement, getWindows, sharedMutationObserver } from './dom.js';
 import { mainWindow } from './window.js';
 import { autorun } from '../common/observableInternal/reactions/autorun.js';
@@ -56,6 +57,9 @@ function createStyleSheet(container = mainWindow.document.head, beforeAppend, di
     if (container === mainWindow.document.head) {
         const globalStylesheetClones = ( new Set());
         globalStylesheets.set(style, globalStylesheetClones);
+        if (disposableStore) {
+            disposableStore.add(toDisposable(() => globalStylesheets.delete(style)));
+        }
         for (const { window: targetWindow, disposables } of getWindows()) {
             if (targetWindow === mainWindow) {
                 continue;
@@ -85,7 +89,7 @@ function cloneGlobalStyleSheet(globalStylesheet, globalStylesheetClones, windowE
     for (const rule of getDynamicStyleSheetRules(globalStylesheet)) {
         clone.sheet?.insertRule(rule.cssText, clone.sheet?.cssRules.length);
     }
-    disposables.add(sharedMutationObserver.observe(globalStylesheet, disposables, { childList: true, subtree: true, characterData: true })(() => {
+    disposables.add(sharedMutationObserver.observe(globalStylesheet, disposables, { childList: true, subtree: isFirefox, characterData: isFirefox })(() => {
         clone.textContent = globalStylesheet.textContent;
     }));
     globalStylesheetClones.add(clone);

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

@@ -84,7 +84,7 @@ function renderMarkdown(markdown, options = {}, target) {
         renderedMarkdown = ( elements.map(e => typeof e === 'string' ? e : e.outerHTML)).join('');
     }
     const renderedContent = createElement('div');
-    const sanitizerConfig = getDomSanitizerConfig(markdown.isTrusted ?? false, options.sanitizerConfig ?? {});
+    const sanitizerConfig = getDomSanitizerConfig(markdown, options.sanitizerConfig ?? {});
     safeSetInnerHtml(renderedContent, renderedMarkdown, sanitizerConfig);
     rewriteRenderedLinks(markdown, options, renderedContent);
     let outElement;
@@ -337,8 +337,8 @@ function resolveWithBaseUri(baseUri, href) {
         return ( resolvePath(dirname(baseUri), href).toString());
     }
 }
-function sanitizeRenderedMarkdown(renderedMarkdown, isTrusted, options = {}) {
-    const sanitizerConfig = getDomSanitizerConfig(isTrusted, options);
+function sanitizeRenderedMarkdown(renderedMarkdown, originalMdStrConfig, options = {}) {
+    const sanitizerConfig = getDomSanitizerConfig(originalMdStrConfig, options);
     return sanitizeHtml(renderedMarkdown, sanitizerConfig);
 }
 const allowedMarkdownHtmlTags = ( Object.freeze([
@@ -393,7 +393,8 @@ const allowedMarkdownHtmlAttributes = ( Object.freeze([
         },
     },
 ]));
-function getDomSanitizerConfig(isTrusted, options) {
+function getDomSanitizerConfig(mdStrConfig, options) {
+    const isTrusted = mdStrConfig.isTrusted ?? false;
     const allowedLinkSchemes = [
         Schemas.http,
         Schemas.https,
@@ -420,6 +421,7 @@ function getDomSanitizerConfig(isTrusted, options) {
         allowedLinkProtocols: {
             override: allowedLinkSchemes,
         },
+        allowRelativeLinkPaths: !!mdStrConfig.baseUri,
         allowedMediaProtocols: {
             override: [
                 Schemas.http,
@@ -443,7 +445,7 @@ function renderAsPlaintext(str, options) {
         value = `${value.substr(0, 100_000)}…`;
     }
     const html = parse$1(value, { async: false, renderer: options?.includeCodeBlocksFences ? plainTextWithCodeBlocksRenderer.value : plainTextRenderer.value });
-    return ( sanitizeRenderedMarkdown(html,  false, {})
+    return ( sanitizeRenderedMarkdown(html, { isTrusted: false }, {})
         .toString())
         .replace(/&(#\d+|[a-zA-Z]+);/g, m => unescapeInfo.get(m) ?? m)
         .trim();

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

@@ -1,7 +1,7 @@
 
 import { registerCss } from '@codingame/monaco-vscode-api/css';
 import { BrowserFeatures } from '../../canIUse.js';
-import { $, hide, createElement, addStandardDisposableListener, clearNode, show, isHTMLElement, getDomNodePagePosition, getDomNodeZoomLevel, getTotalWidth, getTotalHeight, getActiveWindow, getWindow, isAncestor } from '../../dom.js';
+import { $, hide, createElement, addStandardDisposableListener, clearNode, show, isHTMLElement, getDomNodePagePosition, getDomNodeZoomLevel, getTotalWidth, getTotalHeight, getActiveWindow, getActiveElement, getWindow, isAncestor } from '../../dom.js';
 import { Disposable, toDisposable, DisposableStore } from '../../../common/lifecycle.js';
 import { isIOS } from '../../../common/platform.js';
 import { Range } from '../../../common/range.js';
@@ -243,7 +243,7 @@ class ContextView extends Disposable {
     onDOMEvent(e, onCapture) {
         if (this.delegate) {
             if (this.delegate.onDOMEvent) {
-                this.delegate.onDOMEvent(e, getWindow(e).document.activeElement);
+                this.delegate.onDOMEvent(e, getActiveElement(getWindow(e).document));
             }
             else if (onCapture && !isAncestor(e.target, this.container)) {
                 this.hide();

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

@@ -31,7 +31,7 @@ class BaseDropdown extends ActionRunner {
         }
         for (const event of [EventType.MOUSE_DOWN, EventType$1.Tap]) {
             this._register(addDisposableListener(this._label, event, e => {
-                if (isMouseEvent(e) && (e.detail > 1 || e.button !== 0)) {
+                if (isMouseEvent(e) && e.button !== 0) {
                     return;
                 }
                 if (this.visible) {

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

@@ -645,6 +645,7 @@ class SubmenuMenuActionViewItem extends BaseMenuActionViewItem {
             this.submenuContainer.style.position = 'fixed';
             this.submenuContainer.style.top = '0';
             this.submenuContainer.style.left = '0';
+            this.submenuContainer.style.zIndex = '1';
             this.parentData.submenu = ( new Menu(
                 this.submenuContainer,
                 this.submenuActions.length ? this.submenuActions : [( new EmptySubmenuAction())],

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

@@ -57,7 +57,7 @@ export declare class ProgressBar extends Disposable {
      */
     worked(value: number): ProgressBar;
     /**
-     * Tells the progress bar the total amount of work that has been completed.
+     * Tells the progress bar the total amount of work (0 to 100) that has been completed.
      */
     setWorked(value: number): ProgressBar;
     private doSetWorked;

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

@@ -921,6 +921,9 @@ class DeferredPromise {
         }));
     }
     complete(value) {
+        if (this.isSettled) {
+            return Promise.resolve();
+        }
         return ( new Promise(resolve => {
             this.completeCallback(value);
             this.outcome = { outcome: DeferredOutcome.Resolved, value };
@@ -928,6 +931,9 @@ class DeferredPromise {
         }));
     }
     error(err) {
+        if (this.isSettled) {
+            return Promise.resolve();
+        }
         return ( new Promise(resolve => {
             this.errorCallback(err);
             this.outcome = { outcome: DeferredOutcome.Rejected, value: err };

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

@@ -28,3 +28,24 @@ export declare class CancellationTokenSource {
     dispose(cancel?: boolean): void;
 }
 export declare function cancelOnDispose(store: DisposableStore): CancellationToken;
+/**
+ * A pool that aggregates multiple cancellation tokens. The pool's own token
+ * (accessible via `pool.token`) is cancelled only after every token added
+ * to the pool has been cancelled. Adding tokens after the pool token has
+ * been cancelled has no effect.
+ */
+export declare class CancellationTokenPool {
+    private readonly _source;
+    private readonly _listeners;
+    private _total;
+    private _cancelled;
+    private _isDone;
+    get token(): CancellationToken;
+    /**
+     * Add a token to the pool. If the token is already cancelled it is counted
+     * immediately. Tokens added after the pool token has been cancelled are ignored.
+     */
+    add(token: CancellationToken): void;
+    private _check;
+    dispose(): void;
+}

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

@@ -1,5 +1,6 @@
 
 import { Event, Emitter } from './event.js';
+import { DisposableStore } from './lifecycle.js';
 
 const shortcutEvent = ( Object.freeze(function (callback, context) {
     const handle = setTimeout(callback.bind(context), 0);
@@ -101,5 +102,45 @@ function cancelOnDispose(store) {
     store.add({ dispose() { source.cancel(); } });
     return source.token;
 }
+class CancellationTokenPool {
+    constructor() {
+        this._source = ( new CancellationTokenSource());
+        this._listeners = ( new DisposableStore());
+        this._total = 0;
+        this._cancelled = 0;
+        this._isDone = false;
+    }
+    get token() {
+        return this._source.token;
+    }
+    add(token) {
+        if (this._isDone) {
+            return;
+        }
+        this._total++;
+        if (token.isCancellationRequested) {
+            this._cancelled++;
+            this._check();
+            return;
+        }
+        const d = token.onCancellationRequested(() => {
+            d.dispose();
+            this._cancelled++;
+            this._check();
+        });
+        this._listeners.add(d);
+    }
+    _check() {
+        if (!this._isDone && this._total > 0 && this._total === this._cancelled) {
+            this._isDone = true;
+            this._listeners.dispose();
+            this._source.cancel();
+        }
+    }
+    dispose() {
+        this._listeners.dispose();
+        this._source.dispose();
+    }
+}
 
-export { CancellationToken, CancellationTokenSource, cancelOnDispose };
+export { CancellationToken, CancellationTokenPool, CancellationTokenSource, cancelOnDispose };

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

@@ -677,4 +677,7 @@ export declare const Codicon: {
     readonly commentDiscussionSparkle: ThemeIcon;
     readonly chatSparkleWarning: ThemeIcon;
     readonly chatSparkleError: ThemeIcon;
+    readonly collection: ThemeIcon;
+    readonly newCollection: ThemeIcon;
+    readonly thinking: ThemeIcon;
 };

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

@@ -603,4 +603,7 @@ export declare const codiconsLibrary: {
     readonly commentDiscussionSparkle: import("./themables.js").ThemeIcon;
     readonly chatSparkleWarning: import("./themables.js").ThemeIcon;
     readonly chatSparkleError: import("./themables.js").ThemeIcon;
+    readonly collection: import("./themables.js").ThemeIcon;
+    readonly newCollection: import("./themables.js").ThemeIcon;
+    readonly thinking: import("./themables.js").ThemeIcon;
 };

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

@@ -606,6 +606,9 @@ const codiconsLibrary = {
     commentDiscussionSparkle: register('comment-discussion-sparkle', 0xec54),
     chatSparkleWarning: register('chat-sparkle-warning', 0xec55),
     chatSparkleError: register('chat-sparkle-error', 0xec56),
+    collection: register('collection', 0xec57),
+    newCollection: register('new-collection', 0xec58),
+    thinking: register('thinking', 0xec59),
 };
 
 export { codiconsLibrary };

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

@@ -0,0 +1,84 @@
+import { Disposable } from "../lifecycle.js";
+import { CancellationToken } from "../cancellation.js";
+/**
+ * Helper type that represents a function that has an optional {@linkcode CancellationToken}
+ * argument argument at the end of the arguments list.
+ *
+ * @typeparam `TFunction` - Type of the function arguments list of which will be extended
+ * 							with an optional {@linkcode CancellationToken} argument.
+ */
+type TWithOptionalCancellationToken<TFunction extends Function> = TFunction extends (...args: infer TArgs) => infer TReturn ? (...args: [
+    ...TArgs,
+    cancellatioNToken?: CancellationToken
+]) => TReturn : never;
+/**
+ * Decorator that provides a mechanism to cancel previous calls of the decorated method
+ * by providing a `cancellation token` as the last argument of the method, which gets
+ * cancelled immediately on subsequent call of the decorated method.
+ *
+ * Therefore to use this decorator, the two conditions must be met:
+ *
+ * - the decorated method must have an *optional* {@linkcode CancellationToken} argument at
+ * 	 the end of the arguments list
+ * - the object that the decorated method belongs to must implement the {@linkcode Disposable};
+ *   this requirement comes from the internal implementation of the decorator that
+ *   creates new resources that need to be eventually disposed by someone
+ *
+ * @typeparam `TObject` - Object type that the decorated method belongs to.
+ * @typeparam `TArgs` - Argument list of the decorated method.
+ * @typeparam `TReturn` - Return value type of the decorated method.
+ *
+ * ### Examples
+ *
+ * ```typescript
+ * // let's say we have a class that implements the `Disposable` interface that we want
+ * // to use the decorator on
+ * class Example extends Disposable {
+ * 		async doSomethingAsync(arg1: number, arg2: string): Promise<void> {
+ * 			// do something async..
+ * 			await new Promise(resolve => setTimeout(resolve, 1000));
+ * 		}
+ * }
+ * ```
+ *
+ * ```typescript
+ * // to do that we need to add the `CancellationToken` argument to the end of args list
+ * class Example extends Disposable {
+ * 		@cancelPreviousCalls
+ * 		async doSomethingAsync(arg1: number, arg2: string, cancellationToken?: CancellationToken): Promise<void> {
+ * 			console.log(`call with args ${arg1} and ${arg2} initiated`);
+ *
+ * 			// the decorator will create the cancellation token automatically
+ * 			assertDefined(
+ * 				cancellationToken,
+ * 				`The method must now have the `CancellationToken` passed to it.`,
+ * 			);
+ *
+ * 			cancellationToken.onCancellationRequested(() => {
+ * 				console.log(`call with args ${arg1} and ${arg2} was cancelled`);
+ * 			});
+ *
+ * 			// do something async..
+ * 			await new Promise(resolve => setTimeout(resolve, 1000));
+ *
+ * 			// check cancellation token state after the async operations
+ * 			console.log(
+ * 				`call with args ${arg1} and ${arg2} completed, canceled?: ${cancellationToken.isCancellationRequested}`,
+ * 			);
+ * 		}
+ * }
+ *
+ * const example = new Example();
+ * // call the decorate method first time
+ * example.doSomethingAsync(1, 'foo');
+ * // wait for 500ms which is less than 1000ms of the async operation in the first call
+ * await new Promise(resolve => setTimeout(resolve, 500));
+ * // calling the decorate method second time cancels the token passed to the first call
+ * example.doSomethingAsync(2, 'bar');
+ * ```
+ */
+export declare function cancelPreviousCalls<TObject extends Disposable, TArgs extends unknown[], TReturn extends unknown>(_proto: TObject, methodName: string, descriptor: TypedPropertyDescriptor<TWithOptionalCancellationToken<(...args: TArgs) => TReturn>>): TypedPropertyDescriptor<(...args: [
+    ...TArgs,
+    cancellatioNToken?: CancellationToken | undefined
+]) => TReturn>;
+export {};

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

@@ -4,4 +4,4 @@ export interface IDebounceReducer<T> {
 }
 export declare function debounce<T>(delay: number, reducer?: IDebounceReducer<T>, initialValueProvider?: () => T): MethodDecorator;
 export declare function throttle<T>(delay: number, reducer?: IDebounceReducer<T>, initialValueProvider?: () => T): MethodDecorator;
-export { cancelPreviousCalls } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/base/common/decorators/cancelPreviousCalls";
+export { cancelPreviousCalls } from "./decorators/cancelPreviousCalls.js";

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

@@ -55,4 +55,6 @@ export declare function markdownCommandLink(command: {
     title: string;
     id: string;
     arguments?: unknown[];
+    tooltip?: string;
 }, escapeTokens?: boolean): string;
+export declare function createCommandUri(commandId: string, ...commandArgs: unknown[]): URI;

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

@@ -153,12 +153,15 @@ function parseHrefAndDimensions(href) {
     return { href, dimensions };
 }
 function markdownCommandLink(command, escapeTokens = true) {
-    const uri = ( ( URI.from({
+    const uri = ( createCommandUri(command.id, ...(command.arguments || [])).toString());
+    return `[${escapeTokens ? escapeMarkdownSyntaxTokens(command.title) : command.title}](${uri}${command.tooltip ? ` "${escapeMarkdownSyntaxTokens(command.tooltip)}"` : ''})`;
+}
+function createCommandUri(commandId, ...commandArgs) {
+    return ( URI.from({
         scheme: Schemas.command,
-        path: command.id,
-        query: command.arguments?.length ? encodeURIComponent(JSON.stringify(command.arguments)) : undefined,
-    })).toString());
-    return `[${escapeTokens ? escapeMarkdownSyntaxTokens(command.title) : command.title}](${uri})`;
+        path: commandId,
+        query: commandArgs.length ? encodeURIComponent(JSON.stringify(commandArgs)) : undefined,
+    }));
 }
 
-export { MarkdownString, MarkdownStringTextNewlineStyle, appendEscapedMarkdownCodeBlockFence, escapeDoubleQuotes, escapeMarkdownSyntaxTokens, isEmptyMarkdownString, isMarkdownString, markdownCommandLink, markdownStringEqual, parseHrefAndDimensions, removeMarkdownEscapes };
+export { MarkdownString, MarkdownStringTextNewlineStyle, appendEscapedMarkdownCodeBlockFence, createCommandUri, escapeDoubleQuotes, escapeMarkdownSyntaxTokens, isEmptyMarkdownString, isMarkdownString, markdownCommandLink, markdownStringEqual, parseHrefAndDimensions, removeMarkdownEscapes };

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

@@ -214,14 +214,28 @@ function combinedDisposable(...disposables) {
     setParentOfDisposables(disposables, parent);
     return parent;
 }
+class FunctionDisposable {
+    constructor(fn) {
+        this._isDisposed = false;
+        this._fn = fn;
+        trackDisposable(this);
+    }
+    dispose() {
+        if (this._isDisposed) {
+            return;
+        }
+        if (!this._fn) {
+            throw ( new Error(
+                `Unbound disposable context: Need to use an arrow function to preserve the value of this`
+            ));
+        }
+        this._isDisposed = true;
+        markAsDisposed(this);
+        this._fn();
+    }
+}
 function toDisposable(fn) {
-    const self = trackDisposable({
-        dispose: createSingleCallFunction(() => {
-            markAsDisposed(self);
-            fn();
-        })
-    });
-    return self;
+    return ( new FunctionDisposable(fn));
 }
 class DisposableStore {
     static { this.DISABLE_DISPOSED_WARNING = false; }

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

@@ -22,49 +22,4 @@ export declare class SlidingWindowAverage {
 }
 /** Returns whether the point is within the triangle formed by the following 6 x/y point pairs */
 export declare function isPointWithinTriangle(x: number, y: number, ax: number, ay: number, bx: number, by: number, cx: number, cy: number): boolean;
-/**
- * Function to get a (pseudo)random integer from a provided `max`...[`min`] range.
- * Both `min` and `max` values are inclusive. The `min` value is optional (defaults to `0`).
- *
- * @throws in the next cases:
- * 	- if provided `min` or `max` is not a number
- *  - if provided `min` or `max` is not finite
- *  - if provided `min` is larger than `max` value
- *
- * ## Examples
- *
- * Specifying a `max` value only uses `0` as the `min` value by default:
- *
- * ```typescript
- * // get a random integer between 0 and 10
- * const randomInt = randomInt(10);
- *
- * assert(
- *   randomInt >= 0,
- *   'Should be greater than or equal to 0.',
- * );
- *
- * assert(
- *   randomInt <= 10,
- *   'Should be less than or equal to 10.',
- * );
- * ```
- * * Specifying both `max` and `min` values:
- *
- * ```typescript
- * // get a random integer between 5 and 8
- * const randomInt = randomInt(8, 5);
- *
- * assert(
- *   randomInt >= 5,
- *   'Should be greater than or equal to 5.',
- * );
- *
- * assert(
- *   randomInt <= 8,
- *   'Should be less than or equal to 8.',
- * );
- * ```
- */
-export declare function randomInt(max: number, min?: number): number;
 export declare function randomChance(p: number): boolean;

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

@@ -550,3 +550,36 @@ export declare function getClaimsFromJWT(token: string): IAuthorizationJWTClaims
  * ```
  */
 export declare function scopesMatch(scopes1: readonly string[], scopes2: readonly string[]): boolean;
+interface CommonResponse {
+    status: number;
+    statusText: string;
+    json(): Promise<any>;
+    text(): Promise<string>;
+}
+interface IFetcher {
+    (input: string, init: {
+        method: string;
+        headers: Record<string, string>;
+    }): Promise<CommonResponse>;
+}
+export interface IFetchResourceMetadataOptions {
+    /**
+     * Headers to include only when the resource metadata URL has the same origin as the target resource
+     */
+    sameOriginHeaders?: Record<string, string>;
+    /**
+     * Optional custom fetch implementation (defaults to global fetch)
+     */
+    fetch?: IFetcher;
+}
+/**
+ * Fetches and validates OAuth 2.0 protected resource metadata from the given URL.
+ *
+ * @param targetResource The target resource URL to compare origins with (e.g., the MCP server URL)
+ * @param resourceMetadataUrl Optional URL to fetch the resource metadata from. If not provided, will try well-known URIs.
+ * @param options Configuration options for the fetch operation
+ * @returns Promise that resolves to the validated resource metadata
+ * @throws Error if the fetch fails, returns non-200 status, or the response is invalid
+ */
+export declare function fetchResourceMetadata(targetResource: string, resourceMetadataUrl: string | undefined, options?: IFetchResourceMetadataOptions): Promise<IAuthorizationProtectedResourceMetadata>;
+export {};