@codingame/monaco-vscode-api 25.1.2 → 26.0.1

package/vscode/src/vs/workbench/contrib/extensions/browser/extensionsWorkbenchService.js

@@ -71,7 +71,19 @@ import Severity$1 from '../../../../base/common/severity.js';
 
 var ExtensionsWorkbenchService_1;
 let Extension = class Extension {
-    constructor(stateProvider, runtimeStateProvider, server, local, _gallery, resourceExtensionInfo, galleryService, telemetryService, logService, fileService, productService) {
+    constructor(
+        stateProvider,
+        runtimeStateProvider,
+        server,
+        local,
+        _gallery,
+        resourceExtensionInfo,
+        galleryService,
+        telemetryService,
+        logService,
+        fileService,
+        productService
+    ) {
         this.stateProvider = stateProvider;
         this.runtimeStateProvider = runtimeStateProvider;
         this.server = server;
@@ -92,12 +104,12 @@ let Extension = class Extension {
         }
         if (this.local?.isWorkspaceScoped) {
             return {
-                type: 'resource',
+                type: "resource",
                 identifier: this.local.identifier,
                 location: this.local.location,
                 manifest: this.local.manifest,
                 changelogUri: this.local.changelogUrl,
-                readmeUri: this.local.readmeUrl,
+                readmeUri: this.local.readmeUrl
             };
         }
         return undefined;
@@ -134,7 +146,7 @@ let Extension = class Extension {
         if (this.gallery) {
             return this.gallery.name;
         }
-        return this.getManifestFromLocalOrResource()?.name ?? '';
+        return this.getManifestFromLocalOrResource()?.name ?? "";
     }
     get displayName() {
         if (this.gallery) {
@@ -149,7 +161,9 @@ let Extension = class Extension {
         if (this.resourceExtension) {
             return this.resourceExtension.identifier;
         }
-        return this.local?.identifier ?? { id: '' };
+        return this.local?.identifier ?? {
+            id: ""
+        };
     }
     get uuid() {
         return this.gallery ? this.gallery.identifier.uuid : this.local?.identifier.uuid;
@@ -158,7 +172,7 @@ let Extension = class Extension {
         if (this.gallery) {
             return this.gallery.publisher;
         }
-        return this.getManifestFromLocalOrResource()?.publisher ?? '';
+        return this.getManifestFromLocalOrResource()?.publisher ?? "";
     }
     get publisherDisplayName() {
         if (this.gallery) {
@@ -188,10 +202,10 @@ let Extension = class Extension {
         return !!this.local?.pinned;
     }
     get latestVersion() {
-        return this.gallery ? this.gallery.version : this.getManifestFromLocalOrResource()?.version ?? '';
+        return this.gallery ? this.gallery.version : this.getManifestFromLocalOrResource()?.version ?? "";
     }
     get description() {
-        return this.gallery ? this.gallery.description : this.getManifestFromLocalOrResource()?.description ?? '';
+        return this.gallery ? this.gallery.description : this.getManifestFromLocalOrResource()?.description ?? "";
     }
     get url() {
         return this.gallery?.detailsLink;
@@ -210,7 +224,9 @@ let Extension = class Extension {
     }
     get resourceExtensionIconUrl() {
         if (this.resourceExtension?.manifest.icon) {
-            return ( FileAccess.uriToBrowserUri(joinPath(this.resourceExtension.location, this.resourceExtension.manifest.icon)).toString(true));
+            return ( FileAccess.uriToBrowserUri(
+                joinPath(this.resourceExtension.location, this.resourceExtension.manifest.icon)
+            ).toString(true));
         }
         return undefined;
     }
@@ -221,10 +237,10 @@ let Extension = class Extension {
         if (this.type === ExtensionType.System && this.local) {
             if (this.local.manifest && this.local.manifest.contributes) {
                 if (Array.isArray(this.local.manifest.contributes.themes) && this.local.manifest.contributes.themes.length) {
-                    return ( ( FileAccess.asBrowserUri('vs/workbench/contrib/extensions/browser/media/theme-icon.png')).toString(true));
+                    return ( ( FileAccess.asBrowserUri("vs/workbench/contrib/extensions/browser/media/theme-icon.png")).toString(true));
                 }
                 if (Array.isArray(this.local.manifest.contributes.grammars) && this.local.manifest.contributes.grammars.length) {
-                    return ( ( FileAccess.asBrowserUri('vs/workbench/contrib/extensions/browser/media/language-icon.svg')).toString(true));
+                    return ( ( FileAccess.asBrowserUri("vs/workbench/contrib/extensions/browser/media/language-icon.svg")).toString(true));
                 }
             }
         }
@@ -265,7 +281,7 @@ let Extension = class Extension {
             if (!this.gallery || !this.local) {
                 return false;
             }
-            if (this.type === ExtensionType.System && this.productService.quality === 'stable') {
+            if (this.type === ExtensionType.System && this.productService.quality === "stable") {
                 return false;
             }
             if (!this.local.preRelease && this.gallery.properties.isPreReleaseVersion) {
@@ -277,30 +293,25 @@ let Extension = class Extension {
             if (this.outdatedTargetPlatform) {
                 return true;
             }
-        }
-        catch (error) {
-        }
+        } catch (error) {}
         return false;
     }
     get outdatedTargetPlatform() {
-        return !!this.local && !!this.gallery
-            && ![TargetPlatform.UNDEFINED, TargetPlatform.WEB].includes(this.local.targetPlatform)
-            && this.gallery.properties.targetPlatform !== TargetPlatform.WEB
-            && this.local.targetPlatform !== this.gallery.properties.targetPlatform
-            && semverExports.eq(this.latestVersion, this.version);
+        return !!this.local && !!this.gallery && ![TargetPlatform.UNDEFINED, TargetPlatform.WEB].includes(this.local.targetPlatform) && this.gallery.properties.targetPlatform !== TargetPlatform.WEB && this.local.targetPlatform !== this.gallery.properties.targetPlatform && semverExports.eq(this.latestVersion, this.version);
     }
     get runtimeState() {
         return this.runtimeStateProvider(this);
     }
     get telemetryData() {
-        const { local, gallery } = this;
+        const {
+            local,
+            gallery
+        } = this;
         if (gallery) {
             return getGalleryExtensionTelemetryData(gallery);
-        }
-        else if (local) {
+        } else if (local) {
             return getLocalExtensionTelemetryData(local);
-        }
-        else {
+        } else {
             return {};
         }
     }
@@ -340,17 +351,18 @@ let Extension = class Extension {
     }
     async getGalleryManifest(token = CancellationToken.None) {
         if (this.gallery) {
-            let cache = this.galleryResourcesCache.get('manifest');
+            let cache = this.galleryResourcesCache.get("manifest");
             if (!cache) {
                 if (this.gallery.assets.manifest) {
-                    this.galleryResourcesCache.set('manifest', cache = this.galleryService.getManifest(this.gallery, token)
-                        .catch(e => {
-                        this.galleryResourcesCache.delete('manifest');
-                        throw e;
-                    }));
-                }
-                else {
-                    this.logService.error(( localize(7787, "Manifest is not found")), this.identifier.id);
+                    this.galleryResourcesCache.set(
+                        "manifest",
+                        cache = this.galleryService.getManifest(this.gallery, token).catch(e => {
+                            this.galleryResourcesCache.delete("manifest");
+                            throw e;
+                        })
+                    );
+                } else {
+                    this.logService.error(( localize(8099, "Manifest is not found")), this.identifier.id);
                 }
             }
             return cache;
@@ -379,7 +391,7 @@ let Extension = class Extension {
             if (this.gallery.assets.readme) {
                 return this.galleryService.getReadme(this.gallery, token);
             }
-            this.telemetryService.publicLog('extensions:NotFoundReadMe', this.telemetryData);
+            this.telemetryService.publicLog("extensions:NotFoundReadMe", this.telemetryData);
         }
         if (this.type === ExtensionType.System) {
             return Promise.resolve(`# ${this.displayName || this.name}
@@ -392,7 +404,7 @@ ${this.description}
             const content = await this.fileService.readFile(this.resourceExtension?.readmeUri);
             return ( content.value.toString());
         }
-        return Promise.reject(( new Error('not available')));
+        return Promise.reject(( new Error("not available")));
     }
     hasChangelog() {
         if (this.local && this.local.changelogUrl) {
@@ -413,12 +425,18 @@ ${this.description}
             return this.galleryService.getChangelog(this.gallery, token);
         }
         if (this.type === ExtensionType.System) {
-            return Promise.resolve(`Please check the [VS Code Release Notes](command:${ShowCurrentReleaseNotesActionId}) for changes to the built-in extensions.`);
+            return Promise.resolve(
+                `Please check the [VS Code Release Notes](command:${ShowCurrentReleaseNotesActionId}) for changes to the built-in extensions.`
+            );
         }
-        return Promise.reject(( new Error('not available')));
+        return Promise.reject(( new Error("not available")));
     }
     get categories() {
-        const { local, gallery, resourceExtension } = this;
+        const {
+            local,
+            gallery,
+            resourceExtension
+        } = this;
         if (local && local.manifest.categories && !this.outdated) {
             return local.manifest.categories;
         }
@@ -431,14 +449,20 @@ ${this.description}
         return [];
     }
     get tags() {
-        const { gallery } = this;
+        const {
+            gallery
+        } = this;
         if (gallery) {
-            return gallery.tags.filter(tag => !tag.startsWith('_'));
+            return gallery.tags.filter(tag => !tag.startsWith("_"));
         }
         return [];
     }
     get dependencies() {
-        const { local, gallery, resourceExtension } = this;
+        const {
+            local,
+            gallery,
+            resourceExtension
+        } = this;
         if (local && local.manifest.extensionDependencies && !this.outdated) {
             return local.manifest.extensionDependencies;
         }
@@ -451,7 +475,11 @@ ${this.description}
         return [];
     }
     get extensionPack() {
-        const { local, gallery, resourceExtension } = this;
+        const {
+            local,
+            gallery,
+            resourceExtension
+        } = this;
         if (local && local.manifest.extensionPack && !this.outdated) {
             return local.manifest.extensionPack;
         }
@@ -477,20 +505,28 @@ ${this.description}
         return null;
     }
 };
-Extension = ( __decorate([
-    ( __param(6, IExtensionGalleryService)),
-    ( __param(7, ITelemetryService)),
-    ( __param(8, ILogService)),
-    ( __param(9, IFileService)),
-    ( __param(10, IProductService))
-], Extension));
-const EXTENSIONS_AUTO_UPDATE_KEY = 'extensions.autoUpdate';
-const EXTENSIONS_DONOT_AUTO_UPDATE_KEY = 'extensions.donotAutoUpdate';
-const EXTENSIONS_DISMISSED_NOTIFICATIONS_KEY = 'extensions.dismissedNotifications';
+Extension = ( __decorate([( __param(6, IExtensionGalleryService)), ( __param(7, ITelemetryService)), ( __param(8, ILogService)), ( __param(9, IFileService)), ( __param(10, IProductService))], Extension));
+const EXTENSIONS_AUTO_UPDATE_KEY = "extensions.autoUpdate";
+const EXTENSIONS_DONOT_AUTO_UPDATE_KEY = "extensions.donotAutoUpdate";
+const EXTENSIONS_DISMISSED_NOTIFICATIONS_KEY = "extensions.dismissedNotifications";
 let Extensions = class Extensions extends Disposable {
-    get onChange() { return this._onChange.event; }
-    get onReset() { return this._onReset.event; }
-    constructor(server, stateProvider, runtimeStateProvider, isWorkspaceServer, galleryService, extensionEnablementService, workbenchExtensionManagementService, telemetryService, instantiationService) {
+    get onChange() {
+        return this._onChange.event;
+    }
+    get onReset() {
+        return this._onReset.event;
+    }
+    constructor(
+        server,
+        stateProvider,
+        runtimeStateProvider,
+        isWorkspaceServer,
+        galleryService,
+        extensionEnablementService,
+        workbenchExtensionManagementService,
+        telemetryService,
+        instantiationService
+    ) {
         super();
         this.server = server;
         this.stateProvider = stateProvider;
@@ -506,13 +542,25 @@ let Extensions = class Extensions extends Disposable {
         this.installing = [];
         this.uninstalling = [];
         this.installed = [];
-        this._register(server.extensionManagementService.onInstallExtension(e => this.onInstallExtension(e)));
-        this._register(server.extensionManagementService.onDidInstallExtensions(e => this.onDidInstallExtensions(e)));
-        this._register(server.extensionManagementService.onUninstallExtension(e => this.onUninstallExtension(e.identifier)));
-        this._register(server.extensionManagementService.onDidUninstallExtension(e => this.onDidUninstallExtension(e)));
-        this._register(server.extensionManagementService.onDidUpdateExtensionMetadata(e => this.onDidUpdateExtensionMetadata(e.local)));
+        this._register(
+            server.extensionManagementService.onInstallExtension(e => this.onInstallExtension(e))
+        );
+        this._register(
+            server.extensionManagementService.onDidInstallExtensions(e => this.onDidInstallExtensions(e))
+        );
+        this._register(
+            server.extensionManagementService.onUninstallExtension(e => this.onUninstallExtension(e.identifier))
+        );
+        this._register(
+            server.extensionManagementService.onDidUninstallExtension(e => this.onDidUninstallExtension(e))
+        );
+        this._register(
+            server.extensionManagementService.onDidUpdateExtensionMetadata(e => this.onDidUpdateExtensionMetadata(e.local))
+        );
         this._register(server.extensionManagementService.onDidChangeProfile(() => this.reset()));
-        this._register(extensionEnablementService.onEnablementChanged(e => this.onEnablementChanged(e)));
+        this._register(
+            extensionEnablementService.onEnablementChanged(e => this.onEnablementChanged(e))
+        );
         this._register(Event.any(this.onChange, this.onReset)(() => this._local = undefined));
         if (this.isWorkspaceServer) {
             this._register(this.workbenchExtensionManagementService.onInstallExtension(e => {
@@ -565,7 +613,9 @@ let Extensions = class Extensions extends Disposable {
             }
             if (!extension.gallery || extension.gallery.version !== gallery.version || extension.gallery.properties.targetPlatform !== gallery.properties.targetPlatform) {
                 extension.gallery = gallery;
-                this._onChange.fire({ extension });
+                this._onChange.fire({
+                    extension
+                });
             }
         }
         if (flagExtensionsMissingFromGallery) {
@@ -586,7 +636,10 @@ let Extensions = class Extensions extends Disposable {
                 extensionsToQuery.push(extension);
             }
             if (extensionsToQuery.length) {
-                const queryResult = await this.galleryService.getExtensions(( extensionsToQuery.map(e => ({ ...e.identifier, version: e.version }))), CancellationToken.None);
+                const queryResult = await this.galleryService.getExtensions(( extensionsToQuery.map(e => ({
+                    ...e.identifier,
+                    version: e.version
+                }))), CancellationToken.None);
                 const queriedIds = [];
                 const missingIds = [];
                 for (const extension of extensionsToQuery) {
@@ -594,16 +647,17 @@ let Extensions = class Extensions extends Disposable {
                     const gallery = queryResult.find(g => areSameExtensions(g.identifier, extension.identifier));
                     if (gallery) {
                         extension.gallery = gallery;
-                    }
-                    else {
+                    } else {
                         extension.missingFromGallery = true;
                         missingIds.push(extension.identifier.id);
                     }
-                    this._onChange.fire({ extension });
+                    this._onChange.fire({
+                        extension
+                    });
                 }
-                this.telemetryService.publicLog2('extensions:missingFromGallery', {
-                    queriedIds: ( new TelemetryTrustedValue(queriedIds.join(';'))),
-                    missingIds: ( new TelemetryTrustedValue(missingIds.join(';')))
+                this.telemetryService.publicLog2("extensions:missingFromGallery", {
+                    queriedIds: ( new TelemetryTrustedValue(queriedIds.join(";"))),
+                    missingIds: ( new TelemetryTrustedValue(missingIds.join(";")))
                 });
             }
         }
@@ -617,21 +671,29 @@ let Extensions = class Extensions extends Disposable {
             if (extension.local) {
                 if (await this.galleryService.isExtensionCompatible(gallery, extension.local.preRelease, targetPlatform, productVersion)) {
                     compatibleGalleryExtensions.push(gallery);
-                }
-                else {
-                    compatibleGalleryExtensionsToFetch.push({ ...extension.local.identifier, preRelease: extension.local.preRelease });
+                } else {
+                    compatibleGalleryExtensionsToFetch.push({
+                        ...extension.local.identifier,
+                        preRelease: extension.local.preRelease
+                    });
                 }
             }
         })));
         if (compatibleGalleryExtensionsToFetch.length) {
-            const result = await this.galleryService.getExtensions(compatibleGalleryExtensionsToFetch, { targetPlatform, compatible: true, queryAllVersions: true, productVersion }, CancellationToken.None);
+            const result = await this.galleryService.getExtensions(compatibleGalleryExtensionsToFetch, {
+                targetPlatform,
+                compatible: true,
+                queryAllVersions: true,
+                productVersion
+            }, CancellationToken.None);
             compatibleGalleryExtensions.push(...result);
         }
         return this.mapInstalledExtensionWithGalleryExtension(compatibleGalleryExtensions);
     }
     mapInstalledExtensionWithGalleryExtension(galleryExtensions) {
         const mappedExtensions = [];
-        const byUUID = ( new Map()), byID = ( new Map());
+        const byUUID = ( new Map()),
+              byID = ( new Map());
         for (const gallery of galleryExtensions) {
             byUUID.set(gallery.identifier.uuid, gallery);
             byID.set(gallery.identifier.id.toLowerCase(), gallery);
@@ -644,7 +706,7 @@ let Extensions = class Extensions extends Disposable {
                     continue;
                 }
             }
-            if (installed.local?.source !== 'resource') {
+            if (installed.local?.source !== "resource") {
                 const gallery = byID.get(installed.identifier.id.toLowerCase());
                 if (gallery) {
                     mappedExtensions.push([installed, gallery]);
@@ -656,44 +718,62 @@ let Extensions = class Extensions extends Disposable {
     async updateMetadata(localExtension, gallery) {
         let isPreReleaseVersion = false;
         if (localExtension.manifest.version !== gallery.version) {
-            this.telemetryService.publicLog2('galleryService:updateMetadata');
-            const galleryWithLocalVersion = (await this.galleryService.getExtensions([{ ...localExtension.identifier, version: localExtension.manifest.version }], CancellationToken.None))[0];
+            this.telemetryService.publicLog2("galleryService:updateMetadata");
+            const galleryWithLocalVersion = (await this.galleryService.getExtensions([{
+                ...localExtension.identifier,
+                version: localExtension.manifest.version
+            }], CancellationToken.None))[0];
             isPreReleaseVersion = !!galleryWithLocalVersion?.properties?.isPreReleaseVersion;
         }
-        return this.workbenchExtensionManagementService.updateMetadata(localExtension, { id: gallery.identifier.uuid, publisherDisplayName: gallery.publisherDisplayName, publisherId: gallery.publisherId, isPreReleaseVersion });
+        return this.workbenchExtensionManagementService.updateMetadata(localExtension, {
+            id: gallery.identifier.uuid,
+            publisherDisplayName: gallery.publisherDisplayName,
+            publisherId: gallery.publisherId,
+            isPreReleaseVersion
+        });
     }
     canInstall(galleryExtension) {
         return this.server.extensionManagementService.canInstall(galleryExtension);
     }
     onInstallExtension(event) {
-        const { source } = event;
+        const {
+            source
+        } = event;
         if (source && !URI.isUri(source)) {
-            const extension = this.installed.find(e => areSameExtensions(e.identifier, source.identifier))
-                ?? this.instantiationService.createInstance(Extension, this.stateProvider, this.runtimeStateProvider, this.server, undefined, source, undefined);
+            const extension = this.installed.find(e => areSameExtensions(e.identifier, source.identifier)) ?? this.instantiationService.createInstance(
+                Extension,
+                this.stateProvider,
+                this.runtimeStateProvider,
+                this.server,
+                undefined,
+                source,
+                undefined
+            );
             this.installing.push(extension);
-            this._onChange.fire({ extension });
+            this._onChange.fire({
+                extension
+            });
         }
     }
     async fetchInstalledExtensions(productVersion) {
         const extensionsControlManifest = await this.server.extensionManagementService.getExtensionsControlManifest();
         const all = await this.server.extensionManagementService.getInstalled(undefined, undefined, productVersion);
         if (this.isWorkspaceServer) {
-            all.push(...(await this.workbenchExtensionManagementService.getInstalledWorkspaceExtensions(true)));
+            all.push(
+                ...(await this.workbenchExtensionManagementService.getInstalledWorkspaceExtensions(true))
+            );
         }
         const installed = groupByExtension(all, r => r.identifier).reduce((result, extensions) => {
             if (extensions.length === 1) {
                 result.push(extensions[0]);
-            }
-            else {
+            } else {
                 let workspaceExtension, userExtension, systemExtension;
                 for (const extension of extensions) {
                     if (extension.isWorkspaceScoped) {
                         workspaceExtension = extension;
-                    }
-                    else if (extension.type === ExtensionType.User) {
+                    } else if (extension.type === ExtensionType.User) {
                         userExtension = extension;
-                    }
-                    else {
+                    } else {
                         systemExtension = extension;
                     }
                 }
@@ -706,7 +786,15 @@ let Extensions = class Extensions extends Disposable {
         }, []);
         const byId = index(this.installed, e => e.local ? e.local.identifier.id : e.identifier.id);
         this.installed = ( installed.map(local => {
-            const extension = byId[local.identifier.id] || this.instantiationService.createInstance(Extension, this.stateProvider, this.runtimeStateProvider, this.server, local, undefined, undefined);
+            const extension = byId[local.identifier.id] || this.instantiationService.createInstance(
+                Extension,
+                this.stateProvider,
+                this.runtimeStateProvider,
+                this.server,
+                local,
+                undefined,
+                undefined
+            );
             extension.local = local;
             extension.enablementState = this.extensionEnablementService.getEnablementState(local);
             extension.setExtensionsControlManifest(extensionsControlManifest);
@@ -723,21 +811,29 @@ let Extensions = class Extensions extends Disposable {
     async onDidInstallExtensions(results) {
         const extensions = [];
         for (const event of results) {
-            const { local, source } = event;
+            const {
+                local,
+                source
+            } = event;
             const gallery = source && !URI.isUri(source) ? source : undefined;
             const location = source && URI.isUri(source) ? source : undefined;
             const installingExtension = gallery ? this.installing.filter(e => areSameExtensions(e.identifier, gallery.identifier))[0] : null;
             this.installing = installingExtension ? this.installing.filter(e => e !== installingExtension) : this.installing;
-            let extension = installingExtension ? installingExtension
-                : (location || local) ? this.instantiationService.createInstance(Extension, this.stateProvider, this.runtimeStateProvider, this.server, local, undefined, undefined)
-                    : undefined;
+            let extension = installingExtension ? installingExtension : (location || local) ? this.instantiationService.createInstance(
+                Extension,
+                this.stateProvider,
+                this.runtimeStateProvider,
+                this.server,
+                local,
+                undefined,
+                undefined
+            ) : undefined;
             if (extension) {
                 if (local) {
                     const installed = this.installed.filter(e => areSameExtensions(e.identifier, extension.identifier))[0];
                     if (installed) {
                         extension = installed;
-                    }
-                    else {
+                    } else {
                         this.installed.push(extension);
                     }
                     extension.local = local;
@@ -748,7 +844,10 @@ let Extensions = class Extensions extends Disposable {
                 }
                 extensions.push(extension);
             }
-            this._onChange.fire(!local || !extension ? undefined : { extension, operation: event.operation });
+            this._onChange.fire(!local || !extension ? undefined : {
+                extension,
+                operation: event.operation
+            });
         }
         if (extensions.length) {
             const manifest = await this.server.extensionManagementService.getExtensionsControlManifest();
@@ -762,23 +861,33 @@ let Extensions = class Extensions extends Disposable {
         const extension = this.installed.find(e => areSameExtensions(e.identifier, local.identifier));
         if (extension?.local) {
             extension.local = local;
-            this._onChange.fire({ extension });
+            this._onChange.fire({
+                extension
+            });
         }
     }
     async matchInstalledExtensionsWithGallery(extensions) {
-        const toMatch = extensions.filter(e => e.local && !e.gallery && e.local.source !== 'resource');
+        const toMatch = extensions.filter(e => e.local && !e.gallery && e.local.source !== "resource");
         if (!toMatch.length) {
             return;
         }
         if (!this.galleryService.isEnabled()) {
             return;
         }
-        const galleryExtensions = await this.galleryService.getExtensions(( toMatch.map(e => ({ ...e.identifier, preRelease: e.local?.preRelease }))), { compatible: true, targetPlatform: await this.server.extensionManagementService.getTargetPlatform() }, CancellationToken.None);
+        const galleryExtensions = await this.galleryService.getExtensions(( toMatch.map(e => ({
+            ...e.identifier,
+            preRelease: e.local?.preRelease
+        }))), {
+            compatible: true,
+            targetPlatform: await this.server.extensionManagementService.getTargetPlatform()
+        }, CancellationToken.None);
         for (const extension of extensions) {
             const compatible = galleryExtensions.find(e => areSameExtensions(e.identifier, extension.identifier));
             if (compatible) {
                 extension.gallery = compatible;
-                this._onChange.fire({ extension });
+                this._onChange.fire({
+                    extension
+                });
             }
         }
     }
@@ -786,18 +895,30 @@ let Extensions = class Extensions extends Disposable {
         const extension = this.installed.filter(e => areSameExtensions(e.identifier, identifier))[0];
         if (extension) {
             const uninstalling = this.uninstalling.filter(e => areSameExtensions(e.identifier, identifier))[0] || extension;
-            this.uninstalling = [uninstalling, ...this.uninstalling.filter(e => !areSameExtensions(e.identifier, identifier))];
-            this._onChange.fire(uninstalling ? { extension: uninstalling } : undefined);
+            this.uninstalling = [
+                uninstalling,
+                ...this.uninstalling.filter(e => !areSameExtensions(e.identifier, identifier))
+            ];
+            this._onChange.fire(uninstalling ? {
+                extension: uninstalling
+            } : undefined);
         }
     }
-    onDidUninstallExtension({ identifier, error }) {
+    onDidUninstallExtension(
+        {
+            identifier,
+            error
+        }
+    ) {
         const uninstalled = this.uninstalling.find(e => areSameExtensions(e.identifier, identifier)) || this.installed.find(e => areSameExtensions(e.identifier, identifier));
         this.uninstalling = this.uninstalling.filter(e => !areSameExtensions(e.identifier, identifier));
         if (!error) {
             this.installed = this.installed.filter(e => !areSameExtensions(e.identifier, identifier));
         }
         if (uninstalled) {
-            this._onChange.fire({ extension: uninstalled });
+            this._onChange.fire({
+                extension: uninstalled
+            });
         }
     }
     onEnablementChanged(platformExtensions) {
@@ -807,7 +928,9 @@ let Extensions = class Extensions extends Disposable {
                 const enablementState = this.extensionEnablementService.getEnablementState(extension.local);
                 if (enablementState !== extension.enablementState) {
                     extension.enablementState = enablementState;
-                    this._onChange.fire({ extension });
+                    this._onChange.fire({
+                        extension
+                    });
                 }
             }
         }
@@ -821,23 +944,64 @@ let Extensions = class Extensions extends Disposable {
         if (( this.uninstalling.some(e => areSameExtensions(e.identifier, extension.identifier)))) {
             return ExtensionState.Uninstalling;
         }
-        const local = this.installed.filter(e => e === extension || (e.gallery && extension.gallery && areSameExtensions(e.gallery.identifier, extension.gallery.identifier)))[0];
+        const local = this.installed.filter(
+            e => e === extension || (e.gallery && extension.gallery && areSameExtensions(e.gallery.identifier, extension.gallery.identifier))
+        )[0];
         return local ? ExtensionState.Installed : ExtensionState.Uninstalled;
     }
 };
-Extensions = ( __decorate([
-    ( __param(4, IExtensionGalleryService)),
-    ( __param(5, IWorkbenchExtensionEnablementService)),
-    ( __param(6, IWorkbenchExtensionManagementService)),
-    ( __param(7, ITelemetryService)),
-    ( __param(8, IInstantiationService))
-], Extensions));
+Extensions = ( __decorate([( __param(4, IExtensionGalleryService)), ( __param(5, IWorkbenchExtensionEnablementService)), ( __param(6, IWorkbenchExtensionManagementService)), ( __param(7, ITelemetryService)), ( __param(8, IInstantiationService))], Extensions));
 let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Disposable {
-    static { ExtensionsWorkbenchService_1 = this; }
-    static { this.UpdatesCheckInterval = 1000 * 60 * 60 * 12; }
-    get onChange() { return this._onChange.event; }
-    get onReset() { return this._onReset.event; }
-    constructor(instantiationService, editorService, extensionManagementService, galleryService, extensionGalleryManifestService, configurationService, telemetryService, notificationService, urlService, extensionEnablementService, hostService, progressService, extensionManagementServerService, languageService, extensionsSyncManagementService, userDataAutoSyncService, productService, contextKeyService, extensionManifestPropertiesService, logService, extensionService, localeService, lifecycleService, fileService, userDataProfileService, userDataProfilesService, storageService, dialogService, userDataSyncEnablementService, updateService, uriIdentityService, workspaceContextService, viewsService, fileDialogService, quickInputService, allowedExtensionsService) {
+    static {
+        ExtensionsWorkbenchService_1 = this;
+    }
+    static {
+        this.UpdatesCheckInterval = 1000 * 60 * 60 * 12;
+    }
+    get onChange() {
+        return this._onChange.event;
+    }
+    get onReset() {
+        return this._onReset.event;
+    }
+    constructor(
+        instantiationService,
+        editorService,
+        extensionManagementService,
+        galleryService,
+        extensionGalleryManifestService,
+        configurationService,
+        telemetryService,
+        notificationService,
+        urlService,
+        extensionEnablementService,
+        hostService,
+        progressService,
+        extensionManagementServerService,
+        languageService,
+        extensionsSyncManagementService,
+        userDataAutoSyncService,
+        productService,
+        contextKeyService,
+        extensionManifestPropertiesService,
+        logService,
+        extensionService,
+        localeService,
+        lifecycleService,
+        fileService,
+        userDataProfileService,
+        userDataProfilesService,
+        storageService,
+        dialogService,
+        userDataSyncEnablementService,
+        updateService,
+        uriIdentityService,
+        workspaceContextService,
+        viewsService,
+        fileDialogService,
+        quickInputService,
+        allowedExtensionsService
+    ) {
         super();
         this.instantiationService = instantiationService;
         this.editorService = editorService;
@@ -886,19 +1050,41 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         this.autoRestartListenerDisposable = this._register(( new MutableDisposable()));
         this.hasOutdatedExtensionsContextKey = HasOutdatedExtensionsContext.bindTo(contextKeyService);
         if (extensionManagementServerService.localExtensionManagementServer) {
-            this.localExtensions = this._register(instantiationService.createInstance(Extensions, extensionManagementServerService.localExtensionManagementServer, ext => this.getExtensionState(ext), ext => this.getRuntimeState(ext), !extensionManagementServerService.remoteExtensionManagementServer));
-            this._register(this.localExtensions.onChange(e => this.onDidChangeExtensions(e?.extension)));
+            this.localExtensions = this._register(instantiationService.createInstance(
+                Extensions,
+                extensionManagementServerService.localExtensionManagementServer,
+                ext => this.getExtensionState(ext),
+                ext => this.getRuntimeState(ext),
+                !extensionManagementServerService.remoteExtensionManagementServer
+            ));
+            this._register(
+                this.localExtensions.onChange(e => this.onDidChangeExtensions(e?.extension))
+            );
             this._register(this.localExtensions.onReset(e => this.reset()));
             this.extensionsServers.push(this.localExtensions);
         }
         if (extensionManagementServerService.remoteExtensionManagementServer) {
-            this.remoteExtensions = this._register(instantiationService.createInstance(Extensions, extensionManagementServerService.remoteExtensionManagementServer, ext => this.getExtensionState(ext), ext => this.getRuntimeState(ext), true));
-            this._register(this.remoteExtensions.onChange(e => this.onDidChangeExtensions(e?.extension)));
+            this.remoteExtensions = this._register(instantiationService.createInstance(
+                Extensions,
+                extensionManagementServerService.remoteExtensionManagementServer,
+                ext => this.getExtensionState(ext),
+                ext => this.getRuntimeState(ext),
+                true
+            ));
+            this._register(
+                this.remoteExtensions.onChange(e => this.onDidChangeExtensions(e?.extension))
+            );
             this._register(this.remoteExtensions.onReset(e => this.reset()));
             this.extensionsServers.push(this.remoteExtensions);
         }
         if (extensionManagementServerService.webExtensionManagementServer) {
-            this.webExtensions = this._register(instantiationService.createInstance(Extensions, extensionManagementServerService.webExtensionManagementServer, ext => this.getExtensionState(ext), ext => this.getRuntimeState(ext), !(extensionManagementServerService.remoteExtensionManagementServer || extensionManagementServerService.localExtensionManagementServer)));
+            this.webExtensions = this._register(instantiationService.createInstance(
+                Extensions,
+                extensionManagementServerService.webExtensionManagementServer,
+                ext => this.getExtensionState(ext),
+                ext => this.getRuntimeState(ext),
+                !(extensionManagementServerService.remoteExtensionManagementServer || extensionManagementServerService.localExtensionManagementServer)
+            ));
             this._register(this.webExtensions.onChange(e => this.onDidChangeExtensions(e?.extension)));
             this._register(this.webExtensions.onReset(e => this.reset()));
             this.extensionsServers.push(this.webExtensions);
@@ -913,12 +1099,20 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         this.whenInitialized = this.initialize();
     }
     async initialize() {
-        await Promise.all([this.queryLocal(), this.extensionService.whenInstalledExtensionsRegistered()]);
+        await Promise.all([
+            this.queryLocal(),
+            this.extensionService.whenInstalledExtensionsRegistered()
+        ]);
         if (this._store.isDisposed) {
             return;
         }
         this.onDidChangeRunningExtensions(this.extensionService.extensions, []);
-        this._register(this.extensionService.onDidChangeExtensions(({ added, removed }) => this.onDidChangeRunningExtensions(added, removed)));
+        this._register(this.extensionService.onDidChangeExtensions((
+            {
+                added,
+                removed
+            }
+        ) => this.onDidChangeRunningExtensions(added, removed)));
         await this.lifecycleService.when(LifecyclePhase.Eventually);
         if (this._store.isDisposed) {
             return;
@@ -926,9 +1120,15 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         this.initializeAutoUpdate();
         this.updateExtensionsNotificaiton();
         this.reportInstalledExtensionsTelemetry();
-        this._register(this.storageService.onDidChangeValue(StorageScope.PROFILE, EXTENSIONS_DISMISSED_NOTIFICATIONS_KEY, this._store)(e => this.onDidDismissedNotificationsValueChange()));
-        this._register(this.storageService.onDidChangeValue(StorageScope.APPLICATION, EXTENSIONS_AUTO_UPDATE_KEY, this._store)(e => this.onDidSelectedExtensionToAutoUpdateValueChange()));
-        this._register(this.storageService.onDidChangeValue(StorageScope.APPLICATION, EXTENSIONS_DONOT_AUTO_UPDATE_KEY, this._store)(e => this.onDidSelectedExtensionToAutoUpdateValueChange()));
+        this._register(
+            this.storageService.onDidChangeValue(StorageScope.PROFILE, EXTENSIONS_DISMISSED_NOTIFICATIONS_KEY, this._store)(e => this.onDidDismissedNotificationsValueChange())
+        );
+        this._register(
+            this.storageService.onDidChangeValue(StorageScope.APPLICATION, EXTENSIONS_AUTO_UPDATE_KEY, this._store)(e => this.onDidSelectedExtensionToAutoUpdateValueChange())
+        );
+        this._register(
+            this.storageService.onDidChangeValue(StorageScope.APPLICATION, EXTENSIONS_DONOT_AUTO_UPDATE_KEY, this._store)(e => this.onDidSelectedExtensionToAutoUpdateValueChange())
+        );
         this._register(Event.debounce(this.onChange, () => undefined, 100)(() => {
             this.updateExtensionsNotificaiton();
             this.reportProgressFromOtherSources();
@@ -947,25 +1147,31 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
                 }
             }
         }));
-        this._register(this.extensionEnablementService.onEnablementChanged(platformExtensions => {
-            if (this.getAutoUpdateValue() === 'onlyEnabledExtensions' && ( platformExtensions.some(e => this.extensionEnablementService.isEnabled(e)))) {
-                this.checkForUpdates('Extension enablement changed');
-            }
-        }));
-        this._register(Event.debounce(this.onChange, () => undefined, 100)(() => this.hasOutdatedExtensionsContextKey.set(this.outdated.length > 0)));
+        this._register(
+            this.extensionEnablementService.onEnablementChanged(platformExtensions => {
+                if (this.getAutoUpdateValue() === "onlyEnabledExtensions" && ( platformExtensions.some(e => this.extensionEnablementService.isEnabled(e)))) {
+                    this.checkForUpdates("Extension enablement changed");
+                }
+            })
+        );
+        this._register(
+            Event.debounce(this.onChange, () => undefined, 100)(() => this.hasOutdatedExtensionsContextKey.set(this.outdated.length > 0))
+        );
         this._register(this.updateService.onStateChange(e => {
             if ((e.type === StateType.CheckingForUpdates && e.explicit) || e.type === StateType.AvailableForDownload || e.type === StateType.Downloaded) {
-                this.telemetryService.publicLog2('extensions:updatecheckonproductupdate');
+                this.telemetryService.publicLog2("extensions:updatecheckonproductupdate");
                 if (this.isAutoCheckUpdatesEnabled()) {
-                    this.checkForUpdates('Product update');
+                    this.checkForUpdates("Product update");
                 }
             }
         }));
-        this._register(this.allowedExtensionsService.onDidChangeAllowedExtensionsConfigValue(() => {
-            if (this.isAutoCheckUpdatesEnabled()) {
-                this.checkForUpdates('Allowed extensions changed');
-            }
-        }));
+        this._register(
+            this.allowedExtensionsService.onDidChangeAllowedExtensionsConfigValue(() => {
+                if (this.isAutoCheckUpdatesEnabled()) {
+                    this.checkForUpdates("Allowed extensions changed");
+                }
+            })
+        );
         this.hasOutdatedExtensionsContextKey.set(this.outdated.length > 0);
         this.eventuallyCheckForUpdates(true);
         if (isWeb) {
@@ -986,10 +1192,10 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
     }
     getAutoUpdateValue() {
         const autoUpdate = this.configurationService.getValue(AutoUpdateConfigurationKey);
-        if (autoUpdate === 'onlySelectedExtensions') {
+        if (autoUpdate === "onlySelectedExtensions") {
             return false;
         }
-        return isBoolean(autoUpdate) || autoUpdate === 'onlyEnabledExtensions' ? autoUpdate : true;
+        return isBoolean(autoUpdate) || autoUpdate === "onlyEnabledExtensions" ? autoUpdate : true;
     }
     async updateAutoUpdateForAllExtensions(isAutoUpdateEnabled) {
         const wasAutoUpdateEnabled = this.isAutoUpdateEnabled();
@@ -997,14 +1203,12 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             return;
         }
         const result = await this.dialogService.confirm({
-            title: ( localize(7788, "Auto Update Extensions")),
-            message: isAutoUpdateEnabled
-                ? ( localize(7789, "Do you want to enable auto update for all extensions?"))
-                : ( localize(7790, "Do you want to disable auto update for all extensions?")),
+            title: ( localize(8100, "Auto Update Extensions")),
+            message: isAutoUpdateEnabled ? ( localize(8101, "Do you want to enable auto update for all extensions?")) : ( localize(8102, "Do you want to disable auto update for all extensions?")),
             detail: ( localize(
-                7791,
+                8103,
                 "This will reset any auto update settings you have set for individual extensions."
-            )),
+            ))
         });
         if (!result.confirmed) {
             return;
@@ -1026,21 +1230,25 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         }
     }
     reportInstalledExtensionsTelemetry() {
-        const extensionIds = ( this.installed.filter(extension => !extension.isBuiltin &&
-            (extension.enablementState === EnablementState.EnabledWorkspace ||
-                extension.enablementState === EnablementState.EnabledGlobally))
-            .map(extension => ExtensionIdentifier.toKey(extension.identifier.id)));
-        this.telemetryService.publicLog2('installedExtensions', { extensionIds: ( new TelemetryTrustedValue(extensionIds.join(';'))), count: extensionIds.length });
+        const extensionIds = ( this.installed.filter(
+            extension => !extension.isBuiltin && (extension.enablementState === EnablementState.EnabledWorkspace || extension.enablementState === EnablementState.EnabledGlobally)
+        ).map(extension => ExtensionIdentifier.toKey(extension.identifier.id)));
+        this.telemetryService.publicLog2("installedExtensions", {
+            extensionIds: ( new TelemetryTrustedValue(extensionIds.join(";"))),
+            count: extensionIds.length
+        });
     }
     async onDidChangeRunningExtensions(added, removed) {
         const changedExtensions = [];
         const extensionsToFetch = [];
         for (const desc of added) {
-            const extension = this.installed.find(e => areSameExtensions({ id: desc.identifier.value, uuid: desc.uuid }, e.identifier));
+            const extension = this.installed.find(e => areSameExtensions({
+                id: desc.identifier.value,
+                uuid: desc.uuid
+            }, e.identifier));
             if (extension) {
                 changedExtensions.push(extension);
-            }
-            else {
+            } else {
                 extensionsToFetch.push(desc);
             }
         }
@@ -1048,13 +1256,15 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         for (const desc of removed) {
             if (this.workspaceContextService.isInsideWorkspace(desc.extensionLocation)) {
                 workspaceExtensions.push(desc);
-            }
-            else {
+            } else {
                 extensionsToFetch.push(desc);
             }
         }
         if (extensionsToFetch.length) {
-            const extensions = await this.getExtensions(( extensionsToFetch.map(e => ({ id: e.identifier.value, uuid: e.uuid }))), CancellationToken.None);
+            const extensions = await this.getExtensions(( extensionsToFetch.map(e => ({
+                id: e.identifier.value,
+                uuid: e.uuid
+            }))), CancellationToken.None);
             changedExtensions.push(...extensions);
         }
         if (workspaceExtensions.length) {
@@ -1068,7 +1278,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
     updateExtensionsPinnedState(pinned) {
         return this.progressService.withProgress({
             location: ProgressLocation.Extensions,
-            title: ( localize(7792, "Updating Extensions Auto Update State")),
+            title: ( localize(8104, "Updating Extensions Auto Update State"))
         }, () => this.extensionManagementService.resetPinnedStateForAllUserExtensions(pinned));
     }
     reset() {
@@ -1089,8 +1299,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         if (!this._local) {
             if (this.extensionsServers.length === 1) {
                 this._local = this.installed;
-            }
-            else {
+            } else {
                 this._local = [];
                 const byId = groupByExtension(this.installed, r => r.identifier);
                 for (const extensions of byId) {
@@ -1129,24 +1338,21 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         if (this.localExtensions) {
             try {
                 await this.localExtensions.queryInstalled(this.getProductVersion());
-            }
-            catch (error) {
+            } catch (error) {
                 this.logService.error(error);
             }
         }
         if (this.remoteExtensions) {
             try {
                 await this.remoteExtensions.queryInstalled(this.getProductVersion());
-            }
-            catch (error) {
+            } catch (error) {
                 this.logService.error(error);
             }
         }
         if (this.webExtensions) {
             try {
                 await this.webExtensions.queryInstalled(this.getProductVersion());
-            }
-            catch (error) {
+            } catch (error) {
                 this.logService.error(error);
             }
         }
@@ -1178,7 +1384,9 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         if (!this.galleryService.isEnabled()) {
             return [];
         }
-        extensionInfos.forEach(e => e.preRelease = e.preRelease ?? this.extensionManagementService.preferPreReleases);
+        extensionInfos.forEach(
+            e => e.preRelease = e.preRelease ?? this.extensionManagementService.preferPreReleases
+        );
         const extensionsControlManifest = await this.extensionManagementService.getExtensionsControlManifest();
         const galleryExtensions = await this.galleryService.getExtensions(extensionInfos, arg1, arg2);
         this.syncInstalledExtensionsWithGallery(galleryExtensions);
@@ -1187,8 +1395,18 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
     async getResourceExtensions(locations, isWorkspaceScoped) {
         const resourceExtensions = await this.extensionManagementService.getExtensions(locations);
         return ( resourceExtensions.map(
-            resourceExtension => this.getInstalledExtensionMatchingLocation(resourceExtension.location)
-                ?? this.instantiationService.createInstance(Extension, ext => this.getExtensionState(ext), ext => this.getRuntimeState(ext), undefined, undefined, undefined, { resourceExtension, isWorkspaceScoped })
+            resourceExtension => this.getInstalledExtensionMatchingLocation(resourceExtension.location) ?? this.instantiationService.createInstance(
+                Extension,
+                ext => this.getExtensionState(ext),
+                ext => this.getRuntimeState(ext),
+                undefined,
+                undefined,
+                undefined,
+                {
+                    resourceExtension,
+                    isWorkspaceScoped
+                }
+            )
         ));
     }
     onDidDismissedNotificationsValueChange() {
@@ -1216,7 +1434,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
                     dismiss: () => {
                         this.setDismissedNotifications([...this.getDismissedNotifications(), computedNotificiations[0].key]);
                         this.updateExtensionsNotificaiton();
-                    },
+                    }
                 };
             }
         }
@@ -1231,53 +1449,57 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         const disallowedExtensions = this.local.filter(e => e.enablementState === EnablementState.DisabledByAllowlist);
         if (disallowedExtensions.length) {
             computedNotificiations.push({
-                message: this.configurationService.inspect(AllowedExtensionsConfigKey).policy
-                    ? ( localize(
-                    7793,
+                message: this.configurationService.inspect(AllowedExtensionsConfigKey).policy ? ( localize(
+                    8105,
                     "Some extensions are disabled because they are not allowed by your system administrator."
-                ))
-                    : ( localize(
-                    7794,
+                )) : ( localize(
+                    8106,
                     "Some extensions are disabled because they are configured not to be allowed."
                 )),
                 severity: Severity$1.Warning,
                 extensions: disallowedExtensions,
-                key: 'disallowedExtensions:' + ( disallowedExtensions.sort((a, b) => a.identifier.id.localeCompare(b.identifier.id)).map(e => e.identifier.id.toLowerCase())).join('-'),
+                key: "disallowedExtensions:" + ( disallowedExtensions.sort((a, b) => a.identifier.id.localeCompare(b.identifier.id)).map(e => e.identifier.id.toLowerCase())).join("-")
             });
         }
-        const invalidExtensions = this.local.filter(e => e.enablementState === EnablementState.DisabledByInvalidExtension && !e.isWorkspaceScoped);
+        const invalidExtensions = this.local.filter(
+            e => e.enablementState === EnablementState.DisabledByInvalidExtension && !e.isWorkspaceScoped
+        );
         if (invalidExtensions.length) {
-            if (( invalidExtensions.some(e => e.local && e.local.manifest.engines?.vscode &&
-                (!isEngineValid(e.local.manifest.engines.vscode, this.productService.version, this.productService.date) || areApiProposalsCompatible([...(e.local.manifest.enabledApiProposals ?? [])]))))) {
+            if (( invalidExtensions.some(e => e.local && e.local.manifest.engines?.vscode && (!isEngineValid(
+                e.local.manifest.engines.vscode,
+                this.productService.version,
+                this.productService.date
+            ) || areApiProposalsCompatible([...(e.local.manifest.enabledApiProposals ?? [])]))))) {
                 computedNotificiations.push({
                     message: ( localize(
-                        7795,
+                        8107,
                         "Some extensions are disabled due to version incompatibility. Review and update them."
                     )),
                     severity: Severity$1.Warning,
                     extensions: invalidExtensions,
-                    key: 'incompatibleExtensions:' + ( invalidExtensions.sort((a, b) => a.identifier.id.localeCompare(b.identifier.id)).map(e => `${e.identifier.id.toLowerCase()}@${e.local?.manifest.version}`)).join('-'),
+                    key: "incompatibleExtensions:" + ( invalidExtensions.sort((a, b) => a.identifier.id.localeCompare(b.identifier.id)).map(e => `${e.identifier.id.toLowerCase()}@${e.local?.manifest.version}`)).join("-")
                 });
-            }
-            else {
+            } else {
                 computedNotificiations.push({
-                    message: ( localize(7796, "Invalid extensions detected. Review them.")),
+                    message: ( localize(8108, "Invalid extensions detected. Review them.")),
                     severity: Severity$1.Warning,
                     extensions: invalidExtensions,
-                    key: 'invalidExtensions:' + ( invalidExtensions.sort((a, b) => a.identifier.id.localeCompare(b.identifier.id)).map(e => `${e.identifier.id.toLowerCase()}@${e.local?.manifest.version}`)).join('-'),
+                    key: "invalidExtensions:" + ( invalidExtensions.sort((a, b) => a.identifier.id.localeCompare(b.identifier.id)).map(e => `${e.identifier.id.toLowerCase()}@${e.local?.manifest.version}`)).join("-")
                 });
             }
         }
-        const deprecatedExtensions = this.local.filter(e => !!e.deprecationInfo && e.local && this.extensionEnablementService.isEnabled(e.local));
+        const deprecatedExtensions = this.local.filter(
+            e => !!e.deprecationInfo && e.local && this.extensionEnablementService.isEnabled(e.local)
+        );
         if (deprecatedExtensions.length) {
             computedNotificiations.push({
                 message: ( localize(
-                    7797,
+                    8109,
                     "Deprecated extensions detected. Review them and migrate to alternatives."
                 )),
                 severity: Severity$1.Warning,
                 extensions: deprecatedExtensions,
-                key: 'deprecatedExtensions:' + ( deprecatedExtensions.sort((a, b) => a.identifier.id.localeCompare(b.identifier.id)).map(e => e.identifier.id.toLowerCase())).join('-'),
+                key: "deprecatedExtensions:" + ( deprecatedExtensions.sort((a, b) => a.identifier.id.localeCompare(b.identifier.id)).map(e => e.identifier.id.toLowerCase())).join("-")
             });
         }
         return computedNotificiations;
@@ -1294,8 +1516,8 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
                 const keywords = lookup[ext] || [];
                 const languageId = this.languageService.guessLanguageIdByFilepathOrFirstLine(URI.file(`.${ext}`));
                 const languageName = languageId && this.languageService.getLanguageName(languageId);
-                const languageTag = languageName ? ` tag:"${languageName}"` : '';
-                return `tag:"__ext_${ext}" tag:"__ext_.${ext}" ${( keywords.map(tag => `tag:"${tag}"`)).join(' ')}${languageTag} tag:"${ext}"`;
+                const languageTag = languageName ? ` tag:"${languageName}"` : "";
+                return `tag:"__ext_${ext}" tag:"__ext_.${ext}" ${( keywords.map(tag => `tag:"${tag}"`)).join(" ")}${languageTag} tag:"${ext}"`;
             });
         }
         return text.substr(0, 350);
@@ -1303,7 +1525,15 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
     fromGallery(gallery, extensionsControlManifest) {
         let extension = this.getInstalledExtensionMatchingGallery(gallery);
         if (!extension) {
-            extension = this.instantiationService.createInstance(Extension, ext => this.getExtensionState(ext), ext => this.getRuntimeState(ext), undefined, undefined, gallery, undefined);
+            extension = this.instantiationService.createInstance(
+                Extension,
+                ext => this.getExtensionState(ext),
+                ext => this.getRuntimeState(ext),
+                undefined,
+                undefined,
+                gallery,
+                undefined
+            );
             extension.setExtensionsControlManifest(extensionsControlManifest);
         }
         return extension;
@@ -1314,8 +1544,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
                 if (installed.identifier.uuid === gallery.identifier.uuid) {
                     return installed;
                 }
-            }
-            else if (installed.local?.source !== 'resource') {
+            } else if (installed.local?.source !== "resource") {
                 if (areSameExtensions(installed.identifier, gallery.identifier)) {
                     return installed;
                 }
@@ -1324,17 +1553,27 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         return null;
     }
     getInstalledExtensionMatchingLocation(location) {
-        return this.local.find(e => e.local && this.uriIdentityService.extUri.isEqualOrParent(location, e.local?.location)) ?? null;
+        return this.local.find(
+            e => e.local && this.uriIdentityService.extUri.isEqualOrParent(location, e.local?.location)
+        ) ?? null;
     }
     async open(extension, options) {
-        if (typeof extension === 'string') {
+        if (typeof extension === "string") {
             const id = extension;
-            extension = this.installed.find(e => areSameExtensions(e.identifier, { id })) ?? (await this.getExtensions([{ id: extension }], CancellationToken.None))[0];
+            extension = this.installed.find(e => areSameExtensions(e.identifier, {
+                id
+            })) ?? (await this.getExtensions([{
+                id: extension
+            }], CancellationToken.None))[0];
         }
         if (!extension) {
             throw ( new Error(`Extension not found. ${extension}`));
         }
-        await this.editorService.openEditor(this.instantiationService.createInstance(ExtensionsInput, extension), options, options?.sideByside ? SIDE_GROUP : ACTIVE_GROUP);
+        await this.editorService.openEditor(
+            this.instantiationService.createInstance(ExtensionsInput, extension),
+            options,
+            options?.sideByside ? SIDE_GROUP : ACTIVE_GROUP
+        );
     }
     async openSearch(searchValue, preserveFoucs) {
         const viewPaneContainer = (await this.viewsService.openViewContainer(VIEWLET_ID, true))?.getViewPaneContainer();
@@ -1346,13 +1585,18 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
     getExtensionRuntimeStatus(extension) {
         const extensionsStatus = this.extensionService.getExtensionsStatus();
         for (const id of ( Object.keys(extensionsStatus))) {
-            if (areSameExtensions({ id }, extension.identifier)) {
+            if (areSameExtensions({
+                id
+            }, extension.identifier)) {
                 return extensionsStatus[id];
             }
         }
         return undefined;
     }
-    async updateRunningExtensions(message = ( localize(7798, "Changing extension enablement")), auto = false) {
+    async updateRunningExtensions(
+        message = ( localize(8110, "Changing extension enablement")),
+        auto = false
+    ) {
         const toAdd = [];
         const toRemove = [];
         const extensionsToCheck = [...this.local];
@@ -1370,13 +1614,15 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             }
             const isEnabled = this.extensionEnablementService.isEnabled(extension.local);
             if (isEnabled) {
-                const runningExtension = this.extensionService.extensions.find(e => areSameExtensions({ id: e.identifier.value, uuid: e.uuid }, extension.identifier));
+                const runningExtension = this.extensionService.extensions.find(e => areSameExtensions({
+                    id: e.identifier.value,
+                    uuid: e.uuid
+                }, extension.identifier));
                 if (runningExtension) {
                     toRemove.push(runningExtension.identifier.value);
                 }
                 toAdd.push(extension.local);
-            }
-            else {
+            } else {
                 toRemove.push(extension.identifier.id);
             }
         }
@@ -1384,43 +1630,53 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             if (extension.isUnderDevelopment) {
                 continue;
             }
-            if (( extensionsToCheck.some(
-                e => areSameExtensions({ id: extension.identifier.value, uuid: extension.uuid }, e.local?.identifier ?? e.identifier)
-            ))) {
+            if (( extensionsToCheck.some(e => areSameExtensions({
+                id: extension.identifier.value,
+                uuid: extension.uuid
+            }, e.local?.identifier ?? e.identifier)))) {
                 continue;
             }
             toRemove.push(extension.identifier.value);
         }
         if (toAdd.length || toRemove.length) {
             if (await this.extensionService.stopExtensionHosts(message, auto)) {
-                await this.extensionService.startExtensionHosts({ toAdd, toRemove });
+                await this.extensionService.startExtensionHosts({
+                    toAdd,
+                    toRemove
+                });
                 if (auto) {
                     this.notificationService.notify({
                         severity: Severity$1.Info,
-                        message: ( localize(7799, "Extensions were auto restarted to enable updates.")),
+                        message: ( localize(8111, "Extensions were auto restarted to enable updates.")),
                         priority: NotificationPriority.SILENT
                     });
                 }
-                this.telemetryService.publicLog2('extensions:autorestart', { count: toAdd.length + toRemove.length, auto });
+                this.telemetryService.publicLog2("extensions:autorestart", {
+                    count: toAdd.length + toRemove.length,
+                    auto
+                });
             }
         }
     }
     getRuntimeState(extension) {
         const isUninstalled = extension.state === ExtensionState.Uninstalled;
-        const runningExtension = this.extensionService.extensions.find(e => areSameExtensions({ id: e.identifier.value }, extension.identifier));
+        const runningExtension = this.extensionService.extensions.find(e => areSameExtensions({
+            id: e.identifier.value
+        }, extension.identifier));
         const reloadAction = this.extensionManagementServerService.remoteExtensionManagementServer ? ExtensionRuntimeActionType.ReloadWindow : ExtensionRuntimeActionType.RestartExtensions;
-        const reloadActionLabel = reloadAction === ExtensionRuntimeActionType.ReloadWindow ? ( localize(7800, "reload window")) : ( localize(7801, "restart extensions"));
+        const reloadActionLabel = reloadAction === ExtensionRuntimeActionType.ReloadWindow ? ( localize(8112, "reload window")) : ( localize(8113, "restart extensions"));
         if (isUninstalled) {
             const canRemoveRunningExtension = runningExtension && this.extensionService.canRemoveExtension(runningExtension);
-            const isSameExtensionRunning = runningExtension
-                && (!extension.server || extension.server === this.extensionManagementServerService.getExtensionManagementServer(toExtension(runningExtension)))
-                && (!extension.resourceExtension || this.uriIdentityService.extUri.isEqual(extension.resourceExtension.location, runningExtension.extensionLocation));
+            const isSameExtensionRunning = runningExtension && (!extension.server || extension.server === this.extensionManagementServerService.getExtensionManagementServer(toExtension(runningExtension))) && (!extension.resourceExtension || this.uriIdentityService.extUri.isEqual(extension.resourceExtension.location, runningExtension.extensionLocation));
             if (!canRemoveRunningExtension && isSameExtensionRunning && !runningExtension.isUnderDevelopment) {
-                return { action: reloadAction, reason: ( localize(
-                    7802,
-                    "Please {0} to complete the uninstallation of this extension.",
-                    reloadActionLabel
-                )) };
+                return {
+                    action: reloadAction,
+                    reason: ( localize(
+                        8114,
+                        "Please {0} to complete the uninstallation of this extension.",
+                        reloadActionLabel
+                    ))
+                };
             }
             return undefined;
         }
@@ -1437,82 +1693,123 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
                         if (!runningExtension.isUnderDevelopment && (extension.version !== runningExtension.version || extension.local.targetPlatform !== runningExtension.targetPlatform)) {
                             const productCurrentVersion = this.getProductCurrentVersion();
                             const productUpdateVersion = this.getProductUpdateVersion();
-                            if (productUpdateVersion
-                                && !isEngineValid(extension.local.manifest.engines.vscode, productCurrentVersion.version, productCurrentVersion.date)
-                                && isEngineValid(extension.local.manifest.engines.vscode, productUpdateVersion.version, productUpdateVersion.date)) {
+                            if (productUpdateVersion && !isEngineValid(
+                                extension.local.manifest.engines.vscode,
+                                productCurrentVersion.version,
+                                productCurrentVersion.date
+                            ) && isEngineValid(
+                                extension.local.manifest.engines.vscode,
+                                productUpdateVersion.version,
+                                productUpdateVersion.date
+                            )) {
                                 const state = this.updateService.state;
                                 if (state.type === StateType.AvailableForDownload) {
-                                    return { action: ExtensionRuntimeActionType.DownloadUpdate, reason: ( localize(
-                                        7803,
-                                        "Please update {0} to enable the updated extension.",
-                                        this.productService.nameLong
-                                    )) };
+                                    return {
+                                        action: ExtensionRuntimeActionType.DownloadUpdate,
+                                        reason: ( localize(
+                                            8115,
+                                            "Please update {0} to enable the updated extension.",
+                                            this.productService.nameLong
+                                        ))
+                                    };
                                 }
                                 if (state.type === StateType.Downloaded) {
-                                    return { action: ExtensionRuntimeActionType.ApplyUpdate, reason: ( localize(
-                                        7804,
-                                        "Please update {0} to enable the updated extension.",
-                                        this.productService.nameLong
-                                    )) };
+                                    return {
+                                        action: ExtensionRuntimeActionType.ApplyUpdate,
+                                        reason: ( localize(
+                                            8116,
+                                            "Please update {0} to enable the updated extension.",
+                                            this.productService.nameLong
+                                        ))
+                                    };
                                 }
                                 if (state.type === StateType.Ready) {
-                                    return { action: ExtensionRuntimeActionType.QuitAndInstall, reason: ( localize(
-                                        7805,
-                                        "Please restart {0} to enable the updated extension.",
-                                        this.productService.nameLong
-                                    )) };
+                                    return {
+                                        action: ExtensionRuntimeActionType.QuitAndInstall,
+                                        reason: ( localize(
+                                            8117,
+                                            "Please restart {0} to enable the updated extension.",
+                                            this.productService.nameLong
+                                        ))
+                                    };
                                 }
                                 return undefined;
                             }
-                            return { action: reloadAction, reason: ( localize(7806, "Please {0} to enable the updated extension.", reloadActionLabel)) };
+                            return {
+                                action: reloadAction,
+                                reason: ( localize(8118, "Please {0} to enable the updated extension.", reloadActionLabel))
+                            };
                         }
                         if (this.extensionsServers.length > 1) {
-                            const extensionInOtherServer = this.installed.filter(e => areSameExtensions(e.identifier, extension.identifier) && e.server !== extension.server)[0];
+                            const extensionInOtherServer = this.installed.filter(
+                                e => areSameExtensions(e.identifier, extension.identifier) && e.server !== extension.server
+                            )[0];
                             if (extensionInOtherServer) {
                                 if (runningExtensionServer === this.extensionManagementServerService.remoteExtensionManagementServer && this.extensionManifestPropertiesService.prefersExecuteOnUI(extension.local.manifest) && extensionInOtherServer.server === this.extensionManagementServerService.localExtensionManagementServer) {
-                                    return { action: reloadAction, reason: ( localize(7807, "Please {0} to enable this extension locally.", reloadActionLabel)) };
+                                    return {
+                                        action: reloadAction,
+                                        reason: ( localize(8119, "Please {0} to enable this extension locally.", reloadActionLabel))
+                                    };
                                 }
                                 if (runningExtensionServer === this.extensionManagementServerService.localExtensionManagementServer && this.extensionManifestPropertiesService.prefersExecuteOnWorkspace(extension.local.manifest) && extensionInOtherServer.server === this.extensionManagementServerService.remoteExtensionManagementServer) {
-                                    return { action: reloadAction, reason: ( localize(
-                                        7808,
-                                        "Please {0} to enable this extension in {1}.",
-                                        reloadActionLabel,
-                                        this.extensionManagementServerService.remoteExtensionManagementServer?.label
-                                    )) };
+                                    return {
+                                        action: reloadAction,
+                                        reason: ( localize(
+                                            8120,
+                                            "Please {0} to enable this extension in {1}.",
+                                            reloadActionLabel,
+                                            this.extensionManagementServerService.remoteExtensionManagementServer?.label
+                                        ))
+                                    };
                                 }
                             }
                         }
-                    }
-                    else {
+                    } else {
                         if (extension.server === this.extensionManagementServerService.localExtensionManagementServer && runningExtensionServer === this.extensionManagementServerService.remoteExtensionManagementServer) {
                             if (this.extensionManifestPropertiesService.prefersExecuteOnUI(extension.local.manifest)) {
-                                return { action: reloadAction, reason: ( localize(7809, "Please {0} to enable this extension.", reloadActionLabel)) };
+                                return {
+                                    action: reloadAction,
+                                    reason: ( localize(8121, "Please {0} to enable this extension.", reloadActionLabel))
+                                };
                             }
                         }
                         if (extension.server === this.extensionManagementServerService.remoteExtensionManagementServer && runningExtensionServer === this.extensionManagementServerService.localExtensionManagementServer) {
                             if (this.extensionManifestPropertiesService.prefersExecuteOnWorkspace(extension.local.manifest)) {
-                                return { action: reloadAction, reason: ( localize(7809, "Please {0} to enable this extension.", reloadActionLabel)) };
+                                return {
+                                    action: reloadAction,
+                                    reason: ( localize(8121, "Please {0} to enable this extension.", reloadActionLabel))
+                                };
                             }
                         }
                     }
                     return undefined;
-                }
-                else {
+                } else {
                     if (isSameExtensionRunning) {
-                        return { action: reloadAction, reason: ( localize(7810, "Please {0} to disable this extension.", reloadActionLabel)) };
+                        return {
+                            action: reloadAction,
+                            reason: ( localize(8122, "Please {0} to disable this extension.", reloadActionLabel))
+                        };
                     }
                 }
                 return undefined;
             }
             else {
                 if (isEnabled && !this.extensionService.canAddExtension(toExtensionDescription(extension.local))) {
-                    return { action: reloadAction, reason: ( localize(7809, "Please {0} to enable this extension.", reloadActionLabel)) };
+                    return {
+                        action: reloadAction,
+                        reason: ( localize(8121, "Please {0} to enable this extension.", reloadActionLabel))
+                    };
                 }
                 const otherServer = extension.server ? extension.server === this.extensionManagementServerService.localExtensionManagementServer ? this.extensionManagementServerService.remoteExtensionManagementServer : this.extensionManagementServerService.localExtensionManagementServer : null;
                 if (otherServer && extension.enablementState === EnablementState.DisabledByExtensionKind) {
-                    const extensionInOtherServer = this.local.filter(e => areSameExtensions(e.identifier, extension.identifier) && e.server === otherServer)[0];
+                    const extensionInOtherServer = this.local.filter(
+                        e => areSameExtensions(e.identifier, extension.identifier) && e.server === otherServer
+                    )[0];
                     if (extensionInOtherServer && extensionInOtherServer.local && this.extensionEnablementService.isEnabled(extensionInOtherServer.local)) {
-                        return { action: reloadAction, reason: ( localize(7809, "Please {0} to enable this extension.", reloadActionLabel)) };
+                        return {
+                            action: reloadAction,
+                            reason: ( localize(8121, "Please {0} to enable this extension.", reloadActionLabel))
+                        };
                     }
                 }
             }
@@ -1536,21 +1833,21 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         let extension = extensionsToChoose.find(extension => {
             for (const extensionKind of extensionKinds) {
                 switch (extensionKind) {
-                    case 'ui':
-                        if (extension.server === this.extensionManagementServerService.localExtensionManagementServer) {
-                            return true;
-                        }
-                        return false;
-                    case 'workspace':
-                        if (extension.server === this.extensionManagementServerService.remoteExtensionManagementServer) {
-                            return true;
-                        }
-                        return false;
-                    case 'web':
-                        if (extension.server === this.extensionManagementServerService.webExtensionManagementServer) {
-                            return true;
-                        }
-                        return false;
+                case "ui":
+                    if (extension.server === this.extensionManagementServerService.localExtensionManagementServer) {
+                        return true;
+                    }
+                    return false;
+                case "workspace":
+                    if (extension.server === this.extensionManagementServerService.remoteExtensionManagementServer) {
+                        return true;
+                    }
+                    return false;
+                case "web":
+                    if (extension.server === this.extensionManagementServerService.webExtensionManagementServer) {
+                        return true;
+                    }
+                    return false;
                 }
             }
             return false;
@@ -1559,16 +1856,16 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             extension = extensionsToChoose.find(extension => {
                 for (const extensionKind of extensionKinds) {
                     switch (extensionKind) {
-                        case 'workspace':
-                            if (extension.server === this.extensionManagementServerService.localExtensionManagementServer) {
-                                return true;
-                            }
-                            return false;
-                        case 'web':
-                            if (extension.server === this.extensionManagementServerService.localExtensionManagementServer) {
-                                return true;
-                            }
-                            return false;
+                    case "workspace":
+                        if (extension.server === this.extensionManagementServerService.localExtensionManagementServer) {
+                            return true;
+                        }
+                        return false;
+                    case "web":
+                        if (extension.server === this.extensionManagementServerService.localExtensionManagementServer) {
+                            return true;
+                        }
+                        return false;
                     }
                 }
                 return false;
@@ -1578,11 +1875,11 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             extension = extensionsToChoose.find(extension => {
                 for (const extensionKind of extensionKinds) {
                     switch (extensionKind) {
-                        case 'web':
-                            if (extension.server === this.extensionManagementServerService.webExtensionManagementServer) {
-                                return true;
-                            }
-                            return false;
+                    case "web":
+                        if (extension.server === this.extensionManagementServerService.webExtensionManagementServer) {
+                            return true;
+                        }
+                        return false;
                     }
                 }
                 return false;
@@ -1592,11 +1889,11 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             extension = extensionsToChoose.find(extension => {
                 for (const extensionKind of extensionKinds) {
                     switch (extensionKind) {
-                        case 'web':
-                            if (extension.server === this.extensionManagementServerService.remoteExtensionManagementServer) {
-                                return true;
-                            }
-                            return false;
+                    case "web":
+                        if (extension.server === this.extensionManagementServerService.remoteExtensionManagementServer) {
+                            return true;
+                        }
+                        return false;
                     }
                 }
                 return false;
@@ -1630,8 +1927,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
     async checkForUpdates(reason, onlyBuiltin) {
         if (reason) {
             this.logService.trace(`[Extensions]: Checking for updates. Reason: ${reason}`);
-        }
-        else {
+        } else {
             this.logService.trace(`[Extensions]: Checking for updates`);
         }
         if (!this.galleryService.isEnabled()) {
@@ -1658,18 +1954,25 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             if (installed.isBuiltin && !installed.local?.pinned && (installed.type === ExtensionType.System || !installed.local?.identifier.uuid)) {
                 continue;
             }
-            if (installed.local?.source === 'resource') {
+            if (installed.local?.source === "resource") {
                 continue;
             }
-            infos.push({ ...installed.identifier, preRelease: !!installed.local?.preRelease });
+            infos.push({
+                ...installed.identifier,
+                preRelease: !!installed.local?.preRelease
+            });
         }
         if (infos.length) {
             const targetPlatform = await extensions[0].server.extensionManagementService.getTargetPlatform();
-            this.telemetryService.publicLog2('galleryService:checkingForUpdates', {
-                count: infos.length,
+            this.telemetryService.publicLog2("galleryService:checkingForUpdates", {
+                count: infos.length
             });
-            this.logService.trace(`Checking updates for extensions`, ( infos.map(e => e.id)).join(', '));
-            const galleryExtensions = await this.galleryService.getExtensions(infos, { targetPlatform, compatible: true, productVersion: this.getProductVersion() }, CancellationToken.None);
+            this.logService.trace(`Checking updates for extensions`, ( infos.map(e => e.id)).join(", "));
+            const galleryExtensions = await this.galleryService.getExtensions(infos, {
+                targetPlatform,
+                compatible: true,
+                productVersion: this.getProductVersion()
+            }, CancellationToken.None);
             if (galleryExtensions.length) {
                 await this.syncInstalledExtensionsWithGallery(galleryExtensions, infos);
             }
@@ -1677,7 +1980,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
     }
     async updateAll() {
         const toUpdate = [];
-        this.outdated.forEach((extension) => {
+        this.outdated.forEach(extension => {
             if (extension.gallery) {
                 toUpdate.push({
                     extension: extension.gallery,
@@ -1686,7 +1989,9 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
                         installPreReleaseVersion: extension.local?.isPreReleaseVersion,
                         profileLocation: this.userDataProfileService.currentProfile.extensionsResource,
                         isApplicationScoped: extension.local?.isApplicationScoped,
-                        context: { [EXTENSION_INSTALL_SKIP_PUBLISHER_TRUST_CONTEXT]: true }
+                        context: {
+                            [EXTENSION_INSTALL_SKIP_PUBLISHER_TRUST_CONTEXT]: true
+                        }
                     }
                 });
             }
@@ -1695,78 +2000,100 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
     }
     async downloadVSIX(extensionId, versionKind) {
         let version;
-        if (versionKind === 'any') {
+        if (versionKind === "any") {
             version = await this.pickVersionToDownload(extensionId);
             if (!version) {
                 return;
             }
         }
-        const extensionInfo = version ? { id: extensionId, version: version.version } : { id: extensionId, preRelease: versionKind === 'prerelease' };
-        const queryOptions = version ? {} : { compatible: true };
+        const extensionInfo = version ? {
+            id: extensionId,
+            version: version.version
+        } : {
+            id: extensionId,
+            preRelease: versionKind === "prerelease"
+        };
+        const queryOptions = version ? {} : {
+            compatible: true
+        };
         let [galleryExtension] = await this.galleryService.getExtensions([extensionInfo], queryOptions, CancellationToken.None);
         if (!galleryExtension) {
-            throw ( new Error(( localize(7811, "Extension '{0}' not found.", extensionId))));
+            throw ( new Error(( localize(8123, "Extension '{0}' not found.", extensionId))));
         }
         let targetPlatform = galleryExtension.properties.targetPlatform;
         const options = [];
         for (const targetPlatform of version?.targetPlatforms ?? galleryExtension.allTargetPlatforms) {
             if (targetPlatform !== TargetPlatform.UNKNOWN && targetPlatform !== TargetPlatform.UNIVERSAL) {
                 options.push({
-                    label: targetPlatform === TargetPlatform.UNDEFINED ? ( localize(7812, "All Platforms")) : TargetPlatformToString(targetPlatform),
+                    label: targetPlatform === TargetPlatform.UNDEFINED ? ( localize(8124, "All Platforms")) : TargetPlatformToString(targetPlatform),
                     id: targetPlatform
                 });
             }
         }
         if (options.length > 1) {
-            const message = ( localize(7813, "Please select the platform for which you want to download the VSIX"));
-            const option = await this.quickInputService.pick(options.sort((a, b) => a.label.localeCompare(b.label)), { placeHolder: message });
+            const message = ( localize(8125, "Please select the platform for which you want to download the VSIX"));
+            const option = await this.quickInputService.pick(options.sort((a, b) => a.label.localeCompare(b.label)), {
+                placeHolder: message
+            });
             if (!option) {
                 return;
             }
             targetPlatform = option.id;
         }
         if (targetPlatform !== galleryExtension.properties.targetPlatform) {
-            [galleryExtension] = await this.galleryService.getExtensions([extensionInfo], { ...queryOptions, targetPlatform }, CancellationToken.None);
+            [galleryExtension] = await this.galleryService.getExtensions([extensionInfo], {
+                ...queryOptions,
+                targetPlatform
+            }, CancellationToken.None);
         }
         const result = await this.fileDialogService.showOpenDialog({
-            title: ( localize(7814, "Select folder to download the VSIX")),
+            title: ( localize(8126, "Select folder to download the VSIX")),
             canSelectFiles: false,
             canSelectFolders: true,
             canSelectMany: false,
-            openLabel: ( localize(7815, "Download")),
+            openLabel: ( localize(8127, "Download"))
         });
         if (!result?.[0]) {
             return;
         }
-        this.progressService.withProgress({ location: ProgressLocation.Notification }, async (progress) => {
+        this.progressService.withProgress({
+            location: ProgressLocation.Notification
+        }, async progress => {
             try {
-                progress.report({ message: ( localize(7816, "Downloading VSIX...")) });
-                const name = `${galleryExtension.identifier.id}-${galleryExtension.version}${targetPlatform !== TargetPlatform.UNDEFINED && targetPlatform !== TargetPlatform.UNIVERSAL && targetPlatform !== TargetPlatform.UNKNOWN ? `-${targetPlatform}` : ''}.vsix`;
-                await this.galleryService.download(galleryExtension, this.uriIdentityService.extUri.joinPath(result[0], name), InstallOperation.None);
-                this.notificationService.info(( localize(7817, "Successfully downloaded the VSIX")));
-            }
-            catch (error) {
-                this.notificationService.error(( localize(7818, "Error while downloading the VSIX: {0}", getErrorMessage(error))));
+                progress.report({
+                    message: ( localize(8128, "Downloading VSIX..."))
+                });
+                const name = `${galleryExtension.identifier.id}-${galleryExtension.version}${targetPlatform !== TargetPlatform.UNDEFINED && targetPlatform !== TargetPlatform.UNIVERSAL && targetPlatform !== TargetPlatform.UNKNOWN ? `-${targetPlatform}` : ""}.vsix`;
+                await this.galleryService.download(
+                    galleryExtension,
+                    this.uriIdentityService.extUri.joinPath(result[0], name),
+                    InstallOperation.None
+                );
+                this.notificationService.info(( localize(8129, "Successfully downloaded the VSIX")));
+            } catch (error) {
+                this.notificationService.error(( localize(8130, "Error while downloading the VSIX: {0}", getErrorMessage(error))));
             }
         });
     }
     async pickVersionToDownload(extensionId) {
-        const allVersions = await this.galleryService.getAllVersions({ id: extensionId });
+        const allVersions = await this.galleryService.getAllVersions({
+            id: extensionId
+        });
         if (!allVersions.length) {
-            await this.dialogService.info(( localize(7819, "This extension has no other versions.")));
+            await this.dialogService.info(( localize(8131, "This extension has no other versions.")));
             return;
         }
         const picks = ( allVersions.map((v, i) => {
             return {
                 id: v.version,
                 label: v.version,
-                description: `${fromNow(( new Date(Date.parse(v.date))), true)}${v.isPreReleaseVersion ? ` (${( localize(7820, "pre-release"))})` : ''}`,
-                ariaLabel: `${v.isPreReleaseVersion ? 'Pre-Release version' : 'Release version'} ${v.version}`,
-                data: v,
+                description: `${fromNow(( new Date(Date.parse(v.date))), true)}${v.isPreReleaseVersion ? ` (${( localize(8132, "pre-release"))})` : ""}`,
+                ariaLabel: `${v.isPreReleaseVersion ? "Pre-Release version" : "Release version"} ${v.version}`,
+                data: v
             };
         }));
         const pick = await this.quickInputService.pick(picks, {
-            placeHolder: ( localize(7821, "Select Version to Download")),
+            placeHolder: ( localize(8133, "Select Version to Download")),
             matchOnDetail: true
         });
         return pick?.data;
@@ -1789,7 +2116,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             extensions => extensions.syncInstalledExtensionsWithGallery(gallery, this.getProductVersion(), flagExtensionsMissingFromGallery)
         )));
         if (this.outdated.length) {
-            this.logService.info(`Auto updating outdated extensions.`, ( this.outdated.map(e => e.identifier.id)).join(', '));
+            this.logService.info(`Auto updating outdated extensions.`, ( this.outdated.map(e => e.identifier.id)).join(", "));
             this.eventuallyAutoUpdateExtensions();
         }
     }
@@ -1806,27 +2133,29 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         }, immediate ? 0 : this.getUpdatesCheckInterval()).then(undefined, err => null);
     }
     getUpdatesCheckInterval() {
-        if (this.productService.quality === 'insider' && this.getProductUpdateVersion()) {
+        if (this.productService.quality === "insider" && this.getProductUpdateVersion()) {
             return 1000 * 60 * 60 * 1;
         }
         return ExtensionsWorkbenchService_1.UpdatesCheckInterval;
     }
     eventuallyAutoUpdateExtensions() {
-        this.autoUpdateDelayer.trigger(() => this.autoUpdateExtensions())
-            .then(undefined, err => null);
+        this.autoUpdateDelayer.trigger(() => this.autoUpdateExtensions()).then(undefined, err => null);
     }
     async autoUpdateBuiltinExtensions() {
         await this.checkForUpdates(undefined, true);
         const toUpdate = this.outdated.filter(e => e.isBuiltin);
-        await Promises.settled(( toUpdate.map(
-            e => this.install(e, e.local?.preRelease ? { installPreReleaseVersion: true } : undefined)
-        )));
+        await Promises.settled(( toUpdate.map(e => this.install(e, e.local?.preRelease ? {
+            installPreReleaseVersion: true
+        } : undefined))));
     }
     async syncPinnedBuiltinExtensions() {
         const infos = [];
         for (const installed of this.local) {
             if (installed.isBuiltin && installed.local?.pinned && installed.local?.identifier.uuid) {
-                infos.push({ ...installed.identifier, version: installed.version });
+                infos.push({
+                    ...installed.identifier,
+                    version: installed.version
+                });
             }
         }
         if (infos.length) {
@@ -1852,34 +2181,44 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             toUpdate.push(extension);
         }
         if (disabledAutoUpdate.length) {
-            this.logService.trace('Auto update disabled for extensions', disabledAutoUpdate.join(', '));
+            this.logService.trace("Auto update disabled for extensions", disabledAutoUpdate.join(", "));
         }
         if (consentRequired.length) {
-            this.logService.info('Auto update consent required for extensions', consentRequired.join(', '));
+            this.logService.info("Auto update consent required for extensions", consentRequired.join(", "));
         }
         if (!toUpdate.length) {
             return;
         }
         const productVersion = this.getProductVersion();
-        await Promises.settled(( toUpdate.map(
-            e => this.install(e, e.local?.preRelease ? { installPreReleaseVersion: true, productVersion } : { productVersion })
-        )));
+        await Promises.settled(( toUpdate.map(e => this.install(e, e.local?.preRelease ? {
+            installPreReleaseVersion: true,
+            productVersion
+        } : {
+            productVersion
+        }))));
     }
     getProductVersion() {
         return this.getProductUpdateVersion() ?? this.getProductCurrentVersion();
     }
     getProductCurrentVersion() {
-        return { version: this.productService.version, date: this.productService.date };
+        return {
+            version: this.productService.version,
+            date: this.productService.date
+        };
     }
     getProductUpdateVersion() {
         switch (this.updateService.state.type) {
-            case StateType.AvailableForDownload:
-            case StateType.Downloaded:
-            case StateType.Updating:
-            case StateType.Ready: {
+        case StateType.AvailableForDownload:
+        case StateType.Downloaded:
+        case StateType.Updating:
+        case StateType.Ready:
+            {
                 const version = this.updateService.state.update.productVersion;
                 if (version && semverExports.valid(version)) {
-                    return { version, date: this.updateService.state.update.timestamp ? ( new Date(this.updateService.state.update.timestamp)).toISOString() : undefined };
+                    return {
+                        version,
+                        date: this.updateService.state.update.timestamp ? ( new Date(this.updateService.state.update.timestamp)).toISOString() : undefined
+                    };
                 }
             }
         }
@@ -1911,7 +2250,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         if (autoUpdateValue === true) {
             return true;
         }
-        if (autoUpdateValue === 'onlyEnabledExtensions') {
+        if (autoUpdateValue === "onlyEnabledExtensions") {
             return extension.enablementState !== EnablementState.DisabledGlobally && extension.enablementState !== EnablementState.DisabledWorkspace;
         }
         return false;
@@ -1925,7 +2264,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         }
         if (extension.local.identifier.uuid && extension.local.identifier.uuid !== extension.gallery.identifier.uuid) {
             return localize(
-                7822,
+                8134,
                 "The marketplace metadata of this extension changed, likely due to a re-publish."
             );
         }
@@ -1936,17 +2275,14 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             if (!extension.gallery.properties.executesCode) {
                 return;
             }
-        }
-        else {
-            const manifest = extension instanceof Extension
-                ? await extension.getGalleryManifest()
-                : await this.galleryService.getManifest(extension.gallery, CancellationToken.None);
+        } else {
+            const manifest = extension instanceof Extension ? await extension.getGalleryManifest() : await this.galleryService.getManifest(extension.gallery, CancellationToken.None);
             if (!manifest?.main && !manifest?.browser) {
                 return;
             }
         }
         return localize(
-            7823,
+            8135,
             "The update for {0} extension introduces executable code, which is not present in the currently installed version.",
             extension.displayName
         );
@@ -1954,7 +2290,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
     isAutoUpdateEnabledFor(extensionOrPublisher) {
         if (isString(extensionOrPublisher)) {
             if (EXTENSION_IDENTIFIER_REGEX.test(extensionOrPublisher)) {
-                throw ( new Error('Expected publisher string, found extension identifier'));
+                throw ( new Error("Expected publisher string, found extension identifier"));
             }
             if (this.isAutoUpdateEnabled()) {
                 return true;
@@ -1970,7 +2306,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
     async updateAutoUpdateEnablementFor(extensionOrPublisher, enable) {
         if (this.isAutoUpdateEnabled()) {
             if (isString(extensionOrPublisher)) {
-                throw ( new Error('Expected extension, found publisher string'));
+                throw ( new Error("Expected extension, found publisher string"));
             }
             const disabledAutoUpdateExtensions = this.getDisabledAutoUpdateExtensions();
             const extensionId = extensionOrPublisher.identifier.id.toLowerCase();
@@ -1979,30 +2315,29 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
                 if (extensionIndex !== -1) {
                     disabledAutoUpdateExtensions.splice(extensionIndex, 1);
                 }
-            }
-            else {
+            } else {
                 if (extensionIndex === -1) {
                     disabledAutoUpdateExtensions.push(extensionId);
                 }
             }
             this.setDisabledAutoUpdateExtensions(disabledAutoUpdateExtensions);
             if (enable && extensionOrPublisher.local && extensionOrPublisher.pinned) {
-                await this.extensionManagementService.updateMetadata(extensionOrPublisher.local, { pinned: false });
+                await this.extensionManagementService.updateMetadata(extensionOrPublisher.local, {
+                    pinned: false
+                });
             }
             this._onChange.fire(extensionOrPublisher);
-        }
-        else {
+        } else {
             const enabledAutoUpdateExtensions = this.getEnabledAutoUpdateExtensions();
             if (isString(extensionOrPublisher)) {
                 if (EXTENSION_IDENTIFIER_REGEX.test(extensionOrPublisher)) {
-                    throw ( new Error('Expected publisher string, found extension identifier'));
+                    throw ( new Error("Expected publisher string, found extension identifier"));
                 }
                 extensionOrPublisher = extensionOrPublisher.toLowerCase();
                 if (this.isAutoUpdateEnabledFor(extensionOrPublisher) !== enable) {
                     if (enable) {
                         enabledAutoUpdateExtensions.push(extensionOrPublisher);
-                    }
-                    else {
+                    } else {
                         if (enabledAutoUpdateExtensions.includes(extensionOrPublisher)) {
                             enabledAutoUpdateExtensions.splice(enabledAutoUpdateExtensions.indexOf(extensionOrPublisher), 1);
                         }
@@ -2014,8 +2349,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
                         this._onChange.fire(e);
                     }
                 }
-            }
-            else {
+            } else {
                 const extensionId = extensionOrPublisher.identifier.id.toLowerCase();
                 const enableAutoUpdatesForPublisher = this.isAutoUpdateEnabledFor(extensionOrPublisher.publisher.toLowerCase());
                 const enableAutoUpdatesForExtension = enabledAutoUpdateExtensions.includes(extensionId);
@@ -2028,8 +2362,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
                         if (enableAutoUpdatesForExtension) {
                             enabledAutoUpdateExtensions.splice(enabledAutoUpdateExtensions.indexOf(extensionId), 1);
                         }
-                    }
-                    else {
+                    } else {
                         if (!enableAutoUpdatesForExtension) {
                             enabledAutoUpdateExtensions.push(extensionId);
                         }
@@ -2043,8 +2376,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
                         if (!disableAutoUpdatesForExtension) {
                             enabledAutoUpdateExtensions.push(`-${extensionId}`);
                         }
-                    }
-                    else {
+                    } else {
                         if (disableAutoUpdatesForExtension) {
                             enabledAutoUpdateExtensions.splice(enabledAutoUpdateExtensions.indexOf(`-${extensionId}`), 1);
                         }
@@ -2059,17 +2391,15 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         }
     }
     onDidSelectedExtensionToAutoUpdateValueChange() {
-        if (this.enabledAuotUpdateExtensionsValue !== this.getEnabledAutoUpdateExtensionsValue()
-            || this.disabledAutoUpdateExtensionsValue !== this.getDisabledAutoUpdateExtensionsValue() ) {
+        if (this.enabledAuotUpdateExtensionsValue !== this.getEnabledAutoUpdateExtensionsValue()  || this.disabledAutoUpdateExtensionsValue !== this.getDisabledAutoUpdateExtensionsValue() ) {
             const userExtensions = this.installed.filter(e => !e.isBuiltin);
-            const groupBy = (extensions) => {
+            const groupBy = extensions => {
                 const shouldAutoUpdate = [];
                 const shouldNotAutoUpdate = [];
                 for (const extension of extensions) {
                     if (this.shouldAutoUpdateExtension(extension)) {
                         shouldAutoUpdate.push(extension);
-                    }
-                    else {
+                    } else {
                         shouldNotAutoUpdate.push(extension);
                     }
                 }
@@ -2093,17 +2423,20 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
     }
     async canInstall(extension) {
         if (!(extension instanceof Extension)) {
-            return ( new MarkdownString()).appendText(( localize(7824, "The provided object is not an extension.")));
+            return ( new MarkdownString()).appendText(( localize(8136, "The provided object is not an extension.")));
         }
         if (extension.isMalicious) {
-            return ( new MarkdownString()).appendText(( localize(7825, "This extension is reported to be problematic.")));
+            return ( new MarkdownString()).appendText(( localize(8137, "This extension is reported to be problematic.")));
         }
         if (extension.deprecationInfo?.disallowInstall) {
-            return ( new MarkdownString()).appendText(( localize(7826, "This extension is disallowed to be installed.")));
+            return ( new MarkdownString()).appendText(( localize(8138, "This extension is disallowed to be installed.")));
         }
         if (extension.gallery) {
-            if (!extension.gallery.isSigned && shouldRequireRepositorySignatureFor(extension.private, await this.extensionGalleryManifestService.getExtensionGalleryManifest())) {
-                return ( new MarkdownString()).appendText(( localize(7827, "This extension is not signed.")));
+            if (!extension.gallery.isSigned && shouldRequireRepositorySignatureFor(
+                extension.private,
+                await this.extensionGalleryManifestService.getExtensionGalleryManifest()
+            )) {
+                return ( new MarkdownString()).appendText(( localize(8139, "This extension is not signed.")));
             }
             const localResult = this.localExtensions ? await this.localExtensions.canInstall(extension.gallery) : undefined;
             if (localResult === true) {
@@ -2118,7 +2451,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
                 return true;
             }
             return localResult ?? remoteResult ?? webResult ?? ( new MarkdownString()).appendText(( localize(
-                7828,
+                8140,
                 "Cannot install the '{0}' extension because it is not available in this setup.",
                 extension.displayName ?? extension.identifier.id
             )));
@@ -2127,7 +2460,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             return true;
         }
         return ( new MarkdownString()).appendText(( localize(
-            7828,
+            8140,
             "Cannot install the '{0}' extension because it is not available in this setup.",
             extension.displayName ?? extension.identifier.id
         )));
@@ -2138,21 +2471,29 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         let servers;
         if (arg instanceof URI) {
             installable = arg;
-        }
-        else {
+        } else {
             let installableInfo;
             let gallery;
             if (isString(arg)) {
-                extension = this.local.find(e => areSameExtensions(e.identifier, { id: arg }));
+                extension = this.local.find(e => areSameExtensions(e.identifier, {
+                    id: arg
+                }));
                 if (!extension?.isBuiltin) {
-                    installableInfo = { id: arg, version: installOptions.version, preRelease: installOptions.installPreReleaseVersion ?? this.extensionManagementService.preferPreReleases };
+                    installableInfo = {
+                        id: arg,
+                        version: installOptions.version,
+                        preRelease: installOptions.installPreReleaseVersion ?? this.extensionManagementService.preferPreReleases
+                    };
                 }
             }
             else if (arg.gallery) {
                 extension = arg;
                 gallery = arg.gallery;
                 if (installOptions.version && installOptions.version !== gallery?.version) {
-                    installableInfo = { id: extension.identifier.id, version: installOptions.version };
+                    installableInfo = {
+                        id: extension.identifier.id,
+                        version: installOptions.version
+                    };
                 }
             }
             else if (arg.resourceExtension) {
@@ -2161,14 +2502,24 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             }
             if (installableInfo) {
                 const targetPlatform = extension?.server ? await extension.server.extensionManagementService.getTargetPlatform() : undefined;
-                gallery = (await this.galleryService.getExtensions([installableInfo], { targetPlatform }, CancellationToken.None)).at(0);
+                gallery = (await this.galleryService.getExtensions([installableInfo], {
+                    targetPlatform
+                }, CancellationToken.None)).at(0);
             }
             if (!extension && gallery) {
-                extension = this.instantiationService.createInstance(Extension, ext => this.getExtensionState(ext), ext => this.getRuntimeState(ext), undefined, undefined, gallery, undefined);
+                extension = this.instantiationService.createInstance(
+                    Extension,
+                    ext => this.getExtensionState(ext),
+                    ext => this.getRuntimeState(ext),
+                    undefined,
+                    undefined,
+                    gallery,
+                    undefined
+                );
                 extension.setExtensionsControlManifest(await this.extensionManagementService.getExtensionsControlManifest());
             }
             if (extension?.isMalicious) {
-                throw ( new Error(( localize(7825, "This extension is reported to be problematic."))));
+                throw ( new Error(( localize(8137, "This extension is reported to be problematic."))));
             }
             if (gallery) {
                 if (installOptions.installEverywhere) {
@@ -2197,13 +2548,13 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
                         const manifest = await this.extensionGalleryManifestService.getExtensionGalleryManifest();
                         const reportIssueUri = manifest ? getExtensionGalleryManifestResourceUri(manifest, ExtensionGalleryResourceType.ContactSupportUri) : undefined;
                         const reportIssueMessage = reportIssueUri ? ( localize(
-                            7829,
+                            8141,
                             "If this issue persists, please report it at {0}",
                             (reportIssueUri.toString())
-                        )) : '';
+                        )) : "";
                         if (installOptions.version) {
                             const message = ( localize(
-                                7830,
+                                8142,
                                 "The extension '{0}' cannot be installed because the requested version '{1}' was not found.",
                                 id,
                                 installOptions.version
@@ -2212,10 +2563,9 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
                                 reportIssueMessage ? `${message} ${reportIssueMessage}` : message,
                                 ExtensionManagementErrorCode.NotFound
                             ));
-                        }
-                        else {
+                        } else {
                             const message = ( localize(
-                                7831,
+                                8143,
                                 "The extension '{0}' cannot be installed because it was not found.",
                                 id
                             ));
@@ -2240,28 +2590,33 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
                 const syncCheck = isUndefined(installOptions.isMachineScoped) && this.userDataSyncEnablementService.isEnabled() && this.userDataSyncEnablementService.isResourceEnabled(SyncResource.Extensions);
                 const buttons = [];
                 buttons.push({
-                    label: isString(installOptions.justification) || !installOptions.justification.action
-                        ? ( localize(7832, "&&Install Extension"))
-                        : ( localize(7833, "&&Install Extension and {0}", installOptions.justification.action)), run: () => true
+                    label: isString(installOptions.justification) || !installOptions.justification.action ? ( localize(8144, "&&Install Extension")) : ( localize(8145, "&&Install Extension and {0}", installOptions.justification.action)),
+                    run: () => true
                 });
                 if (!extension) {
-                    buttons.push({ label: ( localize(7834, "Open Extension")), run: () => { this.open(extension); return false; } });
+                    buttons.push({
+                        label: ( localize(8146, "Open Extension")),
+                        run: () => {
+                            this.open(extension);
+                            return false;
+                        }
+                    });
                 }
                 const result = await this.dialogService.prompt({
-                    title: ( localize(7835, "Install Extension")),
+                    title: ( localize(8147, "Install Extension")),
                     message: extension ? ( localize(
-                        7836,
+                        8148,
                         "Would you like to install '{0}' extension from '{1}'?",
                         extension.displayName,
                         extension.publisherDisplayName
-                    )) : ( localize(7837, "Would you like to install the extension?")),
+                    )) : ( localize(8149, "Would you like to install the extension?")),
                     detail: isString(installOptions.justification) ? installOptions.justification : installOptions.justification.reason,
                     cancelButton: true,
                     buttons,
                     checkbox: syncCheck ? {
-                        label: ( localize(7838, "Sync this extension")),
-                        checked: true,
-                    } : undefined,
+                        label: ( localize(8150, "Sync this extension")),
+                        checked: true
+                    } : undefined
                 });
                 if (!result.result) {
                     throw ( new CancellationError());
@@ -2271,34 +2626,47 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
                 }
             }
             if (installable instanceof URI) {
-                extension = await this.doInstall(undefined, () => this.installFromVSIX(installable, installOptions), progressLocation);
-            }
-            else if (extension) {
+                extension = await this.doInstall(
+                    undefined,
+                    () => this.installFromVSIX(installable, installOptions),
+                    progressLocation
+                );
+            } else if (extension) {
                 if (extension.resourceExtension) {
-                    extension = await this.doInstall(extension, () => this.extensionManagementService.installResourceExtension(installable, installOptions), progressLocation);
-                }
-                else {
-                    extension = await this.doInstall(extension, () => this.installFromGallery(extension, installable, installOptions, servers), progressLocation);
+                    extension = await this.doInstall(
+                        extension,
+                        () => this.extensionManagementService.installResourceExtension(installable, installOptions),
+                        progressLocation
+                    );
+                } else {
+                    extension = await this.doInstall(
+                        extension,
+                        () => this.installFromGallery(extension, installable, installOptions, servers),
+                        progressLocation
+                    );
                 }
             }
         }
         if (!extension) {
-            throw ( new Error(( localize(7839, "Unable to install extension"))));
+            throw ( new Error(( localize(8151, "Unable to install extension"))));
         }
         if (installOptions.enable) {
             if (extension.enablementState === EnablementState.DisabledWorkspace || extension.enablementState === EnablementState.DisabledGlobally) {
                 if (installOptions.justification) {
                     const result = await this.dialogService.confirm({
-                        title: ( localize(7840, "Enable Extension")),
-                        message: ( localize(7841, "Would you like to enable '{0}' extension?", extension.displayName)),
+                        title: ( localize(8152, "Enable Extension")),
+                        message: ( localize(8153, "Would you like to enable '{0}' extension?", extension.displayName)),
                         detail: isString(installOptions.justification) ? installOptions.justification : installOptions.justification.reason,
-                        primaryButton: isString(installOptions.justification) ? ( localize(7842, "&&Enable Extension")) : ( localize(7843, "&&Enable Extension and {0}", installOptions.justification.action)),
+                        primaryButton: isString(installOptions.justification) ? ( localize(8154, "&&Enable Extension")) : ( localize(8155, "&&Enable Extension and {0}", installOptions.justification.action))
                     });
                     if (!result.confirmed) {
                         throw ( new CancellationError());
                     }
                 }
-                await this.setEnablement(extension, extension.enablementState === EnablementState.DisabledWorkspace ? EnablementState.EnabledWorkspace : EnablementState.EnabledGlobally);
+                await this.setEnablement(
+                    extension,
+                    extension.enablementState === EnablementState.DisabledWorkspace ? EnablementState.EnabledWorkspace : EnablementState.EnabledGlobally
+                );
             }
             await this.waitUntilExtensionIsEnabled(extension);
         }
@@ -2308,18 +2676,24 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         await this.doInstall(extension, async () => {
             const local = extension.local;
             if (!local) {
-                throw ( new Error('Extension not found'));
+                throw ( new Error("Extension not found"));
             }
             if (!extension.gallery) {
-                extension = (await this.getExtensions([{ ...extension.identifier, preRelease: local.preRelease }], CancellationToken.None))[0] ?? extension;
+                extension = (await this.getExtensions([{
+                    ...extension.identifier,
+                    preRelease: local.preRelease
+                }], CancellationToken.None))[0] ?? extension;
             }
             if (extension.gallery) {
-                return server.extensionManagementService.installFromGallery(extension.gallery, { installPreReleaseVersion: local.preRelease, ...installOptions });
+                return server.extensionManagementService.installFromGallery(extension.gallery, {
+                    installPreReleaseVersion: local.preRelease,
+                    ...installOptions
+                });
             }
             const targetPlatform = await server.extensionManagementService.getTargetPlatform();
             if (!isTargetPlatformCompatible(local.targetPlatform, [local.targetPlatform], targetPlatform)) {
                 throw ( new Error(( localize(
-                    7844,
+                    8156,
                     "Can't install '{0}' extension because it is not compatible.",
                     extension.identifier.id
                 ))));
@@ -2327,12 +2701,10 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             const vsix = await this.extensionManagementService.zip(local);
             try {
                 return await server.extensionManagementService.install(vsix);
-            }
-            finally {
+            } finally {
                 try {
                     await this.fileService.del(vsix);
-                }
-                catch (error) {
+                } catch (error) {
                     this.logService.error(error);
                 }
             }
@@ -2353,14 +2725,19 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
     }
     async setLanguage(extension) {
         if (!this.canSetLanguage(extension)) {
-            throw ( new Error('Can not set language'));
+            throw ( new Error("Can not set language"));
         }
         const locale = getLocale(extension.gallery);
         if (locale === language) {
             return;
         }
         const localizedLanguageName = extension.gallery?.properties?.localizedLanguages?.[0];
-        return this.localeService.setLocale({ id: locale, galleryExtension: extension.gallery, extensionId: extension.identifier.id, label: localizedLanguageName ?? extension.displayName });
+        return this.localeService.setLocale({
+            id: locale,
+            galleryExtension: extension.gallery,
+            extensionId: extension.identifier.id,
+            label: localizedLanguageName ?? extension.displayName
+        });
     }
     setEnablement(extensions, enablementState) {
         extensions = Array.isArray(extensions) ? extensions : [extensions];
@@ -2369,37 +2746,49 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
     async uninstall(e) {
         const extension = e.local ? e : this.local.find(local => areSameExtensions(local.identifier, e.identifier));
         if (!extension?.local) {
-            throw ( new Error('Missing local'));
+            throw ( new Error("Missing local"));
         }
         if (extension.local.isApplicationScoped && this.userDataProfilesService.profiles.length > 1) {
-            const { confirmed } = await this.dialogService.confirm({
-                title: ( localize(7845, "Uninstall Extension")),
+            const {
+                confirmed
+            } = await this.dialogService.confirm({
+                title: ( localize(8157, "Uninstall Extension")),
                 type: Severity$1.Info,
                 message: ( localize(
-                    7846,
+                    8158,
                     "Would you like to Uninstall {0} from all profiles?",
                     extension.displayName
                 )),
-                primaryButton: ( localize(7847, "Uninstall (All Profiles)"))
+                primaryButton: ( localize(8159, "Uninstall (All Profiles)"))
             });
             if (!confirmed) {
                 throw ( new CancellationError());
             }
         }
-        const extensionsToUninstall = [{ extension: extension.local }];
-        for (const packExtension of this.getAllPackedExtensions(extension, this.local)) {
-            if (packExtension.local && !( extensionsToUninstall.some(e => areSameExtensions(e.extension.identifier, packExtension.identifier)))) {
-                extensionsToUninstall.push({ extension: packExtension.local });
+        const extensionsToUninstall = [{
+            extension: extension.local
+        }];
+        if (this.productService.defaultChatAgent == null || !areSameExtensions(extension.identifier, {
+            id: this.productService.defaultChatAgent.extensionId
+        })) {
+            for (const packExtension of this.getAllPackedExtensions(extension, this.local)) {
+                if (packExtension.local && !( extensionsToUninstall.some(e => areSameExtensions(e.extension.identifier, packExtension.identifier)))) {
+                    extensionsToUninstall.push({
+                        extension: packExtension.local
+                    });
+                }
             }
         }
         const dependents = [];
         let extensionsFromAllProfiles;
-        for (const { extension } of extensionsToUninstall) {
+        for (const {
+            extension
+        } of extensionsToUninstall) {
             const installedExtensions = [];
             if (extension.isApplicationScoped && this.userDataProfilesService.profiles.length > 1) {
                 if (!extensionsFromAllProfiles) {
                     extensionsFromAllProfiles = [];
-                    await Promise.allSettled(( this.userDataProfilesService.profiles.map(async (profile) => {
+                    await Promise.allSettled(( this.userDataProfilesService.profiles.map(async profile => {
                         const installed = await this.extensionManagementService.getInstalled(ExtensionType.User, profile.extensionsResource);
                         for (const local of installed) {
                             extensionsFromAllProfiles?.push([local, profile.extensionsResource]);
@@ -2407,9 +2796,10 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
                     })));
                 }
                 installedExtensions.push(...extensionsFromAllProfiles);
-            }
-            else {
-                for (const { local } of this.local) {
+            } else {
+                for (const {
+                    local
+                } of this.local) {
                     if (local) {
                         installedExtensions.push([local, undefined]);
                     }
@@ -2422,29 +2812,40 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
                 if (!local.manifest.extensionDependencies || local.manifest.extensionDependencies.length === 0) {
                     continue;
                 }
-                if (extension.manifest.extensionPack?.some(id => areSameExtensions({ id }, local.identifier))) {
+                if (extension.manifest.extensionPack?.some(id => areSameExtensions({
+                    id
+                }, local.identifier))) {
                     continue;
                 }
-                if (( dependents.some(
-                    d => d.manifest.extensionPack?.some(id => areSameExtensions({ id }, local.identifier))
-                ))) {
+                if (( dependents.some(d => d.manifest.extensionPack?.some(id => areSameExtensions({
+                    id
+                }, local.identifier))))) {
                     continue;
                 }
-                if (( local.manifest.extensionDependencies.some(dep => areSameExtensions(extension.identifier, { id: dep })))) {
+                if (( local.manifest.extensionDependencies.some(dep => areSameExtensions(extension.identifier, {
+                    id: dep
+                })))) {
                     dependents.push(local);
-                    extensionsToUninstall.push({ extension: local, options: { profileLocation } });
+                    extensionsToUninstall.push({
+                        extension: local,
+                        options: {
+                            profileLocation
+                        }
+                    });
                 }
             }
         }
         if (dependents.length) {
-            const { result } = await this.dialogService.prompt({
-                title: ( localize(7848, "Uninstall Extension with Dependents")),
+            const {
+                result
+            } = await this.dialogService.prompt({
+                title: ( localize(8160, "Uninstall Extension with Dependents")),
                 type: Severity$1.Warning,
                 message: this.getErrorMessageForUninstallingAnExtensionWithDependents(extension, dependents),
                 buttons: [{
-                        label: ( localize(7849, "Uninstall All")),
-                        run: () => true
-                    }],
+                    label: ( localize(8161, "Uninstall All")),
+                    run: () => true
+                }],
                 cancelButton: {
                     run: () => false
                 }
@@ -2455,7 +2856,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         }
         return this.withProgress({
             location: ProgressLocation.Extensions,
-            title: ( localize(7850, 'Uninstalling extension...')),
+            title: ( localize(8162, "Uninstalling extension...")),
             source: `${extension.identifier.id}`
         }, () => this.extensionManagementService.uninstallExtensions(extensionsToUninstall).then(() => undefined));
     }
@@ -2468,7 +2869,9 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         if (extensionsPack.length) {
             const packedExtensions = [];
             for (const i of installed) {
-                if (!i.isBuiltin && ( extensionsPack.some(id => areSameExtensions({ id }, i.identifier)))) {
+                if (!i.isBuiltin && ( extensionsPack.some(id => areSameExtensions({
+                    id
+                }, i.identifier)))) {
                     packedExtensions.push(i);
                 }
             }
@@ -2483,7 +2886,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
     getErrorMessageForUninstallingAnExtensionWithDependents(extension, dependents) {
         if (dependents.length === 1) {
             return localize(
-                7851,
+                8163,
                 "Cannot uninstall '{0}' extension alone. '{1}' extension depends on this. Do you want to uninstall all these extensions?",
                 extension.displayName,
                 dependents[0].manifest.displayName
@@ -2491,7 +2894,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         }
         if (dependents.length === 2) {
             return localize(
-                7852,
+                8164,
                 "Cannot uninstall '{0}' extension alone. '{1}' and '{2}' extensions depend on this. Do you want to uninstall all these extensions?",
                 extension.displayName,
                 dependents[0].manifest.displayName,
@@ -2499,7 +2902,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             );
         }
         return localize(
-            7853,
+            8165,
             "Cannot uninstall '{0}' extension alone. '{1}', '{2}' and other extensions depend on this. Do you want to uninstall all these extensions?",
             extension.displayName,
             dependents[0].manifest.displayName,
@@ -2507,41 +2910,46 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         );
     }
     isExtensionIgnoredToSync(extension) {
-        return extension.local ? !this.isInstalledExtensionSynced(extension.local)
-            : this.extensionsSyncManagementService.hasToNeverSyncExtension(extension.identifier.id);
+        return extension.local ? !this.isInstalledExtensionSynced(extension.local) : this.extensionsSyncManagementService.hasToNeverSyncExtension(extension.identifier.id);
     }
     async togglePreRelease(extension) {
         if (!extension.local) {
             return;
         }
         if (extension.preRelease !== extension.isPreReleaseVersion) {
-            await this.extensionManagementService.updateMetadata(extension.local, { preRelease: !extension.preRelease });
+            await this.extensionManagementService.updateMetadata(extension.local, {
+                preRelease: !extension.preRelease
+            });
             return;
         }
-        await this.install(extension, { installPreReleaseVersion: !extension.preRelease, preRelease: !extension.preRelease });
+        await this.install(extension, {
+            installPreReleaseVersion: !extension.preRelease,
+            preRelease: !extension.preRelease
+        });
     }
     async toggleExtensionIgnoredToSync(extension) {
         const extensionsIncludingPackedExtensions = [extension, ...this.getAllPackedExtensions(extension, this.local)];
         for (const e of extensionsIncludingPackedExtensions) {
             const isIgnored = this.isExtensionIgnoredToSync(e);
             if (e.local && isIgnored && e.local.isMachineScoped) {
-                await this.extensionManagementService.updateMetadata(e.local, { isMachineScoped: false });
-            }
-            else {
+                await this.extensionManagementService.updateMetadata(e.local, {
+                    isMachineScoped: false
+                });
+            } else {
                 await this.extensionsSyncManagementService.updateIgnoredExtensions(e.identifier.id, !isIgnored);
             }
         }
-        await this.userDataAutoSyncService.triggerSync(['IgnoredExtensionsUpdated']);
+        await this.userDataAutoSyncService.triggerSync(["IgnoredExtensionsUpdated"]);
     }
     async toggleApplyExtensionToAllProfiles(extension) {
         const extensionsIncludingPackedExtensions = [extension, ...this.getAllPackedExtensions(extension, this.local)];
         const allExtensionServers = this.getAllExtensionServers();
-        await Promise.allSettled(( extensionsIncludingPackedExtensions.map(async (e) => {
+        await Promise.allSettled(( extensionsIncludingPackedExtensions.map(async e => {
             if (!e.local || isApplicationScopedExtension(e.local.manifest) || e.isBuiltin) {
                 return;
             }
             const isApplicationScoped = e.local.isApplicationScoped;
-            await Promise.all(( allExtensionServers.map(async (extensionServer) => {
+            await Promise.all(( allExtensionServers.map(async extensionServer => {
                 const local = extensionServer.local.find(local => areSameExtensions(e.identifier, local.identifier))?.local;
                 if (local && local.isApplicationScoped === isApplicationScoped) {
                     await this.extensionManagementService.toggleApplicationScope(local, this.userDataProfileService.currentProfile.extensionsResource);
@@ -2572,7 +2980,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         return !this.extensionsSyncManagementService.hasToNeverSyncExtension(extension.identifier.id);
     }
     doInstall(extension, installTask, progressLocation) {
-        const title = extension ? ( localize(7854, "Installing '{0}' extension...", extension.displayName)) : ( localize(7855, 'Installing extension...'));
+        const title = extension ? ( localize(8166, "Installing '{0}' extension...", extension.displayName)) : ( localize(8167, "Installing extension..."));
         return this.withProgress({
             location: progressLocation ?? ProgressLocation.Extensions,
             title
@@ -2584,8 +2992,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
                 }
                 const local = await installTask();
                 return await this.waitAndGetInstalledExtension(local.identifier);
-            }
-            finally {
+            } finally {
                 if (extension) {
                     this.installing = this.installing.filter(e => e !== extension);
                     this._onChange.fire(undefined);
@@ -2595,13 +3002,14 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
     }
     async installFromVSIX(vsix, installOptions) {
         const manifest = await this.extensionManagementService.getManifest(vsix);
-        const existingExtension = this.local.find(local => areSameExtensions(local.identifier, { id: getGalleryExtensionId(manifest.publisher, manifest.name) }));
+        const existingExtension = this.local.find(local => areSameExtensions(local.identifier, {
+            id: getGalleryExtensionId(manifest.publisher, manifest.name)
+        }));
         if (existingExtension) {
             installOptions = installOptions || {};
             if (existingExtension.latestVersion === manifest.version) {
                 installOptions.pinned = installOptions.pinned ?? (existingExtension.local?.pinned || !this.shouldAutoUpdateExtension(existingExtension));
-            }
-            else {
+            } else {
                 installOptions.installGivenVersion = true;
             }
         }
@@ -2614,8 +3022,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             installOptions.productVersion = this.getProductVersion();
             installOptions.operation = InstallOperation.Update;
             return this.extensionManagementService.updateFromGallery(gallery, extension.local, installOptions);
-        }
-        else {
+        } else {
             return this.extensionManagementService.installFromGallery(gallery, installOptions, servers);
         }
     }
@@ -2626,7 +3033,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         }
         installedExtension = this.local.find(local => areSameExtensions(local.identifier, identifier));
         if (!installedExtension) {
-            throw ( new Error('Extension should have been installed'));
+            throw ( new Error("Extension should have been installed"));
         }
         return installedExtension;
     }
@@ -2644,8 +3051,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
                         disposable.dispose();
                         c();
                     }
-                }
-                catch (error) {
+                } catch (error) {
                     e(error);
                 }
             });
@@ -2654,11 +3060,16 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
     promptAndSetEnablement(extensions, enablementState) {
         const enable = enablementState === EnablementState.EnabledGlobally || enablementState === EnablementState.EnabledWorkspace;
         if (enable) {
-            const allDependenciesAndPackedExtensions = this.getExtensionsRecursively(extensions, this.local, enablementState, { dependencies: true, pack: true });
+            const allDependenciesAndPackedExtensions = this.getExtensionsRecursively(extensions, this.local, enablementState, {
+                dependencies: true,
+                pack: true
+            });
             return this.checkAndSetEnablement(extensions, allDependenciesAndPackedExtensions, enablementState);
-        }
-        else {
-            const packedExtensions = this.getExtensionsRecursively(extensions, this.local, enablementState, { dependencies: false, pack: true });
+        } else {
+            const packedExtensions = this.getExtensionsRecursively(extensions, this.local, enablementState, {
+                dependencies: false,
+                pack: true
+            });
             if (packedExtensions.length) {
                 return this.checkAndSetEnablement(extensions, packedExtensions, enablementState);
             }
@@ -2672,14 +3083,16 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             for (const extension of extensions) {
                 const dependents = this.getDependentsAfterDisablement(extension, allExtensions, this.local);
                 if (dependents.length) {
-                    const { result } = await this.dialogService.prompt({
-                        title: ( localize(7856, "Disable Extension with Dependents")),
+                    const {
+                        result
+                    } = await this.dialogService.prompt({
+                        title: ( localize(8168, "Disable Extension with Dependents")),
                         type: Severity$1.Warning,
                         message: this.getDependentsErrorMessageForDisablement(extension, allExtensions, dependents),
                         buttons: [{
-                                label: ( localize(7857, 'Disable All')),
-                                run: () => true
-                            }],
+                            label: ( localize(8169, "Disable All")),
+                            run: () => true
+                        }],
                         cancelButton: {
                             run: () => false
                         }
@@ -2708,13 +3121,18 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
                 if (enable === isExtensionEnabled) {
                     return false;
                 }
-                return (enable || !i.isBuiltin)
-                    && (options.dependencies || options.pack)
-                    && ( extensions.some(extension => (options.dependencies && ( extension.dependencies.some(id => areSameExtensions({ id }, i.identifier))))
-                        || (options.pack && ( extension.extensionPack.some(id => areSameExtensions({ id }, i.identifier))))));
+                return (
+                    (enable || !i.isBuiltin) && (options.dependencies || options.pack) && ( extensions.some(extension => (options.dependencies && ( extension.dependencies.some(id => areSameExtensions({
+                        id
+                    }, i.identifier)))) || (options.pack && ( extension.extensionPack.some(id => areSameExtensions({
+                        id
+                    }, i.identifier))))))
+                );
             });
             if (extensionsToEanbleOrDisable.length) {
-                extensionsToEanbleOrDisable.push(...this.getExtensionsRecursively(extensionsToEanbleOrDisable, installed, enablementState, options, checked));
+                extensionsToEanbleOrDisable.push(
+                    ...this.getExtensionsRecursively(extensionsToEanbleOrDisable, installed, enablementState, options, checked)
+                );
             }
             return extensionsToEanbleOrDisable;
         }
@@ -2734,22 +3152,26 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             if (extensionsToDisable.indexOf(i) !== -1) {
                 return false;
             }
-            return ( i.dependencies.some(dep => ( [extension, ...extensionsToDisable].some(d => areSameExtensions(d.identifier, { id: dep })))));
+            return ( i.dependencies.some(dep => ( [extension, ...extensionsToDisable].some(d => areSameExtensions(d.identifier, {
+                id: dep
+            })))));
         });
     }
     getDependentsErrorMessageForDisablement(extension, allDisabledExtensions, dependents) {
         for (const e of [extension, ...allDisabledExtensions]) {
-            const dependentsOfTheExtension = dependents.filter(d => ( d.dependencies.some(id => areSameExtensions({ id }, e.identifier))));
+            const dependentsOfTheExtension = dependents.filter(d => ( d.dependencies.some(id => areSameExtensions({
+                id
+            }, e.identifier))));
             if (dependentsOfTheExtension.length) {
                 return this.getErrorMessageForDisablingAnExtensionWithDependents(e, dependentsOfTheExtension);
             }
         }
-        return '';
+        return "";
     }
     getErrorMessageForDisablingAnExtensionWithDependents(extension, dependents) {
         if (dependents.length === 1) {
             return localize(
-                7858,
+                8170,
                 "Cannot disable '{0}' extension alone. '{1}' extension depends on this. Do you want to disable all these extensions?",
                 extension.displayName,
                 dependents[0].displayName
@@ -2757,7 +3179,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         }
         if (dependents.length === 2) {
             return localize(
-                7859,
+                8171,
                 "Cannot disable '{0}' extension alone. '{1}' and '{2}' extensions depend on this. Do you want to disable all these extensions?",
                 extension.displayName,
                 dependents[0].displayName,
@@ -2765,7 +3187,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             );
         }
         return localize(
-            7860,
+            8172,
             "Cannot disable '{0}' extension alone. '{1}', '{2}' and other extensions depend on this. Do you want to disable all these extensions?",
             extension.displayName,
             dependents[0].displayName,
@@ -2780,10 +3202,11 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             e => e.state === ExtensionState.Installing || e.state === ExtensionState.Uninstalling
         ))) {
             if (!this._activityCallBack) {
-                this.withProgress({ location: ProgressLocation.Extensions }, () => ( new Promise(resolve => this._activityCallBack = resolve)));
+                this.withProgress({
+                    location: ProgressLocation.Extensions
+                }, () => ( new Promise(resolve => this._activityCallBack = resolve)));
             }
-        }
-        else {
+        } else {
             this._activityCallBack?.();
             this._activityCallBack = undefined;
         }
@@ -2794,8 +3217,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             this.tasksInProgress.push(cancelableTask);
             try {
                 return await cancelableTask;
-            }
-            finally {
+            } finally {
                 const index = this.tasksInProgress.indexOf(cancelableTask);
                 if (index !== -1) {
                     this.tasksInProgress.splice(index, 1);
@@ -2807,7 +3229,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         if (isCancellationError(err)) {
             return;
         }
-        const message = err && err.message || '';
+        const message = err && err.message || "";
         if (/getaddrinfo ENOTFOUND|getaddrinfo ENOENT|connect EACCES|connect ECONNREFUSED/.test(message)) {
             return;
         }
@@ -2826,10 +3248,16 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             return;
         }
         const extensionId = match[1];
-        this.queryLocal().then(async (local) => {
-            let extension = local.find(local => areSameExtensions(local.identifier, { id: extensionId }));
+        this.queryLocal().then(async local => {
+            let extension = local.find(local => areSameExtensions(local.identifier, {
+                id: extensionId
+            }));
             if (!extension) {
-                [extension] = await this.getExtensions([{ id: extensionId }], { source: 'uri' }, CancellationToken.None);
+                [extension] = await this.getExtensions([{
+                    id: extensionId
+                }], {
+                    source: "uri"
+                }, CancellationToken.None);
             }
             if (extension) {
                 await this.hostService.focus(mainWindow);
@@ -2846,8 +3274,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             if (Array.isArray(parsedValue)) {
                 return parsedValue;
             }
-        }
-        catch (e) {  }
+        } catch (e) {}
         return [];
     }
     setEnabledAutoUpdateExtensions(enabledAutoUpdateExtensions) {
@@ -2866,10 +3293,15 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         }
     }
     getEnabledAutoUpdateExtensionsValue() {
-        return this.storageService.get(EXTENSIONS_AUTO_UPDATE_KEY, StorageScope.APPLICATION, '[]');
+        return this.storageService.get(EXTENSIONS_AUTO_UPDATE_KEY, StorageScope.APPLICATION, "[]");
     }
     setEnabledAutoUpdateExtensionsValue(value) {
-        this.storageService.store(EXTENSIONS_AUTO_UPDATE_KEY, value, StorageScope.APPLICATION, StorageTarget.USER);
+        this.storageService.store(
+            EXTENSIONS_AUTO_UPDATE_KEY,
+            value,
+            StorageScope.APPLICATION,
+            StorageTarget.USER
+        );
     }
     getDisabledAutoUpdateExtensions() {
         try {
@@ -2877,8 +3309,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             if (Array.isArray(parsedValue)) {
                 return parsedValue;
             }
-        }
-        catch (e) {  }
+        } catch (e) {}
         return [];
     }
     setDisabledAutoUpdateExtensions(disabledAutoUpdateExtensions) {
@@ -2897,10 +3328,15 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         }
     }
     getDisabledAutoUpdateExtensionsValue() {
-        return this.storageService.get(EXTENSIONS_DONOT_AUTO_UPDATE_KEY, StorageScope.APPLICATION, '[]');
+        return this.storageService.get(EXTENSIONS_DONOT_AUTO_UPDATE_KEY, StorageScope.APPLICATION, "[]");
     }
     setDisabledAutoUpdateExtensionsValue(value) {
-        this.storageService.store(EXTENSIONS_DONOT_AUTO_UPDATE_KEY, value, StorageScope.APPLICATION, StorageTarget.USER);
+        this.storageService.store(
+            EXTENSIONS_DONOT_AUTO_UPDATE_KEY,
+            value,
+            StorageScope.APPLICATION,
+            StorageTarget.USER
+        );
     }
     getDismissedNotifications() {
         try {
@@ -2908,8 +3344,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             if (Array.isArray(parsedValue)) {
                 return parsedValue;
             }
-        }
-        catch (e) {  }
+        } catch (e) {}
         return [];
     }
     setDismissedNotifications(dismissedNotifications) {
@@ -2928,49 +3363,17 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         }
     }
     getDismissedNotificationsValue() {
-        return this.storageService.get(EXTENSIONS_DISMISSED_NOTIFICATIONS_KEY, StorageScope.PROFILE, '[]');
+        return this.storageService.get(EXTENSIONS_DISMISSED_NOTIFICATIONS_KEY, StorageScope.PROFILE, "[]");
     }
     setDismissedNotificationsValue(value) {
-        this.storageService.store(EXTENSIONS_DISMISSED_NOTIFICATIONS_KEY, value, StorageScope.PROFILE, StorageTarget.USER);
+        this.storageService.store(
+            EXTENSIONS_DISMISSED_NOTIFICATIONS_KEY,
+            value,
+            StorageScope.PROFILE,
+            StorageTarget.USER
+        );
     }
 };
-ExtensionsWorkbenchService = ExtensionsWorkbenchService_1 = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IEditorService)),
-    ( __param(2, IWorkbenchExtensionManagementService)),
-    ( __param(3, IExtensionGalleryService)),
-    ( __param(4, IExtensionGalleryManifestService)),
-    ( __param(5, IConfigurationService)),
-    ( __param(6, ITelemetryService)),
-    ( __param(7, INotificationService)),
-    ( __param(8, IURLService)),
-    ( __param(9, IWorkbenchExtensionEnablementService)),
-    ( __param(10, IHostService)),
-    ( __param(11, IProgressService)),
-    ( __param(12, IExtensionManagementServerService)),
-    ( __param(13, ILanguageService)),
-    ( __param(14, IIgnoredExtensionsManagementService)),
-    ( __param(15, IUserDataAutoSyncService)),
-    ( __param(16, IProductService)),
-    ( __param(17, IContextKeyService)),
-    ( __param(18, IExtensionManifestPropertiesService)),
-    ( __param(19, ILogService)),
-    ( __param(20, IExtensionService)),
-    ( __param(21, ILocaleService)),
-    ( __param(22, ILifecycleService)),
-    ( __param(23, IFileService)),
-    ( __param(24, IUserDataProfileService)),
-    ( __param(25, IUserDataProfilesService)),
-    ( __param(26, IStorageService)),
-    ( __param(27, IDialogService)),
-    ( __param(28, IUserDataSyncEnablementService)),
-    ( __param(29, IUpdateService)),
-    ( __param(30, IUriIdentityService)),
-    ( __param(31, IWorkspaceContextService)),
-    ( __param(32, IViewsService)),
-    ( __param(33, IFileDialogService)),
-    ( __param(34, IQuickInputService)),
-    ( __param(35, IAllowedExtensionsService))
-], ExtensionsWorkbenchService));
+ExtensionsWorkbenchService = ExtensionsWorkbenchService_1 = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IEditorService)), ( __param(2, IWorkbenchExtensionManagementService)), ( __param(3, IExtensionGalleryService)), ( __param(4, IExtensionGalleryManifestService)), ( __param(5, IConfigurationService)), ( __param(6, ITelemetryService)), ( __param(7, INotificationService)), ( __param(8, IURLService)), ( __param(9, IWorkbenchExtensionEnablementService)), ( __param(10, IHostService)), ( __param(11, IProgressService)), ( __param(12, IExtensionManagementServerService)), ( __param(13, ILanguageService)), ( __param(14, IIgnoredExtensionsManagementService)), ( __param(15, IUserDataAutoSyncService)), ( __param(16, IProductService)), ( __param(17, IContextKeyService)), ( __param(18, IExtensionManifestPropertiesService)), ( __param(19, ILogService)), ( __param(20, IExtensionService)), ( __param(21, ILocaleService)), ( __param(22, ILifecycleService)), ( __param(23, IFileService)), ( __param(24, IUserDataProfileService)), ( __param(25, IUserDataProfilesService)), ( __param(26, IStorageService)), ( __param(27, IDialogService)), ( __param(28, IUserDataSyncEnablementService)), ( __param(29, IUpdateService)), ( __param(30, IUriIdentityService)), ( __param(31, IWorkspaceContextService)), ( __param(32, IViewsService)), ( __param(33, IFileDialogService)), ( __param(34, IQuickInputService)), ( __param(35, IAllowedExtensionsService))], ExtensionsWorkbenchService));
 
 export { Extension, ExtensionsWorkbenchService };