@codingame/monaco-vscode-api 22.1.9 → 23.0.1

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

@@ -68,7 +68,7 @@ export interface IDisposable {
 /**
  * Check if `thing` is {@link IDisposable disposable}.
  */
-export declare function isDisposable<E extends any>(thing: E): thing is E & IDisposable;
+export declare function isDisposable<E>(thing: E): thing is E & IDisposable;
 /**
  * Disposes of the value(s) passed in.
  */
@@ -159,7 +159,22 @@ export declare class MutableDisposable<T extends IDisposable> implements IDispos
     private _value?;
     private _isDisposed;
     constructor();
+    /**
+     * Get the currently held disposable value, or `undefined` if this MutableDisposable has been disposed
+     */
     get value(): T | undefined;
+    /**
+     * Set a new disposable value.
+     *
+     * Behaviour:
+     * - If the MutableDisposable has been disposed, the setter is a no-op.
+     * - If the new value is strictly equal to the current value, the setter is a no-op.
+     * - Otherwise the previous value (if any) is disposed and the new value is stored.
+     *
+     * Related helpers:
+     * - clear() resets the value to `undefined` (and disposes the previous value).
+     * - clearAndLeak() returns the old value without disposing it and removes its parent.
+     */
     set value(value: T | undefined);
     /**
      * Resets the stored value and disposed of the previously stored value.
@@ -196,8 +211,8 @@ export interface IReference<T> extends IDisposable {
 }
 export declare abstract class ReferenceCollection<T> {
     private readonly references;
-    acquire(key: string, ...args: any[]): IReference<T>;
-    protected abstract createReferencedObject(key: string, ...args: any[]): T;
+    acquire(key: string, ...args: unknown[]): IReference<T>;
+    protected abstract createReferencedObject(key: string, ...args: unknown[]): T;
     protected abstract destroyReferencedObject(key: string, object: T): void;
 }
 /**

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

@@ -135,7 +135,9 @@ class DisposableTracker {
                 const continuations = groupBy(( [...prevStarts].map(d => getStackTracePath(d)[i])), v => v);
                 delete continuations[stackTracePath[i]];
                 for (const [cont, set] of Object.entries(continuations)) {
-                    stackTraceFormattedLines.unshift(`    - stacktraces of ${set.length} other leaks continue with ${cont}`);
+                    if (set) {
+                        stackTraceFormattedLines.unshift(`    - stacktraces of ${set.length} other leaks continue with ${cont}`);
+                    }
                 }
                 stackTraceFormattedLines.unshift(line);
             }

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

@@ -52,8 +52,8 @@ export declare namespace Schemas {
     const vscodeChatEditor = "vscode-chat-editor";
     /** Scheme used for the chat input part */
     const vscodeChatInput = "chatSessionInput";
-    /** Scheme for chat session content */
-    const vscodeChatSession = "vscode-chat-session";
+    /** Scheme used for local chat session content */
+    const vscodeLocalChatSession = "vscode-chat-session";
     /**
      * Scheme used internally for webviews that aren't linked to a resource (i.e. not custom editors)
      */
@@ -104,6 +104,10 @@ export declare namespace Schemas {
      */
     const chatEditingSnapshotScheme = "chat-editing-snapshot-text-model";
     const chatEditingModel = "chat-editing-text-model";
+    /**
+     * Used for rendering multidiffs in copilot agent sessions
+     */
+    const copilotPr = "copilot-pr";
 }
 export declare function matchesScheme(target: URI | string, scheme: string): boolean;
 export declare function matchesSomeScheme(target: URI | string, ...schemes: string[]): boolean;

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

@@ -40,7 +40,7 @@ var Schemas;
     Schemas.vscodeChatCodeCompareBlock = 'vscode-chat-code-compare-block';
     Schemas.vscodeChatEditor = 'vscode-chat-editor';
     Schemas.vscodeChatInput = 'chatSessionInput';
-    Schemas.vscodeChatSession = 'vscode-chat-session';
+    Schemas.vscodeLocalChatSession = 'vscode-chat-session';
     Schemas.webviewPanel = 'webview-panel';
     Schemas.vscodeWebview = 'vscode-webview';
     Schemas.extension = 'extension';
@@ -54,6 +54,7 @@ var Schemas;
     Schemas.accessibleView = 'accessible-view';
     Schemas.chatEditingSnapshotScheme = 'chat-editing-snapshot-text-model';
     Schemas.chatEditingModel = 'chat-editing-text-model';
+    Schemas.copilotPr = 'copilot-pr';
 })(Schemas || (Schemas = {}));
 function matchesScheme(target, scheme) {
     if (URI.isUri(target)) {

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

@@ -209,6 +209,96 @@ export interface IAuthorizationServerMetadata {
      * OPTIONAL. JSON array containing a list of PKCE code challenge methods supported.
      */
     code_challenge_methods_supported?: string[];
+    /**
+     * OPTIONAL. Boolean flag indicating whether the authorization server supports the
+     * client_id_metadata document.
+     * ref https://datatracker.ietf.org/doc/html/draft-parecki-oauth-client-id-metadata-document-03
+     */
+    client_id_metadata_document_supported?: boolean;
+}
+/**
+ * Request for the dynamic client registration endpoint.
+ * @see https://datatracker.ietf.org/doc/html/rfc7591#section-2
+ */
+export interface IAuthorizationDynamicClientRegistrationRequest {
+    /**
+     * OPTIONAL. Array of redirection URI strings for use in redirect-based flows
+     * such as the authorization code and implicit flows.
+     */
+    redirect_uris?: string[];
+    /**
+     * OPTIONAL. String indicator of the requested authentication method for the token endpoint.
+     * Values: "none", "client_secret_post", "client_secret_basic".
+     * Default is "client_secret_basic".
+     */
+    token_endpoint_auth_method?: string;
+    /**
+     * OPTIONAL. Array of OAuth 2.0 grant type strings that the client can use at the token endpoint.
+     * Default is ["authorization_code"].
+     */
+    grant_types?: string[];
+    /**
+     * OPTIONAL. Array of the OAuth 2.0 response type strings that the client can use at the authorization endpoint.
+     * Default is ["code"].
+     */
+    response_types?: string[];
+    /**
+     * OPTIONAL. Human-readable string name of the client to be presented to the end-user during authorization.
+     */
+    client_name?: string;
+    /**
+     * OPTIONAL. URL string of a web page providing information about the client.
+     */
+    client_uri?: string;
+    /**
+     * OPTIONAL. URL string that references a logo for the client.
+     */
+    logo_uri?: string;
+    /**
+     * OPTIONAL. String containing a space-separated list of scope values that the client can use when requesting access tokens.
+     */
+    scope?: string;
+    /**
+     * OPTIONAL. Array of strings representing ways to contact people responsible for this client, typically email addresses.
+     */
+    contacts?: string[];
+    /**
+     * OPTIONAL. URL string that points to a human-readable terms of service document for the client.
+     */
+    tos_uri?: string;
+    /**
+     * OPTIONAL. URL string that points to a human-readable privacy policy document.
+     */
+    policy_uri?: string;
+    /**
+     * OPTIONAL. URL string referencing the client's JSON Web Key (JWK) Set document.
+     */
+    jwks_uri?: string;
+    /**
+     * OPTIONAL. Client's JSON Web Key Set document value.
+     */
+    jwks?: object;
+    /**
+     * OPTIONAL. A unique identifier string assigned by the client developer or software publisher.
+     */
+    software_id?: string;
+    /**
+     * OPTIONAL. A version identifier string for the client software.
+     */
+    software_version?: string;
+    /**
+     * OPTIONAL. A software statement containing client metadata values about the client software as claims.
+     */
+    software_statement?: string;
+    /**
+     * OPTIONAL. Application type. Usually "native" for OAuth clients.
+     * https://openid.net/specs/openid-connect-registration-1_0.html
+     */
+    application_type?: "native" | "web" | string;
+    /**
+     * OPTIONAL. Additional metadata fields as defined by extensions.
+     */
+    [key: string]: unknown;
 }
 /**
  * Response from the dynamic client registration endpoint.
@@ -539,17 +629,19 @@ export declare function getClaimsFromJWT(token: string): IAuthorizationJWTClaims
  * Checks if two scope lists are equivalent, regardless of order.
  * This is useful for comparing OAuth scopes where the order should not matter.
  *
- * @param scopes1 First list of scopes to compare
- * @param scopes2 Second list of scopes to compare
+ * @param scopes1 First list of scopes to compare (can be undefined)
+ * @param scopes2 Second list of scopes to compare (can be undefined)
  * @returns true if the scope lists contain the same scopes (order-independent), false otherwise
  *
  * @example
  * ```typescript
  * scopesMatch(['read', 'write'], ['write', 'read']) // Returns: true
  * scopesMatch(['read'], ['write']) // Returns: false
+ * scopesMatch(undefined, undefined) // Returns: true
+ * scopesMatch(['read'], undefined) // Returns: false
  * ```
  */
-export declare function scopesMatch(scopes1: readonly string[], scopes2: readonly string[]): boolean;
+export declare function scopesMatch(scopes1: readonly string[] | undefined, scopes2: readonly string[] | undefined): boolean;
 interface CommonResponse {
     status: number;
     statusText: string;
@@ -582,4 +674,37 @@ export interface IFetchResourceMetadataOptions {
  * @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 interface IFetchAuthorizationServerMetadataOptions {
+    /**
+     * Headers to include in the requests
+     */
+    additionalHeaders?: Record<string, string>;
+    /**
+     * Optional custom fetch implementation (defaults to global fetch)
+     */
+    fetch?: IFetcher;
+}
+/**
+ * Fetches and validates OAuth 2.0 authorization server metadata from the given authorization server URL.
+ *
+ * This function tries multiple discovery endpoints in the following order:
+ * 1. OAuth 2.0 Authorization Server Metadata with path insertion (RFC 8414)
+ * 2. OpenID Connect Discovery with path insertion
+ * 3. OpenID Connect Discovery with path addition
+ *
+ * Path insertion: For issuer URLs with path components (e.g., https://example.com/tenant),
+ * the well-known path is inserted after the origin and before the path:
+ * https://example.com/.well-known/oauth-authorization-server/tenant
+ *
+ * Path addition: The well-known path is simply appended to the existing path:
+ * https://example.com/tenant/.well-known/openid-configuration
+ *
+ * @param authorizationServer The authorization server URL (issuer identifier)
+ * @param options Configuration options for the fetch operation
+ * @returns Promise that resolves to the validated authorization server metadata
+ * @throws Error if all discovery attempts fail or the response is invalid
+ *
+ * @see https://datatracker.ietf.org/doc/html/rfc8414#section-3
+ */
+export declare function fetchAuthorizationServerMetadata(authorizationServer: string, options?: IFetchAuthorizationServerMetadataOptions): Promise<IAuthorizationServerMetadata>;
 export {};

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

@@ -115,28 +115,29 @@ async function fetchDynamicRegistration(serverMetadata, clientName, scopes) {
     if (!serverMetadata.registration_endpoint) {
         throw ( new Error('Server does not support dynamic registration'));
     }
+    const requestBody = {
+        client_name: clientName,
+        client_uri: 'https://code.visualstudio.com',
+        grant_types: serverMetadata.grant_types_supported
+            ? serverMetadata.grant_types_supported.filter(gt => grantTypesSupported.includes(gt))
+            : grantTypesSupported,
+        response_types: ['code'],
+        redirect_uris: [
+            'https://insiders.vscode.dev/redirect',
+            'https://vscode.dev/redirect',
+            'http://127.0.0.1/',
+            `http://127.0.0.1:${DEFAULT_AUTH_FLOW_PORT}/`
+        ],
+        scope: scopes?.join(AUTH_SCOPE_SEPARATOR),
+        token_endpoint_auth_method: 'none',
+        application_type: 'native'
+    };
     const response = await fetch(serverMetadata.registration_endpoint, {
         method: 'POST',
         headers: {
             'Content-Type': 'application/json'
         },
-        body: JSON.stringify({
-            client_name: clientName,
-            client_uri: 'https://code.visualstudio.com',
-            grant_types: serverMetadata.grant_types_supported
-                ? serverMetadata.grant_types_supported.filter(gt => grantTypesSupported.includes(gt))
-                : grantTypesSupported,
-            response_types: ['code'],
-            redirect_uris: [
-                'https://insiders.vscode.dev/redirect',
-                'https://vscode.dev/redirect',
-                'http://127.0.0.1/',
-                `http://127.0.0.1:${DEFAULT_AUTH_FLOW_PORT}/`
-            ],
-            scope: scopes?.join(AUTH_SCOPE_SEPARATOR),
-            token_endpoint_auth_method: 'none',
-            application_type: 'native'
-        })
+        body: JSON.stringify(requestBody)
     });
     if (!response.ok) {
         const result = await response.text();
@@ -257,6 +258,12 @@ function getClaimsFromJWT(token) {
     }
 }
 function scopesMatch(scopes1, scopes2) {
+    if (scopes1 === scopes2) {
+        return true;
+    }
+    if (!scopes1 || !scopes2) {
+        return false;
+    }
     if (scopes1.length !== scopes2.length) {
         return false;
     }
@@ -341,5 +348,63 @@ async function fetchResourceMetadata(targetResource, resourceMetadataUrl, option
         throw ( new AggregateError(errors, 'Failed to fetch resource metadata from all attempted URLs'));
     }
 }
+async function tryParseAuthServerMetadata(response) {
+    if (response.status !== 200) {
+        return undefined;
+    }
+    try {
+        const body = await response.json();
+        if (isAuthorizationServerMetadata(body)) {
+            return body;
+        }
+    }
+    catch {
+    }
+    return undefined;
+}
+async function getErrText(res) {
+    try {
+        return await res.text();
+    }
+    catch {
+        return res.statusText;
+    }
+}
+async function fetchAuthorizationServerMetadata(authorizationServer, options = {}) {
+    const { additionalHeaders = {}, fetch: fetchImpl = fetch } = options;
+    const authorizationServerUrl = ( new URL(authorizationServer));
+    const extraPath = authorizationServerUrl.pathname === '/' ? '' : authorizationServerUrl.pathname;
+    const doFetch = async (url) => {
+        const rawResponse = await fetchImpl(url, {
+            method: 'GET',
+            headers: {
+                ...additionalHeaders,
+                'Accept': 'application/json'
+            }
+        });
+        const metadata = await tryParseAuthServerMetadata(rawResponse);
+        return { metadata, rawResponse };
+    };
+    const pathToFetch = ( ( new URL(AUTH_SERVER_METADATA_DISCOVERY_PATH, authorizationServer)).toString()) + extraPath;
+    let result = await doFetch(pathToFetch);
+    if (result.metadata) {
+        return result.metadata;
+    }
+    const openidPathInsertionUrl = ( ( new URL(OPENID_CONNECT_DISCOVERY_PATH, authorizationServer)).toString()) + extraPath;
+    result = await doFetch(openidPathInsertionUrl);
+    if (result.metadata) {
+        return result.metadata;
+    }
+    const openidPathAdditionUrl = authorizationServer.endsWith('/')
+        ? authorizationServer + OPENID_CONNECT_DISCOVERY_PATH.substring(1)
+        : authorizationServer + OPENID_CONNECT_DISCOVERY_PATH;
+    result = await doFetch(openidPathAdditionUrl);
+    if (result.metadata) {
+        return result.metadata;
+    }
+    throw ( new Error(
+        `Failed to fetch authorization server metadata: ${result.rawResponse.status} ${await getErrText(result.rawResponse)}`
+    ));
+}
 
-export { AUTH_PROTECTED_RESOURCE_METADATA_DISCOVERY_PATH, AUTH_SCOPE_SEPARATOR, AUTH_SERVER_METADATA_DISCOVERY_PATH, AuthorizationDeviceCodeErrorType, AuthorizationErrorType, AuthorizationRegistrationErrorType, DEFAULT_AUTH_FLOW_PORT, OPENID_CONNECT_DISCOVERY_PATH, fetchDynamicRegistration, fetchResourceMetadata, getClaimsFromJWT, getDefaultMetadataForUrl, isAuthorizationDynamicClientRegistrationResponse, isAuthorizationErrorResponse, isAuthorizationProtectedResourceMetadata, isAuthorizationRegistrationErrorResponse, isAuthorizationServerMetadata, isAuthorizationTokenResponse, parseWWWAuthenticateHeader, scopesMatch };
+export { AUTH_PROTECTED_RESOURCE_METADATA_DISCOVERY_PATH, AUTH_SCOPE_SEPARATOR, AUTH_SERVER_METADATA_DISCOVERY_PATH, AuthorizationDeviceCodeErrorType, AuthorizationErrorType, AuthorizationRegistrationErrorType, DEFAULT_AUTH_FLOW_PORT, OPENID_CONNECT_DISCOVERY_PATH, fetchAuthorizationServerMetadata, fetchDynamicRegistration, fetchResourceMetadata, getClaimsFromJWT, getDefaultMetadataForUrl, isAuthorizationDynamicClientRegistrationResponse, isAuthorizationErrorResponse, isAuthorizationProtectedResourceMetadata, isAuthorizationRegistrationErrorResponse, isAuthorizationServerMetadata, isAuthorizationTokenResponse, parseWWWAuthenticateHeader, scopesMatch };

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

@@ -10,8 +10,8 @@ import { IDerivedReader } from "./derivedImpl.js";
  *
  * {@link computeFn} should start with a JS Doc using `@description` to name the derived.
  */
-export declare function derived<T, TChange = void>(computeFn: (reader: IDerivedReader<TChange>) => T): IObservableWithChange<T, TChange>;
-export declare function derived<T, TChange = void>(owner: DebugOwner, computeFn: (reader: IDerivedReader<TChange>) => T): IObservableWithChange<T, TChange>;
+export declare function derived<T, TChange = void>(computeFn: (reader: IDerivedReader<TChange>, debugLocation?: DebugLocation) => T): IObservableWithChange<T, TChange>;
+export declare function derived<T, TChange = void>(owner: DebugOwner, computeFn: (reader: IDerivedReader<TChange>) => T, debugLocation?: DebugLocation): IObservableWithChange<T, TChange>;
 export declare function derivedWithSetter<T>(owner: DebugOwner | undefined, computeFn: (reader: IReader) => T, setter: (value: T, transaction: ITransaction | undefined) => void, debugLocation?: DebugLocation): ISettableObservable<T>;
 export declare function derivedOpts<T>(options: IDebugNameData & {
     equalsFn?: EqualityComparer<T>;

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

@@ -12,7 +12,9 @@ function derived(computeFnOrOwner, computeFn, debugLocation = DebugLocation.ofCa
     if (computeFn !== undefined) {
         return ( new Derived(( new DebugNameData(computeFnOrOwner, undefined, computeFn)), computeFn, undefined, undefined, strictEquals, debugLocation));
     }
-    return ( new Derived(( new DebugNameData(undefined, undefined, computeFnOrOwner)), computeFnOrOwner, undefined, undefined, strictEquals, debugLocation));
+    return ( new Derived((
+    new DebugNameData(undefined, undefined, computeFnOrOwner)),
+    computeFnOrOwner, undefined, undefined, strictEquals, debugLocation));
 }
 function derivedWithSetter(owner, computeFn, setter, debugLocation = DebugLocation.ofCaller()) {
     return ( new DerivedWithSetter(( new DebugNameData(owner, undefined, computeFn)), computeFn, undefined, undefined, strictEquals, setter, debugLocation));

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

@@ -19,6 +19,7 @@ export declare class ObservableLazy<T> {
  */
 export declare class ObservablePromise<T> {
     static fromFn<T>(fn: () => Promise<T>): ObservablePromise<T>;
+    static resolved<T>(value: T): ObservablePromise<T>;
     private readonly _value;
     /**
      * The promise that this object wraps.

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

@@ -22,6 +22,9 @@ class ObservablePromise {
     static fromFn(fn) {
         return ( new ObservablePromise(fn()));
     }
+    static resolved(value) {
+        return ( new ObservablePromise(Promise.resolve(value)));
+    }
     constructor(promise) {
         this._value = observableValue(this, undefined);
         this.promiseResult = this._value;

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

@@ -97,3 +97,4 @@ export declare const isSafari: boolean;
 export declare const isEdge: boolean;
 export declare const isAndroid: boolean;
 export declare function isBigSurOrNewer(osVersion: string): boolean;
+export declare function isTahoeOrNewer(osVersion: string): boolean;

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

@@ -1,18 +1,49 @@
 import { IDefaultAccount } from "./defaultAccount.js";
+/**
+ * System-wide policy file path for Linux systems.
+ */
+export declare const LINUX_SYSTEM_POLICY_FILE_PATH = "/etc/vscode/policy.json";
 export type PolicyName = string;
+export type LocalizedValue = {
+    key: string;
+    value: string;
+};
+export declare enum PolicyCategory {
+    Extensions = "Extensions",
+    IntegratedTerminal = "IntegratedTerminal",
+    InteractiveSession = "InteractiveSession",
+    Telemetry = "Telemetry",
+    Update = "Update"
+}
+export declare const PolicyCategoryData: {
+    [key in PolicyCategory]: {
+        name: LocalizedValue;
+    };
+};
 export interface IPolicy {
     /**
      * The policy name.
      */
     readonly name: PolicyName;
+    /**
+     * The policy category.
+     */
+    readonly category: PolicyCategory;
     /**
      * The Code version in which this policy was introduced.
     */
     readonly minimumVersion: `${number}.${number}`;
     /**
-     * The policy description (optional).
+     * Localization info for the policy.
+     *
+     * IMPORTANT: the key values for these must be unique to avoid collisions, as during the export time the module information is not available.
      */
-    readonly description?: string;
+    readonly localization: {
+        /** The localization key or key value pair. If only a key is provided, the default value will fallback to the parent configuration's description property. */
+        description: LocalizedValue;
+        /** List of localization key or key value pair. If only a key is provided, the default value will fallback to the parent configuration's enumDescriptions property. */
+        enumDescriptions?: LocalizedValue[];
+    };
     /**
      * The value that an ACCOUNT-based feature will use when its corresponding policy is active.
      *

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

@@ -0,0 +1,13 @@
+
+import '../../nls.js';
+
+var PolicyCategory;
+(function (PolicyCategory) {
+    PolicyCategory["Extensions"] = "Extensions";
+    PolicyCategory["IntegratedTerminal"] = "IntegratedTerminal";
+    PolicyCategory["InteractiveSession"] = "InteractiveSession";
+    PolicyCategory["Telemetry"] = "Telemetry";
+    PolicyCategory["Update"] = "Update";
+})(PolicyCategory || (PolicyCategory = {}));
+
+export { PolicyCategory };

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

@@ -205,12 +205,14 @@ export interface IProductConfiguration {
             readonly id: string;
             readonly enterpriseProviderId: string;
             readonly enterpriseProviderConfig: string;
+            readonly enterpriseProviderUriSetting: string;
             readonly scopes: string[];
         };
         readonly tokenEntitlementUrl: string;
         readonly chatEntitlementUrl: string;
         readonly mcpRegistryDataUrl: string;
     };
+    readonly authClientIdMetadataUrl?: string;
     readonly "configurationSync.store"?: ConfigurationSyncStore;
     readonly "editSessions.store"?: Omit<ConfigurationSyncStore, "insidersUrl" | "stableUrl">;
     readonly darwinUniversalAssetId?: string;

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

@@ -94,7 +94,9 @@ export declare function isAsciiDigit(code: number): boolean;
 export declare function isLowerAsciiLetter(code: number): boolean;
 export declare function isUpperAsciiLetter(code: number): boolean;
 export declare function equalsIgnoreCase(a: string, b: string): boolean;
+export declare function equals(a: string | undefined, b: string | undefined, ignoreCase?: boolean): boolean;
 export declare function startsWithIgnoreCase(str: string, candidate: string): boolean;
+export declare function endsWithIgnoreCase(str: string, candidate: string): boolean;
 /**
  * @returns the length of the common prefix of the two strings.
  */

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

@@ -277,11 +277,13 @@ function equalsIgnoreCase(a, b) {
     return a.length === b.length && compareSubstringIgnoreCase(a, b) === 0;
 }
 function startsWithIgnoreCase(str, candidate) {
-    const candidateLength = candidate.length;
-    if (candidate.length > str.length) {
-        return false;
-    }
-    return compareSubstringIgnoreCase(str, candidate, 0, candidateLength) === 0;
+    const len = candidate.length;
+    return len <= str.length && compareSubstringIgnoreCase(str, candidate, 0, len) === 0;
+}
+function endsWithIgnoreCase(str, candidate) {
+    const len = str.length;
+    const start = len - candidate.length;
+    return start >= 0 && compareSubstringIgnoreCase(str, candidate, start, len) === 0;
 }
 function commonPrefixLength(a, b) {
     const len = Math.min(a.length, b.length);
@@ -746,7 +748,7 @@ class AmbiguousCharacters {
             return result;
         }
         const data = this.ambiguousCharacterData.value;
-        let filteredLocales = locales.filter((l) => !l.startsWith('_') && l in data);
+        let filteredLocales = locales.filter((l) => !l.startsWith('_') && Object.hasOwn(data, l));
         if (filteredLocales.length === 0) {
             filteredLocales = ['_default'];
         }
@@ -832,4 +834,4 @@ function multibyteAwareBtoa(str) {
     return btoa(toBinary(str));
 }
 
-export { AmbiguousCharacters, CodePointIterator, Ellipsis, GraphemeBreakType, GraphemeIterator, InvisibleCharacters, UNUSUAL_LINE_TERMINATORS, UTF8_BOM_CHARACTER, commonPrefixLength, commonSuffixLength, compare, compareIgnoreCase, compareSubstring, compareSubstringIgnoreCase, computeCodePoint, containsRTL, containsUnusualLineTerminators, containsUppercaseCharacter, convertSimple2RegExpPattern, count, createRegExp, equalsIgnoreCase, escape, escapeRegExpCharacters, firstNonWhitespaceIndex, forAnsiStringParts, format, format2, fuzzyContains, getCharContainingOffset, getLeadingWhitespace, getLeftDeleteOffset, getNLines, getNextCodePoint, htmlAttributeEncodeValue, isAsciiDigit, isBasicASCII, isEmojiImprecise, isFalsyOrWhitespace, isFullWidthCharacter, isHighSurrogate, isLowSurrogate, isLowerAsciiLetter, isUpperAsciiLetter, joinStrings, lastNonWhitespaceIndex, lcut, ltrim, multibyteAwareBtoa, nextCharLength, noBreakWhitespace, prevCharLength, regExpLeadsToEndlessLoop, removeAnsiEscapeCodes, removeAnsiEscapeCodesFromPrompt, rtrim, singleLetterHash, splitLines, splitLinesIncludeSeparators, startsWithIgnoreCase, startsWithUTF8BOM, trim, truncate, truncateMiddle, uppercaseFirstLetter };
+export { AmbiguousCharacters, CodePointIterator, Ellipsis, GraphemeBreakType, GraphemeIterator, InvisibleCharacters, UNUSUAL_LINE_TERMINATORS, UTF8_BOM_CHARACTER, commonPrefixLength, commonSuffixLength, compare, compareIgnoreCase, compareSubstring, compareSubstringIgnoreCase, computeCodePoint, containsRTL, containsUnusualLineTerminators, containsUppercaseCharacter, convertSimple2RegExpPattern, count, createRegExp, endsWithIgnoreCase, equalsIgnoreCase, escape, escapeRegExpCharacters, firstNonWhitespaceIndex, forAnsiStringParts, format, format2, fuzzyContains, getCharContainingOffset, getLeadingWhitespace, getLeftDeleteOffset, getNLines, getNextCodePoint, htmlAttributeEncodeValue, isAsciiDigit, isBasicASCII, isEmojiImprecise, isFalsyOrWhitespace, isFullWidthCharacter, isHighSurrogate, isLowSurrogate, isLowerAsciiLetter, isUpperAsciiLetter, joinStrings, lastNonWhitespaceIndex, lcut, ltrim, multibyteAwareBtoa, nextCharLength, noBreakWhitespace, prevCharLength, regExpLeadsToEndlessLoop, removeAnsiEscapeCodes, removeAnsiEscapeCodesFromPrompt, rtrim, singleLetterHash, splitLines, splitLinesIncludeSeparators, startsWithIgnoreCase, startsWithUTF8BOM, trim, truncate, truncateMiddle, uppercaseFirstLetter };

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

@@ -27,4 +27,12 @@ export declare namespace ThemeIcon {
     function modify(icon: ThemeIcon, modifier: "disabled" | "spin" | undefined): ThemeIcon;
     function getModifier(icon: ThemeIcon): string | undefined;
     function isEqual(ti1: ThemeIcon, ti2: ThemeIcon): boolean;
+    /**
+     * Returns whether specified icon is defined and has 'file' ID.
+     */
+    function isFile(icon: ThemeIcon | undefined): boolean;
+    /**
+     * Returns whether specified icon is defined and has 'folder' ID.
+     */
+    function isFolder(icon: ThemeIcon | undefined): boolean;
 }

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

@@ -85,6 +85,14 @@ var ThemeIcon;
         return ti1.id === ti2.id && ti1.color?.id === ti2.color?.id;
     }
     ThemeIcon.isEqual = isEqual;
+    function isFile(icon) {
+        return icon?.id === Codicon.file.id;
+    }
+    ThemeIcon.isFile = isFile;
+    function isFolder(icon) {
+        return icon?.id === Codicon.folder.id;
+    }
+    ThemeIcon.isFolder = isFolder;
 })(ThemeIcon || (ThemeIcon = {}));
 
 export { ThemeColor, ThemeIcon, themeColorFromId };

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

@@ -6,6 +6,10 @@ export declare function isString(str: unknown): str is string;
  * @returns whether the provided parameter is a JavaScript Array and each element in the array is a string.
  */
 export declare function isStringArray(value: unknown): value is string[];
+/**
+ * @returns whether the provided parameter is a JavaScript Array and each element in the array satisfies the provided type guard.
+ */
+export declare function isArrayOf<T>(value: unknown, check: (item: unknown) => item is T): value is T[];
 /**
  * @returns whether the provided parameter is of type `object` but **not**
  *	`null`, an `array`, a `regexp`, nor a `date`.
@@ -172,6 +176,12 @@ export type OmitOptional<T> = {
 export type Mutable<T> = {
     -readonly [P in keyof T]: T[P];
 };
+/**
+ * A type that adds readonly to all properties of T, recursively.
+ */
+export type DeepImmutable<T> = T extends (infer U)[] ? ReadonlyArray<DeepImmutable<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepImmutable<U>> : T extends Map<infer K, infer V> ? ReadonlyMap<K, DeepImmutable<V>> : T extends Set<infer U> ? ReadonlySet<DeepImmutable<U>> : T extends object ? {
+    readonly [K in keyof T]: DeepImmutable<T[K]>;
+} : T;
 /**
  * A single object or an array of the objects.
  */
@@ -192,4 +202,31 @@ export type DeepPartial<T> = {
  * Represents a type that is a partial version of a given type `T`, except a subset.
  */
 export type PartialExcept<T, K extends keyof T> = Partial<Omit<T, K>> & Pick<T, K>;
+type KeysOfUnionType<T> = T extends T ? keyof T : never;
+type FilterType<T, TTest> = T extends TTest ? T : never;
+type MakeOptionalAndBool<T extends object> = {
+    [K in keyof T]?: boolean;
+};
+/**
+ * Type guard that checks if an object has specific keys and narrows the type accordingly.
+ *
+ * @param x - The object to check
+ * @param key - An object with boolean values indicating which keys to check for
+ * @returns true if all specified keys exist in the object, false otherwise
+ *
+ * @example
+ * ```typescript
+ * type A = { a: string };
+ * type B = { b: number };
+ * const obj: A | B = getObject();
+ *
+ * if (hasKey(obj, { a: true })) {
+ *   // obj is now narrowed to type A
+ *   console.log(obj.a);
+ * }
+ * ```
+ */
+export declare function hasKey<T extends object, TKeys>(x: T, key: TKeys & MakeOptionalAndBool<T>): x is FilterType<T, {
+    [K in KeysOfUnionType<T> & keyof TKeys]: unknown;
+}>;
 export {};