@codingame/monaco-vscode-api 1.83.14 → 1.83.15

package/vscode/src/vs/workbench/services/extensions/browser/extensionUrlHandler.js

@@ -1,15 +1,34 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { combinedDisposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IExtensionManagementService, IExtensionGalleryService } from '../../../../platform/extensionManagement/common/extensionManagement.js';
+import { IWorkbenchExtensionEnablementService } from '../../extensionManagement/common/extensionManagement.js';
+import { areSameExtensions } from '../../../../platform/extensionManagement/common/extensionManagementUtil.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
 import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
 import { IURLService } from '../../../../platform/url/common/url.js';
+import { IHostService } from '../../host/browser/host.js';
+import { toExtensionDescription, IExtensionService } from '../common/extensions.js';
+import { ExtensionIdentifier } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { Extensions } from '../../../common/contributions.js';
 import { registerAction2, Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
 import { IsWebContext } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkeys.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
 var ExtensionUrlBootstrapHandler_1;
+const FIVE_MINUTES = 5 * 60 * 1000;
+const THIRTY_SECONDS = 30 * 1000;
+const URL_TO_HANDLE = 'extensionUrlHandler.urlToHandle';
+const USER_TRUSTED_EXTENSIONS_CONFIGURATION_KEY = 'extensions.confirmedUriHandlerExtensionIds';
 const USER_TRUSTED_EXTENSIONS_STORAGE_KEY = 'extensionUrlHandler.confirmedExtensions';
 function isExtensionId(value) {
     return /^[a-z0-9][a-z0-9\-]*\.[a-z0-9][a-z0-9\-]*$/i.test(value);
@@ -38,6 +57,293 @@ class UserTrustedExtensionIdStorage {
     }
 }
 const IExtensionUrlHandler = ( createDecorator('extensionUrlHandler'));
+let ExtensionUrlHandler = class ExtensionUrlHandler {
+    constructor(urlService, extensionService, dialogService, notificationService, extensionManagementService, extensionEnablementService, hostService, galleryService, storageService, configurationService, progressService, telemetryService, productService) {
+        this.extensionService = extensionService;
+        this.dialogService = dialogService;
+        this.notificationService = notificationService;
+        this.extensionManagementService = extensionManagementService;
+        this.extensionEnablementService = extensionEnablementService;
+        this.hostService = hostService;
+        this.galleryService = galleryService;
+        this.storageService = storageService;
+        this.configurationService = configurationService;
+        this.progressService = progressService;
+        this.telemetryService = telemetryService;
+        this.productService = productService;
+        this.extensionHandlers = ( new Map());
+        this.uriBuffer = ( new Map());
+        this.userTrustedExtensionsStorage = ( new UserTrustedExtensionIdStorage(storageService));
+        const interval = setInterval(() => this.garbageCollect(), THIRTY_SECONDS);
+        const urlToHandleValue = this.storageService.get(URL_TO_HANDLE, 1 );
+        if (urlToHandleValue) {
+            this.storageService.remove(URL_TO_HANDLE, 1 );
+            this.handleURL(URI.revive(JSON.parse(urlToHandleValue)), { trusted: true });
+        }
+        this.disposable = combinedDisposable(urlService.registerHandler(this), toDisposable(() => clearInterval(interval)));
+        const cache = ExtensionUrlBootstrapHandler.cache;
+        setTimeout(() => cache.forEach(([uri, option]) => this.handleURL(uri, option)));
+    }
+    async handleURL(uri, options) {
+        if (!isExtensionId(uri.authority)) {
+            return false;
+        }
+        const extensionId = uri.authority;
+        this.telemetryService.publicLog2('uri_invoked/start', { extensionId });
+        const initialHandler = this.extensionHandlers.get(ExtensionIdentifier.toKey(extensionId));
+        let extensionDisplayName;
+        if (!initialHandler) {
+            const extension = await this.extensionService.getExtension(extensionId);
+            if (!extension) {
+                await this.handleUnhandledURL(uri, { id: extensionId }, options);
+                return true;
+            }
+            else {
+                extensionDisplayName = extension.displayName ?? '';
+            }
+        }
+        else {
+            extensionDisplayName = initialHandler.extensionDisplayName;
+        }
+        const trusted = options?.trusted
+            || this.productService.trustedExtensionProtocolHandlers?.includes(extensionId)
+            || this.didUserTrustExtension(ExtensionIdentifier.toKey(extensionId));
+        if (!trusted) {
+            let uriString = ( uri.toString(false));
+            if (uriString.length > 40) {
+                uriString = `${uriString.substring(0, 30)}...${uriString.substring(uriString.length - 5)}`;
+            }
+            const result = await this.dialogService.confirm({
+                message: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    'confirmUrl',
+                    "Allow '{0}' extension to open this URI?",
+                    extensionDisplayName
+                )),
+                checkbox: {
+                    label: ( localizeWithPath(
+                        'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                        'rememberConfirmUrl',
+                        "Don't ask again for this extension."
+                    )),
+                },
+                detail: uriString,
+                primaryButton: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    { key: 'open', comment: ['&& denotes a mnemonic'] },
+                    "&&Open"
+                ))
+            });
+            if (!result.confirmed) {
+                this.telemetryService.publicLog2('uri_invoked/cancel', { extensionId });
+                return true;
+            }
+            if (result.checkboxChecked) {
+                this.userTrustedExtensionsStorage.add(ExtensionIdentifier.toKey(extensionId));
+            }
+        }
+        const handler = this.extensionHandlers.get(ExtensionIdentifier.toKey(extensionId));
+        if (handler) {
+            if (!initialHandler) {
+                return await this.handleURLByExtension(extensionId, handler, uri, options);
+            }
+            return false;
+        }
+        const timestamp = ( new Date()).getTime();
+        let uris = this.uriBuffer.get(ExtensionIdentifier.toKey(extensionId));
+        if (!uris) {
+            uris = [];
+            this.uriBuffer.set(ExtensionIdentifier.toKey(extensionId), uris);
+        }
+        uris.push({ timestamp, uri });
+        await this.extensionService.activateByEvent(`onUri:${ExtensionIdentifier.toKey(extensionId)}`, 1 );
+        return true;
+    }
+    registerExtensionHandler(extensionId, handler) {
+        this.extensionHandlers.set(ExtensionIdentifier.toKey(extensionId), handler);
+        const uris = this.uriBuffer.get(ExtensionIdentifier.toKey(extensionId)) || [];
+        for (const { uri } of uris) {
+            this.handleURLByExtension(extensionId, handler, uri);
+        }
+        this.uriBuffer.delete(ExtensionIdentifier.toKey(extensionId));
+    }
+    unregisterExtensionHandler(extensionId) {
+        this.extensionHandlers.delete(ExtensionIdentifier.toKey(extensionId));
+    }
+    async handleURLByExtension(extensionId, handler, uri, options) {
+        this.telemetryService.publicLog2('uri_invoked/end', { extensionId: ExtensionIdentifier.toKey(extensionId) });
+        return await handler.handleURL(uri, options);
+    }
+    async handleUnhandledURL(uri, extensionIdentifier, options) {
+        const installedExtensions = await this.extensionManagementService.getInstalled();
+        let extension = installedExtensions.find(e => areSameExtensions(e.identifier, extensionIdentifier));
+        if (!extension) {
+            let galleryExtension;
+            try {
+                galleryExtension = (await this.galleryService.getExtensions([extensionIdentifier], CancellationToken.None))[0] ?? undefined;
+            }
+            catch (err) {
+                return;
+            }
+            if (!galleryExtension) {
+                return;
+            }
+            this.telemetryService.publicLog2('uri_invoked/install_extension/start', { extensionId: extensionIdentifier.id });
+            const result = await this.dialogService.confirm({
+                message: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    'installAndHandle',
+                    "Would you like to install '{0}' extension from '{1}' to open this URI?",
+                    galleryExtension.displayName,
+                    galleryExtension.publisherDisplayName
+                )),
+                detail: `${( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    'installDetail',
+                    "'{0}' extension wants to open a URI:",
+                    galleryExtension.displayName
+                ))}\n\n${( uri.toString())}`,
+                primaryButton: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    { key: 'install and open', comment: ['&& denotes a mnemonic'] },
+                    "&&Install and Open"
+                ))
+            });
+            if (!result.confirmed) {
+                this.telemetryService.publicLog2('uri_invoked/install_extension/cancel', { extensionId: extensionIdentifier.id });
+                return;
+            }
+            this.telemetryService.publicLog2('uri_invoked/install_extension/accept', { extensionId: extensionIdentifier.id });
+            try {
+                extension = await this.progressService.withProgress({
+                    location: 15 ,
+                    title: ( localizeWithPath(
+                        'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                        'Installing',
+                        "Installing Extension '{0}'...",
+                        galleryExtension.displayName || galleryExtension.name
+                    ))
+                }, () => this.extensionManagementService.installFromGallery(galleryExtension));
+            }
+            catch (error) {
+                this.notificationService.error(error);
+                return;
+            }
+        }
+        if (!this.extensionEnablementService.isEnabled(extension)) {
+            this.telemetryService.publicLog2('uri_invoked/enable_extension/start', { extensionId: extensionIdentifier.id });
+            const result = await this.dialogService.confirm({
+                message: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    'enableAndHandle',
+                    "Extension '{0}' is disabled. Would you like to enable the extension and open the URL?",
+                    extension.manifest.displayName || extension.manifest.name
+                )),
+                detail: `${extension.manifest.displayName || extension.manifest.name} (${extensionIdentifier.id}) wants to open a URL:\n\n${( uri.toString())}`,
+                primaryButton: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    { key: 'enableAndReload', comment: ['&& denotes a mnemonic'] },
+                    "&&Enable and Open"
+                ))
+            });
+            if (!result.confirmed) {
+                this.telemetryService.publicLog2('uri_invoked/enable_extension/cancel', { extensionId: extensionIdentifier.id });
+                return;
+            }
+            this.telemetryService.publicLog2('uri_invoked/enable_extension/accept', { extensionId: extensionIdentifier.id });
+            await this.extensionEnablementService.setEnablement([extension], 8 );
+        }
+        if (this.extensionService.canAddExtension(toExtensionDescription(extension))) {
+            await this.waitUntilExtensionIsAdded(extensionIdentifier);
+            await this.handleURL(uri, { ...options, trusted: true });
+        }
+        else {
+            this.telemetryService.publicLog2('uri_invoked/activate_extension/start', { extensionId: extensionIdentifier.id });
+            const result = await this.dialogService.confirm({
+                message: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    'reloadAndHandle',
+                    "Extension '{0}' is not loaded. Would you like to reload the window to load the extension and open the URL?",
+                    extension.manifest.displayName || extension.manifest.name
+                )),
+                detail: `${extension.manifest.displayName || extension.manifest.name} (${extensionIdentifier.id}) wants to open a URL:\n\n${( uri.toString())}`,
+                primaryButton: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    { key: 'reloadAndOpen', comment: ['&& denotes a mnemonic'] },
+                    "&&Reload Window and Open"
+                ))
+            });
+            if (!result.confirmed) {
+                this.telemetryService.publicLog2('uri_invoked/activate_extension/cancel', { extensionId: extensionIdentifier.id });
+                return;
+            }
+            this.telemetryService.publicLog2('uri_invoked/activate_extension/accept', { extensionId: extensionIdentifier.id });
+            this.storageService.store(URL_TO_HANDLE, JSON.stringify(uri.toJSON()), 1 , 1 );
+            await this.hostService.reload();
+        }
+    }
+    async waitUntilExtensionIsAdded(extensionId) {
+        if (!(await this.extensionService.getExtension(extensionId.id))) {
+            await ( new Promise((c, e) => {
+                const disposable = this.extensionService.onDidChangeExtensions(async () => {
+                    try {
+                        if (await this.extensionService.getExtension(extensionId.id)) {
+                            disposable.dispose();
+                            c();
+                        }
+                    }
+                    catch (error) {
+                        e(error);
+                    }
+                });
+            }));
+        }
+    }
+    garbageCollect() {
+        const now = ( new Date()).getTime();
+        const uriBuffer = ( new Map());
+        this.uriBuffer.forEach((uris, extensionId) => {
+            uris = uris.filter(({ timestamp }) => now - timestamp < FIVE_MINUTES);
+            if (uris.length > 0) {
+                uriBuffer.set(extensionId, uris);
+            }
+        });
+        this.uriBuffer = uriBuffer;
+    }
+    didUserTrustExtension(id) {
+        if (( this.userTrustedExtensionsStorage.has(id))) {
+            return true;
+        }
+        return this.getConfirmedTrustedExtensionIdsFromConfiguration().indexOf(id) > -1;
+    }
+    getConfirmedTrustedExtensionIdsFromConfiguration() {
+        const trustedExtensionIds = this.configurationService.getValue(USER_TRUSTED_EXTENSIONS_CONFIGURATION_KEY);
+        if (!Array.isArray(trustedExtensionIds)) {
+            return [];
+        }
+        return trustedExtensionIds;
+    }
+    dispose() {
+        this.disposable.dispose();
+        this.extensionHandlers.clear();
+        this.uriBuffer.clear();
+    }
+};
+ExtensionUrlHandler = ( __decorate([
+    ( __param(0, IURLService)),
+    ( __param(1, IExtensionService)),
+    ( __param(2, IDialogService)),
+    ( __param(3, INotificationService)),
+    ( __param(4, IExtensionManagementService)),
+    ( __param(5, IWorkbenchExtensionEnablementService)),
+    ( __param(6, IHostService)),
+    ( __param(7, IExtensionGalleryService)),
+    ( __param(8, IStorageService)),
+    ( __param(9, IConfigurationService)),
+    ( __param(10, IProgressService)),
+    ( __param(11, ITelemetryService)),
+    ( __param(12, IProductService))
+], ExtensionUrlHandler));
 let ExtensionUrlBootstrapHandler = class ExtensionUrlBootstrapHandler {
     static { ExtensionUrlBootstrapHandler_1 = this; }
     static { this._cache = []; }
@@ -104,4 +410,4 @@ class ManageAuthorizedExtensionURIsAction extends Action2 {
     }
 }
 registerAction2(ManageAuthorizedExtensionURIsAction);
