@codingame/monaco-vscode-extension-gallery-service-override 1.83.9

package/vscode/src/vs/workbench/services/extensionManagement/common/extensionManagementService.js

@@ -0,0 +1,633 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Event, EventMultiplexer } from 'monaco-editor/esm/vs/base/common/event.js';
+import { ExtensionManagementErrorCode, EXTENSION_INSTALL_SYNC_CONTEXT, ExtensionManagementError, IExtensionGalleryService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
+import { IExtensionManagementServerService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
+import { isLanguagePackExtension, getWorkspaceSupportTypeMessage } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { areSameExtensions, computeTargetPlatform } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { IDownloadService } from 'vscode/vscode/vs/platform/download/common/download';
+import { flatten } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { IUserDataSyncEnablementService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync';
+import { Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { IWorkspaceTrustRequestService } from 'monaco-editor/esm/vs/platform/workspace/common/workspaceTrust.js';
+import { IExtensionManifestPropertiesService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { isUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { CancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+let ExtensionManagementService = class ExtensionManagementService extends Disposable {
+    constructor(extensionManagementServerService, extensionGalleryService, userDataProfileService, configurationService, productService, downloadService, userDataSyncEnablementService, dialogService, workspaceTrustRequestService, extensionManifestPropertiesService, fileService, logService, instantiationService) {
+        super();
+        this.extensionManagementServerService = extensionManagementServerService;
+        this.extensionGalleryService = extensionGalleryService;
+        this.userDataProfileService = userDataProfileService;
+        this.configurationService = configurationService;
+        this.productService = productService;
+        this.downloadService = downloadService;
+        this.userDataSyncEnablementService = userDataSyncEnablementService;
+        this.dialogService = dialogService;
+        this.workspaceTrustRequestService = workspaceTrustRequestService;
+        this.extensionManifestPropertiesService = extensionManifestPropertiesService;
+        this.fileService = fileService;
+        this.logService = logService;
+        this.instantiationService = instantiationService;
+        this.servers = [];
+        if (this.extensionManagementServerService.localExtensionManagementServer) {
+            this.servers.push(this.extensionManagementServerService.localExtensionManagementServer);
+        }
+        if (this.extensionManagementServerService.remoteExtensionManagementServer) {
+            this.servers.push(this.extensionManagementServerService.remoteExtensionManagementServer);
+        }
+        if (this.extensionManagementServerService.webExtensionManagementServer) {
+            this.servers.push(this.extensionManagementServerService.webExtensionManagementServer);
+        }
+        this.onInstallExtension = this._register(this.servers.reduce((emitter, server) => { this._register(emitter.add(( Event.map(
+            server.extensionManagementService.onInstallExtension,
+            e => ({ ...e, server })
+        )))); return emitter; }, this._register(( new EventMultiplexer())))).event;
+        this.onDidInstallExtensions = this._register(this.servers.reduce((emitter, server) => { this._register(emitter.add(server.extensionManagementService.onDidInstallExtensions)); return emitter; }, this._register(( new EventMultiplexer())))).event;
+        this.onUninstallExtension = this._register(this.servers.reduce((emitter, server) => { this._register(emitter.add(( Event.map(
+            server.extensionManagementService.onUninstallExtension,
+            e => ({ ...e, server })
+        )))); return emitter; }, this._register(( new EventMultiplexer())))).event;
+        this.onDidUninstallExtension = this._register(this.servers.reduce((emitter, server) => { this._register(emitter.add(( Event.map(
+            server.extensionManagementService.onDidUninstallExtension,
+            e => ({ ...e, server })
+        )))); return emitter; }, this._register(( new EventMultiplexer())))).event;
+        this.onDidUpdateExtensionMetadata = this._register(this.servers.reduce((emitter, server) => { this._register(emitter.add(server.extensionManagementService.onDidUpdateExtensionMetadata)); return emitter; }, this._register(( new EventMultiplexer())))).event;
+        this.onDidChangeProfile = this._register(this.servers.reduce((emitter, server) => { this._register(emitter.add(( Event.map(
+            server.extensionManagementService.onDidChangeProfile,
+            e => ({ ...e, server })
+        )))); return emitter; }, this._register(( new EventMultiplexer())))).event;
+    }
+    async getInstalled(type, profileLocation) {
+        const result = await Promise.all(( this.servers.map(
+            ({ extensionManagementService }) => extensionManagementService.getInstalled(type, profileLocation)
+        )));
+        return flatten(result);
+    }
+    async uninstall(extension, options) {
+        const server = this.getServer(extension);
+        if (!server) {
+            return Promise.reject(`Invalid location ${( extension.location.toString())}`);
+        }
+        if (this.servers.length > 1) {
+            if (isLanguagePackExtension(extension.manifest)) {
+                return this.uninstallEverywhere(extension, options);
+            }
+            return this.uninstallInServer(extension, server, options);
+        }
+        return server.extensionManagementService.uninstall(extension, options);
+    }
+    async uninstallEverywhere(extension, options) {
+        const server = this.getServer(extension);
+        if (!server) {
+            return Promise.reject(`Invalid location ${( extension.location.toString())}`);
+        }
+        const promise = server.extensionManagementService.uninstall(extension, options);
+        const otherServers = this.servers.filter(s => s !== server);
+        if (otherServers.length) {
+            for (const otherServer of otherServers) {
+                const installed = await otherServer.extensionManagementService.getInstalled();
+                extension = installed.filter(i => !i.isBuiltin && areSameExtensions(i.identifier, extension.identifier))[0];
+                if (extension) {
+                    await otherServer.extensionManagementService.uninstall(extension, options);
+                }
+            }
+        }
+        return promise;
+    }
+    async uninstallInServer(extension, server, options) {
+        if (server === this.extensionManagementServerService.localExtensionManagementServer) {
+            const installedExtensions = await this.extensionManagementServerService.remoteExtensionManagementServer.extensionManagementService.getInstalled(1 );
+            const dependentNonUIExtensions = installedExtensions.filter(i => !this.extensionManifestPropertiesService.prefersExecuteOnUI(i.manifest)
+                && i.manifest.extensionDependencies && ( i.manifest.extensionDependencies.some(id => areSameExtensions({ id }, extension.identifier))));
+            if (dependentNonUIExtensions.length) {
+                return Promise.reject(( new Error(this.getDependentsErrorMessage(extension, dependentNonUIExtensions))));
+            }
+        }
+        return server.extensionManagementService.uninstall(extension, options);
+    }
+    getDependentsErrorMessage(extension, dependents) {
+        if (dependents.length === 1) {
+            return ( localizeWithPath(
+                'vs/workbench/services/extensionManagement/common/extensionManagementService',
+                'singleDependentError',
+                "Cannot uninstall extension '{0}'. Extension '{1}' depends on this.",
+                extension.manifest.displayName || extension.manifest.name,
+                dependents[0].manifest.displayName || dependents[0].manifest.name
+            ));
+        }
+        if (dependents.length === 2) {
+            return ( localizeWithPath(
+                'vs/workbench/services/extensionManagement/common/extensionManagementService',
+                'twoDependentsError',
+                "Cannot uninstall extension '{0}'. Extensions '{1}' and '{2}' depend on this.",
+                extension.manifest.displayName || extension.manifest.name,
+                dependents[0].manifest.displayName || dependents[0].manifest.name,
+                dependents[1].manifest.displayName || dependents[1].manifest.name
+            ));
+        }
+        return ( localizeWithPath(
+            'vs/workbench/services/extensionManagement/common/extensionManagementService',
+            'multipleDependentsError',
+            "Cannot uninstall extension '{0}'. Extensions '{1}', '{2}' and others depend on this.",
+            extension.manifest.displayName || extension.manifest.name,
+            dependents[0].manifest.displayName || dependents[0].manifest.name,
+            dependents[1].manifest.displayName || dependents[1].manifest.name
+        ));
+    }
+    async reinstallFromGallery(extension) {
+        const server = this.getServer(extension);
+        if (server) {
+            await this.checkForWorkspaceTrust(extension.manifest);
+            return server.extensionManagementService.reinstallFromGallery(extension);
+        }
+        return Promise.reject(`Invalid location ${( extension.location.toString())}`);
+    }
+    updateMetadata(extension, metadata, profileLocation) {
+        const server = this.getServer(extension);
+        if (server) {
+            return server.extensionManagementService.updateMetadata(extension, metadata, profileLocation);
+        }
+        return Promise.reject(`Invalid location ${( extension.location.toString())}`);
+    }
+    zip(extension) {
+        const server = this.getServer(extension);
+        if (server) {
+            return server.extensionManagementService.zip(extension);
+        }
+        return Promise.reject(`Invalid location ${( extension.location.toString())}`);
+    }
+    unzip(zipLocation) {
+        return Promises.settled(( this.servers
+            .filter(server => server !== this.extensionManagementServerService.webExtensionManagementServer)
+            .map(
+            ({ extensionManagementService }) => extensionManagementService.unzip(zipLocation)
+        ))).then(([extensionIdentifier]) => extensionIdentifier);
+    }
+    download(extension, operation, donotVerifySignature) {
+        if (this.extensionManagementServerService.localExtensionManagementServer) {
+            return this.extensionManagementServerService.localExtensionManagementServer.extensionManagementService.download(extension, operation, donotVerifySignature);
+        }
+        throw new Error('Cannot download extension');
+    }
+    async install(vsix, options) {
+        const manifest = await this.getManifest(vsix);
+        return this.installVSIX(vsix, manifest, options);
+    }
+    async installVSIX(vsix, manifest, options) {
+        const serversToInstall = this.getServersToInstall(manifest);
+        if (serversToInstall?.length) {
+            await this.checkForWorkspaceTrust(manifest);
+            const [local] = await Promises.settled(( serversToInstall.map(server => this.installVSIXInServer(vsix, server, options))));
+            return local;
+        }
+        return Promise.reject('No Servers to Install');
+    }
+    getServersToInstall(manifest) {
+        if (this.extensionManagementServerService.localExtensionManagementServer && this.extensionManagementServerService.remoteExtensionManagementServer) {
+            if (isLanguagePackExtension(manifest)) {
+                return [this.extensionManagementServerService.localExtensionManagementServer, this.extensionManagementServerService.remoteExtensionManagementServer];
+            }
+            if (this.extensionManifestPropertiesService.prefersExecuteOnUI(manifest)) {
+                return [this.extensionManagementServerService.localExtensionManagementServer];
+            }
+            return [this.extensionManagementServerService.remoteExtensionManagementServer];
+        }
+        if (this.extensionManagementServerService.localExtensionManagementServer) {
+            return [this.extensionManagementServerService.localExtensionManagementServer];
+        }
+        if (this.extensionManagementServerService.remoteExtensionManagementServer) {
+            return [this.extensionManagementServerService.remoteExtensionManagementServer];
+        }
+        return undefined;
+    }
+    async installFromLocation(location) {
+        if (location.scheme === Schemas.file) {
+            if (this.extensionManagementServerService.localExtensionManagementServer) {
+                return this.extensionManagementServerService.localExtensionManagementServer.extensionManagementService.installFromLocation(location, this.userDataProfileService.currentProfile.extensionsResource);
+            }
+            throw new Error('Local extension management server is not found');
+        }
+        if (location.scheme === Schemas.vscodeRemote) {
+            if (this.extensionManagementServerService.remoteExtensionManagementServer) {
+                return this.extensionManagementServerService.remoteExtensionManagementServer.extensionManagementService.installFromLocation(location, this.userDataProfileService.currentProfile.extensionsResource);
+            }
+            throw new Error('Remote extension management server is not found');
+        }
+        if (!this.extensionManagementServerService.webExtensionManagementServer) {
+            throw new Error('Web extension management server is not found');
+        }
+        return this.extensionManagementServerService.webExtensionManagementServer.extensionManagementService.installFromLocation(location, this.userDataProfileService.currentProfile.extensionsResource);
+    }
+    installVSIXInServer(vsix, server, options) {
+        return server.extensionManagementService.install(vsix, options);
+    }
+    getManifest(vsix) {
+        if (vsix.scheme === Schemas.file && this.extensionManagementServerService.localExtensionManagementServer) {
+            return this.extensionManagementServerService.localExtensionManagementServer.extensionManagementService.getManifest(vsix);
+        }
+        if (vsix.scheme === Schemas.file && this.extensionManagementServerService.remoteExtensionManagementServer) {
+            return this.extensionManagementServerService.remoteExtensionManagementServer.extensionManagementService.getManifest(vsix);
+        }
+        if (vsix.scheme === Schemas.vscodeRemote && this.extensionManagementServerService.remoteExtensionManagementServer) {
+            return this.extensionManagementServerService.remoteExtensionManagementServer.extensionManagementService.getManifest(vsix);
+        }
+        return Promise.reject('No Servers');
+    }
+    async canInstall(gallery) {
+        if (this.extensionManagementServerService.localExtensionManagementServer
+            && (await this.extensionManagementServerService.localExtensionManagementServer.extensionManagementService.canInstall(gallery))) {
+            return true;
+        }
+        const manifest = await this.extensionGalleryService.getManifest(gallery, CancellationToken.None);
+        if (!manifest) {
+            return false;
+        }
+        if (this.extensionManagementServerService.remoteExtensionManagementServer
+            && (await this.extensionManagementServerService.remoteExtensionManagementServer.extensionManagementService.canInstall(gallery))
+            && this.extensionManifestPropertiesService.canExecuteOnWorkspace(manifest)) {
+            return true;
+        }
+        if (this.extensionManagementServerService.webExtensionManagementServer
+            && (await this.extensionManagementServerService.webExtensionManagementServer.extensionManagementService.canInstall(gallery))
+            && this.extensionManifestPropertiesService.canExecuteOnWeb(manifest)) {
+            return true;
+        }
+        return false;
+    }
+    async updateFromGallery(gallery, extension, installOptions) {
+        const server = this.getServer(extension);
+        if (!server) {
+            return Promise.reject(`Invalid location ${( extension.location.toString())}`);
+        }
+        const servers = [];
+        if (isLanguagePackExtension(extension.manifest)) {
+            servers.push(...this.servers.filter(server => server !== this.extensionManagementServerService.webExtensionManagementServer));
+        }
+        else {
+            servers.push(server);
+        }
+        return Promises.settled(( servers.map(
+            server => server.extensionManagementService.installFromGallery(gallery, installOptions)
+        ))).then(([local]) => local);
+    }
+    async installGalleryExtensions(extensions) {
+        const results = ( new Map());
+        const extensionsByServer = ( new Map());
+        await Promise.all(( extensions.map(async ({ extension, options }) => {
+            try {
+                const servers = await this.validateAndGetExtensionManagementServersToInstall(extension, options);
+                if (!options.isMachineScoped && this.isExtensionsSyncEnabled()) {
+                    if (this.extensionManagementServerService.localExtensionManagementServer && !servers.includes(this.extensionManagementServerService.localExtensionManagementServer) && (await this.extensionManagementServerService.localExtensionManagementServer.extensionManagementService.canInstall(extension))) {
+                        servers.push(this.extensionManagementServerService.localExtensionManagementServer);
+                    }
+                }
+                for (const server of servers) {
+                    let exensions = extensionsByServer.get(server);
+                    if (!exensions) {
+                        extensionsByServer.set(server, exensions = []);
+                    }
+                    exensions.push({ extension, options });
+                }
+            }
+            catch (error) {
+                results.set(extension.identifier.id.toLowerCase(), { identifier: extension.identifier, source: extension, error, operation: 2  });
+            }
+        })));
+        await Promise.all(( [...extensionsByServer.entries()].map(async ([server, extensions]) => {
+            const serverResults = await server.extensionManagementService.installGalleryExtensions(extensions);
+            for (const result of serverResults) {
+                results.set(result.identifier.id.toLowerCase(), result);
+            }
+        })));
+        return [...( results.values())];
+    }
+    async installFromGallery(gallery, installOptions) {
+        const servers = await this.validateAndGetExtensionManagementServersToInstall(gallery, installOptions);
+        if (!installOptions || isUndefined(installOptions.isMachineScoped)) {
+            const isMachineScoped = await this.hasToFlagExtensionsMachineScoped([gallery]);
+            installOptions = { ...(installOptions || {}), isMachineScoped };
+        }
+        if (!installOptions.isMachineScoped && this.isExtensionsSyncEnabled()) {
+            if (this.extensionManagementServerService.localExtensionManagementServer && !servers.includes(this.extensionManagementServerService.localExtensionManagementServer) && (await this.extensionManagementServerService.localExtensionManagementServer.extensionManagementService.canInstall(gallery))) {
+                servers.push(this.extensionManagementServerService.localExtensionManagementServer);
+            }
+        }
+        return Promises.settled(( servers.map(
+            server => server.extensionManagementService.installFromGallery(gallery, installOptions)
+        ))).then(([local]) => local);
+    }
+    async validateAndGetExtensionManagementServersToInstall(gallery, installOptions) {
+        const manifest = await this.extensionGalleryService.getManifest(gallery, CancellationToken.None);
+        if (!manifest) {
+            return Promise.reject(( localizeWithPath(
+                'vs/workbench/services/extensionManagement/common/extensionManagementService',
+                'Manifest is not found',
+                "Installing Extension {0} failed: Manifest is not found.",
+                gallery.displayName || gallery.name
+            )));
+        }
+        const servers = [];
+        if (isLanguagePackExtension(manifest)) {
+            servers.push(...this.servers.filter(server => server !== this.extensionManagementServerService.webExtensionManagementServer));
+        }
+        else {
+            const server = this.getExtensionManagementServerToInstall(manifest);
+            if (server) {
+                servers.push(server);
+            }
+        }
+        if (!servers.length) {
+            const error = ( new Error(( localizeWithPath(
+                'vs/workbench/services/extensionManagement/common/extensionManagementService',
+                'cannot be installed',
+                "Cannot install the '{0}' extension because it is not available in this setup.",
+                gallery.displayName || gallery.name
+            ))));
+            error.name = ExtensionManagementErrorCode.Unsupported;
+            throw error;
+        }
+        if (!installOptions?.context?.[EXTENSION_INSTALL_SYNC_CONTEXT]) {
+            await this.checkForWorkspaceTrust(manifest);
+        }
+        if (!installOptions?.donotIncludePackAndDependencies) {
+            await this.checkInstallingExtensionOnWeb(gallery, manifest);
+        }
+        return servers;
+    }
+    getExtensionManagementServerToInstall(manifest) {
+        if (this.servers.length === 1 && this.extensionManagementServerService.localExtensionManagementServer) {
+            return this.extensionManagementServerService.localExtensionManagementServer;
+        }
+        const extensionKind = this.extensionManifestPropertiesService.getExtensionKind(manifest);
+        for (const kind of extensionKind) {
+            if (kind === 'ui' && this.extensionManagementServerService.localExtensionManagementServer) {
+                return this.extensionManagementServerService.localExtensionManagementServer;
+            }
+            if (kind === 'workspace' && this.extensionManagementServerService.remoteExtensionManagementServer) {
+                return this.extensionManagementServerService.remoteExtensionManagementServer;
+            }
+            if (kind === 'web' && this.extensionManagementServerService.webExtensionManagementServer) {
+                return this.extensionManagementServerService.webExtensionManagementServer;
+            }
+        }
+        return this.extensionManagementServerService.localExtensionManagementServer;
+    }
+    isExtensionsSyncEnabled() {
+        return this.userDataSyncEnablementService.isEnabled() && this.userDataSyncEnablementService.isResourceEnabled("extensions" );
+    }
+    async hasToFlagExtensionsMachineScoped(extensions) {
+        if (this.isExtensionsSyncEnabled()) {
+            const { result } = await this.dialogService.prompt({
+                type: Severity.Info,
+                message: extensions.length === 1 ? ( localizeWithPath(
+                    'vs/workbench/services/extensionManagement/common/extensionManagementService',
+                    'install extension',
+                    "Install Extension"
+                )) : ( localizeWithPath(
+                    'vs/workbench/services/extensionManagement/common/extensionManagementService',
+                    'install extensions',
+                    "Install Extensions"
+                )),
+                detail: extensions.length === 1
+                    ? ( localizeWithPath(
+                    'vs/workbench/services/extensionManagement/common/extensionManagementService',
+                    'install single extension',
+                    "Would you like to install and synchronize '{0}' extension across your devices?",
+                    extensions[0].displayName
+                ))
+                    : ( localizeWithPath(
+                    'vs/workbench/services/extensionManagement/common/extensionManagementService',
+                    'install multiple extensions',
+                    "Would you like to install and synchronize extensions across your devices?"
+                )),
+                buttons: [
+                    {
+                        label: ( localizeWithPath(
+                            'vs/workbench/services/extensionManagement/common/extensionManagementService',
+                            { key: 'install', comment: ['&& denotes a mnemonic'] },
+                            "&&Install"
+                        )),
+                        run: () => false
+                    },
+                    {
+                        label: ( localizeWithPath(
+                            'vs/workbench/services/extensionManagement/common/extensionManagementService',
+                            { key: 'install and do no sync', comment: ['&& denotes a mnemonic'] },
+                            "Install (Do &&not sync)"
+                        )),
+                        run: () => true
+                    }
+                ],
+                cancelButton: {
+                    run: () => {
+                        throw new CancellationError();
+                    }
+                }
+            });
+            return result;
+        }
+        return false;
+    }
+    getExtensionsControlManifest() {
+        if (this.extensionManagementServerService.localExtensionManagementServer) {
+            return this.extensionManagementServerService.localExtensionManagementServer.extensionManagementService.getExtensionsControlManifest();
+        }
+        if (this.extensionManagementServerService.remoteExtensionManagementServer) {
+            return this.extensionManagementServerService.remoteExtensionManagementServer.extensionManagementService.getExtensionsControlManifest();
+        }
+        if (this.extensionManagementServerService.webExtensionManagementServer) {
+            return this.extensionManagementServerService.webExtensionManagementServer.extensionManagementService.getExtensionsControlManifest();
+        }
+        return Promise.resolve({ malicious: [], deprecated: {}, search: [] });
+    }
+    getServer(extension) {
+        return this.extensionManagementServerService.getExtensionManagementServer(extension);
+    }
+    async checkForWorkspaceTrust(manifest) {
+        if (this.extensionManifestPropertiesService.getExtensionUntrustedWorkspaceSupportType(manifest) === false) {
+            const trustState = await this.workspaceTrustRequestService.requestWorkspaceTrust({
+                message: ( localizeWithPath(
+                    'vs/workbench/services/extensionManagement/common/extensionManagementService',
+                    'extensionInstallWorkspaceTrustMessage',
+                    "Enabling this extension requires a trusted workspace."
+                )),
+                buttons: [
+                    { label: ( localizeWithPath(
+                        'vs/workbench/services/extensionManagement/common/extensionManagementService',
+                        'extensionInstallWorkspaceTrustButton',
+                        "Trust Workspace & Install"
+                    )), type: 'ContinueWithTrust' },
+                    { label: ( localizeWithPath(
+                        'vs/workbench/services/extensionManagement/common/extensionManagementService',
+                        'extensionInstallWorkspaceTrustContinueButton',
+                        "Install"
+                    )), type: 'ContinueWithoutTrust' },
+                    { label: ( localizeWithPath(
+                        'vs/workbench/services/extensionManagement/common/extensionManagementService',
+                        'extensionInstallWorkspaceTrustManageButton',
+                        "Learn More"
+                    )), type: 'Manage' }
+                ]
+            });
+            if (trustState === undefined) {
+                throw new CancellationError();
+            }
+        }
+    }
+    async checkInstallingExtensionOnWeb(extension, manifest) {
+        if (this.servers.length !== 1 || this.servers[0] !== this.extensionManagementServerService.webExtensionManagementServer) {
+            return;
+        }
+        const nonWebExtensions = [];
+        if (manifest.extensionPack?.length) {
+            const extensions = await this.extensionGalleryService.getExtensions(( manifest.extensionPack.map(id => ({ id }))), CancellationToken.None);
+            for (const extension of extensions) {
+                if (!(await this.servers[0].extensionManagementService.canInstall(extension))) {
+                    nonWebExtensions.push(extension);
+                }
+            }
+            if (nonWebExtensions.length && nonWebExtensions.length === extensions.length) {
+                throw new ExtensionManagementError('Not supported in Web', ExtensionManagementErrorCode.Unsupported);
+            }
+        }
+        const productName = ( localizeWithPath(
+            'vs/workbench/services/extensionManagement/common/extensionManagementService',
+            'VS Code for Web',
+            "{0} for the Web",
+            this.productService.nameLong
+        ));
+        const virtualWorkspaceSupport = this.extensionManifestPropertiesService.getExtensionVirtualWorkspaceSupportType(manifest);
+        const virtualWorkspaceSupportReason = getWorkspaceSupportTypeMessage(manifest.capabilities?.virtualWorkspaces);
+        const hasLimitedSupport = virtualWorkspaceSupport === 'limited' || !!virtualWorkspaceSupportReason;
+        if (!nonWebExtensions.length && !hasLimitedSupport) {
+            return;
+        }
+        const limitedSupportMessage = ( localizeWithPath(
+            'vs/workbench/services/extensionManagement/common/extensionManagementService',
+            'limited support',
+            "'{0}' has limited functionality in {1}.",
+            extension.displayName || extension.identifier.id,
+            productName
+        ));
+        let message;
+        let buttons = [];
+        let detail;
+        const installAnywayButton = {
+            label: ( localizeWithPath(
+                'vs/workbench/services/extensionManagement/common/extensionManagementService',
+                { key: 'install anyways', comment: ['&& denotes a mnemonic'] },
+                "&&Install Anyway"
+            )),
+            run: () => { }
+        };
+        const showExtensionsButton = {
+            label: ( localizeWithPath(
+                'vs/workbench/services/extensionManagement/common/extensionManagementService',
+                { key: 'showExtensions', comment: ['&& denotes a mnemonic'] },
+                "&&Show Extensions"
+            )),
+            run: () => this.instantiationService.invokeFunction(accessor => accessor.get(ICommandService).executeCommand('extension.open', extension.identifier.id, 'extensionPack'))
+        };
+        if (nonWebExtensions.length && hasLimitedSupport) {
+            message = limitedSupportMessage;
+            detail = `${virtualWorkspaceSupportReason ? `${virtualWorkspaceSupportReason}\n` : ''}${( localizeWithPath(
+                'vs/workbench/services/extensionManagement/common/extensionManagementService',
+                'non web extensions detail',
+                "Contains extensions which are not supported."
+            ))}`;
+            buttons = [
+                installAnywayButton,
+                showExtensionsButton
+            ];
+        }
+        else if (hasLimitedSupport) {
+            message = limitedSupportMessage;
+            detail = virtualWorkspaceSupportReason || undefined;
+            buttons = [installAnywayButton];
+        }
+        else {
+            message = ( localizeWithPath(
+                'vs/workbench/services/extensionManagement/common/extensionManagementService',
+                'non web extensions',
+                "'{0}' contains extensions which are not supported in {1}.",
+                extension.displayName || extension.identifier.id,
+                productName
+            ));
+            buttons = [
+                installAnywayButton,
+                showExtensionsButton
+            ];
+        }
+        await this.dialogService.prompt({
+            type: Severity.Info,
+            message,
+            detail,
+            buttons,
+            cancelButton: {
+                run: () => { throw new CancellationError(); }
+            }
+        });
+    }
+    getTargetPlatform() {
+        if (!this._targetPlatformPromise) {
+            this._targetPlatformPromise = computeTargetPlatform(this.fileService, this.logService);
+        }
+        return this._targetPlatformPromise;
+    }
+    async cleanUp() {
+        await Promise.allSettled(( this.servers.map(server => server.extensionManagementService.cleanUp())));
+    }
+    toggleAppliationScope(extension, fromProfileLocation) {
+        const server = this.getServer(extension);
+        if (server) {
+            return server.extensionManagementService.toggleAppliationScope(extension, fromProfileLocation);
+        }
+        throw new Error('Not Supported');
+    }
+    copyExtensions(from, to) {
+        if (this.extensionManagementServerService.remoteExtensionManagementServer) {
+            throw new Error('Not Supported');
+        }
+        if (this.extensionManagementServerService.localExtensionManagementServer) {
+            return this.extensionManagementServerService.localExtensionManagementServer.extensionManagementService.copyExtensions(from, to);
+        }
+        if (this.extensionManagementServerService.webExtensionManagementServer) {
+            return this.extensionManagementServerService.webExtensionManagementServer.extensionManagementService.copyExtensions(from, to);
+        }
+        return Promise.resolve();
+    }
+    registerParticipant() { throw new Error('Not Supported'); }
+    installExtensionsFromProfile(extensions, fromProfileLocation, toProfileLocation) { throw new Error('Not Supported'); }
+};
+ExtensionManagementService = ( __decorate([
+    ( __param(0, IExtensionManagementServerService)),
+    ( __param(1, IExtensionGalleryService)),
+    ( __param(2, IUserDataProfileService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IProductService)),
+    ( __param(5, IDownloadService)),
+    ( __param(6, IUserDataSyncEnablementService)),
+    ( __param(7, IDialogService)),
+    ( __param(8, IWorkspaceTrustRequestService)),
+    ( __param(9, IExtensionManifestPropertiesService)),
+    ( __param(10, IFileService)),
+    ( __param(11, ILogService)),
+    ( __param(12, IInstantiationService))
+], ExtensionManagementService));
+
+export { ExtensionManagementService };