-export { IExtensionUrlHandler };
+export { ExtensionUrlHandler, IExtensionUrlHandler };

package/vscode/src/vs/workbench/services/extensions/browser/webWorkerExtensionHost.d.ts

@@ -0,0 +1,10 @@
+import { ExtensionHostExtensions } from '../common/extensions.js';
+
+interface IWebWorkerExtensionHostInitData {
+    readonly extensions: ExtensionHostExtensions;
+}
+interface IWebWorkerExtensionHostDataProvider {
+    getInitData(): Promise<IWebWorkerExtensionHostInitData>;
+}
+
+export type { IWebWorkerExtensionHostDataProvider, IWebWorkerExtensionHostInitData };

package/vscode/src/vs/workbench/services/extensions/common/extensionDescriptionRegistry.d.ts

@@ -1,11 +1,5 @@
-import { Event } from '../../../../base/common/event.js';
-import { ExtensionIdentifier, IExtensionDescription } from '../../../../platform/extensions/common/extensions.js';
+import { IExtensionDescription, ExtensionIdentifier } from '../../../../platform/extensions/common/extensions.js';
 
-declare class DeltaExtensionsResult {
-    readonly versionId: number;
-    readonly removedDueToLooping: IExtensionDescription[];
-    constructor(versionId: number, removedDueToLooping: IExtensionDescription[]);
-}
 interface IReadOnlyExtensionDescriptionRegistry {
     containsActivationEvent(activationEvent: string): boolean;
     containsExtension(extensionId: ExtensionIdentifier): boolean;
@@ -15,39 +9,10 @@ interface IReadOnlyExtensionDescriptionRegistry {
     getExtensionDescriptionByUUID(uuid: string): IExtensionDescription | undefined;
     getExtensionDescriptionByIdOrUUID(extensionId: ExtensionIdentifier | string, uuid: string | undefined): IExtensionDescription | undefined;
 }
-declare class ExtensionDescriptionRegistry implements IReadOnlyExtensionDescriptionRegistry {
-    private readonly _activationEventsReader;
-    static isHostExtension(extensionId: ExtensionIdentifier | string, myRegistry: ExtensionDescriptionRegistry, globalRegistry: ExtensionDescriptionRegistry): boolean;
-    private readonly _onDidChange;
-    readonly onDidChange: Event<void>;
-    private _versionId;
-    private _extensionDescriptions;
-    private _extensionsMap;
-    private _extensionsArr;
-    private _activationMap;
-    constructor(_activationEventsReader: IActivationEventsReader, extensionDescriptions: IExtensionDescription[]);
-    private _initialize;
-    set(extensionDescriptions: IExtensionDescription[]): {
-        versionId: number;
-    };
-    deltaExtensions(toAdd: IExtensionDescription[], toRemove: ExtensionIdentifier[]): DeltaExtensionsResult;
-    private static _findLoopingExtensions;
-    containsActivationEvent(activationEvent: string): boolean;
-    containsExtension(extensionId: ExtensionIdentifier): boolean;
-    getExtensionDescriptionsForActivationEvent(activationEvent: string): IExtensionDescription[];
-    getAllExtensionDescriptions(): IExtensionDescription[];
-    getSnapshot(): ExtensionDescriptionRegistrySnapshot;
-    getExtensionDescription(extensionId: ExtensionIdentifier | string): IExtensionDescription | undefined;
-    getExtensionDescriptionByUUID(uuid: string): IExtensionDescription | undefined;
-    getExtensionDescriptionByIdOrUUID(extensionId: ExtensionIdentifier | string, uuid: string | undefined): IExtensionDescription | undefined;
-}
 declare class ExtensionDescriptionRegistrySnapshot {
     readonly versionId: number;
     readonly extensions: readonly IExtensionDescription[];
     constructor(versionId: number, extensions: readonly IExtensionDescription[]);
 }
-interface IActivationEventsReader {
-    readActivationEvents(extensionDescription: IExtensionDescription): string[] | undefined;
-}
 
-export { DeltaExtensionsResult, ExtensionDescriptionRegistry, ExtensionDescriptionRegistrySnapshot, type IActivationEventsReader, type IReadOnlyExtensionDescriptionRegistry };
+export { ExtensionDescriptionRegistrySnapshot, type IReadOnlyExtensionDescriptionRegistry };

package/vscode/src/vs/workbench/services/extensions/common/extensionHostProtocol.d.ts

@@ -1,7 +1,4 @@
-import { URI, UriDto, UriComponents } from '../../../../base/common/uri.js';
-import { ExtensionIdentifier, IExtensionDescription } from '../../../../platform/extensions/common/extensions.js';
-import { LogLevel, ILoggerResource } from '../../../../platform/log/common/log.js';
-import { IRemoteConnectionData } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
+import { IExtensionDescription, ExtensionIdentifier } from '../../../../platform/extensions/common/extensions.js';
 
 interface IExtensionDescriptionSnapshot {
     readonly versionId: number;
@@ -21,73 +18,5 @@ interface IExtensionDescriptionDelta {
     readonly myToRemove: ExtensionIdentifier[];
     readonly myToAdd: ExtensionIdentifier[];
 }
-interface IExtensionHostInitData {
-    version: string;
-    quality: string | undefined;
-    commit?: string;
-    /**
-     * When set to `0`, no polling for the parent process still running will happen.
-     */
-    parentPid: number | 0;
-    environment: IEnvironment;
-    workspace?: IStaticWorkspaceData | null;
-    extensions: IExtensionDescriptionSnapshot;
-    nlsBaseUrl?: URI;
-    telemetryInfo: {
-        readonly sessionId: string;
-        readonly machineId: string;
-        readonly firstSessionDate: string;
-        readonly msftInternal?: boolean;
-    };
-    logLevel: LogLevel;
-    loggers: UriDto<ILoggerResource>[];
-    logsLocation: URI;
-    autoStart: boolean;
-    remote: {
-        isRemote: boolean;
-        authority: string | undefined;
-        connectionData: IRemoteConnectionData | null;
-    };
-    consoleForward: {
-        includeStack: boolean;
-        logNative: boolean;
-    };
-    uiKind: UIKind;
-    messagePorts?: ReadonlyMap<string, MessagePortLike>;
-}
-interface IEnvironment {
-    isExtensionDevelopmentDebug: boolean;
-    appName: string;
-    appHost: string;
-    appRoot?: URI;
-    appLanguage: string;
-    extensionTelemetryLogResource: URI;
-    isExtensionTelemetryLoggingOnly: boolean;
-    appUriScheme: string;
-    extensionDevelopmentLocationURI?: URI[];
-    extensionTestsLocationURI?: URI;
-    globalStorageHome: URI;
-    workspaceStorageHome: URI;
-    useHostProxy?: boolean;
-    skipWorkspaceStorageLock?: boolean;
-    extensionLogLevel?: [string, string][];
-}
-interface IStaticWorkspaceData {
-    id: string;
-    name: string;
-    transient?: boolean;
-    configuration?: UriComponents | null;
-    isUntitled?: boolean | null;
-}
-interface MessagePortLike {
-    postMessage(message: any, transfer?: any[]): void;
-    addEventListener(type: 'message', listener: (e: any) => any): void;
-    removeEventListener(type: 'message', listener: (e: any) => any): void;
-    start(): void;
-}
-declare enum UIKind {
-    Desktop = 1,
-    Web = 2
-}
 
-export { type IEnvironment, type IExtensionDescriptionDelta, type IExtensionDescriptionSnapshot, type IExtensionHostInitData, type IStaticWorkspaceData, type MessagePortLike, UIKind };
+export type { IExtensionDescriptionDelta, IExtensionDescriptionSnapshot };

package/vscode/src/vs/workbench/services/extensions/common/extensions.d.ts

@@ -22,10 +22,6 @@ interface IExtensionsStatus {
     runtimeErrors: Error[];
     runningLocation: ExtensionRunningLocation | null;
 }
-declare class MissingExtensionDependency {
-    readonly dependency: string;
-    constructor(dependency: string);
-}
 declare const enum ExtensionHostStartup {
     /**
      * The extension host should be launched immediately and doesn't require a `$startExtensionHost` call.
@@ -237,4 +233,4 @@ interface IExtensionService {
     }): Promise<void>;
 }
 
-export { ActivationKind, ActivationTimes, type ExtensionActivationReason, ExtensionHostExtensions, ExtensionHostStartup, ExtensionPointContribution, type IExtensionHost, IExtensionService, type IExtensionsStatus, type IMessage, type IResponsiveStateChangeEvent, type IWillActivateEvent, MissingExtensionDependency, type WillStopExtensionHostsEvent };
+export { ActivationKind, ActivationTimes, type ExtensionActivationReason, ExtensionHostExtensions, ExtensionHostStartup, ExtensionPointContribution, type IExtensionHost, IExtensionService, type IExtensionsStatus, type IMessage, type IResponsiveStateChangeEvent, type IWillActivateEvent, type WillStopExtensionHostsEvent };

package/vscode/src/vs/workbench/services/textfile/common/textfiles.js

@@ -1,7 +1,7 @@
 import { FileOperationError } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { isUndefinedOrNull } from 'monaco-editor/esm/vs/base/common/types.js';
+import { isUndefinedOrNull, areFunctions } from 'monaco-editor/esm/vs/base/common/types.js';
 const ITextFileService = ( createDecorator('textFileService'));
 class TextFileOperationError extends FileOperationError {
     static isTextFileOperationError(obj) {
@@ -13,6 +13,10 @@ class TextFileOperationError extends FileOperationError {
         this.options = options;
     }
 }
+function isTextFileEditorModel(model) {
+    const candidate = model;
+    return areFunctions(candidate.setEncoding, candidate.getEncoding, candidate.save, candidate.revert, candidate.isDirty, candidate.getLanguageId);
+}
 function stringToSnapshot(value) {
     let done = false;
     return {
@@ -42,4 +46,4 @@ function toBufferOrReadable(value) {
         }
     };
 }
-export { ITextFileService, TextFileOperationError, stringToSnapshot, toBufferOrReadable };
+export { ITextFileService, TextFileOperationError, isTextFileEditorModel, stringToSnapshot, toBufferOrReadable };