@codingame/monaco-vscode-api 25.1.2 → 26.0.1

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

@@ -38,7 +38,7 @@ import { registerColor } from '../../../../platform/theme/common/colorUtils.js';
 import '../../../../platform/theme/common/colors/baseColors.js';
 import '../../../../platform/theme/common/colors/chartsColors.js';
 import { editorErrorForeground, editorWarningForeground, editorInfoForeground } from '../../../../platform/theme/common/colors/editorColors.js';
-import { buttonSecondaryBackground, buttonSecondaryForeground, buttonSecondaryHoverBackground, buttonSeparator, buttonBackground, buttonForeground, buttonHoverBackground } from '../../../../platform/theme/common/colors/inputColors.js';
+import { buttonSecondaryBackground, buttonSecondaryForeground, buttonSecondaryHoverBackground, buttonSecondaryBorder, buttonSeparator, buttonBackground, buttonForeground, buttonHoverBackground } from '../../../../platform/theme/common/colors/inputColors.js';
 import '../../../../platform/theme/common/colors/listColors.js';
 import '../../../../platform/theme/common/colors/menuColors.js';
 import '../../../../platform/theme/common/colors/minimapColors.js';
@@ -97,8 +97,25 @@ import Severity$1 from '../../../../base/common/severity.js';
 var InstallAction_1, InstallInOtherServerAction_1, UninstallAction_1, UpdateAction_1, ToggleAutoUpdateForExtensionAction_1, ToggleAutoUpdatesForPublisherAction_1, MigrateDeprecatedExtensionAction_1, ManageExtensionAction_1, TogglePreReleaseExtensionAction_1, InstallAnotherVersionAction_1, EnableForWorkspaceAction_1, EnableGloballyAction_1, DisableForWorkspaceAction_1, DisableGloballyAction_1, ExtensionRuntimeStateAction_1, SetColorThemeAction_1, SetFileIconThemeAction_1, SetProductIconThemeAction_1, SetLanguageAction_1, ClearLanguageAction_1, ShowRecommendedExtensionAction_1, InstallRecommendedExtensionAction_1, IgnoreExtensionRecommendationAction_1, UndoIgnoreExtensionRecommendationAction_1, ExtensionStatusLabelAction_1, ToggleSyncExtensionAction_1, ExtensionStatusAction_1, InstallSpecificVersionOfExtensionAction_1;
 registerCss(extensionActions);
 let PromptExtensionInstallFailureAction = class PromptExtensionInstallFailureAction extends Action {
-    constructor(extension, options, version, installOperation, error, productService, openerService, notificationService, dialogService, commandService, logService, extensionManagementServerService, instantiationService, galleryService, extensionManifestPropertiesService, workbenchIssueService) {
-        super('extension.promptExtensionInstallFailure');
+    constructor(
+        extension,
+        options,
+        version,
+        installOperation,
+        error,
+        productService,
+        openerService,
+        notificationService,
+        dialogService,
+        commandService,
+        logService,
+        extensionManagementServerService,
+        instantiationService,
+        galleryService,
+        extensionManifestPropertiesService,
+        workbenchIssueService
+    ) {
+        super("extension.promptExtensionInstallFailure");
         this.extension = extension;
         this.options = options;
         this.version = version;
@@ -122,135 +139,157 @@ let PromptExtensionInstallFailureAction = class PromptExtensionInstallFailureAct
         }
         this.logService.error(this.error);
         if (this.error.name === ExtensionManagementErrorCode.Unsupported) {
-            const productName = isWeb ? ( localize(7509, "{0} for the Web", this.productService.nameLong)) : this.productService.nameLong;
+            const productName = isWeb ? ( localize(7820, "{0} for the Web", this.productService.nameLong)) : this.productService.nameLong;
             const message = ( localize(
-                7510,
+                7821,
                 "The '{0}' extension is not available in {1}. Click 'More Information' to learn more.",
                 this.extension.displayName || this.extension.identifier.id,
                 productName
             ));
-            const { confirmed } = await this.dialogService.confirm({
+            const {
+                confirmed
+            } = await this.dialogService.confirm({
                 type: Severity$1.Info,
                 message,
-                primaryButton: ( localize(7511, "&&More Information")),
-                cancelButton: ( localize(7512, "Close"))
+                primaryButton: ( localize(7822, "&&More Information")),
+                cancelButton: ( localize(7823, "Close"))
             });
             if (confirmed) {
-                this.openerService.open(isWeb ? ( URI.parse('https://aka.ms/vscode-web-extensions-guide')) : ( URI.parse('https://aka.ms/vscode-remote')));
+                this.openerService.open(isWeb ? ( URI.parse("https://aka.ms/vscode-web-extensions-guide")) : ( URI.parse("https://aka.ms/vscode-remote")));
             }
             return;
         }
         if (ExtensionManagementErrorCode.ReleaseVersionNotFound === this.error.name) {
             await this.dialogService.prompt({
-                type: 'error',
+                type: "error",
                 message: getErrorMessage(this.error),
                 buttons: [{
-                        label: ( localize(7513, "Install Pre-Release")),
-                        run: () => {
-                            const installAction = this.instantiationService.createInstance(InstallAction, { installPreReleaseVersion: true });
-                            installAction.extension = this.extension;
-                            return installAction.run();
-                        }
-                    }],
-                cancelButton: ( localize(7514, "Cancel"))
+                    label: ( localize(7824, "Install Pre-Release")),
+                    run: () => {
+                        const installAction = this.instantiationService.createInstance(InstallAction, {
+                            installPreReleaseVersion: true
+                        });
+                        installAction.extension = this.extension;
+                        return installAction.run();
+                    }
+                }],
+                cancelButton: ( localize(7825, "Cancel"))
             });
             return;
         }
-        if ([ExtensionManagementErrorCode.Incompatible, ExtensionManagementErrorCode.IncompatibleApi, ExtensionManagementErrorCode.IncompatibleTargetPlatform, ExtensionManagementErrorCode.Malicious, ExtensionManagementErrorCode.Deprecated].includes(this.error.name)) {
+        if ([
+            ExtensionManagementErrorCode.Incompatible,
+            ExtensionManagementErrorCode.IncompatibleApi,
+            ExtensionManagementErrorCode.IncompatibleTargetPlatform,
+            ExtensionManagementErrorCode.Malicious,
+            ExtensionManagementErrorCode.Deprecated
+        ].includes(this.error.name)) {
             await this.dialogService.info(getErrorMessage(this.error));
             return;
         }
         if (ExtensionManagementErrorCode.PackageNotSigned === this.error.name) {
             await this.dialogService.prompt({
-                type: 'error',
+                type: "error",
                 message: ( localize(
-                    7515,
+                    7826,
                     "'{0}' is an extension from an unknown source. Are you sure you want to install?",
                     this.extension.displayName
                 )),
                 detail: getErrorMessage(this.error),
                 buttons: [{
-                        label: ( localize(7516, "Install Anyway")),
-                        run: () => {
-                            const installAction = this.instantiationService.createInstance(InstallAction, { ...this.options, donotVerifySignature: true, });
-                            installAction.extension = this.extension;
-                            return installAction.run();
-                        }
-                    }],
+                    label: ( localize(7827, "Install Anyway")),
+                    run: () => {
+                        const installAction = this.instantiationService.createInstance(InstallAction, {
+                            ...this.options,
+                            donotVerifySignature: true
+                        });
+                        installAction.extension = this.extension;
+                        return installAction.run();
+                    }
+                }],
                 cancelButton: true
             });
             return;
         }
         if (ExtensionManagementErrorCode.SignatureVerificationFailed === this.error.name) {
             await this.dialogService.prompt({
-                type: 'error',
+                type: "error",
                 message: ( localize(
-                    7517,
+                    7828,
                     "Cannot install '{0}' extension because {1} cannot verify the extension signature",
                     this.extension.displayName,
                     this.productService.nameLong
                 )),
                 detail: getErrorMessage(this.error),
                 buttons: [{
-                        label: ( localize(7518, "Learn More")),
-                        run: () => this.openerService.open('https://code.visualstudio.com/docs/editor/extension-marketplace#_the-extension-signature-cannot-be-verified-by-vs-code')
-                    }, {
-                        label: ( localize(7519, "Install Anyway (Don't Verify Signature)")),
-                        run: () => {
-                            const installAction = this.instantiationService.createInstance(InstallAction, { ...this.options, donotVerifySignature: true, });
-                            installAction.extension = this.extension;
-                            return installAction.run();
-                        }
-                    }],
+                    label: ( localize(7829, "Learn More")),
+                    run: () => this.openerService.open(
+                        "https://code.visualstudio.com/docs/editor/extension-marketplace#_the-extension-signature-cannot-be-verified-by-vs-code"
+                    )
+                }, {
+                    label: ( localize(7830, "Install Anyway (Don't Verify Signature)")),
+                    run: () => {
+                        const installAction = this.instantiationService.createInstance(InstallAction, {
+                            ...this.options,
+                            donotVerifySignature: true
+                        });
+                        installAction.extension = this.extension;
+                        return installAction.run();
+                    }
+                }],
                 cancelButton: true
             });
             return;
         }
         if (ExtensionManagementErrorCode.SignatureVerificationInternal === this.error.name) {
             await this.dialogService.prompt({
-                type: 'error',
+                type: "error",
                 message: ( localize(
-                    7517,
+                    7828,
                     "Cannot install '{0}' extension because {1} cannot verify the extension signature",
                     this.extension.displayName,
                     this.productService.nameLong
                 )),
                 detail: getErrorMessage(this.error),
                 buttons: [{
-                        label: ( localize(7518, "Learn More")),
-                        run: () => this.openerService.open('https://code.visualstudio.com/docs/editor/extension-marketplace#_the-extension-signature-cannot-be-verified-by-vs-code')
-                    }, {
-                        label: ( localize(7520, "Report Issue")),
-                        run: () => this.workbenchIssueService.openReporter({
-                            issueTitle: ( localize(
-                                7521,
-                                "Extension Signature Verification Failed: {0}",
-                                this.extension.displayName
-                            )),
-                            issueBody: ( localize(
-                                7522,
-                                "Please include following log `F1 > Open View... > Shared` below.\n\n"
-                            ))
-                        })
-                    }, {
-                        label: ( localize(7519, "Install Anyway (Don't Verify Signature)")),
-                        run: () => {
-                            const installAction = this.instantiationService.createInstance(InstallAction, { ...this.options, donotVerifySignature: true, });
-                            installAction.extension = this.extension;
-                            return installAction.run();
-                        }
-                    }],
+                    label: ( localize(7829, "Learn More")),
+                    run: () => this.openerService.open(
+                        "https://code.visualstudio.com/docs/editor/extension-marketplace#_the-extension-signature-cannot-be-verified-by-vs-code"
+                    )
+                }, {
+                    label: ( localize(7831, "Report Issue")),
+                    run: () => this.workbenchIssueService.openReporter({
+                        issueTitle: ( localize(
+                            7832,
+                            "Extension Signature Verification Failed: {0}",
+                            this.extension.displayName
+                        )),
+                        issueBody: ( localize(
+                            7833,
+                            "Please include following log `F1 > Open View... > Shared` below.\n\n"
+                        ))
+                    })
+                }, {
+                    label: ( localize(7830, "Install Anyway (Don't Verify Signature)")),
+                    run: () => {
+                        const installAction = this.instantiationService.createInstance(InstallAction, {
+                            ...this.options,
+                            donotVerifySignature: true
+                        });
+                        installAction.extension = this.extension;
+                        return installAction.run();
+                    }
+                }],
                 cancelButton: true
             });
             return;
         }
         const operationMessage = this.installOperation === InstallOperation.Update ? ( localize(
-            7523,
+            7834,
             "Error while updating '{0}' extension.",
             this.extension.displayName || this.extension.identifier.id
-        ))
-            : ( localize(
-            7524,
+        )) : ( localize(
+            7835,
             "Error while installing '{0}' extension.",
             this.extension.displayName || this.extension.identifier.id
         ));
@@ -259,25 +298,25 @@ let PromptExtensionInstallFailureAction = class PromptExtensionInstallFailureAct
         const downloadUrl = await this.getDownloadUrl();
         if (downloadUrl) {
             additionalMessage = ( localize(
-                7525,
+                7836,
                 "Please check the [log]({0}) for more details.",
                 (createCommandUri(showWindowLogActionId).toString())
             ));
             promptChoices.push({
-                label: ( localize(7526, "Try Downloading Manually...")),
+                label: ( localize(7837, "Try Downloading Manually...")),
                 run: () => this.openerService.open(downloadUrl).then(() => {
                     this.notificationService.prompt(Severity$1.Info, ( localize(
-                        7527,
-                        'Once downloaded, please manually install the downloaded VSIX of \'{0}\'.',
+                        7838,
+                        "Once downloaded, please manually install the downloaded VSIX of '{0}'.",
                         this.extension.identifier.id
                     )), [{
-                            label: ( localize(7528, "Install from VSIX...")),
-                            run: () => this.commandService.executeCommand(SELECT_INSTALL_VSIX_EXTENSION_COMMAND_ID)
-                        }]);
+                        label: ( localize(7839, "Install from VSIX...")),
+                        run: () => this.commandService.executeCommand(SELECT_INSTALL_VSIX_EXTENSION_COMMAND_ID)
+                    }]);
                 })
             });
         }
-        const message = `${operationMessage}${additionalMessage ? ` ${additionalMessage}` : ''}`;
+        const message = `${operationMessage}${additionalMessage ? ` ${additionalMessage}` : ""}`;
         this.notificationService.prompt(Severity$1.Error, message, promptChoices);
     }
     async getDownloadUrl() {
@@ -297,8 +336,7 @@ let PromptExtensionInstallFailureAction = class PromptExtensionInstallFailureAct
                 if (manifest && this.extensionManifestPropertiesService.prefersExecuteOnWorkspace(manifest)) {
                     targetPlatform = await this.extensionManagementServerService.remoteExtensionManagementServer.extensionManagementService.getTargetPlatform();
                 }
-            }
-            catch (error) {
+            } catch (error) {
                 this.logService.error(error);
                 return undefined;
             }
@@ -307,9 +345,9 @@ let PromptExtensionInstallFailureAction = class PromptExtensionInstallFailureAct
             return undefined;
         }
         const [extension] = await this.galleryService.getExtensions([{
-                ...this.extension.identifier,
-                version: this.version
-            }], {
+            ...this.extension.identifier,
+            version: this.version
+        }], {
             targetPlatform
         }, CancellationToken.None);
         if (!extension) {
@@ -318,19 +356,7 @@ let PromptExtensionInstallFailureAction = class PromptExtensionInstallFailureAct
         return ( URI.parse(extension.assets.download.uri));
     }
 };
-PromptExtensionInstallFailureAction = ( __decorate([
-    ( __param(5, IProductService)),
-    ( __param(6, IOpenerService)),
-    ( __param(7, INotificationService)),
-    ( __param(8, IDialogService)),
-    ( __param(9, ICommandService)),
-    ( __param(10, ILogService)),
-    ( __param(11, IExtensionManagementServerService)),
-    ( __param(12, IInstantiationService)),
-    ( __param(13, IExtensionGalleryService)),
-    ( __param(14, IExtensionManifestPropertiesService)),
-    ( __param(15, IWorkbenchIssueService))
-], PromptExtensionInstallFailureAction));
+PromptExtensionInstallFailureAction = ( __decorate([( __param(5, IProductService)), ( __param(6, IOpenerService)), ( __param(7, INotificationService)), ( __param(8, IDialogService)), ( __param(9, ICommandService)), ( __param(10, ILogService)), ( __param(11, IExtensionManagementServerService)), ( __param(12, IInstantiationService)), ( __param(13, IExtensionGalleryService)), ( __param(14, IExtensionManifestPropertiesService)), ( __param(15, IWorkbenchIssueService))], PromptExtensionInstallFailureAction));
 class ExtensionAction extends Action {
     constructor() {
         super(...arguments);
@@ -339,18 +365,37 @@ class ExtensionAction extends Action {
         this._hidden = false;
         this.hideOnDisabled = true;
     }
-    get onDidChange() { return this._onDidChange.event; }
-    static { this.EXTENSION_ACTION_CLASS = 'extension-action'; }
-    static { this.TEXT_ACTION_CLASS = `${ExtensionAction.EXTENSION_ACTION_CLASS} text`; }
-    static { this.LABEL_ACTION_CLASS = `${ExtensionAction.EXTENSION_ACTION_CLASS} label`; }
-    static { this.ICON_ACTION_CLASS = `${ExtensionAction.EXTENSION_ACTION_CLASS} icon`; }
-    get extension() { return this._extension; }
-    set extension(extension) { this._extension = extension; this.update(); }
-    get hidden() { return this._hidden; }
+    get onDidChange() {
+        return this._onDidChange.event;
+    }
+    static {
+        this.EXTENSION_ACTION_CLASS = "extension-action";
+    }
+    static {
+        this.TEXT_ACTION_CLASS = `${ExtensionAction.EXTENSION_ACTION_CLASS} text`;
+    }
+    static {
+        this.LABEL_ACTION_CLASS = `${ExtensionAction.EXTENSION_ACTION_CLASS} label`;
+    }
+    static {
+        this.ICON_ACTION_CLASS = `${ExtensionAction.EXTENSION_ACTION_CLASS} icon`;
+    }
+    get extension() {
+        return this._extension;
+    }
+    set extension(extension) {
+        this._extension = extension;
+        this.update();
+    }
+    get hidden() {
+        return this._hidden;
+    }
     set hidden(hidden) {
         if (this._hidden !== hidden) {
             this._hidden = hidden;
-            this._onDidChange.fire({ hidden });
+            this._onDidChange.fire({
+                hidden
+            });
         }
     }
     _setEnabled(value) {
@@ -361,7 +406,9 @@ class ExtensionAction extends Action {
     }
 }
 class ButtonWithDropDownExtensionAction extends ExtensionAction {
-    get menuActions() { return [...this._menuActions]; }
+    get menuActions() {
+        return [...this._menuActions];
+    }
     get extension() {
         return super.extension;
     }
@@ -375,7 +422,7 @@ class ButtonWithDropDownExtensionAction extends ExtensionAction {
         this.actionsGroups = actionsGroups;
         this.menuActionClassNames = [];
         this._menuActions = [];
-        this.menuActionClassNames = clazz.split(' ');
+        this.menuActionClassNames = clazz.split(" ");
         this.hideOnDisabled = false;
         this.extensionActions = actionsGroups.flat();
         this.update();
@@ -396,14 +443,15 @@ class ButtonWithDropDownExtensionAction extends ExtensionAction {
         actions = actions.length ? actions.slice(0, actions.length - 1) : actions;
         this.primaryAction = actions[0];
         this._menuActions = actions.length > 1 ? actions : [];
-        this._onDidChange.fire({ menuActions: this._menuActions });
+        this._onDidChange.fire({
+            menuActions: this._menuActions
+        });
         if (this.primaryAction) {
             this.hidden = false;
             this.enabled = this.primaryAction.enabled;
             this.label = this.getLabel(this.primaryAction);
             this.tooltip = this.primaryAction.tooltip;
-        }
-        else {
+        } else {
             this.hidden = true;
             this.enabled = false;
         }
@@ -433,23 +481,42 @@ class ButtonWithDropdownExtensionActionViewItem extends ActionWithDropdownAction
     updateClass() {
         super.updateClass();
         if (this.element && this.dropdownMenuActionViewItem?.element) {
-            this.element.classList.toggle('hide', this._action.hidden);
+            this.element.classList.toggle("hide", this._action.hidden);
             const isMenuEmpty = this._action.menuActions.length === 0;
-            this.element.classList.toggle('empty', isMenuEmpty);
-            this.dropdownMenuActionViewItem.element.classList.toggle('hide', isMenuEmpty);
+            this.element.classList.toggle("empty", isMenuEmpty);
+            this.dropdownMenuActionViewItem.element.classList.toggle("hide", isMenuEmpty);
         }
     }
 }
 let InstallAction = class InstallAction extends ExtensionAction {
-    static { InstallAction_1 = this; }
-    static { this.CLASS = `${this.LABEL_ACTION_CLASS} prominent install`; }
-    static { this.HIDE = `${this.CLASS} hide`; }
+    static {
+        InstallAction_1 = this;
+    }
+    static {
+        this.CLASS = `${this.LABEL_ACTION_CLASS} prominent install`;
+    }
+    static {
+        this.HIDE = `${this.CLASS} hide`;
+    }
     set manifest(manifest) {
         this._manifest = manifest;
         this.updateLabel();
     }
-    constructor(options, extensionsWorkbenchService, instantiationService, runtimeExtensionService, workbenchThemeService, labelService, dialogService, preferencesService, telemetryService, contextService, allowedExtensionsService, extensionGalleryManifestService) {
-        super('extensions.install', ( localize(7529, "Install")), InstallAction_1.CLASS, false);
+    constructor(
+        options,
+        extensionsWorkbenchService,
+        instantiationService,
+        runtimeExtensionService,
+        workbenchThemeService,
+        labelService,
+        dialogService,
+        preferencesService,
+        telemetryService,
+        contextService,
+        allowedExtensionsService,
+        extensionGalleryManifestService
+    ) {
+        super("extensions.install", ( localize(7840, "Install")), InstallAction_1.CLASS, false);
         this.extensionsWorkbenchService = extensionsWorkbenchService;
         this.instantiationService = instantiationService;
         this.runtimeExtensionService = runtimeExtensionService;
@@ -464,9 +531,14 @@ let InstallAction = class InstallAction extends ExtensionAction {
         this._manifest = null;
         this.updateThrottler = ( new Throttler());
         this.hideOnDisabled = false;
-        this.options = { isMachineScoped: false, ...options };
+        this.options = {
+            isMachineScoped: false,
+            ...options
+        };
         this.update();
-        this._register(allowedExtensionsService.onDidChangeAllowedExtensionsConfigValue(() => this.update()));
+        this._register(
+            allowedExtensionsService.onDidChangeAllowedExtensionsConfigValue(() => this.update())
+        );
         this._register(this.labelService.onDidChangeFormatters(() => this.updateLabel(), this));
     }
     update() {
@@ -488,7 +560,11 @@ let InstallAction = class InstallAction extends ExtensionAction {
         if (this.extension.state !== ExtensionState.Uninstalled) {
             return;
         }
-        if (this.options.installPreReleaseVersion && (!this.extension.hasPreReleaseVersion || this.allowedExtensionsService.isAllowed({ id: this.extension.identifier.id, publisherDisplayName: this.extension.publisherDisplayName, prerelease: true }) !== true)) {
+        if (this.options.installPreReleaseVersion && (!this.extension.hasPreReleaseVersion || this.allowedExtensionsService.isAllowed({
+            id: this.extension.identifier.id,
+            publisherDisplayName: this.extension.publisherDisplayName,
+            prerelease: true
+        }) !== true)) {
             return;
         }
         if (!this.options.installPreReleaseVersion && !this.extension.hasReleaseVersion) {
@@ -505,24 +581,27 @@ let InstallAction = class InstallAction extends ExtensionAction {
         if (!this.extension) {
             return;
         }
-        if (this.extension.gallery && !this.extension.gallery.isSigned && shouldRequireRepositorySignatureFor(this.extension.private, await this.extensionGalleryManifestService.getExtensionGalleryManifest())) {
-            const { result } = await this.dialogService.prompt({
+        if (this.extension.gallery && !this.extension.gallery.isSigned && shouldRequireRepositorySignatureFor(
+            this.extension.private,
+            await this.extensionGalleryManifestService.getExtensionGalleryManifest()
+        )) {
+            const {
+                result
+            } = await this.dialogService.prompt({
                 type: Severity$1.Warning,
                 message: ( localize(
-                    7515,
+                    7826,
                     "'{0}' is an extension from an unknown source. Are you sure you want to install?",
                     this.extension.displayName
                 )),
-                detail: ( localize(7530, "Extension is not signed.")),
-                buttons: [
-                    {
-                        label: ( localize(7516, "Install Anyway")),
-                        run: () => {
-                            this.options.donotVerifySignature = true;
-                            return true;
-                        }
+                detail: ( localize(7841, "Extension is not signed.")),
+                buttons: [{
+                    label: ( localize(7827, "Install Anyway")),
+                    run: () => {
+                        this.options.donotVerifySignature = true;
+                        return true;
                     }
-                ],
+                }],
                 cancelButton: {
                     run: () => false
                 }
@@ -532,65 +611,68 @@ let InstallAction = class InstallAction extends ExtensionAction {
             }
         }
         if (this.extension.deprecationInfo) {
-            let detail = ( localize(7531, "This extension is deprecated as it is no longer being maintained."));
+            let detail = ( localize(7842, "This extension is deprecated as it is no longer being maintained."));
             let DeprecationChoice;
-            (function (DeprecationChoice) {
+            (function(DeprecationChoice) {
                 DeprecationChoice[DeprecationChoice["InstallAnyway"] = 0] = "InstallAnyway";
                 DeprecationChoice[DeprecationChoice["ShowAlternateExtension"] = 1] = "ShowAlternateExtension";
                 DeprecationChoice[DeprecationChoice["ConfigureSettings"] = 2] = "ConfigureSettings";
                 DeprecationChoice[DeprecationChoice["Cancel"] = 3] = "Cancel";
             })(DeprecationChoice || (DeprecationChoice = {}));
-            const buttons = [
-                {
-                    label: ( localize(7516, "Install Anyway")),
-                    run: () => DeprecationChoice.InstallAnyway
-                }
-            ];
+            const buttons = [{
+                label: ( localize(7827, "Install Anyway")),
+                run: () => DeprecationChoice.InstallAnyway
+            }];
             if (this.extension.deprecationInfo.extension) {
                 detail = ( localize(
-                    7532,
+                    7843,
                     "This extension is deprecated. Use the {0} extension instead.",
                     this.extension.deprecationInfo.extension.displayName
                 ));
                 const alternateExtension = this.extension.deprecationInfo.extension;
                 buttons.push({
-                    label: ( localize(7533, "&&Open {0}", this.extension.deprecationInfo.extension.displayName)),
+                    label: ( localize(7844, "&&Open {0}", this.extension.deprecationInfo.extension.displayName)),
                     run: async () => {
-                        const [extension] = await this.extensionsWorkbenchService.getExtensions([{ id: alternateExtension.id, preRelease: alternateExtension.preRelease }], CancellationToken.None);
+                        const [extension] = await this.extensionsWorkbenchService.getExtensions([{
+                            id: alternateExtension.id,
+                            preRelease: alternateExtension.preRelease
+                        }], CancellationToken.None);
                         await this.extensionsWorkbenchService.open(extension);
                         return DeprecationChoice.ShowAlternateExtension;
                     }
                 });
-            }
-            else if (this.extension.deprecationInfo.settings) {
+            } else if (this.extension.deprecationInfo.settings) {
                 detail = ( localize(
-                    7534,
+                    7845,
                     "This extension is deprecated as this functionality is now built-in to VS Code."
                 ));
                 const settings = this.extension.deprecationInfo.settings;
                 buttons.push({
-                    label: ( localize(7535, "&&Configure Settings")),
+                    label: ( localize(7846, "&&Configure Settings")),
                     run: async () => {
-                        await this.preferencesService.openSettings({ query: ( settings.map(setting => `@id:${setting}`)).join(' ') });
+                        await this.preferencesService.openSettings({
+                            query: ( settings.map(setting => `@id:${setting}`)).join(" ")
+                        });
                         return DeprecationChoice.ConfigureSettings;
                     }
                 });
-            }
-            else if (this.extension.deprecationInfo.additionalInfo) {
+            } else if (this.extension.deprecationInfo.additionalInfo) {
                 detail = ( new MarkdownString(`${detail} ${this.extension.deprecationInfo.additionalInfo}`));
             }
-            const { result } = await this.dialogService.prompt({
+            const {
+                result
+            } = await this.dialogService.prompt({
                 type: Severity$1.Warning,
                 message: ( localize(
-                    7536,
+                    7847,
                     "Are you sure you want to install '{0}'?",
                     this.extension.displayName
                 )),
                 detail: isString(detail) ? detail : undefined,
                 custom: isString(detail) ? undefined : {
                     markdownDetails: [{
-                            markdown: detail
-                        }]
+                        markdown: detail
+                    }]
                 },
                 buttons,
                 cancelButton: {
@@ -601,25 +683,32 @@ let InstallAction = class InstallAction extends ExtensionAction {
                 return;
             }
         }
-        this.extensionsWorkbenchService.open(this.extension, { showPreReleaseVersion: this.options.installPreReleaseVersion });
+        this.extensionsWorkbenchService.open(this.extension, {
+            showPreReleaseVersion: this.options.installPreReleaseVersion
+        });
         alert(( localize(
-            7537,
+            7848,
             "Installing extension {0} started. An editor is now open with more details on this extension",
             this.extension.displayName
         )));
-        this.telemetryService.publicLog('extensions:action:install', { ...this.extension.telemetryData, actionId: this.id });
+        this.telemetryService.publicLog("extensions:action:install", {
+            ...this.extension.telemetryData,
+            actionId: this.id
+        });
         const extension = await this.install(this.extension);
         if (extension?.local) {
-            alert(( localize(7538, "Installing extension {0} is completed.", this.extension.displayName)));
+            alert(( localize(7849, "Installing extension {0} is completed.", this.extension.displayName)));
             const runningExtension = await this.getRunningExtension(extension.local);
-            if (runningExtension && !(runningExtension.activationEvents && ( runningExtension.activationEvents.some(activationEent => activationEent.startsWith('onLanguage'))))) {
+            if (runningExtension && !(runningExtension.activationEvents && ( runningExtension.activationEvents.some(activationEent => activationEent.startsWith("onLanguage"))))) {
                 const action = await this.getThemeAction(extension);
                 if (action) {
                     action.extension = extension;
                     try {
-                        return action.run({ showCurrentTheme: true, ignoreFocusLost: true });
-                    }
-                    finally {
+                        return action.run({
+                            showCurrentTheme: true,
+                            ignoreFocusLost: true
+                        });
+                    } finally {
                         action.dispose();
                     }
                 }
@@ -644,9 +733,15 @@ let InstallAction = class InstallAction extends ExtensionAction {
     async install(extension) {
         try {
             return await this.extensionsWorkbenchService.install(extension, this.options);
-        }
-        catch (error) {
-            await this.instantiationService.createInstance(PromptExtensionInstallFailureAction, extension, this.options, extension.latestVersion, InstallOperation.Install, error).run();
+        } catch (error) {
+            await this.instantiationService.createInstance(
+                PromptExtensionInstallFailureAction,
+                extension,
+                this.options,
+                extension.latestVersion,
+                InstallOperation.Install,
+                error
+            ).run();
             return undefined;
         }
     }
@@ -673,69 +768,88 @@ let InstallAction = class InstallAction extends ExtensionAction {
     }
     getLabel(primary) {
         if (this.extension?.isWorkspaceScoped && this.extension.resourceExtension && this.contextService.isInsideWorkspace(this.extension.resourceExtension.location)) {
-            return localize(7539, "Install Workspace Extension");
+            return localize(7850, "Install Workspace Extension");
         }
         if (this.options.installPreReleaseVersion && this.extension?.hasPreReleaseVersion) {
-            return primary ? ( localize(7540, "Install Pre-Release")) : ( localize(7541, "Install Pre-Release Version"));
+            return primary ? ( localize(7851, "Install Pre-Release")) : ( localize(7852, "Install Pre-Release Version"));
         }
         if (this.extension?.hasPreReleaseVersion) {
-            return primary ? ( localize(7529, "Install")) : ( localize(7542, "Install Release Version"));
+            return primary ? ( localize(7840, "Install")) : ( localize(7853, "Install Release Version"));
         }
-        return localize(7529, "Install");
+        return localize(7840, "Install");
     }
 };
-InstallAction = InstallAction_1 = ( __decorate([
-    ( __param(1, IExtensionsWorkbenchService)),
-    ( __param(2, IInstantiationService)),
-    ( __param(3, IExtensionService)),
-    ( __param(4, IWorkbenchThemeService)),
-    ( __param(5, ILabelService)),
-    ( __param(6, IDialogService)),
-    ( __param(7, IPreferencesService)),
-    ( __param(8, ITelemetryService)),
-    ( __param(9, IWorkspaceContextService)),
-    ( __param(10, IAllowedExtensionsService)),
-    ( __param(11, IExtensionGalleryManifestService))
-], InstallAction));
+InstallAction = InstallAction_1 = ( __decorate([( __param(1, IExtensionsWorkbenchService)), ( __param(2, IInstantiationService)), ( __param(3, IExtensionService)), ( __param(4, IWorkbenchThemeService)), ( __param(5, ILabelService)), ( __param(6, IDialogService)), ( __param(7, IPreferencesService)), ( __param(8, ITelemetryService)), ( __param(9, IWorkspaceContextService)), ( __param(10, IAllowedExtensionsService)), ( __param(11, IExtensionGalleryManifestService))], InstallAction));
 let InstallDropdownAction = class InstallDropdownAction extends ButtonWithDropDownExtensionAction {
     set manifest(manifest) {
         this.extensionActions.forEach(a => a.manifest = manifest);
         this.update();
     }
     constructor(instantiationService, extensionManagementService) {
-        super(`extensions.installActions`, InstallAction.CLASS, [
-            [
-                instantiationService.createInstance(InstallAction, { installPreReleaseVersion: extensionManagementService.preferPreReleases }),
-                instantiationService.createInstance(InstallAction, { installPreReleaseVersion: !extensionManagementService.preferPreReleases }),
-            ]
-        ]);
+        super(
+            `extensions.installActions`,
+            InstallAction.CLASS,
+            [[instantiationService.createInstance(InstallAction, {
+                installPreReleaseVersion: extensionManagementService.preferPreReleases
+            }), instantiationService.createInstance(InstallAction, {
+                installPreReleaseVersion: !extensionManagementService.preferPreReleases
+            })]]
+        );
     }
     getLabel(action) {
         return action.getLabel(true);
     }
 };
-InstallDropdownAction = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IWorkbenchExtensionManagementService))
-], InstallDropdownAction));
+InstallDropdownAction = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IWorkbenchExtensionManagementService))], InstallDropdownAction));
 class InstallingLabelAction extends ExtensionAction {
-    static { this.LABEL = ( localize(7543, "Installing")); }
-    static { this.CLASS = `${ExtensionAction.LABEL_ACTION_CLASS} install installing`; }
+    static {
+        this.LABEL = ( localize(7854, "Installing"));
+    }
+    static {
+        this.CLASS = `${ExtensionAction.LABEL_ACTION_CLASS} install installing`;
+    }
     constructor() {
-        super('extension.installing', InstallingLabelAction.LABEL, InstallingLabelAction.CLASS, false);
+        super(
+            "extension.installing",
+            InstallingLabelAction.LABEL,
+            InstallingLabelAction.CLASS,
+            false
+        );
     }
     update() {
-        this.class = `${InstallingLabelAction.CLASS}${this.extension && this.extension.state === ExtensionState.Installing ? '' : ' hide'}`;
+        this.class = `${InstallingLabelAction.CLASS}${this.extension && this.extension.state === ExtensionState.Installing ? "" : " hide"}`;
     }
 }
 let InstallInOtherServerAction = class InstallInOtherServerAction extends ExtensionAction {
-    static { InstallInOtherServerAction_1 = this; }
-    static { this.INSTALL_LABEL = ( localize(7529, "Install")); }
-    static { this.INSTALLING_LABEL = ( localize(7543, "Installing")); }
-    static { this.Class = `${ExtensionAction.LABEL_ACTION_CLASS} prominent install-other-server`; }
-    static { this.InstallingClass = `${ExtensionAction.LABEL_ACTION_CLASS} install-other-server installing`; }
-    constructor(id, server, canInstallAnyWhere, extensionsWorkbenchService, extensionManagementServerService, extensionManifestPropertiesService) {
-        super(id, InstallInOtherServerAction_1.INSTALL_LABEL, InstallInOtherServerAction_1.Class, false);
+    static {
+        InstallInOtherServerAction_1 = this;
+    }
+    static {
+        this.INSTALL_LABEL = ( localize(7840, "Install"));
+    }
+    static {
+        this.INSTALLING_LABEL = ( localize(7854, "Installing"));
+    }
+    static {
+        this.Class = `${ExtensionAction.LABEL_ACTION_CLASS} prominent install-other-server`;
+    }
+    static {
+        this.InstallingClass = `${ExtensionAction.LABEL_ACTION_CLASS} install-other-server installing`;
+    }
+    constructor(
+        id,
+        server,
+        canInstallAnyWhere,
+        extensionsWorkbenchService,
+        extensionManagementServerService,
+        extensionManifestPropertiesService
+    ) {
+        super(
+            id,
+            InstallInOtherServerAction_1.INSTALL_LABEL,
+            InstallInOtherServerAction_1.Class,
+            false
+        );
         this.server = server;
         this.canInstallAnyWhere = canInstallAnyWhere;
         this.extensionsWorkbenchService = extensionsWorkbenchService;
@@ -748,27 +862,23 @@ let InstallInOtherServerAction = class InstallInOtherServerAction extends Extens
         this.enabled = false;
         this.class = InstallInOtherServerAction_1.Class;
         if (this.canInstall()) {
-            const extensionInOtherServer = this.extensionsWorkbenchService.installed.filter(e => areSameExtensions(e.identifier, this.extension.identifier) && e.server === this.server)[0];
+            const extensionInOtherServer = this.extensionsWorkbenchService.installed.filter(
+                e => areSameExtensions(e.identifier, this.extension.identifier) && e.server === this.server
+            )[0];
             if (extensionInOtherServer) {
                 if (extensionInOtherServer.state === ExtensionState.Installing && !extensionInOtherServer.local) {
                     this.enabled = true;
                     this.label = InstallInOtherServerAction_1.INSTALLING_LABEL;
                     this.class = InstallInOtherServerAction_1.InstallingClass;
                 }
-            }
-            else {
+            } else {
                 this.enabled = true;
                 this.label = this.getInstallLabel();
             }
         }
     }
     canInstall() {
-        if (!this.extension
-            || !this.server
-            || !this.extension.local
-            || this.extension.state !== ExtensionState.Installed
-            || this.extension.type !== ExtensionType.User
-            || this.extension.enablementState === EnablementState.DisabledByEnvironment || this.extension.enablementState === EnablementState.DisabledByTrustRequirement || this.extension.enablementState === EnablementState.DisabledByVirtualWorkspace) {
+        if (!this.extension || !this.server || !this.extension.local || this.extension.state !== ExtensionState.Installed || this.extension.type !== ExtensionType.User || this.extension.enablementState === EnablementState.DisabledByEnvironment || this.extension.enablementState === EnablementState.DisabledByTrustRequirement || this.extension.enablementState === EnablementState.DisabledByVirtualWorkspace) {
             return false;
         }
         if (isLanguagePackExtension(this.extension.local.manifest)) {
@@ -805,71 +915,102 @@ let InstallInOtherServerAction = class InstallInOtherServerAction extends Extens
         }
         this.extensionsWorkbenchService.open(this.extension);
         alert(( localize(
-            7537,
+            7848,
             "Installing extension {0} started. An editor is now open with more details on this extension",
             this.extension.displayName
         )));
         return this.extensionsWorkbenchService.installInServer(this.extension, this.server);
     }
 };
-InstallInOtherServerAction = InstallInOtherServerAction_1 = ( __decorate([
-    ( __param(3, IExtensionsWorkbenchService)),
-    ( __param(4, IExtensionManagementServerService)),
-    ( __param(5, IExtensionManifestPropertiesService))
-], InstallInOtherServerAction));
+InstallInOtherServerAction = InstallInOtherServerAction_1 = ( __decorate([( __param(3, IExtensionsWorkbenchService)), ( __param(4, IExtensionManagementServerService)), ( __param(5, IExtensionManifestPropertiesService))], InstallInOtherServerAction));
 let RemoteInstallAction = class RemoteInstallAction extends InstallInOtherServerAction {
-    constructor(canInstallAnyWhere, extensionsWorkbenchService, extensionManagementServerService, extensionManifestPropertiesService) {
-        super(`extensions.remoteinstall`, extensionManagementServerService.remoteExtensionManagementServer, canInstallAnyWhere, extensionsWorkbenchService, extensionManagementServerService, extensionManifestPropertiesService);
+    constructor(
+        canInstallAnyWhere,
+        extensionsWorkbenchService,
+        extensionManagementServerService,
+        extensionManifestPropertiesService
+    ) {
+        super(
+            `extensions.remoteinstall`,
+            extensionManagementServerService.remoteExtensionManagementServer,
+            canInstallAnyWhere,
+            extensionsWorkbenchService,
+            extensionManagementServerService,
+            extensionManifestPropertiesService
+        );
     }
     getInstallLabel() {
-        return this.extensionManagementServerService.remoteExtensionManagementServer
-            ? ( localize(
-            7544,
+        return this.extensionManagementServerService.remoteExtensionManagementServer ? ( localize(
+            7855,
             "Install in {0}",
             this.extensionManagementServerService.remoteExtensionManagementServer.label
-        ))
-            : InstallInOtherServerAction.INSTALL_LABEL;
+        )) : InstallInOtherServerAction.INSTALL_LABEL;
     }
 };
-RemoteInstallAction = ( __decorate([
-    ( __param(1, IExtensionsWorkbenchService)),
-    ( __param(2, IExtensionManagementServerService)),
-    ( __param(3, IExtensionManifestPropertiesService))
-], RemoteInstallAction));
+RemoteInstallAction = ( __decorate([( __param(1, IExtensionsWorkbenchService)), ( __param(2, IExtensionManagementServerService)), ( __param(3, IExtensionManifestPropertiesService))], RemoteInstallAction));
 let LocalInstallAction = class LocalInstallAction extends InstallInOtherServerAction {
-    constructor(extensionsWorkbenchService, extensionManagementServerService, extensionManifestPropertiesService) {
-        super(`extensions.localinstall`, extensionManagementServerService.localExtensionManagementServer, false, extensionsWorkbenchService, extensionManagementServerService, extensionManifestPropertiesService);
+    constructor(
+        extensionsWorkbenchService,
+        extensionManagementServerService,
+        extensionManifestPropertiesService
+    ) {
+        super(
+            `extensions.localinstall`,
+            extensionManagementServerService.localExtensionManagementServer,
+            false,
+            extensionsWorkbenchService,
+            extensionManagementServerService,
+            extensionManifestPropertiesService
+        );
     }
     getInstallLabel() {
-        return localize(7545, "Install Locally");
+        return localize(7856, "Install Locally");
     }
 };
-LocalInstallAction = ( __decorate([
-    ( __param(0, IExtensionsWorkbenchService)),
-    ( __param(1, IExtensionManagementServerService)),
-    ( __param(2, IExtensionManifestPropertiesService))
-], LocalInstallAction));
+LocalInstallAction = ( __decorate([( __param(0, IExtensionsWorkbenchService)), ( __param(1, IExtensionManagementServerService)), ( __param(2, IExtensionManifestPropertiesService))], LocalInstallAction));
 let WebInstallAction = class WebInstallAction extends InstallInOtherServerAction {
-    constructor(extensionsWorkbenchService, extensionManagementServerService, extensionManifestPropertiesService) {
-        super(`extensions.webInstall`, extensionManagementServerService.webExtensionManagementServer, false, extensionsWorkbenchService, extensionManagementServerService, extensionManifestPropertiesService);
+    constructor(
+        extensionsWorkbenchService,
+        extensionManagementServerService,
+        extensionManifestPropertiesService
+    ) {
+        super(
+            `extensions.webInstall`,
+            extensionManagementServerService.webExtensionManagementServer,
+            false,
+            extensionsWorkbenchService,
+            extensionManagementServerService,
+            extensionManifestPropertiesService
+        );
     }
     getInstallLabel() {
-        return localize(7546, "Install in Browser");
+        return localize(7857, "Install in Browser");
     }
 };
-WebInstallAction = ( __decorate([
-    ( __param(0, IExtensionsWorkbenchService)),
-    ( __param(1, IExtensionManagementServerService)),
-    ( __param(2, IExtensionManifestPropertiesService))
-], WebInstallAction));
+WebInstallAction = ( __decorate([( __param(0, IExtensionsWorkbenchService)), ( __param(1, IExtensionManagementServerService)), ( __param(2, IExtensionManifestPropertiesService))], WebInstallAction));
 let UninstallAction = class UninstallAction extends ExtensionAction {
-    static { UninstallAction_1 = this; }
-    static { this.UninstallLabel = ( localize(7547, "Uninstall")); }
-    static { this.UninstallingLabel = ( localize(7548, "Uninstalling")); }
-    static { this.UninstallClass = `${ExtensionAction.LABEL_ACTION_CLASS} uninstall`; }
-    static { this.UnInstallingClass = `${ExtensionAction.LABEL_ACTION_CLASS} uninstall uninstalling`; }
+    static {
+        UninstallAction_1 = this;
+    }
+    static {
+        this.UninstallLabel = ( localize(7858, "Uninstall"));
+    }
+    static {
+        this.UninstallingLabel = ( localize(7859, "Uninstalling"));
+    }
+    static {
+        this.UninstallClass = `${ExtensionAction.LABEL_ACTION_CLASS} uninstall`;
+    }
+    static {
+        this.UnInstallingClass = `${ExtensionAction.LABEL_ACTION_CLASS} uninstall uninstalling`;
+    }
     constructor(extensionsWorkbenchService, userDataProfilesService, dialogService) {
-        super('extensions.uninstall', UninstallAction_1.UninstallLabel, UninstallAction_1.UninstallClass, false);
+        super(
+            "extensions.uninstall",
+            UninstallAction_1.UninstallLabel,
+            UninstallAction_1.UninstallClass,
+            false
+        );
         this.extensionsWorkbenchService = extensionsWorkbenchService;
         this.userDataProfilesService = userDataProfilesService;
         this.dialogService = dialogService;
@@ -887,7 +1028,7 @@ let UninstallAction = class UninstallAction extends ExtensionAction {
             this.enabled = false;
             return;
         }
-        this.label = this.extension.local?.isApplicationScoped && this.userDataProfilesService.profiles.length > 1 ? ( localize(7549, "Uninstall (All Profiles)")) : UninstallAction_1.UninstallLabel;
+        this.label = this.extension.local?.isApplicationScoped && this.userDataProfilesService.profiles.length > 1 ? ( localize(7860, "Uninstall (All Profiles)")) : UninstallAction_1.UninstallLabel;
         this.class = UninstallAction_1.UninstallClass;
         this.tooltip = UninstallAction_1.UninstallLabel;
         if (state !== ExtensionState.Installed) {
@@ -904,33 +1045,40 @@ let UninstallAction = class UninstallAction extends ExtensionAction {
         if (!this.extension) {
             return;
         }
-        alert(( localize(7550, "Uninstalling extension {0} started.", this.extension.displayName)));
+        alert(( localize(7861, "Uninstalling extension {0} started.", this.extension.displayName)));
         try {
             await this.extensionsWorkbenchService.uninstall(this.extension);
             alert(( localize(
-                7551,
+                7862,
                 "Please reload Visual Studio Code to complete the uninstallation of the extension {0}.",
                 this.extension.displayName
             )));
-        }
-        catch (error) {
+        } catch (error) {
             if (!isCancellationError(error)) {
                 this.dialogService.error(getErrorMessage(error));
             }
         }
     }
 };
-UninstallAction = UninstallAction_1 = ( __decorate([
-    ( __param(0, IExtensionsWorkbenchService)),
-    ( __param(1, IUserDataProfilesService)),
-    ( __param(2, IDialogService))
-], UninstallAction));
+UninstallAction = UninstallAction_1 = ( __decorate([( __param(0, IExtensionsWorkbenchService)), ( __param(1, IUserDataProfilesService)), ( __param(2, IDialogService))], UninstallAction));
 let UpdateAction = class UpdateAction extends ExtensionAction {
-    static { UpdateAction_1 = this; }
-    static { this.EnabledClass = `${this.LABEL_ACTION_CLASS} update`; }
-    static { this.DisabledClass = `${this.EnabledClass} disabled`; }
-    constructor(verbose, extensionsWorkbenchService, dialogService, openerService, instantiationService) {
-        super(`extensions.update`, ( localize(7552, "Update")), UpdateAction_1.DisabledClass, false);
+    static {
+        UpdateAction_1 = this;
+    }
+    static {
+        this.EnabledClass = `${this.LABEL_ACTION_CLASS} update`;
+    }
+    static {
+        this.DisabledClass = `${this.EnabledClass} disabled`;
+    }
+    constructor(
+        verbose,
+        extensionsWorkbenchService,
+        dialogService,
+        openerService,
+        instantiationService
+    ) {
+        super(`extensions.update`, ( localize(7863, "Update")), UpdateAction_1.DisabledClass, false);
         this.verbose = verbose;
         this.extensionsWorkbenchService = extensionsWorkbenchService;
         this.dialogService = dialogService;
@@ -942,7 +1090,7 @@ let UpdateAction = class UpdateAction extends ExtensionAction {
     update() {
         this.updateThrottler.queue(() => this.computeAndUpdateEnablement());
         if (this.extension) {
-            this.label = this.verbose ? ( localize(7553, "Update to v{0}", this.extension.latestVersion)) : ( localize(7552, "Update"));
+            this.label = this.verbose ? ( localize(7864, "Update to v{0}", this.extension.latestVersion)) : ( localize(7863, "Update"));
         }
     }
     async computeAndUpdateEnablement() {
@@ -965,27 +1113,31 @@ let UpdateAction = class UpdateAction extends ExtensionAction {
         }
         const consent = await this.extensionsWorkbenchService.shouldRequireConsentToUpdate(this.extension);
         if (consent) {
-            const { result } = await this.dialogService.prompt({
-                type: 'warning',
-                title: ( localize(7554, "Update {0} Extension", this.extension.displayName)),
-                message: ( localize(7555, "{0}\n\nWould you like to update the extension?", consent)),
+            const {
+                result
+            } = await this.dialogService.prompt({
+                type: "warning",
+                title: ( localize(7865, "Update {0} Extension", this.extension.displayName)),
+                message: ( localize(7866, "{0}\n\nWould you like to update the extension?", consent)),
                 buttons: [{
-                        label: ( localize(7552, "Update")),
-                        run: () => 'update'
-                    }, {
-                        label: ( localize(7556, "Review")),
-                        run: () => 'review'
-                    }, {
-                        label: ( localize(7514, "Cancel")),
-                        run: () => 'cancel'
-                    }]
+                    label: ( localize(7863, "Update")),
+                    run: () => "update"
+                }, {
+                    label: ( localize(7867, "Review")),
+                    run: () => "review"
+                }, {
+                    label: ( localize(7825, "Cancel")),
+                    run: () => "cancel"
+                }]
             });
-            if (result === 'cancel') {
+            if (result === "cancel") {
                 return;
             }
-            if (result === 'review') {
+            if (result === "review") {
                 if (this.extension.hasChangelog()) {
-                    return this.extensionsWorkbenchService.open(this.extension, { tab: ExtensionEditorTab.Changelog });
+                    return this.extensionsWorkbenchService.open(this.extension, {
+                        tab: ExtensionEditorTab.Changelog
+                    });
                 }
                 if (this.extension.repository) {
                     return this.openerService.open(this.extension.repository);
@@ -994,7 +1146,7 @@ let UpdateAction = class UpdateAction extends ExtensionAction {
             }
         }
         const installOptions = {};
-        if (this.extension.local?.source === 'vsix' && this.extension.local.pinned) {
+        if (this.extension.local?.source === "vsix" && this.extension.local.pinned) {
             installOptions.pinned = false;
         }
         if (this.extension.local?.preRelease) {
@@ -1002,38 +1154,58 @@ let UpdateAction = class UpdateAction extends ExtensionAction {
         }
         try {
             alert(( localize(
-                7557,
+                7868,
                 "Updating extension {0} to version {1} started.",
                 this.extension.displayName,
                 this.extension.latestVersion
             )));
             await this.extensionsWorkbenchService.install(this.extension, installOptions);
             alert(( localize(
-                7558,
+                7869,
                 "Updating extension {0} to version {1} completed.",
                 this.extension.displayName,
                 this.extension.latestVersion
             )));
-        }
-        catch (err) {
-            this.instantiationService.createInstance(PromptExtensionInstallFailureAction, this.extension, installOptions, this.extension.latestVersion, InstallOperation.Update, err).run();
+        } catch (err) {
+            this.instantiationService.createInstance(
+                PromptExtensionInstallFailureAction,
+                this.extension,
+                installOptions,
+                this.extension.latestVersion,
+                InstallOperation.Update,
+                err
+            ).run();
         }
     }
 };
-UpdateAction = UpdateAction_1 = ( __decorate([
-    ( __param(1, IExtensionsWorkbenchService)),
-    ( __param(2, IDialogService)),
-    ( __param(3, IOpenerService)),
-    ( __param(4, IInstantiationService))
-], UpdateAction));
+UpdateAction = UpdateAction_1 = ( __decorate([( __param(1, IExtensionsWorkbenchService)), ( __param(2, IDialogService)), ( __param(3, IOpenerService)), ( __param(4, IInstantiationService))], UpdateAction));
 let ToggleAutoUpdateForExtensionAction = class ToggleAutoUpdateForExtensionAction extends ExtensionAction {
-    static { ToggleAutoUpdateForExtensionAction_1 = this; }
-    static { this.ID = 'workbench.extensions.action.toggleAutoUpdateForExtension'; }
-    static { this.LABEL = ( localize2(7559, "Auto Update")); }
-    static { this.EnabledClass = `${ExtensionAction.EXTENSION_ACTION_CLASS} auto-update`; }
-    static { this.DisabledClass = `${this.EnabledClass} hide`; }
-    constructor(extensionsWorkbenchService, extensionEnablementService, allowedExtensionsService, configurationService) {
-        super(ToggleAutoUpdateForExtensionAction_1.ID, ToggleAutoUpdateForExtensionAction_1.LABEL.value, ToggleAutoUpdateForExtensionAction_1.DisabledClass);
+    static {
+        ToggleAutoUpdateForExtensionAction_1 = this;
+    }
+    static {
+        this.ID = "workbench.extensions.action.toggleAutoUpdateForExtension";
+    }
+    static {
+        this.LABEL = ( localize2(7870, "Auto Update"));
+    }
+    static {
+        this.EnabledClass = `${ExtensionAction.EXTENSION_ACTION_CLASS} auto-update`;
+    }
+    static {
+        this.DisabledClass = `${this.EnabledClass} hide`;
+    }
+    constructor(
+        extensionsWorkbenchService,
+        extensionEnablementService,
+        allowedExtensionsService,
+        configurationService
+    ) {
+        super(
+            ToggleAutoUpdateForExtensionAction_1.ID,
+            ToggleAutoUpdateForExtensionAction_1.LABEL.value,
+            ToggleAutoUpdateForExtensionAction_1.DisabledClass
+        );
         this.extensionsWorkbenchService = extensionsWorkbenchService;
         this.extensionEnablementService = extensionEnablementService;
         this.allowedExtensionsService = allowedExtensionsService;
@@ -1042,7 +1214,9 @@ let ToggleAutoUpdateForExtensionAction = class ToggleAutoUpdateForExtensionActio
                 this.update();
             }
         }));
-        this._register(allowedExtensionsService.onDidChangeAllowedExtensionsConfigValue(e => this.update()));
+        this._register(
+            allowedExtensionsService.onDidChangeAllowedExtensionsConfigValue(e => this.update())
+        );
         this.update();
     }
     update() {
@@ -1061,7 +1235,7 @@ let ToggleAutoUpdateForExtensionAction = class ToggleAutoUpdateForExtensionActio
         if (extension && this.allowedExtensionsService.isAllowed(extension) !== true) {
             return;
         }
-        if (this.extensionsWorkbenchService.getAutoUpdateValue() === 'onlyEnabledExtensions' && !this.extensionEnablementService.isEnabledEnablementState(this.extension.enablementState)) {
+        if (this.extensionsWorkbenchService.getAutoUpdateValue() === "onlyEnabledExtensions" && !this.extensionEnablementService.isEnabledEnablementState(this.extension.enablementState)) {
             return;
         }
         this.enabled = true;
@@ -1075,56 +1249,62 @@ let ToggleAutoUpdateForExtensionAction = class ToggleAutoUpdateForExtensionActio
         const enableAutoUpdate = !this.extensionsWorkbenchService.isAutoUpdateEnabledFor(this.extension);
         await this.extensionsWorkbenchService.updateAutoUpdateEnablementFor(this.extension, enableAutoUpdate);
         if (enableAutoUpdate) {
-            alert(( localize(7560, "Enabled auto updates for", this.extension.displayName)));
-        }
-        else {
-            alert(( localize(7561, "Disabled auto updates for", this.extension.displayName)));
+            alert(( localize(7871, "Enabled auto updates for", this.extension.displayName)));
+        } else {
+            alert(( localize(7872, "Disabled auto updates for", this.extension.displayName)));
         }
     }
 };
-ToggleAutoUpdateForExtensionAction = ToggleAutoUpdateForExtensionAction_1 = ( __decorate([
-    ( __param(0, IExtensionsWorkbenchService)),
-    ( __param(1, IWorkbenchExtensionEnablementService)),
-    ( __param(2, IAllowedExtensionsService)),
-    ( __param(3, IConfigurationService))
-], ToggleAutoUpdateForExtensionAction));
+ToggleAutoUpdateForExtensionAction = ToggleAutoUpdateForExtensionAction_1 = ( __decorate([( __param(0, IExtensionsWorkbenchService)), ( __param(1, IWorkbenchExtensionEnablementService)), ( __param(2, IAllowedExtensionsService)), ( __param(3, IConfigurationService))], ToggleAutoUpdateForExtensionAction));
 let ToggleAutoUpdatesForPublisherAction = class ToggleAutoUpdatesForPublisherAction extends ExtensionAction {
-    static { ToggleAutoUpdatesForPublisherAction_1 = this; }
-    static { this.ID = 'workbench.extensions.action.toggleAutoUpdatesForPublisher'; }
-    static { this.LABEL = ( localize(7562, "Auto Update All (From Publisher)")); }
+    static {
+        ToggleAutoUpdatesForPublisherAction_1 = this;
+    }
+    static {
+        this.ID = "workbench.extensions.action.toggleAutoUpdatesForPublisher";
+    }
+    static {
+        this.LABEL = ( localize(7873, "Auto Update All (From Publisher)"));
+    }
     constructor(extensionsWorkbenchService) {
-        super(ToggleAutoUpdatesForPublisherAction_1.ID, ToggleAutoUpdatesForPublisherAction_1.LABEL);
+        super(
+            ToggleAutoUpdatesForPublisherAction_1.ID,
+            ToggleAutoUpdatesForPublisherAction_1.LABEL
+        );
         this.extensionsWorkbenchService = extensionsWorkbenchService;
     }
-    update() { }
+    update() {}
     async run() {
         if (!this.extension) {
             return;
         }
         alert(( localize(
-            7563,
+            7874,
             "Ignoring updates published by {0}.",
             this.extension.publisherDisplayName
         )));
         const enableAutoUpdate = !this.extensionsWorkbenchService.isAutoUpdateEnabledFor(this.extension.publisher);
         await this.extensionsWorkbenchService.updateAutoUpdateEnablementFor(this.extension.publisher, enableAutoUpdate);
         if (enableAutoUpdate) {
-            alert(( localize(7560, "Enabled auto updates for", this.extension.displayName)));
-        }
-        else {
-            alert(( localize(7561, "Disabled auto updates for", this.extension.displayName)));
+            alert(( localize(7871, "Enabled auto updates for", this.extension.displayName)));
+        } else {
+            alert(( localize(7872, "Disabled auto updates for", this.extension.displayName)));
         }
     }
 };
-ToggleAutoUpdatesForPublisherAction = ToggleAutoUpdatesForPublisherAction_1 = ( __decorate([
-    ( __param(0, IExtensionsWorkbenchService))
-], ToggleAutoUpdatesForPublisherAction));
+ToggleAutoUpdatesForPublisherAction = ToggleAutoUpdatesForPublisherAction_1 = ( __decorate([( __param(0, IExtensionsWorkbenchService))], ToggleAutoUpdatesForPublisherAction));
 let MigrateDeprecatedExtensionAction = class MigrateDeprecatedExtensionAction extends ExtensionAction {
-    static { MigrateDeprecatedExtensionAction_1 = this; }
-    static { this.EnabledClass = `${ExtensionAction.LABEL_ACTION_CLASS} migrate`; }
-    static { this.DisabledClass = `${this.EnabledClass} disabled`; }
+    static {
+        MigrateDeprecatedExtensionAction_1 = this;
+    }
+    static {
+        this.EnabledClass = `${ExtensionAction.LABEL_ACTION_CLASS} migrate`;
+    }
+    static {
+        this.DisabledClass = `${this.EnabledClass} disabled`;
+    }
     constructor(small, extensionsWorkbenchService) {
-        super('extensionsAction.migrateDeprecatedExtension', ( localize(7564, "Migrate")), MigrateDeprecatedExtensionAction_1.DisabledClass, false);
+        super("extensionsAction.migrateDeprecatedExtension", ( localize(7875, "Migrate")), MigrateDeprecatedExtensionAction_1.DisabledClass, false);
         this.small = small;
         this.extensionsWorkbenchService = extensionsWorkbenchService;
         this.update();
@@ -1142,17 +1322,19 @@ let MigrateDeprecatedExtensionAction = class MigrateDeprecatedExtensionAction ex
             return;
         }
         const id = this.extension.deprecationInfo.extension.id;
-        if (( this.extensionsWorkbenchService.local.some(e => areSameExtensions(e.identifier, { id })))) {
+        if (( this.extensionsWorkbenchService.local.some(e => areSameExtensions(e.identifier, {
+            id
+        })))) {
             return;
         }
         this.enabled = true;
         this.class = MigrateDeprecatedExtensionAction_1.EnabledClass;
         this.tooltip = ( localize(
-            7565,
+            7876,
             "Migrate to {0}",
             this.extension.deprecationInfo.extension.displayName
         ));
-        this.label = this.small ? ( localize(7566, "Migrate")) : this.tooltip;
+        this.label = this.small ? ( localize(7877, "Migrate")) : this.tooltip;
     }
     async run() {
         if (!this.extension?.deprecationInfo?.extension) {
@@ -1160,13 +1342,16 @@ let MigrateDeprecatedExtensionAction = class MigrateDeprecatedExtensionAction ex
         }
         const local = this.extension.local;
         await this.extensionsWorkbenchService.uninstall(this.extension);
-        const [extension] = await this.extensionsWorkbenchService.getExtensions([{ id: this.extension.deprecationInfo.extension.id, preRelease: this.extension.deprecationInfo?.extension?.preRelease }], CancellationToken.None);
-        await this.extensionsWorkbenchService.install(extension, { isMachineScoped: local?.isMachineScoped });
+        const [extension] = await this.extensionsWorkbenchService.getExtensions([{
+            id: this.extension.deprecationInfo.extension.id,
+            preRelease: this.extension.deprecationInfo?.extension?.preRelease
+        }], CancellationToken.None);
+        await this.extensionsWorkbenchService.install(extension, {
+            isMachineScoped: local?.isMachineScoped
+        });
     }
 };
-MigrateDeprecatedExtensionAction = MigrateDeprecatedExtensionAction_1 = ( __decorate([
-    ( __param(1, IExtensionsWorkbenchService))
-], MigrateDeprecatedExtensionAction));
+MigrateDeprecatedExtensionAction = MigrateDeprecatedExtensionAction_1 = ( __decorate([( __param(1, IExtensionsWorkbenchService))], MigrateDeprecatedExtensionAction));
 let DropDownExtensionAction = class DropDownExtensionAction extends ExtensionAction {
     constructor(id, label, cssClass, enabled, instantiationService) {
         super(id, label, cssClass, enabled);
@@ -1182,19 +1367,24 @@ let DropDownExtensionAction = class DropDownExtensionAction extends ExtensionAct
         return Promise.resolve();
     }
 };
-DropDownExtensionAction = ( __decorate([
-    ( __param(4, IInstantiationService))
-], DropDownExtensionAction));
+DropDownExtensionAction = ( __decorate([( __param(4, IInstantiationService))], DropDownExtensionAction));
 let DropDownExtensionActionViewItem = class DropDownExtensionActionViewItem extends ActionViewItem {
     constructor(action, options, contextMenuService) {
-        super(null, action, { ...options, icon: true, label: true });
+        super(null, action, {
+            ...options,
+            icon: true,
+            label: true
+        });
         this.contextMenuService = contextMenuService;
     }
     showMenu(menuActionGroups) {
         if (this.element) {
             const actions = this.getActions(menuActionGroups);
             const elementPosition = getDomNodePagePosition(this.element);
-            const anchor = { x: elementPosition.left, y: elementPosition.top + elementPosition.height + 10 };
+            const anchor = {
+                x: elementPosition.left,
+                y: elementPosition.top + elementPosition.height + 10
+            };
             this.contextMenuService.showContextMenu({
                 getAnchor: () => anchor,
                 getActions: () => actions,
@@ -1211,11 +1401,9 @@ let DropDownExtensionActionViewItem = class DropDownExtensionActionViewItem exte
         return actions.length ? actions.slice(0, actions.length - 1) : actions;
     }
 };
-DropDownExtensionActionViewItem = ( __decorate([
-    ( __param(2, IContextMenuService))
-], DropDownExtensionActionViewItem));
+DropDownExtensionActionViewItem = ( __decorate([( __param(2, IContextMenuService))], DropDownExtensionActionViewItem));
 async function getContextMenuActionsGroups(extension, contextKeyService, instantiationService) {
-    return instantiationService.invokeFunction(async (accessor) => {
+    return instantiationService.invokeFunction(async accessor => {
         const extensionsWorkbenchService = accessor.get(IExtensionsWorkbenchService);
         const extensionEnablementService = accessor.get(IWorkbenchExtensionEnablementService);
         const menuService = accessor.get(IMenuService);
@@ -1226,57 +1414,110 @@ async function getContextMenuActionsGroups(extension, contextKeyService, instant
         const allowedExtensionsService = accessor.get(IAllowedExtensionsService);
         const cksOverlay = [];
         if (extension) {
-            cksOverlay.push(['extension', extension.identifier.id]);
-            cksOverlay.push(['isBuiltinExtension', extension.isBuiltin]);
-            cksOverlay.push(['isDefaultApplicationScopedExtension', extension.local && isApplicationScopedExtension(extension.local.manifest)]);
-            cksOverlay.push(['isApplicationScopedExtension', extension.local && extension.local.isApplicationScoped]);
-            cksOverlay.push(['isWorkspaceScopedExtension', extension.isWorkspaceScoped]);
-            cksOverlay.push(['isGalleryExtension', !!extension.identifier.uuid]);
+            cksOverlay.push(["extension", extension.identifier.id]);
+            cksOverlay.push(["isBuiltinExtension", extension.isBuiltin]);
+            cksOverlay.push([
+                "isDefaultApplicationScopedExtension",
+                extension.local && isApplicationScopedExtension(extension.local.manifest)
+            ]);
+            cksOverlay.push([
+                "isApplicationScopedExtension",
+                extension.local && extension.local.isApplicationScoped
+            ]);
+            cksOverlay.push(["isWorkspaceScopedExtension", extension.isWorkspaceScoped]);
+            cksOverlay.push(["isGalleryExtension", !!extension.identifier.uuid]);
             if (extension.local) {
-                cksOverlay.push(['extensionSource', extension.local.source]);
-            }
-            cksOverlay.push(['extensionHasConfiguration', extension.local && !!extension.local.manifest.contributes && !!extension.local.manifest.contributes.configuration]);
-            cksOverlay.push(['extensionHasKeybindings', extension.local && !!extension.local.manifest.contributes && !!extension.local.manifest.contributes.keybindings]);
-            cksOverlay.push(['extensionHasCommands', extension.local && !!extension.local.manifest.contributes && !!extension.local.manifest.contributes?.commands]);
-            cksOverlay.push(['isExtensionRecommended', !!extensionRecommendationsService.getAllRecommendationsWithReason()[extension.identifier.id.toLowerCase()]]);
-            cksOverlay.push(['isExtensionWorkspaceRecommended', extensionRecommendationsService.getAllRecommendationsWithReason()[extension.identifier.id.toLowerCase()]?.reasonId === ExtensionRecommendationReason.Workspace]);
-            cksOverlay.push(['isUserIgnoredRecommendation', ( extensionIgnoredRecommendationsService.globalIgnoredRecommendations.some(e => e === extension.identifier.id.toLowerCase()))]);
-            cksOverlay.push(['isExtensionPinned', extension.pinned]);
-            cksOverlay.push(['isExtensionEnabled', extensionEnablementService.isEnabledEnablementState(extension.enablementState)]);
+                cksOverlay.push(["extensionSource", extension.local.source]);
+            }
+            cksOverlay.push([
+                "extensionHasConfiguration",
+                extension.local && !!extension.local.manifest.contributes && !!extension.local.manifest.contributes.configuration
+            ]);
+            cksOverlay.push([
+                "extensionHasKeybindings",
+                extension.local && !!extension.local.manifest.contributes && !!extension.local.manifest.contributes.keybindings
+            ]);
+            cksOverlay.push([
+                "extensionHasCommands",
+                extension.local && !!extension.local.manifest.contributes && !!extension.local.manifest.contributes?.commands
+            ]);
+            cksOverlay.push([
+                "isExtensionRecommended",
+                !!extensionRecommendationsService.getAllRecommendationsWithReason()[extension.identifier.id.toLowerCase()]
+            ]);
+            cksOverlay.push([
+                "isExtensionWorkspaceRecommended",
+                extensionRecommendationsService.getAllRecommendationsWithReason()[extension.identifier.id.toLowerCase()]?.reasonId === ExtensionRecommendationReason.Workspace
+            ]);
+            cksOverlay.push(["isUserIgnoredRecommendation", ( extensionIgnoredRecommendationsService.globalIgnoredRecommendations.some(e => e === extension.identifier.id.toLowerCase()))]);
+            cksOverlay.push(["isExtensionPinned", extension.pinned]);
+            cksOverlay.push([
+                "isExtensionEnabled",
+                extensionEnablementService.isEnabledEnablementState(extension.enablementState)
+            ]);
             switch (extension.state) {
-                case ExtensionState.Installing:
-                    cksOverlay.push(['extensionStatus', 'installing']);
-                    break;
-                case ExtensionState.Installed:
-                    cksOverlay.push(['extensionStatus', 'installed']);
-                    break;
-                case ExtensionState.Uninstalling:
-                    cksOverlay.push(['extensionStatus', 'uninstalling']);
-                    break;
-                case ExtensionState.Uninstalled:
-                    cksOverlay.push(['extensionStatus', 'uninstalled']);
-                    break;
-            }
-            cksOverlay.push(['installedExtensionIsPreReleaseVersion', !!extension.local?.isPreReleaseVersion]);
-            cksOverlay.push(['installedExtensionIsOptedToPreRelease', !!extension.local?.preRelease]);
-            cksOverlay.push(['galleryExtensionIsPreReleaseVersion', !!extension.gallery?.properties.isPreReleaseVersion]);
-            cksOverlay.push(['galleryExtensionHasPreReleaseVersion', extension.gallery?.hasPreReleaseVersion]);
-            cksOverlay.push(['extensionHasPreReleaseVersion', extension.hasPreReleaseVersion]);
-            cksOverlay.push(['extensionHasReleaseVersion', extension.hasReleaseVersion]);
-            cksOverlay.push(['extensionDisallowInstall', extension.isMalicious || extension.deprecationInfo?.disallowInstall]);
-            cksOverlay.push(['isExtensionAllowed', allowedExtensionsService.isAllowed({ id: extension.identifier.id, publisherDisplayName: extension.publisherDisplayName }) === true]);
-            cksOverlay.push(['isPreReleaseExtensionAllowed', allowedExtensionsService.isAllowed({ id: extension.identifier.id, publisherDisplayName: extension.publisherDisplayName, prerelease: true }) === true]);
-            cksOverlay.push(['extensionIsUnsigned', extension.gallery && !extension.gallery.isSigned]);
-            cksOverlay.push(['extensionIsPrivate', extension.gallery?.private]);
-            const [colorThemes, fileIconThemes, productIconThemes, extensionUsesAuth] = await Promise.all([workbenchThemeService.getColorThemes(), workbenchThemeService.getFileIconThemes(), workbenchThemeService.getProductIconThemes(), authenticationUsageService.extensionUsesAuth(extension.identifier.id.toLowerCase())]);
-            cksOverlay.push(['extensionHasColorThemes', ( colorThemes.some(theme => isThemeFromExtension(theme, extension)))]);
-            cksOverlay.push(['extensionHasFileIconThemes', ( fileIconThemes.some(theme => isThemeFromExtension(theme, extension)))]);
-            cksOverlay.push(['extensionHasProductIconThemes', ( productIconThemes.some(theme => isThemeFromExtension(theme, extension)))]);
-            cksOverlay.push(['extensionHasAccountPreferences', extensionUsesAuth]);
-            cksOverlay.push(['canSetLanguage', extensionsWorkbenchService.canSetLanguage(extension)]);
-            cksOverlay.push(['isActiveLanguagePackExtension', extension.gallery && language === getLocale(extension.gallery)]);
-        }
-        const actionsGroups = menuService.getMenuActions(MenuId.ExtensionContext, contextKeyService.createOverlay(cksOverlay), { shouldForwardArgs: true });
+            case ExtensionState.Installing:
+                cksOverlay.push(["extensionStatus", "installing"]);
+                break;
+            case ExtensionState.Installed:
+                cksOverlay.push(["extensionStatus", "installed"]);
+                break;
+            case ExtensionState.Uninstalling:
+                cksOverlay.push(["extensionStatus", "uninstalling"]);
+                break;
+            case ExtensionState.Uninstalled:
+                cksOverlay.push(["extensionStatus", "uninstalled"]);
+                break;
+            }
+            cksOverlay.push([
+                "installedExtensionIsPreReleaseVersion",
+                !!extension.local?.isPreReleaseVersion
+            ]);
+            cksOverlay.push(["installedExtensionIsOptedToPreRelease", !!extension.local?.preRelease]);
+            cksOverlay.push([
+                "galleryExtensionIsPreReleaseVersion",
+                !!extension.gallery?.properties.isPreReleaseVersion
+            ]);
+            cksOverlay.push([
+                "galleryExtensionHasPreReleaseVersion",
+                extension.gallery?.hasPreReleaseVersion
+            ]);
+            cksOverlay.push(["extensionHasPreReleaseVersion", extension.hasPreReleaseVersion]);
+            cksOverlay.push(["extensionHasReleaseVersion", extension.hasReleaseVersion]);
+            cksOverlay.push([
+                "extensionDisallowInstall",
+                extension.isMalicious || extension.deprecationInfo?.disallowInstall
+            ]);
+            cksOverlay.push(["isExtensionAllowed", allowedExtensionsService.isAllowed({
+                id: extension.identifier.id,
+                publisherDisplayName: extension.publisherDisplayName
+            }) === true]);
+            cksOverlay.push(["isPreReleaseExtensionAllowed", allowedExtensionsService.isAllowed({
+                id: extension.identifier.id,
+                publisherDisplayName: extension.publisherDisplayName,
+                prerelease: true
+            }) === true]);
+            cksOverlay.push(["extensionIsUnsigned", extension.gallery && !extension.gallery.isSigned]);
+            cksOverlay.push(["extensionIsPrivate", extension.gallery?.private]);
+            const [colorThemes, fileIconThemes, productIconThemes, extensionUsesAuth] = await Promise.all([
+                workbenchThemeService.getColorThemes(),
+                workbenchThemeService.getFileIconThemes(),
+                workbenchThemeService.getProductIconThemes(),
+                authenticationUsageService.extensionUsesAuth(extension.identifier.id.toLowerCase())
+            ]);
+            cksOverlay.push(["extensionHasColorThemes", ( colorThemes.some(theme => isThemeFromExtension(theme, extension)))]);
+            cksOverlay.push(["extensionHasFileIconThemes", ( fileIconThemes.some(theme => isThemeFromExtension(theme, extension)))]);
+            cksOverlay.push(["extensionHasProductIconThemes", ( productIconThemes.some(theme => isThemeFromExtension(theme, extension)))]);
+            cksOverlay.push(["extensionHasAccountPreferences", extensionUsesAuth]);
+            cksOverlay.push(["canSetLanguage", extensionsWorkbenchService.canSetLanguage(extension)]);
+            cksOverlay.push([
+                "isActiveLanguagePackExtension",
+                extension.gallery && language === getLocale(extension.gallery)
+            ]);
+        }
+        const actionsGroups = menuService.getMenuActions(MenuId.ExtensionContext, contextKeyService.createOverlay(cksOverlay), {
+            shouldForwardArgs: true
+        });
         return actionsGroups;
     });
 }
@@ -1297,15 +1538,23 @@ async function getContextMenuActions(extension, contextKeyService, instantiation
     return toActions(actionsGroups, instantiationService);
 }
 let ManageExtensionAction = class ManageExtensionAction extends DropDownExtensionAction {
-    static { ManageExtensionAction_1 = this; }
-    static { this.ID = 'extensions.manage'; }
-    static { this.Class = `${ExtensionAction.ICON_ACTION_CLASS} manage ` + ThemeIcon.asClassName(manageExtensionIcon); }
-    static { this.HideManageExtensionClass = `${this.Class} hide`; }
+    static {
+        ManageExtensionAction_1 = this;
+    }
+    static {
+        this.ID = "extensions.manage";
+    }
+    static {
+        this.Class = `${ExtensionAction.ICON_ACTION_CLASS} manage ` + ThemeIcon.asClassName(manageExtensionIcon);
+    }
+    static {
+        this.HideManageExtensionClass = `${this.Class} hide`;
+    }
     constructor(instantiationService, extensionService, contextKeyService) {
-        super(ManageExtensionAction_1.ID, '', '', true, instantiationService);
+        super(ManageExtensionAction_1.ID, "", "", true, instantiationService);
         this.extensionService = extensionService;
         this.contextKeyService = contextKeyService;
-        this.tooltip = ( localize(7567, "Manage"));
+        this.tooltip = ( localize(7878, "Manage"));
         this.update();
     }
     async getActionGroups() {
@@ -1315,14 +1564,11 @@ let ManageExtensionAction = class ManageExtensionAction extends DropDownExtensio
         for (const [group, actions] of contextMenuActionsGroups) {
             if (group === INSTALL_ACTIONS_GROUP) {
                 installActions.push(...toActions([[group, actions]], this.instantiationService)[0]);
-            }
-            else if (group === UPDATE_ACTIONS_GROUP) {
+            } else if (group === UPDATE_ACTIONS_GROUP) {
                 updateActions.push(...toActions([[group, actions]], this.instantiationService)[0]);
-            }
-            else if (group === THEME_ACTIONS_GROUP) {
+            } else if (group === THEME_ACTIONS_GROUP) {
                 themeActions.push(...toActions([[group, actions]], this.instantiationService)[0]);
-            }
-            else {
+            } else {
                 otherActionGroups.push(...toActions([[group, actions]], this.instantiationService));
             }
         }
@@ -1343,7 +1589,7 @@ let ManageExtensionAction = class ManageExtensionAction extends DropDownExtensio
         groups.push([
             ...(installActions.length ? installActions : []),
             this.instantiationService.createInstance(InstallAnotherVersionAction, this.extension, false),
-            this.instantiationService.createInstance(UninstallAction),
+            this.instantiationService.createInstance(UninstallAction)
         ]);
         otherActionGroups.forEach(actions => groups.push(actions));
         groups.forEach(group => group.forEach(extensionAction => {
@@ -1367,18 +1613,20 @@ let ManageExtensionAction = class ManageExtensionAction extends DropDownExtensio
         }
     }
 };
-ManageExtensionAction = ManageExtensionAction_1 = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IExtensionService)),
-    ( __param(2, IContextKeyService))
-], ManageExtensionAction));
+ManageExtensionAction = ManageExtensionAction_1 = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IExtensionService)), ( __param(2, IContextKeyService))], ManageExtensionAction));
 class ExtensionEditorManageExtensionAction extends DropDownExtensionAction {
     constructor(contextKeyService, instantiationService) {
-        super('extensionEditor.manageExtension', '', `${ExtensionAction.ICON_ACTION_CLASS} manage ${ThemeIcon.asClassName(manageExtensionIcon)}`, true, instantiationService);
+        super(
+            "extensionEditor.manageExtension",
+            "",
+            `${ExtensionAction.ICON_ACTION_CLASS} manage ${ThemeIcon.asClassName(manageExtensionIcon)}`,
+            true,
+            instantiationService
+        );
         this.contextKeyService = contextKeyService;
-        this.tooltip = ( localize(7567, "Manage"));
+        this.tooltip = ( localize(7878, "Manage"));
     }
-    update() { }
+    update() {}
     async run() {
         const actionGroups = [];
         (await getContextMenuActions(this.extension, this.contextKeyService, this.instantiationService)).forEach(actions => actionGroups.push(actions));
@@ -1408,22 +1656,20 @@ let MenuItemExtensionAction = class MenuItemExtensionAction extends ExtensionAct
         }
         if (this.action.id === TOGGLE_IGNORE_EXTENSION_ACTION_ID) {
             this.checked = !this.extensionsWorkbenchService.isExtensionIgnoredToSync(this.extension);
-        }
-        else if (this.action.id === ToggleAutoUpdateForExtensionAction.ID) {
+        } else if (this.action.id === ToggleAutoUpdateForExtensionAction.ID) {
             this.checked = this.extensionsWorkbenchService.isAutoUpdateEnabledFor(this.extension);
-        }
-        else if (this.action.id === ToggleAutoUpdatesForPublisherAction.ID) {
+        } else if (this.action.id === ToggleAutoUpdatesForPublisherAction.ID) {
             this.checked = this.extensionsWorkbenchService.isAutoUpdateEnabledFor(this.extension.publisher);
-        }
-        else {
+        } else {
             this.checked = this.action.checked;
         }
     }
     async run() {
         if (this.extension) {
-            const id = this.extension.local ? getExtensionId(this.extension.local.manifest.publisher, this.extension.local.manifest.name)
-                : this.extension.gallery ? getExtensionId(this.extension.gallery.publisher, this.extension.gallery.name)
-                    : this.extension.identifier.id;
+            const id = this.extension.local ? getExtensionId(
+                this.extension.local.manifest.publisher,
+                this.extension.local.manifest.name
+            ) : this.extension.gallery ? getExtensionId(this.extension.gallery.publisher, this.extension.gallery.name) : this.extension.identifier.id;
             const extensionArg = {
                 id: this.extension.identifier.id,
                 version: this.extension.version,
@@ -1434,20 +1680,34 @@ let MenuItemExtensionAction = class MenuItemExtensionAction extends ExtensionAct
         }
     }
 };
-MenuItemExtensionAction = ( __decorate([
-    ( __param(1, IExtensionsWorkbenchService))
-], MenuItemExtensionAction));
+MenuItemExtensionAction = ( __decorate([( __param(1, IExtensionsWorkbenchService))], MenuItemExtensionAction));
 let TogglePreReleaseExtensionAction = class TogglePreReleaseExtensionAction extends ExtensionAction {
-    static { TogglePreReleaseExtensionAction_1 = this; }
-    static { this.ID = 'workbench.extensions.action.togglePreRlease'; }
-    static { this.LABEL = ( localize(7568, "Pre-Release")); }
-    static { this.EnabledClass = `${ExtensionAction.LABEL_ACTION_CLASS} prominent pre-release`; }
-    static { this.DisabledClass = `${this.EnabledClass} hide`; }
+    static {
+        TogglePreReleaseExtensionAction_1 = this;
+    }
+    static {
+        this.ID = "workbench.extensions.action.togglePreRlease";
+    }
+    static {
+        this.LABEL = ( localize(7879, "Pre-Release"));
+    }
+    static {
+        this.EnabledClass = `${ExtensionAction.LABEL_ACTION_CLASS} prominent pre-release`;
+    }
+    static {
+        this.DisabledClass = `${this.EnabledClass} hide`;
+    }
     constructor(extensionsWorkbenchService, allowedExtensionsService) {
-        super(TogglePreReleaseExtensionAction_1.ID, TogglePreReleaseExtensionAction_1.LABEL, TogglePreReleaseExtensionAction_1.DisabledClass);
+        super(
+            TogglePreReleaseExtensionAction_1.ID,
+            TogglePreReleaseExtensionAction_1.LABEL,
+            TogglePreReleaseExtensionAction_1.DisabledClass
+        );
         this.extensionsWorkbenchService = extensionsWorkbenchService;
         this.allowedExtensionsService = allowedExtensionsService;
-        this._register(allowedExtensionsService.onDidChangeAllowedExtensionsConfigValue(() => this.update()));
+        this._register(
+            allowedExtensionsService.onDidChangeAllowedExtensionsConfigValue(() => this.update())
+        );
         this.update();
     }
     update() {
@@ -1472,7 +1732,10 @@ let TogglePreReleaseExtensionAction = class TogglePreReleaseExtensionAction exte
             if (!this.extension.isPreReleaseVersion) {
                 return;
             }
-            if (this.allowedExtensionsService.isAllowed({ id: this.extension.identifier.id, publisherDisplayName: this.extension.publisherDisplayName }) !== true) {
+            if (this.allowedExtensionsService.isAllowed({
+                id: this.extension.identifier.id,
+                publisherDisplayName: this.extension.publisherDisplayName
+            }) !== true) {
                 return;
             }
         }
@@ -1487,13 +1750,12 @@ let TogglePreReleaseExtensionAction = class TogglePreReleaseExtensionAction exte
         this.enabled = true;
         this.class = TogglePreReleaseExtensionAction_1.EnabledClass;
         if (this.extension.preRelease) {
-            this.label = ( localize(7569, "Switch to Release Version"));
-            this.tooltip = ( localize(7570, "This will switch and enable updates to release versions"));
-        }
-        else {
-            this.label = ( localize(7571, "Switch to Pre-Release Version"));
+            this.label = ( localize(7880, "Switch to Release Version"));
+            this.tooltip = ( localize(7881, "This will switch and enable updates to release versions"));
+        } else {
+            this.label = ( localize(7882, "Switch to Pre-Release Version"));
             this.tooltip = ( localize(
-                7572,
+                7883,
                 "This will switch to pre-release version and enable updates to latest version always"
             ));
         }
@@ -1502,20 +1764,39 @@ let TogglePreReleaseExtensionAction = class TogglePreReleaseExtensionAction exte
         if (!this.extension) {
             return;
         }
-        this.extensionsWorkbenchService.open(this.extension, { showPreReleaseVersion: !this.extension.preRelease });
+        this.extensionsWorkbenchService.open(this.extension, {
+            showPreReleaseVersion: !this.extension.preRelease
+        });
         await this.extensionsWorkbenchService.togglePreRelease(this.extension);
     }
 };
-TogglePreReleaseExtensionAction = TogglePreReleaseExtensionAction_1 = ( __decorate([
-    ( __param(0, IExtensionsWorkbenchService)),
-    ( __param(1, IAllowedExtensionsService))
-], TogglePreReleaseExtensionAction));
+TogglePreReleaseExtensionAction = TogglePreReleaseExtensionAction_1 = ( __decorate([( __param(0, IExtensionsWorkbenchService)), ( __param(1, IAllowedExtensionsService))], TogglePreReleaseExtensionAction));
 let InstallAnotherVersionAction = class InstallAnotherVersionAction extends ExtensionAction {
-    static { InstallAnotherVersionAction_1 = this; }
-    static { this.ID = 'workbench.extensions.action.install.anotherVersion'; }
-    static { this.LABEL = ( localize(7573, "Install Specific Version...")); }
-    constructor(extension, whenInstalled, extensionsWorkbenchService, extensionManagementService, extensionGalleryService, quickInputService, instantiationService, dialogService, allowedExtensionsService) {
-        super(InstallAnotherVersionAction_1.ID, InstallAnotherVersionAction_1.LABEL, ExtensionAction.LABEL_ACTION_CLASS);
+    static {
+        InstallAnotherVersionAction_1 = this;
+    }
+    static {
+        this.ID = "workbench.extensions.action.install.anotherVersion";
+    }
+    static {
+        this.LABEL = ( localize(7884, "Install Specific Version..."));
+    }
+    constructor(
+        extension,
+        whenInstalled,
+        extensionsWorkbenchService,
+        extensionManagementService,
+        extensionGalleryService,
+        quickInputService,
+        instantiationService,
+        dialogService,
+        allowedExtensionsService
+    ) {
+        super(
+            InstallAnotherVersionAction_1.ID,
+            InstallAnotherVersionAction_1.LABEL,
+            ExtensionAction.LABEL_ACTION_CLASS
+        );
         this.whenInstalled = whenInstalled;
         this.extensionsWorkbenchService = extensionsWorkbenchService;
         this.extensionManagementService = extensionManagementService;
@@ -1524,13 +1805,17 @@ let InstallAnotherVersionAction = class InstallAnotherVersionAction extends Exte
         this.instantiationService = instantiationService;
         this.dialogService = dialogService;
         this.allowedExtensionsService = allowedExtensionsService;
-        this._register(allowedExtensionsService.onDidChangeAllowedExtensionsConfigValue(() => this.update()));
+        this._register(
+            allowedExtensionsService.onDidChangeAllowedExtensionsConfigValue(() => this.update())
+        );
         this.extension = extension;
         this.update();
     }
     update() {
-        this.enabled = !!this.extension && !this.extension.isBuiltin && !!this.extension.identifier.uuid && !this.extension.deprecationInfo
-            && this.allowedExtensionsService.isAllowed({ id: this.extension.identifier.id, publisherDisplayName: this.extension.publisherDisplayName }) === true;
+        this.enabled = !!this.extension && !this.extension.isBuiltin && !!this.extension.identifier.uuid && !this.extension.deprecationInfo && this.allowedExtensionsService.isAllowed({
+            id: this.extension.identifier.id,
+            publisherDisplayName: this.extension.publisherDisplayName
+        }) === true;
         if (this.enabled && this.whenInstalled) {
             this.enabled = !!this.extension?.local && !!this.extension.server && this.extension.state === ExtensionState.Installed;
         }
@@ -1543,65 +1828,78 @@ let InstallAnotherVersionAction = class InstallAnotherVersionAction extends Exte
             return;
         }
         const targetPlatform = this.extension.server ? await this.extension.server.extensionManagementService.getTargetPlatform() : await this.extensionManagementService.getTargetPlatform();
-        const allVersions = await this.extensionGalleryService.getAllCompatibleVersions(this.extension.identifier, this.extension.local?.preRelease ?? this.extension.gallery?.properties.isPreReleaseVersion ?? false, targetPlatform);
+        const allVersions = await this.extensionGalleryService.getAllCompatibleVersions(
+            this.extension.identifier,
+            this.extension.local?.preRelease ?? this.extension.gallery?.properties.isPreReleaseVersion ?? false,
+            targetPlatform
+        );
         if (!allVersions.length) {
-            await this.dialogService.info(( localize(7574, "This extension has no other versions.")));
+            await this.dialogService.info(( localize(7885, "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(7575, "pre-release"))})` : ''}${v.version === this.extension?.local?.manifest.version ? ` (${( localize(7576, "current"))})` : ''}`,
-                ariaLabel: `${v.isPreReleaseVersion ? 'Pre-Release version' : 'Release version'} ${v.version}`,
+                description: `${fromNow(( new Date(Date.parse(v.date))), true)}${v.isPreReleaseVersion ? ` (${( localize(7886, "pre-release"))})` : ""}${v.version === this.extension?.local?.manifest.version ? ` (${( localize(7887, "current"))})` : ""}`,
+                ariaLabel: `${v.isPreReleaseVersion ? "Pre-Release version" : "Release version"} ${v.version}`,
                 isPreReleaseVersion: v.isPreReleaseVersion
             };
         }));
         const pick = await this.quickInputService.pick(picks, {
-            placeHolder: ( localize(7577, "Select Version to Install")),
+            placeHolder: ( localize(7888, "Select Version to Install")),
             matchOnDetail: true
         });
         if (pick) {
             if (this.extension.local?.manifest.version === pick.id) {
                 return;
             }
-            const options = { installPreReleaseVersion: pick.isPreReleaseVersion, version: pick.id };
+            const options = {
+                installPreReleaseVersion: pick.isPreReleaseVersion,
+                version: pick.id
+            };
             try {
                 await this.extensionsWorkbenchService.install(this.extension, options);
-            }
-            catch (error) {
-                this.instantiationService.createInstance(PromptExtensionInstallFailureAction, this.extension, options, pick.id, InstallOperation.Install, error).run();
+            } catch (error) {
+                this.instantiationService.createInstance(
+                    PromptExtensionInstallFailureAction,
+                    this.extension,
+                    options,
+                    pick.id,
+                    InstallOperation.Install,
+                    error
+                ).run();
             }
         }
         return null;
     }
 };
-InstallAnotherVersionAction = InstallAnotherVersionAction_1 = ( __decorate([
-    ( __param(2, IExtensionsWorkbenchService)),
-    ( __param(3, IWorkbenchExtensionManagementService)),
-    ( __param(4, IExtensionGalleryService)),
-    ( __param(5, IQuickInputService)),
-    ( __param(6, IInstantiationService)),
-    ( __param(7, IDialogService)),
-    ( __param(8, IAllowedExtensionsService))
-], InstallAnotherVersionAction));
+InstallAnotherVersionAction = InstallAnotherVersionAction_1 = ( __decorate([( __param(2, IExtensionsWorkbenchService)), ( __param(3, IWorkbenchExtensionManagementService)), ( __param(4, IExtensionGalleryService)), ( __param(5, IQuickInputService)), ( __param(6, IInstantiationService)), ( __param(7, IDialogService)), ( __param(8, IAllowedExtensionsService))], InstallAnotherVersionAction));
 let EnableForWorkspaceAction = class EnableForWorkspaceAction extends ExtensionAction {
-    static { EnableForWorkspaceAction_1 = this; }
-    static { this.ID = 'extensions.enableForWorkspace'; }
-    static { this.LABEL = ( localize(7578, "Enable (Workspace)")); }
+    static {
+        EnableForWorkspaceAction_1 = this;
+    }
+    static {
+        this.ID = "extensions.enableForWorkspace";
+    }
+    static {
+        this.LABEL = ( localize(7889, "Enable (Workspace)"));
+    }
     constructor(extensionsWorkbenchService, extensionEnablementService) {
-        super(EnableForWorkspaceAction_1.ID, EnableForWorkspaceAction_1.LABEL, ExtensionAction.LABEL_ACTION_CLASS);
+        super(
+            EnableForWorkspaceAction_1.ID,
+            EnableForWorkspaceAction_1.LABEL,
+            ExtensionAction.LABEL_ACTION_CLASS
+        );
         this.extensionsWorkbenchService = extensionsWorkbenchService;
         this.extensionEnablementService = extensionEnablementService;
-        this.tooltip = ( localize(7579, "Enable this extension only in this workspace"));
+        this.tooltip = ( localize(7890, "Enable this extension only in this workspace"));
         this.update();
     }
     update() {
         this.enabled = false;
         if (this.extension && this.extension.local && !this.extension.isWorkspaceScoped) {
-            this.enabled = this.extension.state === ExtensionState.Installed
-                && !this.extensionEnablementService.isEnabled(this.extension.local)
-                && this.extensionEnablementService.canChangeWorkspaceEnablement(this.extension.local);
+            this.enabled = this.extension.state === ExtensionState.Installed && !this.extensionEnablementService.isEnabled(this.extension.local) && this.extensionEnablementService.canChangeWorkspaceEnablement(this.extension.local);
         }
     }
     async run() {
@@ -1611,27 +1909,32 @@ let EnableForWorkspaceAction = class EnableForWorkspaceAction extends ExtensionA
         return this.extensionsWorkbenchService.setEnablement(this.extension, EnablementState.EnabledWorkspace);
     }
 };
-EnableForWorkspaceAction = EnableForWorkspaceAction_1 = ( __decorate([
-    ( __param(0, IExtensionsWorkbenchService)),
-    ( __param(1, IWorkbenchExtensionEnablementService))
-], EnableForWorkspaceAction));
+EnableForWorkspaceAction = EnableForWorkspaceAction_1 = ( __decorate([( __param(0, IExtensionsWorkbenchService)), ( __param(1, IWorkbenchExtensionEnablementService))], EnableForWorkspaceAction));
 let EnableGloballyAction = class EnableGloballyAction extends ExtensionAction {
-    static { EnableGloballyAction_1 = this; }
-    static { this.ID = 'extensions.enableGlobally'; }
-    static { this.LABEL = ( localize(7580, "Enable")); }
+    static {
+        EnableGloballyAction_1 = this;
+    }
+    static {
+        this.ID = "extensions.enableGlobally";
+    }
+    static {
+        this.LABEL = ( localize(7891, "Enable"));
+    }
     constructor(extensionsWorkbenchService, extensionEnablementService) {
-        super(EnableGloballyAction_1.ID, EnableGloballyAction_1.LABEL, ExtensionAction.LABEL_ACTION_CLASS);
+        super(
+            EnableGloballyAction_1.ID,
+            EnableGloballyAction_1.LABEL,
+            ExtensionAction.LABEL_ACTION_CLASS
+        );
         this.extensionsWorkbenchService = extensionsWorkbenchService;
         this.extensionEnablementService = extensionEnablementService;
-        this.tooltip = ( localize(7581, "Enable this extension"));
+        this.tooltip = ( localize(7892, "Enable this extension"));
         this.update();
     }
     update() {
         this.enabled = false;
         if (this.extension && this.extension.local && !this.extension.isWorkspaceScoped) {
-            this.enabled = this.extension.state === ExtensionState.Installed
-                && this.extensionEnablementService.isDisabledGlobally(this.extension.local)
-                && this.extensionEnablementService.canChangeEnablement(this.extension.local);
+            this.enabled = this.extension.state === ExtensionState.Installed && this.extensionEnablementService.isDisabledGlobally(this.extension.local) && this.extensionEnablementService.canChangeEnablement(this.extension.local);
         }
     }
     async run() {
@@ -1641,32 +1944,43 @@ let EnableGloballyAction = class EnableGloballyAction extends ExtensionAction {
         return this.extensionsWorkbenchService.setEnablement(this.extension, EnablementState.EnabledGlobally);
     }
 };
-EnableGloballyAction = EnableGloballyAction_1 = ( __decorate([
-    ( __param(0, IExtensionsWorkbenchService)),
-    ( __param(1, IWorkbenchExtensionEnablementService))
-], EnableGloballyAction));
+EnableGloballyAction = EnableGloballyAction_1 = ( __decorate([( __param(0, IExtensionsWorkbenchService)), ( __param(1, IWorkbenchExtensionEnablementService))], EnableGloballyAction));
 let DisableForWorkspaceAction = class DisableForWorkspaceAction extends ExtensionAction {
-    static { DisableForWorkspaceAction_1 = this; }
-    static { this.ID = 'extensions.disableForWorkspace'; }
-    static { this.LABEL = ( localize(7582, "Disable (Workspace)")); }
-    constructor(workspaceContextService, extensionsWorkbenchService, extensionEnablementService, extensionService) {
-        super(DisableForWorkspaceAction_1.ID, DisableForWorkspaceAction_1.LABEL, ExtensionAction.LABEL_ACTION_CLASS);
+    static {
+        DisableForWorkspaceAction_1 = this;
+    }
+    static {
+        this.ID = "extensions.disableForWorkspace";
+    }
+    static {
+        this.LABEL = ( localize(7893, "Disable (Workspace)"));
+    }
+    constructor(
+        workspaceContextService,
+        extensionsWorkbenchService,
+        extensionEnablementService,
+        extensionService
+    ) {
+        super(
+            DisableForWorkspaceAction_1.ID,
+            DisableForWorkspaceAction_1.LABEL,
+            ExtensionAction.LABEL_ACTION_CLASS
+        );
         this.workspaceContextService = workspaceContextService;
         this.extensionsWorkbenchService = extensionsWorkbenchService;
         this.extensionEnablementService = extensionEnablementService;
         this.extensionService = extensionService;
-        this.tooltip = ( localize(7583, "Disable this extension only in this workspace"));
+        this.tooltip = ( localize(7894, "Disable this extension only in this workspace"));
         this.update();
         this._register(this.extensionService.onDidChangeExtensions(() => this.update()));
     }
     update() {
         this.enabled = false;
-        if (this.extension && this.extension.local && !this.extension.isWorkspaceScoped && ( this.extensionService.extensions.some(
-            e => areSameExtensions({ id: e.identifier.value, uuid: e.uuid }, this.extension.identifier) && this.workspaceContextService.getWorkbenchState() !== WorkbenchState.EMPTY
-        ))) {
-            this.enabled = this.extension.state === ExtensionState.Installed
-                && (this.extension.enablementState === EnablementState.EnabledGlobally || this.extension.enablementState === EnablementState.EnabledWorkspace)
-                && this.extensionEnablementService.canChangeWorkspaceEnablement(this.extension.local);
+        if (this.extension && this.extension.local && !this.extension.isWorkspaceScoped && ( this.extensionService.extensions.some(e => areSameExtensions({
+            id: e.identifier.value,
+            uuid: e.uuid
+        }, this.extension.identifier) && this.workspaceContextService.getWorkbenchState() !== WorkbenchState.EMPTY))) {
+            this.enabled = this.extension.state === ExtensionState.Installed && (this.extension.enablementState === EnablementState.EnabledGlobally || this.extension.enablementState === EnablementState.EnabledWorkspace) && this.extensionEnablementService.canChangeWorkspaceEnablement(this.extension.local);
         }
     }
     async run() {
@@ -1676,33 +1990,37 @@ let DisableForWorkspaceAction = class DisableForWorkspaceAction extends Extensio
         return this.extensionsWorkbenchService.setEnablement(this.extension, EnablementState.DisabledWorkspace);
     }
 };
-DisableForWorkspaceAction = DisableForWorkspaceAction_1 = ( __decorate([
-    ( __param(0, IWorkspaceContextService)),
-    ( __param(1, IExtensionsWorkbenchService)),
-    ( __param(2, IWorkbenchExtensionEnablementService)),
-    ( __param(3, IExtensionService))
-], DisableForWorkspaceAction));
+DisableForWorkspaceAction = DisableForWorkspaceAction_1 = ( __decorate([( __param(0, IWorkspaceContextService)), ( __param(1, IExtensionsWorkbenchService)), ( __param(2, IWorkbenchExtensionEnablementService)), ( __param(3, IExtensionService))], DisableForWorkspaceAction));
 let DisableGloballyAction = class DisableGloballyAction extends ExtensionAction {
-    static { DisableGloballyAction_1 = this; }
-    static { this.ID = 'extensions.disableGlobally'; }
-    static { this.LABEL = ( localize(7584, "Disable")); }
+    static {
+        DisableGloballyAction_1 = this;
+    }
+    static {
+        this.ID = "extensions.disableGlobally";
+    }
+    static {
+        this.LABEL = ( localize(7895, "Disable"));
+    }
     constructor(extensionsWorkbenchService, extensionEnablementService, extensionService) {
-        super(DisableGloballyAction_1.ID, DisableGloballyAction_1.LABEL, ExtensionAction.LABEL_ACTION_CLASS);
+        super(
+            DisableGloballyAction_1.ID,
+            DisableGloballyAction_1.LABEL,
+            ExtensionAction.LABEL_ACTION_CLASS
+        );
         this.extensionsWorkbenchService = extensionsWorkbenchService;
         this.extensionEnablementService = extensionEnablementService;
         this.extensionService = extensionService;
-        this.tooltip = ( localize(7585, "Disable this extension"));
+        this.tooltip = ( localize(7896, "Disable this extension"));
         this.update();
         this._register(this.extensionService.onDidChangeExtensions(() => this.update()));
     }
     update() {
         this.enabled = false;
-        if (this.extension && this.extension.local && !this.extension.isWorkspaceScoped && ( this.extensionService.extensions.some(
-            e => areSameExtensions({ id: e.identifier.value, uuid: e.uuid }, this.extension.identifier)
-        ))) {
-            this.enabled = this.extension.state === ExtensionState.Installed
-                && (this.extension.enablementState === EnablementState.EnabledGlobally || this.extension.enablementState === EnablementState.EnabledWorkspace)
-                && this.extensionEnablementService.canChangeEnablement(this.extension.local);
+        if (this.extension && this.extension.local && !this.extension.isWorkspaceScoped && ( this.extensionService.extensions.some(e => areSameExtensions({
+            id: e.identifier.value,
+            uuid: e.uuid
+        }, this.extension.identifier)))) {
+            this.enabled = this.extension.state === ExtensionState.Installed && (this.extension.enablementState === EnablementState.EnabledGlobally || this.extension.enablementState === EnablementState.EnabledWorkspace) && this.extensionEnablementService.canChangeEnablement(this.extension.local);
         }
     }
     async run() {
@@ -1712,41 +2030,49 @@ let DisableGloballyAction = class DisableGloballyAction extends ExtensionAction
         return this.extensionsWorkbenchService.setEnablement(this.extension, EnablementState.DisabledGlobally);
     }
 };
-DisableGloballyAction = DisableGloballyAction_1 = ( __decorate([
-    ( __param(0, IExtensionsWorkbenchService)),
-    ( __param(1, IWorkbenchExtensionEnablementService)),
-    ( __param(2, IExtensionService))
-], DisableGloballyAction));
+DisableGloballyAction = DisableGloballyAction_1 = ( __decorate([( __param(0, IExtensionsWorkbenchService)), ( __param(1, IWorkbenchExtensionEnablementService)), ( __param(2, IExtensionService))], DisableGloballyAction));
 let EnableDropDownAction = class EnableDropDownAction extends ButtonWithDropDownExtensionAction {
     constructor(instantiationService) {
-        super('extensions.enable', ExtensionAction.LABEL_ACTION_CLASS, [
-            [
-                instantiationService.createInstance(EnableGloballyAction),
-                instantiationService.createInstance(EnableForWorkspaceAction)
-            ]
-        ]);
+        super("extensions.enable", ExtensionAction.LABEL_ACTION_CLASS, [[
+            instantiationService.createInstance(EnableGloballyAction),
+            instantiationService.createInstance(EnableForWorkspaceAction)
+        ]]);
     }
 };
-EnableDropDownAction = ( __decorate([
-    ( __param(0, IInstantiationService))
-], EnableDropDownAction));
+EnableDropDownAction = ( __decorate([( __param(0, IInstantiationService))], EnableDropDownAction));
 let DisableDropDownAction = class DisableDropDownAction extends ButtonWithDropDownExtensionAction {
     constructor(instantiationService) {
-        super('extensions.disable', ExtensionAction.LABEL_ACTION_CLASS, [[
-                instantiationService.createInstance(DisableGloballyAction),
-                instantiationService.createInstance(DisableForWorkspaceAction)
-            ]]);
+        super("extensions.disable", ExtensionAction.LABEL_ACTION_CLASS, [[
+            instantiationService.createInstance(DisableGloballyAction),
+            instantiationService.createInstance(DisableForWorkspaceAction)
+        ]]);
     }
 };
-DisableDropDownAction = ( __decorate([
-    ( __param(0, IInstantiationService))
-], DisableDropDownAction));
+DisableDropDownAction = ( __decorate([( __param(0, IInstantiationService))], DisableDropDownAction));
 let ExtensionRuntimeStateAction = class ExtensionRuntimeStateAction extends ExtensionAction {
-    static { ExtensionRuntimeStateAction_1 = this; }
-    static { this.EnabledClass = `${ExtensionAction.LABEL_ACTION_CLASS} reload`; }
-    static { this.DisabledClass = `${this.EnabledClass} disabled`; }
-    constructor(hostService, extensionsWorkbenchService, updateService, extensionService, productService, telemetryService) {
-        super('extensions.runtimeState', '', ExtensionRuntimeStateAction_1.DisabledClass, false);
+    static {
+        ExtensionRuntimeStateAction_1 = this;
+    }
+    static {
+        this.EnabledClass = `${ExtensionAction.LABEL_ACTION_CLASS} reload`;
+    }
+    static {
+        this.DisabledClass = `${this.EnabledClass} disabled`;
+    }
+    constructor(
+        hostService,
+        extensionsWorkbenchService,
+        updateService,
+        extensionService,
+        productService,
+        telemetryService
+    ) {
+        super(
+            "extensions.runtimeState",
+            "",
+            ExtensionRuntimeStateAction_1.DisabledClass,
+            false
+        );
         this.hostService = hostService;
         this.extensionsWorkbenchService = extensionsWorkbenchService;
         this.updateService = updateService;
@@ -1759,7 +2085,7 @@ let ExtensionRuntimeStateAction = class ExtensionRuntimeStateAction extends Exte
     }
     update() {
         this.enabled = false;
-        this.tooltip = '';
+        this.tooltip = "";
         this.class = ExtensionRuntimeStateAction_1.DisabledClass;
         if (!this.extension) {
             return;
@@ -1778,44 +2104,30 @@ let ExtensionRuntimeStateAction = class ExtensionRuntimeStateAction extends Exte
         this.enabled = true;
         this.class = ExtensionRuntimeStateAction_1.EnabledClass;
         this.tooltip = runtimeState.reason;
-        this.label = runtimeState.action === ExtensionRuntimeActionType.ReloadWindow ? ( localize(7586, 'Reload Window'))
-            : runtimeState.action === ExtensionRuntimeActionType.RestartExtensions ? ( localize(7587, 'Restart Extensions'))
-                : runtimeState.action === ExtensionRuntimeActionType.QuitAndInstall ? ( localize(7588, 'Restart to Update'))
-                    : runtimeState.action === ExtensionRuntimeActionType.ApplyUpdate || runtimeState.action === ExtensionRuntimeActionType.DownloadUpdate ? ( localize(7589, 'Update {0}', this.productService.nameShort)) : '';
+        this.label = runtimeState.action === ExtensionRuntimeActionType.ReloadWindow ? ( localize(7897, "Reload Window")) : runtimeState.action === ExtensionRuntimeActionType.RestartExtensions ? ( localize(7898, "Restart Extensions")) : runtimeState.action === ExtensionRuntimeActionType.QuitAndInstall ? ( localize(7899, "Restart to Update")) : runtimeState.action === ExtensionRuntimeActionType.ApplyUpdate || runtimeState.action === ExtensionRuntimeActionType.DownloadUpdate ? ( localize(7900, "Update {0}", this.productService.nameShort)) : "";
     }
     async run() {
         const runtimeState = this.extension?.runtimeState;
         if (!runtimeState?.action) {
             return;
         }
-        this.telemetryService.publicLog2('extensions:runtimestate:action', {
+        this.telemetryService.publicLog2("extensions:runtimestate:action", {
             action: runtimeState.action
         });
         if (runtimeState?.action === ExtensionRuntimeActionType.ReloadWindow) {
             return this.hostService.reload();
-        }
-        else if (runtimeState?.action === ExtensionRuntimeActionType.RestartExtensions) {
+        } else if (runtimeState?.action === ExtensionRuntimeActionType.RestartExtensions) {
             return this.extensionsWorkbenchService.updateRunningExtensions();
-        }
-        else if (runtimeState?.action === ExtensionRuntimeActionType.DownloadUpdate) {
+        } else if (runtimeState?.action === ExtensionRuntimeActionType.DownloadUpdate) {
             return this.updateService.downloadUpdate();
-        }
-        else if (runtimeState?.action === ExtensionRuntimeActionType.ApplyUpdate) {
+        } else if (runtimeState?.action === ExtensionRuntimeActionType.ApplyUpdate) {
             return this.updateService.applyUpdate();
-        }
-        else if (runtimeState?.action === ExtensionRuntimeActionType.QuitAndInstall) {
+        } else if (runtimeState?.action === ExtensionRuntimeActionType.QuitAndInstall) {
             return this.updateService.quitAndInstall();
         }
     }
 };
-ExtensionRuntimeStateAction = ExtensionRuntimeStateAction_1 = ( __decorate([
-    ( __param(0, IHostService)),
-    ( __param(1, IExtensionsWorkbenchService)),
-    ( __param(2, IUpdateService)),
-    ( __param(3, IExtensionService)),
-    ( __param(4, IProductService)),
-    ( __param(5, ITelemetryService))
-], ExtensionRuntimeStateAction));
+ExtensionRuntimeStateAction = ExtensionRuntimeStateAction_1 = ( __decorate([( __param(0, IHostService)), ( __param(1, IExtensionsWorkbenchService)), ( __param(2, IUpdateService)), ( __param(3, IExtensionService)), ( __param(4, IProductService)), ( __param(5, ITelemetryService))], ExtensionRuntimeStateAction));
 function isThemeFromExtension(theme, extension) {
     return !!(extension && theme.extensionData && ExtensionIdentifier.equals(theme.extensionData.extensionId, extension.identifier.id));
 }
@@ -1823,27 +2135,59 @@ function getQuickPickEntries(themes, currentTheme, extension, showCurrentTheme)
     const picks = [];
     for (const theme of themes) {
         if (isThemeFromExtension(theme, extension) && !(showCurrentTheme && theme === currentTheme)) {
-            picks.push({ label: theme.label, id: theme.id });
+            picks.push({
+                label: theme.label,
+                id: theme.id
+            });
         }
     }
     if (showCurrentTheme) {
-        picks.push({ type: 'separator', label: ( localize(7576, "current")) });
-        picks.push({ label: currentTheme.label, id: currentTheme.id });
+        picks.push({
+            type: "separator",
+            label: ( localize(7887, "current"))
+        });
+        picks.push({
+            label: currentTheme.label,
+            id: currentTheme.id
+        });
     }
     return picks;
 }
 let SetColorThemeAction = class SetColorThemeAction extends ExtensionAction {
-    static { SetColorThemeAction_1 = this; }
-    static { this.ID = 'workbench.extensions.action.setColorTheme'; }
-    static { this.TITLE = ( localize2(7590, 'Set Color Theme')); }
-    static { this.EnabledClass = `${ExtensionAction.LABEL_ACTION_CLASS} theme`; }
-    static { this.DisabledClass = `${this.EnabledClass} disabled`; }
-    constructor(extensionService, workbenchThemeService, quickInputService, extensionEnablementService) {
-        super(SetColorThemeAction_1.ID, SetColorThemeAction_1.TITLE.value, SetColorThemeAction_1.DisabledClass, false);
+    static {
+        SetColorThemeAction_1 = this;
+    }
+    static {
+        this.ID = "workbench.extensions.action.setColorTheme";
+    }
+    static {
+        this.TITLE = ( localize2(7901, "Set Color Theme"));
+    }
+    static {
+        this.EnabledClass = `${ExtensionAction.LABEL_ACTION_CLASS} theme`;
+    }
+    static {
+        this.DisabledClass = `${this.EnabledClass} disabled`;
+    }
+    constructor(
+        extensionService,
+        workbenchThemeService,
+        quickInputService,
+        extensionEnablementService
+    ) {
+        super(
+            SetColorThemeAction_1.ID,
+            SetColorThemeAction_1.TITLE.value,
+            SetColorThemeAction_1.DisabledClass,
+            false
+        );
         this.workbenchThemeService = workbenchThemeService;
         this.quickInputService = quickInputService;
         this.extensionEnablementService = extensionEnablementService;
-        this._register(Event.any(extensionService.onDidChangeExtensions, workbenchThemeService.onDidColorThemeChange)(() => this.update(), this));
+        this._register(Event.any(
+            extensionService.onDidChangeExtensions,
+            workbenchThemeService.onDidColorThemeChange
+        )(() => this.update(), this));
         this.update();
     }
     update() {
@@ -1855,7 +2199,15 @@ let SetColorThemeAction = class SetColorThemeAction extends ExtensionAction {
     computeEnablement(colorThemes) {
         return !!this.extension && this.extension.state === ExtensionState.Installed && this.extensionEnablementService.isEnabledEnablementState(this.extension.enablementState) && ( colorThemes.some(th => isThemeFromExtension(th, this.extension)));
     }
-    async run({ showCurrentTheme, ignoreFocusLost } = { showCurrentTheme: false, ignoreFocusLost: false }) {
+    async run(
+        {
+            showCurrentTheme,
+            ignoreFocusLost
+        } = {
+            showCurrentTheme: false,
+            ignoreFocusLost: false
+        }
+    ) {
         const colorThemes = await this.workbenchThemeService.getColorThemes();
         if (!this.computeEnablement(colorThemes)) {
             return;
@@ -1864,31 +2216,49 @@ let SetColorThemeAction = class SetColorThemeAction extends ExtensionAction {
         const delayer = ( new Delayer(100));
         const picks = getQuickPickEntries(colorThemes, currentTheme, this.extension, showCurrentTheme);
         const pickedTheme = await this.quickInputService.pick(picks, {
-            placeHolder: ( localize(7591, "Select Color Theme")),
+            placeHolder: ( localize(7902, "Select Color Theme")),
             onDidFocus: item => delayer.trigger(() => this.workbenchThemeService.setColorTheme(item.id, undefined)),
             ignoreFocusLost
         });
-        return this.workbenchThemeService.setColorTheme(pickedTheme ? pickedTheme.id : currentTheme.id, 'auto');
+        return this.workbenchThemeService.setColorTheme(pickedTheme ? pickedTheme.id : currentTheme.id, "auto");
     }
 };
-SetColorThemeAction = SetColorThemeAction_1 = ( __decorate([
-    ( __param(0, IExtensionService)),
-    ( __param(1, IWorkbenchThemeService)),
-    ( __param(2, IQuickInputService)),
-    ( __param(3, IWorkbenchExtensionEnablementService))
-], SetColorThemeAction));
+SetColorThemeAction = SetColorThemeAction_1 = ( __decorate([( __param(0, IExtensionService)), ( __param(1, IWorkbenchThemeService)), ( __param(2, IQuickInputService)), ( __param(3, IWorkbenchExtensionEnablementService))], SetColorThemeAction));
 let SetFileIconThemeAction = class SetFileIconThemeAction extends ExtensionAction {
-    static { SetFileIconThemeAction_1 = this; }
-    static { this.ID = 'workbench.extensions.action.setFileIconTheme'; }
-    static { this.TITLE = ( localize2(7592, 'Set File Icon Theme')); }
-    static { this.EnabledClass = `${ExtensionAction.LABEL_ACTION_CLASS} theme`; }
-    static { this.DisabledClass = `${this.EnabledClass} disabled`; }
-    constructor(extensionService, workbenchThemeService, quickInputService, extensionEnablementService) {
-        super(SetFileIconThemeAction_1.ID, SetFileIconThemeAction_1.TITLE.value, SetFileIconThemeAction_1.DisabledClass, false);
+    static {
+        SetFileIconThemeAction_1 = this;
+    }
+    static {
+        this.ID = "workbench.extensions.action.setFileIconTheme";
+    }
+    static {
+        this.TITLE = ( localize2(7903, "Set File Icon Theme"));
+    }
+    static {
+        this.EnabledClass = `${ExtensionAction.LABEL_ACTION_CLASS} theme`;
+    }
+    static {
+        this.DisabledClass = `${this.EnabledClass} disabled`;
+    }
+    constructor(
+        extensionService,
+        workbenchThemeService,
+        quickInputService,
+        extensionEnablementService
+    ) {
+        super(
+            SetFileIconThemeAction_1.ID,
+            SetFileIconThemeAction_1.TITLE.value,
+            SetFileIconThemeAction_1.DisabledClass,
+            false
+        );
         this.workbenchThemeService = workbenchThemeService;
         this.quickInputService = quickInputService;
         this.extensionEnablementService = extensionEnablementService;
-        this._register(Event.any(extensionService.onDidChangeExtensions, workbenchThemeService.onDidFileIconThemeChange)(() => this.update(), this));
+        this._register(Event.any(
+            extensionService.onDidChangeExtensions,
+            workbenchThemeService.onDidFileIconThemeChange
+        )(() => this.update(), this));
         this.update();
     }
     update() {
@@ -1900,7 +2270,15 @@ let SetFileIconThemeAction = class SetFileIconThemeAction extends ExtensionActio
     computeEnablement(colorThemfileIconThemess) {
         return !!this.extension && this.extension.state === ExtensionState.Installed && this.extensionEnablementService.isEnabledEnablementState(this.extension.enablementState) && ( colorThemfileIconThemess.some(th => isThemeFromExtension(th, this.extension)));
     }
-    async run({ showCurrentTheme, ignoreFocusLost } = { showCurrentTheme: false, ignoreFocusLost: false }) {
+    async run(
+        {
+            showCurrentTheme,
+            ignoreFocusLost
+        } = {
+            showCurrentTheme: false,
+            ignoreFocusLost: false
+        }
+    ) {
         const fileIconThemes = await this.workbenchThemeService.getFileIconThemes();
         if (!this.computeEnablement(fileIconThemes)) {
             return;
@@ -1909,31 +2287,49 @@ let SetFileIconThemeAction = class SetFileIconThemeAction extends ExtensionActio
         const delayer = ( new Delayer(100));
         const picks = getQuickPickEntries(fileIconThemes, currentTheme, this.extension, showCurrentTheme);
         const pickedTheme = await this.quickInputService.pick(picks, {
-            placeHolder: ( localize(7593, "Select File Icon Theme")),
+            placeHolder: ( localize(7904, "Select File Icon Theme")),
             onDidFocus: item => delayer.trigger(() => this.workbenchThemeService.setFileIconTheme(item.id, undefined)),
             ignoreFocusLost
         });
-        return this.workbenchThemeService.setFileIconTheme(pickedTheme ? pickedTheme.id : currentTheme.id, 'auto');
+        return this.workbenchThemeService.setFileIconTheme(pickedTheme ? pickedTheme.id : currentTheme.id, "auto");
     }
 };
-SetFileIconThemeAction = SetFileIconThemeAction_1 = ( __decorate([
-    ( __param(0, IExtensionService)),
-    ( __param(1, IWorkbenchThemeService)),
-    ( __param(2, IQuickInputService)),
-    ( __param(3, IWorkbenchExtensionEnablementService))
-], SetFileIconThemeAction));
+SetFileIconThemeAction = SetFileIconThemeAction_1 = ( __decorate([( __param(0, IExtensionService)), ( __param(1, IWorkbenchThemeService)), ( __param(2, IQuickInputService)), ( __param(3, IWorkbenchExtensionEnablementService))], SetFileIconThemeAction));
 let SetProductIconThemeAction = class SetProductIconThemeAction extends ExtensionAction {
-    static { SetProductIconThemeAction_1 = this; }
-    static { this.ID = 'workbench.extensions.action.setProductIconTheme'; }
-    static { this.TITLE = ( localize2(7594, 'Set Product Icon Theme')); }
-    static { this.EnabledClass = `${ExtensionAction.LABEL_ACTION_CLASS} theme`; }
-    static { this.DisabledClass = `${this.EnabledClass} disabled`; }
-    constructor(extensionService, workbenchThemeService, quickInputService, extensionEnablementService) {
-        super(SetProductIconThemeAction_1.ID, SetProductIconThemeAction_1.TITLE.value, SetProductIconThemeAction_1.DisabledClass, false);
+    static {
+        SetProductIconThemeAction_1 = this;
+    }
+    static {
+        this.ID = "workbench.extensions.action.setProductIconTheme";
+    }
+    static {
+        this.TITLE = ( localize2(7905, "Set Product Icon Theme"));
+    }
+    static {
+        this.EnabledClass = `${ExtensionAction.LABEL_ACTION_CLASS} theme`;
+    }
+    static {
+        this.DisabledClass = `${this.EnabledClass} disabled`;
+    }
+    constructor(
+        extensionService,
+        workbenchThemeService,
+        quickInputService,
+        extensionEnablementService
+    ) {
+        super(
+            SetProductIconThemeAction_1.ID,
+            SetProductIconThemeAction_1.TITLE.value,
+            SetProductIconThemeAction_1.DisabledClass,
+            false
+        );
         this.workbenchThemeService = workbenchThemeService;
         this.quickInputService = quickInputService;
         this.extensionEnablementService = extensionEnablementService;
-        this._register(Event.any(extensionService.onDidChangeExtensions, workbenchThemeService.onDidProductIconThemeChange)(() => this.update(), this));
+        this._register(Event.any(
+            extensionService.onDidChangeExtensions,
+            workbenchThemeService.onDidProductIconThemeChange
+        )(() => this.update(), this));
         this.update();
     }
     update() {
@@ -1945,7 +2341,15 @@ let SetProductIconThemeAction = class SetProductIconThemeAction extends Extensio
     computeEnablement(productIconThemes) {
         return !!this.extension && this.extension.state === ExtensionState.Installed && this.extensionEnablementService.isEnabledEnablementState(this.extension.enablementState) && ( productIconThemes.some(th => isThemeFromExtension(th, this.extension)));
     }
-    async run({ showCurrentTheme, ignoreFocusLost } = { showCurrentTheme: false, ignoreFocusLost: false }) {
+    async run(
+        {
+            showCurrentTheme,
+            ignoreFocusLost
+        } = {
+            showCurrentTheme: false,
+            ignoreFocusLost: false
+        }
+    ) {
         const productIconThemes = await this.workbenchThemeService.getProductIconThemes();
         if (!this.computeEnablement(productIconThemes)) {
             return;
@@ -1954,27 +2358,37 @@ let SetProductIconThemeAction = class SetProductIconThemeAction extends Extensio
         const delayer = ( new Delayer(100));
         const picks = getQuickPickEntries(productIconThemes, currentTheme, this.extension, showCurrentTheme);
         const pickedTheme = await this.quickInputService.pick(picks, {
-            placeHolder: ( localize(7595, "Select Product Icon Theme")),
+            placeHolder: ( localize(7906, "Select Product Icon Theme")),
             onDidFocus: item => delayer.trigger(() => this.workbenchThemeService.setProductIconTheme(item.id, undefined)),
             ignoreFocusLost
         });
-        return this.workbenchThemeService.setProductIconTheme(pickedTheme ? pickedTheme.id : currentTheme.id, 'auto');
+        return this.workbenchThemeService.setProductIconTheme(pickedTheme ? pickedTheme.id : currentTheme.id, "auto");
     }
 };
-SetProductIconThemeAction = SetProductIconThemeAction_1 = ( __decorate([
-    ( __param(0, IExtensionService)),
-    ( __param(1, IWorkbenchThemeService)),
-    ( __param(2, IQuickInputService)),
-    ( __param(3, IWorkbenchExtensionEnablementService))
-], SetProductIconThemeAction));
+SetProductIconThemeAction = SetProductIconThemeAction_1 = ( __decorate([( __param(0, IExtensionService)), ( __param(1, IWorkbenchThemeService)), ( __param(2, IQuickInputService)), ( __param(3, IWorkbenchExtensionEnablementService))], SetProductIconThemeAction));
 let SetLanguageAction = class SetLanguageAction extends ExtensionAction {
-    static { SetLanguageAction_1 = this; }
-    static { this.ID = 'workbench.extensions.action.setDisplayLanguage'; }
-    static { this.TITLE = ( localize2(7596, 'Set Display Language')); }
-    static { this.EnabledClass = `${ExtensionAction.LABEL_ACTION_CLASS} language`; }
-    static { this.DisabledClass = `${this.EnabledClass} disabled`; }
+    static {
+        SetLanguageAction_1 = this;
+    }
+    static {
+        this.ID = "workbench.extensions.action.setDisplayLanguage";
+    }
+    static {
+        this.TITLE = ( localize2(7907, "Set Display Language"));
+    }
+    static {
+        this.EnabledClass = `${ExtensionAction.LABEL_ACTION_CLASS} language`;
+    }
+    static {
+        this.DisabledClass = `${this.EnabledClass} disabled`;
+    }
     constructor(extensionsWorkbenchService) {
-        super(SetLanguageAction_1.ID, SetLanguageAction_1.TITLE.value, SetLanguageAction_1.DisabledClass, false);
+        super(
+            SetLanguageAction_1.ID,
+            SetLanguageAction_1.TITLE.value,
+            SetLanguageAction_1.DisabledClass,
+            false
+        );
         this.extensionsWorkbenchService = extensionsWorkbenchService;
         this.update();
     }
@@ -1997,17 +2411,30 @@ let SetLanguageAction = class SetLanguageAction extends ExtensionAction {
         return this.extension && this.extensionsWorkbenchService.setLanguage(this.extension);
     }
 };
-SetLanguageAction = SetLanguageAction_1 = ( __decorate([
-    ( __param(0, IExtensionsWorkbenchService))
-], SetLanguageAction));
+SetLanguageAction = SetLanguageAction_1 = ( __decorate([( __param(0, IExtensionsWorkbenchService))], SetLanguageAction));
 let ClearLanguageAction = class ClearLanguageAction extends ExtensionAction {
-    static { ClearLanguageAction_1 = this; }
-    static { this.ID = 'workbench.extensions.action.clearLanguage'; }
-    static { this.TITLE = ( localize2(7597, 'Clear Display Language')); }
-    static { this.EnabledClass = `${ExtensionAction.LABEL_ACTION_CLASS} language`; }
-    static { this.DisabledClass = `${this.EnabledClass} disabled`; }
+    static {
+        ClearLanguageAction_1 = this;
+    }
+    static {
+        this.ID = "workbench.extensions.action.clearLanguage";
+    }
+    static {
+        this.TITLE = ( localize2(7908, "Clear Display Language"));
+    }
+    static {
+        this.EnabledClass = `${ExtensionAction.LABEL_ACTION_CLASS} language`;
+    }
+    static {
+        this.DisabledClass = `${this.EnabledClass} disabled`;
+    }
     constructor(extensionsWorkbenchService, localeService) {
-        super(ClearLanguageAction_1.ID, ClearLanguageAction_1.TITLE.value, ClearLanguageAction_1.DisabledClass, false);
+        super(
+            ClearLanguageAction_1.ID,
+            ClearLanguageAction_1.TITLE.value,
+            ClearLanguageAction_1.DisabledClass,
+            false
+        );
         this.extensionsWorkbenchService = extensionsWorkbenchService;
         this.localeService = localeService;
         this.update();
@@ -2031,69 +2458,103 @@ let ClearLanguageAction = class ClearLanguageAction extends ExtensionAction {
         return this.extension && this.localeService.clearLocalePreference();
     }
 };
-ClearLanguageAction = ClearLanguageAction_1 = ( __decorate([
-    ( __param(0, IExtensionsWorkbenchService)),
-    ( __param(1, ILocaleService))
-], ClearLanguageAction));
+ClearLanguageAction = ClearLanguageAction_1 = ( __decorate([( __param(0, IExtensionsWorkbenchService)), ( __param(1, ILocaleService))], ClearLanguageAction));
 let ShowRecommendedExtensionAction = class ShowRecommendedExtensionAction extends Action {
-    static { ShowRecommendedExtensionAction_1 = this; }
-    static { this.ID = 'workbench.extensions.action.showRecommendedExtension'; }
-    static { this.LABEL = ( localize(7598, "Show Recommended Extension")); }
+    static {
+        ShowRecommendedExtensionAction_1 = this;
+    }
+    static {
+        this.ID = "workbench.extensions.action.showRecommendedExtension";
+    }
+    static {
+        this.LABEL = ( localize(7909, "Show Recommended Extension"));
+    }
     constructor(extensionId, extensionWorkbenchService) {
-        super(ShowRecommendedExtensionAction_1.ID, ShowRecommendedExtensionAction_1.LABEL, undefined, false);
+        super(
+            ShowRecommendedExtensionAction_1.ID,
+            ShowRecommendedExtensionAction_1.LABEL,
+            undefined,
+            false
+        );
         this.extensionWorkbenchService = extensionWorkbenchService;
         this.extensionId = extensionId;
     }
     async run() {
         await this.extensionWorkbenchService.openSearch(`@id:${this.extensionId}`);
-        const [extension] = await this.extensionWorkbenchService.getExtensions([{ id: this.extensionId }], { source: 'install-recommendation' }, CancellationToken.None);
+        const [extension] = await this.extensionWorkbenchService.getExtensions([{
+            id: this.extensionId
+        }], {
+            source: "install-recommendation"
+        }, CancellationToken.None);
         if (extension) {
             return this.extensionWorkbenchService.open(extension);
         }
         return null;
     }
 };
-ShowRecommendedExtensionAction = ShowRecommendedExtensionAction_1 = ( __decorate([
-    ( __param(1, IExtensionsWorkbenchService))
-], ShowRecommendedExtensionAction));
+ShowRecommendedExtensionAction = ShowRecommendedExtensionAction_1 = ( __decorate([( __param(1, IExtensionsWorkbenchService))], ShowRecommendedExtensionAction));
 let InstallRecommendedExtensionAction = class InstallRecommendedExtensionAction extends Action {
-    static { InstallRecommendedExtensionAction_1 = this; }
-    static { this.ID = 'workbench.extensions.action.installRecommendedExtension'; }
-    static { this.LABEL = ( localize(7599, "Install Recommended Extension")); }
+    static {
+        InstallRecommendedExtensionAction_1 = this;
+    }
+    static {
+        this.ID = "workbench.extensions.action.installRecommendedExtension";
+    }
+    static {
+        this.LABEL = ( localize(7910, "Install Recommended Extension"));
+    }
     constructor(extensionId, instantiationService, extensionWorkbenchService) {
-        super(InstallRecommendedExtensionAction_1.ID, InstallRecommendedExtensionAction_1.LABEL, undefined, false);
+        super(
+            InstallRecommendedExtensionAction_1.ID,
+            InstallRecommendedExtensionAction_1.LABEL,
+            undefined,
+            false
+        );
         this.instantiationService = instantiationService;
         this.extensionWorkbenchService = extensionWorkbenchService;
         this.extensionId = extensionId;
     }
     async run() {
         await this.extensionWorkbenchService.openSearch(`@id:${this.extensionId}`);
-        const [extension] = await this.extensionWorkbenchService.getExtensions([{ id: this.extensionId }], { source: 'install-recommendation' }, CancellationToken.None);
+        const [extension] = await this.extensionWorkbenchService.getExtensions([{
+            id: this.extensionId
+        }], {
+            source: "install-recommendation"
+        }, CancellationToken.None);
         if (extension) {
             await this.extensionWorkbenchService.open(extension);
             try {
                 await this.extensionWorkbenchService.install(extension);
-            }
-            catch (err) {
-                this.instantiationService.createInstance(PromptExtensionInstallFailureAction, extension, undefined, extension.latestVersion, InstallOperation.Install, err).run();
+            } catch (err) {
+                this.instantiationService.createInstance(
+                    PromptExtensionInstallFailureAction,
+                    extension,
+                    undefined,
+                    extension.latestVersion,
+                    InstallOperation.Install,
+                    err
+                ).run();
             }
         }
     }
 };
-InstallRecommendedExtensionAction = InstallRecommendedExtensionAction_1 = ( __decorate([
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IExtensionsWorkbenchService))
-], InstallRecommendedExtensionAction));
+InstallRecommendedExtensionAction = InstallRecommendedExtensionAction_1 = ( __decorate([( __param(1, IInstantiationService)), ( __param(2, IExtensionsWorkbenchService))], InstallRecommendedExtensionAction));
 let IgnoreExtensionRecommendationAction = class IgnoreExtensionRecommendationAction extends Action {
-    static { IgnoreExtensionRecommendationAction_1 = this; }
-    static { this.ID = 'extensions.ignore'; }
-    static { this.Class = `${ExtensionAction.LABEL_ACTION_CLASS} ignore`; }
+    static {
+        IgnoreExtensionRecommendationAction_1 = this;
+    }
+    static {
+        this.ID = "extensions.ignore";
+    }
+    static {
+        this.Class = `${ExtensionAction.LABEL_ACTION_CLASS} ignore`;
+    }
     constructor(extension, extensionRecommendationsManagementService) {
-        super(IgnoreExtensionRecommendationAction_1.ID, 'Ignore Recommendation');
+        super(IgnoreExtensionRecommendationAction_1.ID, "Ignore Recommendation");
         this.extension = extension;
         this.extensionRecommendationsManagementService = extensionRecommendationsManagementService;
         this.class = IgnoreExtensionRecommendationAction_1.Class;
-        this.tooltip = ( localize(7600, "Do not recommend this extension again"));
+        this.tooltip = ( localize(7911, "Do not recommend this extension again"));
         this.enabled = true;
     }
     run() {
@@ -2101,19 +2562,23 @@ let IgnoreExtensionRecommendationAction = class IgnoreExtensionRecommendationAct
         return Promise.resolve();
     }
 };
-IgnoreExtensionRecommendationAction = IgnoreExtensionRecommendationAction_1 = ( __decorate([
-    ( __param(1, IExtensionIgnoredRecommendationsService))
-], IgnoreExtensionRecommendationAction));
+IgnoreExtensionRecommendationAction = IgnoreExtensionRecommendationAction_1 = ( __decorate([( __param(1, IExtensionIgnoredRecommendationsService))], IgnoreExtensionRecommendationAction));
 let UndoIgnoreExtensionRecommendationAction = class UndoIgnoreExtensionRecommendationAction extends Action {
-    static { UndoIgnoreExtensionRecommendationAction_1 = this; }
-    static { this.ID = 'extensions.ignore'; }
-    static { this.Class = `${ExtensionAction.LABEL_ACTION_CLASS} undo-ignore`; }
+    static {
+        UndoIgnoreExtensionRecommendationAction_1 = this;
+    }
+    static {
+        this.ID = "extensions.ignore";
+    }
+    static {
+        this.Class = `${ExtensionAction.LABEL_ACTION_CLASS} undo-ignore`;
+    }
     constructor(extension, extensionRecommendationsManagementService) {
-        super(UndoIgnoreExtensionRecommendationAction_1.ID, 'Undo');
+        super(UndoIgnoreExtensionRecommendationAction_1.ID, "Undo");
         this.extension = extension;
         this.extensionRecommendationsManagementService = extensionRecommendationsManagementService;
         this.class = UndoIgnoreExtensionRecommendationAction_1.Class;
-        this.tooltip = ( localize(7601, "Undo"));
+        this.tooltip = ( localize(7912, "Undo"));
         this.enabled = true;
     }
     run() {
@@ -2121,11 +2586,18 @@ let UndoIgnoreExtensionRecommendationAction = class UndoIgnoreExtensionRecommend
         return Promise.resolve();
     }
 };
-UndoIgnoreExtensionRecommendationAction = UndoIgnoreExtensionRecommendationAction_1 = ( __decorate([
-    ( __param(1, IExtensionIgnoredRecommendationsService))
-], UndoIgnoreExtensionRecommendationAction));
+UndoIgnoreExtensionRecommendationAction = UndoIgnoreExtensionRecommendationAction_1 = ( __decorate([( __param(1, IExtensionIgnoredRecommendationsService))], UndoIgnoreExtensionRecommendationAction));
 let AbstractConfigureRecommendedExtensionsAction = class AbstractConfigureRecommendedExtensionsAction extends Action {
-    constructor(id, label, contextService, fileService, textFileService, editorService, jsonEditingService, textModelResolverService) {
+    constructor(
+        id,
+        label,
+        contextService,
+        fileService,
+        textFileService,
+        editorService,
+        jsonEditingService,
+        textModelResolverService
+    ) {
         super(id, label);
         this.contextService = contextService;
         this.fileService = fileService;
@@ -2135,24 +2607,25 @@ let AbstractConfigureRecommendedExtensionsAction = class AbstractConfigureRecomm
         this.textModelResolverService = textModelResolverService;
     }
     openExtensionsFile(extensionsFileResource) {
-        return this.getOrCreateExtensionsFile(extensionsFileResource)
-            .then(({ created, content }) => this.getSelectionPosition(content, extensionsFileResource, ['recommendations'])
-            .then(selection => this.editorService.openEditor({
+        return this.getOrCreateExtensionsFile(extensionsFileResource).then((
+            {
+                created,
+                content
+            }
+        ) => this.getSelectionPosition(content, extensionsFileResource, ["recommendations"]).then(selection => this.editorService.openEditor({
             resource: extensionsFileResource,
             options: {
                 pinned: created,
                 selection
             }
         })), error => Promise.reject(( new Error(( localize(
-            7602,
+            7913,
             "Unable to create 'extensions.json' file inside the '.vscode' folder ({0}).",
             error
         ))))));
     }
     openWorkspaceConfigurationFile(workspaceConfigurationFile) {
-        return this.getOrUpdateWorkspaceConfigurationFile(workspaceConfigurationFile)
-            .then(content => this.getSelectionPosition(( content.value.toString()), content.resource, ['extensions', 'recommendations']))
-            .then(selection => this.editorService.openEditor({
+        return this.getOrUpdateWorkspaceConfigurationFile(workspaceConfigurationFile).then(content => this.getSelectionPosition(( content.value.toString()), content.resource, ["extensions", "recommendations"])).then(selection => this.editorService.openEditor({
             resource: workspaceConfigurationFile,
             options: {
                 selection,
@@ -2161,12 +2634,15 @@ let AbstractConfigureRecommendedExtensionsAction = class AbstractConfigureRecomm
         }));
     }
     getOrUpdateWorkspaceConfigurationFile(workspaceConfigurationFile) {
-        return Promise.resolve(this.fileService.readFile(workspaceConfigurationFile))
-            .then(content => {
-            const workspaceRecommendations = parse(( content.value.toString()))['extensions'];
+        return Promise.resolve(this.fileService.readFile(workspaceConfigurationFile)).then(content => {
+            const workspaceRecommendations = parse(( content.value.toString()))["extensions"];
             if (!workspaceRecommendations || !workspaceRecommendations.recommendations) {
-                return this.jsonEditingService.write(workspaceConfigurationFile, [{ path: ['extensions'], value: { recommendations: [] } }], true)
-                    .then(() => this.fileService.readFile(workspaceConfigurationFile));
+                return this.jsonEditingService.write(workspaceConfigurationFile, [{
+                    path: ["extensions"],
+                    value: {
+                        recommendations: []
+                    }
+                }], true).then(() => this.fileService.readFile(workspaceConfigurationFile));
             }
             return content;
         });
@@ -2178,15 +2654,14 @@ let AbstractConfigureRecommendedExtensionsAction = class AbstractConfigureRecomm
             const recommendationsValueNode = node.parent.children[1];
             const lastExtensionNode = recommendationsValueNode.children && recommendationsValueNode.children.length ? recommendationsValueNode.children[recommendationsValueNode.children.length - 1] : null;
             const offset = lastExtensionNode ? lastExtensionNode.offset + lastExtensionNode.length : recommendationsValueNode.offset + 1;
-            return Promise.resolve(this.textModelResolverService.createModelReference(resource))
-                .then(reference => {
+            return Promise.resolve(this.textModelResolverService.createModelReference(resource)).then(reference => {
                 const position = reference.object.textEditorModel.getPositionAt(offset);
                 reference.dispose();
                 return {
                     startLineNumber: position.lineNumber,
                     startColumn: position.column,
                     endLineNumber: position.lineNumber,
-                    endColumn: position.column,
+                    endColumn: position.column
                 };
             });
         }
@@ -2194,27 +2669,50 @@ let AbstractConfigureRecommendedExtensionsAction = class AbstractConfigureRecomm
     }
     getOrCreateExtensionsFile(extensionsFileResource) {
         return Promise.resolve(this.fileService.readFile(extensionsFileResource)).then(content => {
-            return { created: false, extensionsFileResource, content: ( content.value.toString()) };
+            return {
+                created: false,
+                extensionsFileResource,
+                content: ( content.value.toString())
+            };
         }, err => {
             return this.textFileService.write(extensionsFileResource, ExtensionsConfigurationInitialContent).then(() => {
-                return { created: true, extensionsFileResource, content: ExtensionsConfigurationInitialContent };
+                return {
+                    created: true,
+                    extensionsFileResource,
+                    content: ExtensionsConfigurationInitialContent
+                };
             });
         });
     }
 };
-AbstractConfigureRecommendedExtensionsAction = ( __decorate([
-    ( __param(2, IWorkspaceContextService)),
-    ( __param(3, IFileService)),
-    ( __param(4, ITextFileService)),
-    ( __param(5, IEditorService)),
-    ( __param(6, IJSONEditingService)),
-    ( __param(7, ITextModelService))
-], AbstractConfigureRecommendedExtensionsAction));
+AbstractConfigureRecommendedExtensionsAction = ( __decorate([( __param(2, IWorkspaceContextService)), ( __param(3, IFileService)), ( __param(4, ITextFileService)), ( __param(5, IEditorService)), ( __param(6, IJSONEditingService)), ( __param(7, ITextModelService))], AbstractConfigureRecommendedExtensionsAction));
 let ConfigureWorkspaceRecommendedExtensionsAction = class ConfigureWorkspaceRecommendedExtensionsAction extends AbstractConfigureRecommendedExtensionsAction {
-    static { this.ID = 'workbench.extensions.action.configureWorkspaceRecommendedExtensions'; }
-    static { this.LABEL = ( localize(7603, "Configure Recommended Extensions (Workspace)")); }
-    constructor(id, label, fileService, textFileService, contextService, editorService, jsonEditingService, textModelResolverService) {
-        super(id, label, contextService, fileService, textFileService, editorService, jsonEditingService, textModelResolverService);
+    static {
+        this.ID = "workbench.extensions.action.configureWorkspaceRecommendedExtensions";
+    }
+    static {
+        this.LABEL = ( localize(7914, "Configure Recommended Extensions (Workspace)"));
+    }
+    constructor(
+        id,
+        label,
+        fileService,
+        textFileService,
+        contextService,
+        editorService,
+        jsonEditingService,
+        textModelResolverService
+    ) {
+        super(
+            id,
+            label,
+            contextService,
+            fileService,
+            textFileService,
+            editorService,
+            jsonEditingService,
+            textModelResolverService
+        );
         this._register(this.contextService.onDidChangeWorkbenchState(() => this.update(), this));
         this.update();
     }
@@ -2223,34 +2721,51 @@ let ConfigureWorkspaceRecommendedExtensionsAction = class ConfigureWorkspaceReco
     }
     run() {
         switch (this.contextService.getWorkbenchState()) {
-            case WorkbenchState.FOLDER:
-                return this.openExtensionsFile(this.contextService.getWorkspace().folders[0].toResource(EXTENSIONS_CONFIG));
-            case WorkbenchState.WORKSPACE:
-                return this.openWorkspaceConfigurationFile(this.contextService.getWorkspace().configuration);
+        case WorkbenchState.FOLDER:
+            return this.openExtensionsFile(
+                this.contextService.getWorkspace().folders[0].toResource(EXTENSIONS_CONFIG)
+            );
+        case WorkbenchState.WORKSPACE:
+            return this.openWorkspaceConfigurationFile(this.contextService.getWorkspace().configuration);
         }
         return Promise.resolve();
     }
 };
-ConfigureWorkspaceRecommendedExtensionsAction = ( __decorate([
-    ( __param(2, IFileService)),
-    ( __param(3, ITextFileService)),
-    ( __param(4, IWorkspaceContextService)),
-    ( __param(5, IEditorService)),
-    ( __param(6, IJSONEditingService)),
-    ( __param(7, ITextModelService))
-], ConfigureWorkspaceRecommendedExtensionsAction));
+ConfigureWorkspaceRecommendedExtensionsAction = ( __decorate([( __param(2, IFileService)), ( __param(3, ITextFileService)), ( __param(4, IWorkspaceContextService)), ( __param(5, IEditorService)), ( __param(6, IJSONEditingService)), ( __param(7, ITextModelService))], ConfigureWorkspaceRecommendedExtensionsAction));
 let ConfigureWorkspaceFolderRecommendedExtensionsAction = class ConfigureWorkspaceFolderRecommendedExtensionsAction extends AbstractConfigureRecommendedExtensionsAction {
-    static { this.ID = 'workbench.extensions.action.configureWorkspaceFolderRecommendedExtensions'; }
-    static { this.LABEL = ( localize(7604, "Configure Recommended Extensions (Workspace Folder)")); }
-    constructor(id, label, fileService, textFileService, contextService, editorService, jsonEditingService, textModelResolverService, commandService) {
-        super(id, label, contextService, fileService, textFileService, editorService, jsonEditingService, textModelResolverService);
+    static {
+        this.ID = "workbench.extensions.action.configureWorkspaceFolderRecommendedExtensions";
+    }
+    static {
+        this.LABEL = ( localize(7915, "Configure Recommended Extensions (Workspace Folder)"));
+    }
+    constructor(
+        id,
+        label,
+        fileService,
+        textFileService,
+        contextService,
+        editorService,
+        jsonEditingService,
+        textModelResolverService,
+        commandService
+    ) {
+        super(
+            id,
+            label,
+            contextService,
+            fileService,
+            textFileService,
+            editorService,
+            jsonEditingService,
+            textModelResolverService
+        );
         this.commandService = commandService;
     }
     run() {
         const folderCount = this.contextService.getWorkspace().folders.length;
         const pickFolderPromise = folderCount === 1 ? Promise.resolve(this.contextService.getWorkspace().folders[0]) : this.commandService.executeCommand(PICK_WORKSPACE_FOLDER_COMMAND_ID);
-        return Promise.resolve(pickFolderPromise)
-            .then(workspaceFolder => {
+        return Promise.resolve(pickFolderPromise).then(workspaceFolder => {
             if (workspaceFolder) {
                 return this.openExtensionsFile(workspaceFolder.toResource(EXTENSIONS_CONFIG));
             }
@@ -2258,20 +2773,20 @@ let ConfigureWorkspaceFolderRecommendedExtensionsAction = class ConfigureWorkspa
         });
     }
 };
-ConfigureWorkspaceFolderRecommendedExtensionsAction = ( __decorate([
-    ( __param(2, IFileService)),
-    ( __param(3, ITextFileService)),
-    ( __param(4, IWorkspaceContextService)),
-    ( __param(5, IEditorService)),
-    ( __param(6, IJSONEditingService)),
-    ( __param(7, ITextModelService)),
-    ( __param(8, ICommandService))
-], ConfigureWorkspaceFolderRecommendedExtensionsAction));
+ConfigureWorkspaceFolderRecommendedExtensionsAction = ( __decorate([( __param(2, IFileService)), ( __param(3, ITextFileService)), ( __param(4, IWorkspaceContextService)), ( __param(5, IEditorService)), ( __param(6, IJSONEditingService)), ( __param(7, ITextModelService)), ( __param(8, ICommandService))], ConfigureWorkspaceFolderRecommendedExtensionsAction));
 let ExtensionStatusLabelAction = class ExtensionStatusLabelAction extends Action {
-    static { ExtensionStatusLabelAction_1 = this; }
-    static { this.ENABLED_CLASS = `${ExtensionAction.TEXT_ACTION_CLASS} extension-status-label`; }
-    static { this.DISABLED_CLASS = `${this.ENABLED_CLASS} hide`; }
-    get extension() { return this._extension; }
+    static {
+        ExtensionStatusLabelAction_1 = this;
+    }
+    static {
+        this.ENABLED_CLASS = `${ExtensionAction.TEXT_ACTION_CLASS} extension-status-label`;
+    }
+    static {
+        this.DISABLED_CLASS = `${this.ENABLED_CLASS} hide`;
+    }
+    get extension() {
+        return this._extension;
+    }
     set extension(extension) {
         if (!(this._extension && extension && areSameExtensions(this._extension.identifier, extension.identifier))) {
             this.initialStatus = null;
@@ -2281,8 +2796,17 @@ let ExtensionStatusLabelAction = class ExtensionStatusLabelAction extends Action
         this._extension = extension;
         this.update();
     }
-    constructor(extensionService, extensionManagementServerService, extensionEnablementService) {
-        super('extensions.action.statusLabel', '', ExtensionStatusLabelAction_1.DISABLED_CLASS, false);
+    constructor(
+        extensionService,
+        extensionManagementServerService,
+        extensionEnablementService
+    ) {
+        super(
+            "extensions.action.statusLabel",
+            "",
+            ExtensionStatusLabelAction_1.DISABLED_CLASS,
+            false
+        );
         this.extensionService = extensionService;
         this.extensionManagementServerService = extensionManagementServerService;
         this.extensionEnablementService = extensionEnablementService;
@@ -2294,7 +2818,7 @@ let ExtensionStatusLabelAction = class ExtensionStatusLabelAction extends Action
     }
     update() {
         const label = this.computeLabel();
-        this.label = label || '';
+        this.label = label || "";
         this.class = label ? ExtensionStatusLabelAction_1.ENABLED_CLASS : ExtensionStatusLabelAction_1.DISABLED_CLASS;
     }
     computeLabel() {
@@ -2311,7 +2835,10 @@ let ExtensionStatusLabelAction = class ExtensionStatusLabelAction extends Action
         }
         this.enablementState = this.extension.enablementState;
         const canAddExtension = () => {
-            const runningExtension = this.extensionService.extensions.filter(e => areSameExtensions({ id: e.identifier.value, uuid: e.uuid }, this.extension.identifier))[0];
+            const runningExtension = this.extensionService.extensions.filter(e => areSameExtensions({
+                id: e.identifier.value,
+                uuid: e.uuid
+            }, this.extension.identifier))[0];
             if (this.extension.local) {
                 if (runningExtension && this.extension.version === runningExtension.version) {
                     return true;
@@ -2322,7 +2849,10 @@ let ExtensionStatusLabelAction = class ExtensionStatusLabelAction extends Action
         };
         const canRemoveExtension = () => {
             if (this.extension.local) {
-                if (this.extensionService.extensions.every(e => !(areSameExtensions({ id: e.identifier.value, uuid: e.uuid }, this.extension.identifier) && this.extension.server === this.extensionManagementServerService.getExtensionManagementServer(toExtension(e))))) {
+                if (this.extensionService.extensions.every(e => !(areSameExtensions({
+                    id: e.identifier.value,
+                    uuid: e.uuid
+                }, this.extension.identifier) && this.extension.server === this.extensionManagementServerService.getExtensionManagementServer(toExtension(e))))) {
                     return true;
                 }
                 return this.extensionService.canRemoveExtension(toExtensionDescription(this.extension.local));
@@ -2332,26 +2862,26 @@ let ExtensionStatusLabelAction = class ExtensionStatusLabelAction extends Action
         if (currentStatus !== null) {
             if (currentStatus === ExtensionState.Installing && this.status === ExtensionState.Installed) {
                 if (this.initialStatus === ExtensionState.Uninstalled && canAddExtension()) {
-                    return localize(7605, "Installed");
+                    return localize(7916, "Installed");
                 }
                 if (this.initialStatus === ExtensionState.Installed && this.version !== currentVersion && canAddExtension()) {
-                    return localize(7606, "Updated");
+                    return localize(7917, "Updated");
                 }
                 return null;
             }
             if (currentStatus === ExtensionState.Uninstalling && this.status === ExtensionState.Uninstalled) {
                 this.initialStatus = this.status;
-                return canRemoveExtension() ? ( localize(7607, "Uninstalled")) : null;
+                return canRemoveExtension() ? ( localize(7918, "Uninstalled")) : null;
             }
         }
         if (currentEnablementState !== null) {
             const currentlyEnabled = this.extensionEnablementService.isEnabledEnablementState(currentEnablementState);
             const enabled = this.extensionEnablementService.isEnabledEnablementState(this.enablementState);
             if (!currentlyEnabled && enabled) {
-                return canAddExtension() ? ( localize(7608, "Enabled")) : null;
+                return canAddExtension() ? ( localize(7919, "Enabled")) : null;
             }
             if (currentlyEnabled && !enabled) {
-                return canRemoveExtension() ? ( localize(7609, "Disabled")) : null;
+                return canRemoveExtension() ? ( localize(7920, "Disabled")) : null;
             }
         }
         return null;
@@ -2360,21 +2890,37 @@ let ExtensionStatusLabelAction = class ExtensionStatusLabelAction extends Action
         return Promise.resolve();
     }
 };
-ExtensionStatusLabelAction = ExtensionStatusLabelAction_1 = ( __decorate([
-    ( __param(0, IExtensionService)),
-    ( __param(1, IExtensionManagementServerService)),
-    ( __param(2, IWorkbenchExtensionEnablementService))
-], ExtensionStatusLabelAction));
+ExtensionStatusLabelAction = ExtensionStatusLabelAction_1 = ( __decorate([( __param(0, IExtensionService)), ( __param(1, IExtensionManagementServerService)), ( __param(2, IWorkbenchExtensionEnablementService))], ExtensionStatusLabelAction));
 let ToggleSyncExtensionAction = class ToggleSyncExtensionAction extends DropDownExtensionAction {
-    static { ToggleSyncExtensionAction_1 = this; }
-    static { this.IGNORED_SYNC_CLASS = `${ExtensionAction.ICON_ACTION_CLASS} extension-sync ${ThemeIcon.asClassName(syncIgnoredIcon)}`; }
-    static { this.SYNC_CLASS = `${this.ICON_ACTION_CLASS} extension-sync ${ThemeIcon.asClassName(syncEnabledIcon)}`; }
-    constructor(configurationService, extensionsWorkbenchService, userDataSyncEnablementService, instantiationService) {
-        super('extensions.sync', '', ToggleSyncExtensionAction_1.SYNC_CLASS, false, instantiationService);
+    static {
+        ToggleSyncExtensionAction_1 = this;
+    }
+    static {
+        this.IGNORED_SYNC_CLASS = `${ExtensionAction.ICON_ACTION_CLASS} extension-sync ${ThemeIcon.asClassName(syncIgnoredIcon)}`;
+    }
+    static {
+        this.SYNC_CLASS = `${this.ICON_ACTION_CLASS} extension-sync ${ThemeIcon.asClassName(syncEnabledIcon)}`;
+    }
+    constructor(
+        configurationService,
+        extensionsWorkbenchService,
+        userDataSyncEnablementService,
+        instantiationService
+    ) {
+        super(
+            "extensions.sync",
+            "",
+            ToggleSyncExtensionAction_1.SYNC_CLASS,
+            false,
+            instantiationService
+        );
         this.configurationService = configurationService;
         this.extensionsWorkbenchService = extensionsWorkbenchService;
         this.userDataSyncEnablementService = userDataSyncEnablementService;
-        this._register(Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('settingsSync.ignoredExtensions'))(() => this.update()));
+        this._register(Event.filter(
+            this.configurationService.onDidChangeConfiguration,
+            e => e.affectsConfiguration("settingsSync.ignoredExtensions")
+        )(() => this.update()));
         this._register(userDataSyncEnablementService.onDidChangeEnablement(() => this.update()));
         this.update();
     }
@@ -2383,35 +2929,47 @@ let ToggleSyncExtensionAction = class ToggleSyncExtensionAction extends DropDown
         if (this.extension) {
             const isIgnored = this.extensionsWorkbenchService.isExtensionIgnoredToSync(this.extension);
             this.class = isIgnored ? ToggleSyncExtensionAction_1.IGNORED_SYNC_CLASS : ToggleSyncExtensionAction_1.SYNC_CLASS;
-            this.tooltip = isIgnored ? ( localize(7610, "This extension is ignored during sync")) : ( localize(7611, "This extension is synced"));
+            this.tooltip = isIgnored ? ( localize(7921, "This extension is ignored during sync")) : ( localize(7922, "This extension is synced"));
         }
     }
     async run() {
-        return super.run([
-            [
-                ( new Action(
-                    'extensions.syncignore',
-                    this.extensionsWorkbenchService.isExtensionIgnoredToSync(this.extension) ? ( localize(7612, "Sync this extension")) : ( localize(7613, "Do not sync this extension")),
-                    undefined,
-                    true,
-                    () => this.extensionsWorkbenchService.toggleExtensionIgnoredToSync(this.extension)
-                ))
-            ]
-        ]);
+        return super.run([[( new Action(
+            "extensions.syncignore",
+            this.extensionsWorkbenchService.isExtensionIgnoredToSync(this.extension) ? ( localize(7923, "Sync this extension")) : ( localize(7924, "Do not sync this extension")),
+            undefined,
+            true,
+            () => this.extensionsWorkbenchService.toggleExtensionIgnoredToSync(this.extension)
+        ))]]);
     }
 };
-ToggleSyncExtensionAction = ToggleSyncExtensionAction_1 = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, IExtensionsWorkbenchService)),
-    ( __param(2, IUserDataSyncEnablementService)),
-    ( __param(3, IInstantiationService))
-], ToggleSyncExtensionAction));
+ToggleSyncExtensionAction = ToggleSyncExtensionAction_1 = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IExtensionsWorkbenchService)), ( __param(2, IUserDataSyncEnablementService)), ( __param(3, IInstantiationService))], ToggleSyncExtensionAction));
 let ExtensionStatusAction = class ExtensionStatusAction extends ExtensionAction {
-    static { ExtensionStatusAction_1 = this; }
-    static { this.CLASS = `${ExtensionAction.ICON_ACTION_CLASS} extension-status`; }
-    get status() { return this._status; }
-    constructor(extensionManagementServerService, labelService, commandService, workspaceTrustEnablementService, workspaceTrustService, extensionsWorkbenchService, extensionService, extensionManifestPropertiesService, contextService, productService, allowedExtensionsService, workbenchExtensionEnablementService, extensionFeaturesManagementService, extensionGalleryManifestService) {
-        super('extensions.status', '', `${ExtensionStatusAction_1.CLASS} hide`, false);
+    static {
+        ExtensionStatusAction_1 = this;
+    }
+    static {
+        this.CLASS = `${ExtensionAction.ICON_ACTION_CLASS} extension-status`;
+    }
+    get status() {
+        return this._status;
+    }
+    constructor(
+        extensionManagementServerService,
+        labelService,
+        commandService,
+        workspaceTrustEnablementService,
+        workspaceTrustService,
+        extensionsWorkbenchService,
+        extensionService,
+        extensionManifestPropertiesService,
+        contextService,
+        productService,
+        allowedExtensionsService,
+        workbenchExtensionEnablementService,
+        extensionFeaturesManagementService,
+        extensionGalleryManifestService
+    ) {
+        super("extensions.status", "", `${ExtensionStatusAction_1.CLASS} hide`, false);
         this.extensionManagementServerService = extensionManagementServerService;
         this.labelService = labelService;
         this.commandService = commandService;
@@ -2433,8 +2991,12 @@ let ExtensionStatusAction = class ExtensionStatusAction extends ExtensionAction
         this.updateThrottler = ( new Throttler());
         this._register(this.labelService.onDidChangeFormatters(() => this.update(), this));
         this._register(this.extensionService.onDidChangeExtensions(() => this.update()));
-        this._register(this.extensionFeaturesManagementService.onDidChangeAccessData(() => this.update()));
-        this._register(allowedExtensionsService.onDidChangeAllowedExtensionsConfigValue(() => this.update()));
+        this._register(
+            this.extensionFeaturesManagementService.onDidChangeAccessData(() => this.update())
+        );
+        this._register(
+            allowedExtensionsService.onDidChangeAllowedExtensionsConfigValue(() => this.update())
+        );
         this.update();
     }
     update() {
@@ -2447,40 +3009,59 @@ let ExtensionStatusAction = class ExtensionStatusAction extends ExtensionAction
             return;
         }
         if (this.extension.isMalicious) {
-            this.updateStatus({ icon: warningIcon, message: ( new MarkdownString(( localize(7614, "This extension was reported to be problematic.")))) }, true);
+            this.updateStatus({
+                icon: warningIcon,
+                message: ( new MarkdownString(( localize(7925, "This extension was reported to be problematic."))))
+            }, true);
             return;
         }
-        if (this.extension.state === ExtensionState.Uninstalled && this.extension.gallery && !this.extension.gallery.isSigned && shouldRequireRepositorySignatureFor(this.extension.private, await this.extensionGalleryManifestService.getExtensionGalleryManifest())) {
-            this.updateStatus({ icon: warningIcon, message: ( new MarkdownString(( localize(7615, "This extension is not signed by the Extension Marketplace.")))) }, true);
+        if (this.extension.state === ExtensionState.Uninstalled && this.extension.gallery && !this.extension.gallery.isSigned && shouldRequireRepositorySignatureFor(
+            this.extension.private,
+            await this.extensionGalleryManifestService.getExtensionGalleryManifest()
+        )) {
+            this.updateStatus({
+                icon: warningIcon,
+                message: ( new MarkdownString(( localize(7926, "This extension is not signed by the Extension Marketplace."))))
+            }, true);
             return;
         }
         if (this.extension.deprecationInfo) {
             if (this.extension.deprecationInfo.extension) {
-                const link = `[${this.extension.deprecationInfo.extension.displayName}](${createCommandUri('extension.open', this.extension.deprecationInfo.extension.id)})`;
-                this.updateStatus({ icon: warningIcon, message: ( new MarkdownString(( localize(7616, "This extension is deprecated. Use the {0} extension instead.", link)))) }, true);
-            }
-            else if (this.extension.deprecationInfo.settings) {
-                const link = `[${( localize(7617, "settings"))}](${createCommandUri('workbench.action.openSettings', ( this.extension.deprecationInfo.settings.map(setting => `@id:${setting}`)).join(' '))}})`;
-                this.updateStatus({ icon: warningIcon, message: ( new MarkdownString(( localize(
-                    7618,
-                    "This extension is deprecated as this functionality is now built-in to VS Code. Configure these {0} to use this functionality.",
-                    link
-                )))) }, true);
-            }
-            else {
-                const message = ( new MarkdownString(( localize(7619, "This extension is deprecated as it is no longer being maintained."))));
+                const link = `[${this.extension.deprecationInfo.extension.displayName}](${createCommandUri("extension.open", this.extension.deprecationInfo.extension.id)})`;
+                this.updateStatus({
+                    icon: warningIcon,
+                    message: ( new MarkdownString(( localize(7927, "This extension is deprecated. Use the {0} extension instead.", link))))
+                }, true);
+            } else if (this.extension.deprecationInfo.settings) {
+                const link = `[${( localize(7928, "settings"))}](${createCommandUri("workbench.action.openSettings", ( this.extension.deprecationInfo.settings.map(setting => `@id:${setting}`)).join(" "))}})`;
+                this.updateStatus({
+                    icon: warningIcon,
+                    message: ( new MarkdownString(( localize(
+                        7929,
+                        "This extension is deprecated as this functionality is now built-in to VS Code. Configure these {0} to use this functionality.",
+                        link
+                    ))))
+                }, true);
+            } else {
+                const message = ( new MarkdownString(( localize(7930, "This extension is deprecated as it is no longer being maintained."))));
                 if (this.extension.deprecationInfo.additionalInfo) {
                     message.appendMarkdown(` ${this.extension.deprecationInfo.additionalInfo}`);
                 }
-                this.updateStatus({ icon: warningIcon, message }, true);
+                this.updateStatus({
+                    icon: warningIcon,
+                    message
+                }, true);
             }
             return;
         }
         if (this.extension.missingFromGallery) {
-            this.updateStatus({ icon: warningIcon, message: ( new MarkdownString(( localize(
-                7620,
-                "This extension is no longer available on the Extension Marketplace."
-            )))) }, true);
+            this.updateStatus({
+                icon: warningIcon,
+                message: ( new MarkdownString(( localize(
+                    7931,
+                    "This extension is no longer available on the Extension Marketplace."
+                ))))
+            }, true);
             return;
         }
         if (this.extensionsWorkbenchService.canSetLanguage(this.extension)) {
@@ -2492,98 +3073,126 @@ let ExtensionStatusAction = class ExtensionStatusAction extends ExtensionAction
                 const markdown = ( new MarkdownString());
                 markdown.appendMarkdown(`${message} `);
                 markdown.appendMarkdown(( localize(
-                    7621,
+                    7932,
                     "Please [review the extension]({0}) and update it manually.",
-                    this.extension.hasChangelog()
-                        ? ( createCommandUri('extension.open', this.extension.identifier.id, ExtensionEditorTab.Changelog).toString())
-                        : this.extension.repository
-                            ? this.extension.repository
-                            : ( createCommandUri('extension.open', this.extension.identifier.id).toString())
+                    this.extension.hasChangelog() ? ( createCommandUri(
+                        "extension.open",
+                        this.extension.identifier.id,
+                        ExtensionEditorTab.Changelog
+                    ).toString()) : this.extension.repository ? this.extension.repository : ( createCommandUri("extension.open", this.extension.identifier.id).toString())
                 )));
-                this.updateStatus({ icon: warningIcon, message: markdown }, true);
+                this.updateStatus({
+                    icon: warningIcon,
+                    message: markdown
+                }, true);
             }
         }
         if (this.extension.gallery && this.extension.state === ExtensionState.Uninstalled) {
             const result = await this.extensionsWorkbenchService.canInstall(this.extension);
             if (result !== true) {
-                this.updateStatus({ icon: warningIcon, message: result }, true);
+                this.updateStatus({
+                    icon: warningIcon,
+                    message: result
+                }, true);
                 return;
             }
         }
-        if (!this.extension.local ||
-            !this.extension.server ||
-            this.extension.state !== ExtensionState.Installed) {
+        if (!this.extension.local || !this.extension.server || this.extension.state !== ExtensionState.Installed) {
             return;
         }
         if (this.extension.enablementState === EnablementState.DisabledByAllowlist) {
             const result = this.allowedExtensionsService.isAllowed(this.extension.local);
             if (result !== true) {
-                this.updateStatus({ icon: warningIcon, message: ( new MarkdownString(( localize(7622, "This extension is disabled because {0}", result.value)))) }, true);
+                this.updateStatus({
+                    icon: warningIcon,
+                    message: ( new MarkdownString(( localize(7933, "This extension is disabled because {0}", result.value))))
+                }, true);
                 return;
             }
         }
         if (this.extension.enablementState === EnablementState.DisabledByEnvironment) {
-            this.updateStatus({ message: ( new MarkdownString(( localize(7623, "This extension is disabled by the environment.")))) }, true);
+            this.updateStatus({
+                message: ( new MarkdownString(( localize(7934, "This extension is disabled by the environment."))))
+            }, true);
             return;
         }
         if (this.extension.enablementState === EnablementState.EnabledByEnvironment) {
-            this.updateStatus({ message: ( new MarkdownString(( localize(
-                7624,
-                "This extension is enabled because it is required in the current environment."
-            )))) }, true);
+            this.updateStatus({
+                message: ( new MarkdownString(( localize(
+                    7935,
+                    "This extension is enabled because it is required in the current environment."
+                ))))
+            }, true);
             return;
         }
         if (this.extension.enablementState === EnablementState.DisabledByVirtualWorkspace) {
             const details = getWorkspaceSupportTypeMessage(this.extension.local.manifest.capabilities?.virtualWorkspaces);
-            this.updateStatus({ icon: infoIcon, message: ( new MarkdownString(details ? escapeMarkdownSyntaxTokens(details) : ( localize(
-                7625,
-                "This extension has been disabled because it does not support virtual workspaces."
-            )))) }, true);
+            this.updateStatus({
+                icon: infoIcon,
+                message: ( new MarkdownString(details ? escapeMarkdownSyntaxTokens(details) : ( localize(
+                    7936,
+                    "This extension has been disabled because it does not support virtual workspaces."
+                ))))
+            }, true);
             return;
         }
         if (isVirtualWorkspace(this.contextService.getWorkspace())) {
             const virtualSupportType = this.extensionManifestPropertiesService.getExtensionVirtualWorkspaceSupportType(this.extension.local.manifest);
             const details = getWorkspaceSupportTypeMessage(this.extension.local.manifest.capabilities?.virtualWorkspaces);
-            if (virtualSupportType === 'limited' || details) {
-                this.updateStatus({ icon: warningIcon, message: ( new MarkdownString(details ? escapeMarkdownSyntaxTokens(details) : ( localize(
-                    7626,
-                    "This extension has limited features because the current workspace is virtual."
-                )))) }, true);
+            if (virtualSupportType === "limited" || details) {
+                this.updateStatus({
+                    icon: warningIcon,
+                    message: ( new MarkdownString(details ? escapeMarkdownSyntaxTokens(details) : ( localize(
+                        7937,
+                        "This extension has limited features because the current workspace is virtual."
+                    ))))
+                }, true);
                 return;
             }
         }
         if (this.extension.enablementState === EnablementState.DisabledByUnification) {
-            this.updateStatus({ icon: infoIcon, message: ( new MarkdownString(( localize(
-                7627,
-                "All GitHub Copilot functionality is now being served from the GitHub Copilot Chat extension. To temporarily opt out of this extension unification, toggle the {0} setting.",
-                '`chat.extensionUnification.enabled`'
-            )))) }, true);
+            this.updateStatus({
+                icon: infoIcon,
+                message: ( new MarkdownString(( localize(
+                    7938,
+                    "All GitHub Copilot functionality is now being served from the GitHub Copilot Chat extension. To temporarily opt out of this extension unification, toggle the {0} setting.",
+                    "`chat.extensionUnification.enabled`"
+                ))))
+            }, true);
             return;
         }
-        if (!this.workspaceTrustService.isWorkspaceTrusted() &&
-            (this.extension.enablementState === EnablementState.DisabledByTrustRequirement ||
-                (this.extension.enablementState === EnablementState.DisabledByExtensionDependency && this.workbenchExtensionEnablementService.getDependenciesEnablementStates(this.extension.local).every(([, enablementState]) => this.workbenchExtensionEnablementService.isEnabledEnablementState(enablementState) || enablementState === EnablementState.DisabledByTrustRequirement)))) {
+        if (
+        !this.workspaceTrustService.isWorkspaceTrusted() && (
+        this.extension.enablementState === EnablementState.DisabledByTrustRequirement || (this.extension.enablementState === EnablementState.DisabledByExtensionDependency && this.workbenchExtensionEnablementService.getDependenciesEnablementStates(this.extension.local).every(
+            ([, enablementState]) => this.workbenchExtensionEnablementService.isEnabledEnablementState(enablementState) || enablementState === EnablementState.DisabledByTrustRequirement
+        )))) {
             this.enabled = true;
             const untrustedDetails = getWorkspaceSupportTypeMessage(this.extension.local.manifest.capabilities?.untrustedWorkspaces);
-            this.updateStatus({ icon: trustIcon, message: ( new MarkdownString(
-                untrustedDetails ? escapeMarkdownSyntaxTokens(untrustedDetails) : ( localize(
-                    7628,
-                    "This extension has been disabled because the current workspace is not trusted."
+            this.updateStatus({
+                icon: trustIcon,
+                message: ( new MarkdownString(
+                    untrustedDetails ? escapeMarkdownSyntaxTokens(untrustedDetails) : ( localize(
+                        7939,
+                        "This extension has been disabled because the current workspace is not trusted."
+                    ))
                 ))
-            )) }, true);
+            }, true);
             return;
         }
         if (this.workspaceTrustEnablementService.isWorkspaceTrustEnabled() && !this.workspaceTrustService.isWorkspaceTrusted()) {
             const untrustedSupportType = this.extensionManifestPropertiesService.getExtensionUntrustedWorkspaceSupportType(this.extension.local.manifest);
             const untrustedDetails = getWorkspaceSupportTypeMessage(this.extension.local.manifest.capabilities?.untrustedWorkspaces);
-            if (untrustedSupportType === 'limited' || untrustedDetails) {
+            if (untrustedSupportType === "limited" || untrustedDetails) {
                 this.enabled = true;
-                this.updateStatus({ icon: trustIcon, message: ( new MarkdownString(
-                    untrustedDetails ? escapeMarkdownSyntaxTokens(untrustedDetails) : ( localize(
-                        7629,
-                        "This extension has limited features because the current workspace is not trusted."
+                this.updateStatus({
+                    icon: trustIcon,
+                    message: ( new MarkdownString(
+                        untrustedDetails ? escapeMarkdownSyntaxTokens(untrustedDetails) : ( localize(
+                            7940,
+                            "This extension has limited features because the current workspace is not trusted."
+                        ))
                     ))
-                )) }, true);
+                }, true);
                 return;
             }
         }
@@ -2596,10 +3205,10 @@ let ExtensionStatusAction = class ExtensionStatusAction extends ExtensionAction
                     if (this.extensionManifestPropertiesService.prefersExecuteOnWorkspace(this.extension.local.manifest)) {
                         if (this.extensionManagementServerService.remoteExtensionManagementServer) {
                             message = ( new MarkdownString(`${( localize(
-                                7630,
+                                7941,
                                 "This extension is disabled in this workspace because it is defined to run in the Remote Extension Host. Please install the extension in '{0}' to enable.",
                                 this.extensionManagementServerService.remoteExtensionManagementServer.label
-                            ))} [${( localize(7518, "Learn More"))}](https://code.visualstudio.com/api/advanced-topics/remote-extensions#architecture-and-extension-kinds)`));
+                            ))} [${( localize(7829, "Learn More"))}](https://code.visualstudio.com/api/advanced-topics/remote-extensions#architecture-and-extension-kinds)`));
                         }
                     }
                 }
@@ -2607,29 +3216,31 @@ let ExtensionStatusAction = class ExtensionStatusAction extends ExtensionAction
                     if (this.extensionManifestPropertiesService.prefersExecuteOnUI(this.extension.local.manifest)) {
                         if (this.extensionManagementServerService.localExtensionManagementServer) {
                             message = ( new MarkdownString(`${( localize(
-                                7631,
+                                7942,
                                 "This extension is disabled in this workspace because it is defined to run in the Local Extension Host. Please install the extension locally to enable.",
                                 this.extensionManagementServerService.remoteExtensionManagementServer.label
-                            ))} [${( localize(7518, "Learn More"))}](https://code.visualstudio.com/api/advanced-topics/remote-extensions#architecture-and-extension-kinds)`));
-                        }
-                        else if (isWeb) {
+                            ))} [${( localize(7829, "Learn More"))}](https://code.visualstudio.com/api/advanced-topics/remote-extensions#architecture-and-extension-kinds)`));
+                        } else if (isWeb) {
                             message = ( new MarkdownString(`${( localize(
-                                7632,
+                                7943,
                                 "This extension is disabled because it is defined to run only in {0} for the Desktop.",
                                 this.productService.nameLong
-                            ))} [${( localize(7518, "Learn More"))}](https://code.visualstudio.com/api/advanced-topics/remote-extensions#architecture-and-extension-kinds)`));
+                            ))} [${( localize(7829, "Learn More"))}](https://code.visualstudio.com/api/advanced-topics/remote-extensions#architecture-and-extension-kinds)`));
                         }
                     }
                 }
                 else if (this.extensionManagementServerService.webExtensionManagementServer === this.extension.server) {
                     message = ( new MarkdownString(`${( localize(
-                        7633,
+                        7944,
                         "This extension is disabled because it is not supported in {0} for the Web.",
                         this.productService.nameLong
-                    ))} [${( localize(7518, "Learn More"))}](https://code.visualstudio.com/api/advanced-topics/remote-extensions#architecture-and-extension-kinds)`));
+                    ))} [${( localize(7829, "Learn More"))}](https://code.visualstudio.com/api/advanced-topics/remote-extensions#architecture-and-extension-kinds)`));
                 }
                 if (message) {
-                    this.updateStatus({ icon: warningIcon, message }, true);
+                    this.updateStatus({
+                        icon: warningIcon,
+                        message
+                    }, true);
                 }
                 return;
             }
@@ -2638,13 +3249,25 @@ let ExtensionStatusAction = class ExtensionStatusAction extends ExtensionAction
         const features = ( Registry.as(Extensions.ExtensionFeaturesRegistry)).getExtensionFeatures();
         for (const feature of features) {
             const status = this.extensionFeaturesManagementService.getAccessData(extensionId, feature.id)?.current?.status;
-            const manageAccessLink = `[${( localize(7634, 'Manage Access'))}](${createCommandUri('extension.open', this.extension.identifier.id, ExtensionEditorTab.Features, false, feature.id)})`;
+            const manageAccessLink = `[${( localize(7945, "Manage Access"))}](${createCommandUri(
+    "extension.open",
+    this.extension.identifier.id,
+    ExtensionEditorTab.Features,
+    false,
+    feature.id
+)})`;
             if (status?.severity === Severity$1.Error) {
-                this.updateStatus({ icon: errorIcon, message: ( new MarkdownString()).appendText(status.message).appendMarkdown(` ${manageAccessLink}`) }, true);
+                this.updateStatus({
+                    icon: errorIcon,
+                    message: ( new MarkdownString()).appendText(status.message).appendMarkdown(` ${manageAccessLink}`)
+                }, true);
                 return;
             }
             if (status?.severity === Severity$1.Warning) {
-                this.updateStatus({ icon: warningIcon, message: ( new MarkdownString()).appendText(status.message).appendMarkdown(` ${manageAccessLink}`) }, true);
+                this.updateStatus({
+                    icon: warningIcon,
+                    message: ( new MarkdownString()).appendText(status.message).appendMarkdown(` ${manageAccessLink}`)
+                }, true);
                 return;
             }
         }
@@ -2653,46 +3276,59 @@ let ExtensionStatusAction = class ExtensionStatusAction extends ExtensionAction
                 if (!( this.extensionsWorkbenchService.installed.some(
                     e => areSameExtensions(e.identifier, this.extension.identifier) && e.server !== this.extension.server
                 ))) {
-                    const message = this.extension.server === this.extensionManagementServerService.localExtensionManagementServer
-                        ? ( new MarkdownString(( localize(
-                        7635,
+                    const message = this.extension.server === this.extensionManagementServerService.localExtensionManagementServer ? ( new MarkdownString(( localize(
+                        7946,
                         "Install the language pack extension on '{0}' to enable it there also.",
                         this.extensionManagementServerService.remoteExtensionManagementServer.label
-                    ))))
-                        : ( new MarkdownString(( localize(
-                        7636,
+                    )))) : ( new MarkdownString(( localize(
+                        7947,
                         "Install the language pack extension locally to enable it there also."
                     ))));
-                    this.updateStatus({ icon: infoIcon, message }, true);
+                    this.updateStatus({
+                        icon: infoIcon,
+                        message
+                    }, true);
                 }
                 return;
             }
-            const runningExtension = this.extensionService.extensions.filter(e => areSameExtensions({ id: e.identifier.value, uuid: e.uuid }, this.extension.identifier))[0];
+            const runningExtension = this.extensionService.extensions.filter(e => areSameExtensions({
+                id: e.identifier.value,
+                uuid: e.uuid
+            }, this.extension.identifier))[0];
             const runningExtensionServer = runningExtension ? this.extensionManagementServerService.getExtensionManagementServer(toExtension(runningExtension)) : null;
             if (this.extension.server === this.extensionManagementServerService.localExtensionManagementServer && runningExtensionServer === this.extensionManagementServerService.remoteExtensionManagementServer) {
                 if (this.extensionManifestPropertiesService.prefersExecuteOnWorkspace(this.extension.local.manifest)) {
-                    this.updateStatus({ icon: infoIcon, message: ( new MarkdownString(`${( localize(
-                        7637,
-                        "This extension is enabled in the Remote Extension Host because it prefers to run there."
-                    ))} [${( localize(7518, "Learn More"))}](https://code.visualstudio.com/api/advanced-topics/remote-extensions#architecture-and-extension-kinds)`)) }, true);
+                    this.updateStatus({
+                        icon: infoIcon,
+                        message: ( new MarkdownString(`${( localize(
+                            7948,
+                            "This extension is enabled in the Remote Extension Host because it prefers to run there."
+                        ))} [${( localize(7829, "Learn More"))}](https://code.visualstudio.com/api/advanced-topics/remote-extensions#architecture-and-extension-kinds)`))
+                    }, true);
                 }
                 return;
             }
             if (this.extension.server === this.extensionManagementServerService.remoteExtensionManagementServer && runningExtensionServer === this.extensionManagementServerService.localExtensionManagementServer) {
                 if (this.extensionManifestPropertiesService.prefersExecuteOnUI(this.extension.local.manifest)) {
-                    this.updateStatus({ icon: infoIcon, message: ( new MarkdownString(`${( localize(
-                        7638,
-                        "This extension is enabled in the Local Extension Host because it prefers to run there."
-                    ))} [${( localize(7518, "Learn More"))}](https://code.visualstudio.com/api/advanced-topics/remote-extensions#architecture-and-extension-kinds)`)) }, true);
+                    this.updateStatus({
+                        icon: infoIcon,
+                        message: ( new MarkdownString(`${( localize(
+                            7949,
+                            "This extension is enabled in the Local Extension Host because it prefers to run there."
+                        ))} [${( localize(7829, "Learn More"))}](https://code.visualstudio.com/api/advanced-topics/remote-extensions#architecture-and-extension-kinds)`))
+                    }, true);
                 }
                 return;
             }
             if (this.extension.server === this.extensionManagementServerService.remoteExtensionManagementServer && runningExtensionServer === this.extensionManagementServerService.webExtensionManagementServer) {
                 if (this.extensionManifestPropertiesService.canExecuteOnWeb(this.extension.local.manifest)) {
-                    this.updateStatus({ icon: infoIcon, message: ( new MarkdownString(`${( localize(
-                        7639,
-                        "This extension is enabled in the Web Worker Extension Host because it prefers to run there."
-                    ))} [${( localize(7518, "Learn More"))}](https://code.visualstudio.com/api/advanced-topics/remote-extensions#architecture-and-extension-kinds)`)) }, true);
+                    this.updateStatus({
+                        icon: infoIcon,
+                        message: ( new MarkdownString(`${( localize(
+                            7950,
+                            "This extension is enabled in the Web Worker Extension Host because it prefers to run there."
+                        ))} [${( localize(7829, "Learn More"))}](https://code.visualstudio.com/api/advanced-topics/remote-extensions#architecture-and-extension-kinds)`))
+                    }, true);
                 }
                 return;
             }
@@ -2700,28 +3336,39 @@ let ExtensionStatusAction = class ExtensionStatusAction extends ExtensionAction
         if (this.extension.enablementState === EnablementState.DisabledByExtensionDependency) {
             this.updateStatus({
                 icon: warningIcon,
-                message: ( new MarkdownString(( localize(7640, "This extension depends on an extension that is disabled."))))
-                    .appendMarkdown(` [${( localize(7641, "Show Dependencies"))}](${createCommandUri('extension.open', this.extension.identifier.id, ExtensionEditorTab.Dependencies)})`)
+                message: ( new MarkdownString(( localize(7951, "This extension depends on an extension that is disabled.")))).appendMarkdown(` [${( localize(7952, "Show Dependencies"))}](${createCommandUri(
+    "extension.open",
+    this.extension.identifier.id,
+    ExtensionEditorTab.Dependencies
+)})`)
             }, true);
             return;
         }
         if (!this.extension.local.isValid) {
             const errors = ( this.extension.local.validations.filter(([severity]) => severity === Severity$1.Error).map(([, message]) => message));
-            this.updateStatus({ icon: warningIcon, message: ( new MarkdownString(errors.join(' ').trim())) }, true);
+            this.updateStatus({
+                icon: warningIcon,
+                message: ( new MarkdownString(errors.join(" ").trim()))
+            }, true);
             return;
         }
         const isEnabled = this.workbenchExtensionEnablementService.isEnabled(this.extension.local);
-        const isRunning = ( this.extensionService.extensions.some(
-            e => areSameExtensions({ id: e.identifier.value, uuid: e.uuid }, this.extension.identifier)
-        ));
+        const isRunning = ( this.extensionService.extensions.some(e => areSameExtensions({
+            id: e.identifier.value,
+            uuid: e.uuid
+        }, this.extension.identifier)));
         if (!this.extension.isWorkspaceScoped && isEnabled && isRunning) {
             if (this.extension.enablementState === EnablementState.EnabledWorkspace) {
-                this.updateStatus({ message: ( new MarkdownString(( localize(7642, "This extension is enabled for this workspace by the user.")))) }, true);
+                this.updateStatus({
+                    message: ( new MarkdownString(( localize(7953, "This extension is enabled for this workspace by the user."))))
+                }, true);
                 return;
             }
             if (this.extensionManagementServerService.localExtensionManagementServer && this.extensionManagementServerService.remoteExtensionManagementServer) {
                 if (this.extension.server === this.extensionManagementServerService.remoteExtensionManagementServer) {
-                    this.updateStatus({ message: ( new MarkdownString(( localize(7643, "Extension is enabled on '{0}'", this.extension.server.label)))) }, true);
+                    this.updateStatus({
+                        message: ( new MarkdownString(( localize(7954, "Extension is enabled on '{0}'", this.extension.server.label))))
+                    }, true);
                     return;
                 }
             }
@@ -2731,11 +3378,15 @@ let ExtensionStatusAction = class ExtensionStatusAction extends ExtensionAction
         }
         if (!isEnabled && !isRunning) {
             if (this.extension.enablementState === EnablementState.DisabledGlobally) {
-                this.updateStatus({ message: ( new MarkdownString(( localize(7644, "This extension is disabled globally by the user.")))) }, true);
+                this.updateStatus({
+                    message: ( new MarkdownString(( localize(7955, "This extension is disabled globally by the user."))))
+                }, true);
                 return;
             }
             if (this.extension.enablementState === EnablementState.DisabledWorkspace) {
-                this.updateStatus({ message: ( new MarkdownString(( localize(7645, "This extension is disabled for this workspace by the user.")))) }, true);
+                this.updateStatus({
+                    message: ( new MarkdownString(( localize(7956, "This extension is disabled for this workspace by the user."))))
+                }, true);
                 return;
             }
         }
@@ -2747,8 +3398,7 @@ let ExtensionStatusAction = class ExtensionStatusAction extends ExtensionAction
             ))) {
                 return;
             }
-        }
-        else {
+        } else {
             if (this._status.length === 0) {
                 return;
             }
@@ -2756,30 +3406,20 @@ let ExtensionStatusAction = class ExtensionStatusAction extends ExtensionAction
         }
         if (status) {
             this._status.push(status);
-            this._status.sort((a, b) => b.icon === trustIcon ? -1 :
-                a.icon === trustIcon ? 1 :
-                    b.icon === errorIcon ? -1 :
-                        a.icon === errorIcon ? 1 :
-                            b.icon === warningIcon ? -1 :
-                                a.icon === warningIcon ? 1 :
-                                    b.icon === infoIcon ? -1 :
-                                        a.icon === infoIcon ? 1 :
-                                            0);
+            this._status.sort(
+                (a, b) => b.icon === trustIcon ? -1 : a.icon === trustIcon ? 1 : b.icon === errorIcon ? -1 : a.icon === errorIcon ? 1 : b.icon === warningIcon ? -1 : a.icon === warningIcon ? 1 : b.icon === infoIcon ? -1 : a.icon === infoIcon ? 1 : 0
+            );
         }
         if (updateClass) {
             if (status?.icon === errorIcon) {
                 this.class = `${ExtensionStatusAction_1.CLASS} extension-status-error ${ThemeIcon.asClassName(errorIcon)}`;
-            }
-            else if (status?.icon === warningIcon) {
+            } else if (status?.icon === warningIcon) {
                 this.class = `${ExtensionStatusAction_1.CLASS} extension-status-warning ${ThemeIcon.asClassName(warningIcon)}`;
-            }
-            else if (status?.icon === infoIcon) {
+            } else if (status?.icon === infoIcon) {
                 this.class = `${ExtensionStatusAction_1.CLASS} extension-status-info ${ThemeIcon.asClassName(infoIcon)}`;
-            }
-            else if (status?.icon === trustIcon) {
+            } else if (status?.icon === trustIcon) {
                 this.class = `${ExtensionStatusAction_1.CLASS} ${ThemeIcon.asClassName(trustIcon)}`;
-            }
-            else {
+            } else {
                 this.class = `${ExtensionStatusAction_1.CLASS} hide`;
             }
         }
@@ -2787,31 +3427,29 @@ let ExtensionStatusAction = class ExtensionStatusAction extends ExtensionAction
     }
     async run() {
         if (this._status[0]?.icon === trustIcon) {
-            return this.commandService.executeCommand('workbench.trust.manage');
+            return this.commandService.executeCommand("workbench.trust.manage");
         }
     }
 };
-ExtensionStatusAction = ExtensionStatusAction_1 = ( __decorate([
-    ( __param(0, IExtensionManagementServerService)),
-    ( __param(1, ILabelService)),
-    ( __param(2, ICommandService)),
-    ( __param(3, IWorkspaceTrustEnablementService)),
-    ( __param(4, IWorkspaceTrustManagementService)),
-    ( __param(5, IExtensionsWorkbenchService)),
-    ( __param(6, IExtensionService)),
-    ( __param(7, IExtensionManifestPropertiesService)),
-    ( __param(8, IWorkspaceContextService)),
-    ( __param(9, IProductService)),
-    ( __param(10, IAllowedExtensionsService)),
-    ( __param(11, IWorkbenchExtensionEnablementService)),
-    ( __param(12, IExtensionFeaturesManagementService)),
-    ( __param(13, IExtensionGalleryManifestService))
-], ExtensionStatusAction));
+ExtensionStatusAction = ExtensionStatusAction_1 = ( __decorate([( __param(0, IExtensionManagementServerService)), ( __param(1, ILabelService)), ( __param(2, ICommandService)), ( __param(3, IWorkspaceTrustEnablementService)), ( __param(4, IWorkspaceTrustManagementService)), ( __param(5, IExtensionsWorkbenchService)), ( __param(6, IExtensionService)), ( __param(7, IExtensionManifestPropertiesService)), ( __param(8, IWorkspaceContextService)), ( __param(9, IProductService)), ( __param(10, IAllowedExtensionsService)), ( __param(11, IWorkbenchExtensionEnablementService)), ( __param(12, IExtensionFeaturesManagementService)), ( __param(13, IExtensionGalleryManifestService))], ExtensionStatusAction));
 let InstallSpecificVersionOfExtensionAction = class InstallSpecificVersionOfExtensionAction extends Action {
-    static { InstallSpecificVersionOfExtensionAction_1 = this; }
-    static { this.ID = 'workbench.extensions.action.install.specificVersion'; }
-    static { this.LABEL = ( localize(7646, "Install Specific Version of Extension...")); }
-    constructor(id = InstallSpecificVersionOfExtensionAction_1.ID, label = InstallSpecificVersionOfExtensionAction_1.LABEL, extensionsWorkbenchService, quickInputService, instantiationService, extensionEnablementService) {
+    static {
+        InstallSpecificVersionOfExtensionAction_1 = this;
+    }
+    static {
+        this.ID = "workbench.extensions.action.install.specificVersion";
+    }
+    static {
+        this.LABEL = ( localize(7957, "Install Specific Version of Extension..."));
+    }
+    constructor(
+        id = InstallSpecificVersionOfExtensionAction_1.ID,
+        label = InstallSpecificVersionOfExtensionAction_1.LABEL,
+        extensionsWorkbenchService,
+        quickInputService,
+        instantiationService,
+        extensionEnablementService
+    ) {
         super(id, label);
         this.extensionsWorkbenchService = extensionsWorkbenchService;
         this.quickInputService = quickInputService;
@@ -2822,7 +3460,10 @@ let InstallSpecificVersionOfExtensionAction = class InstallSpecificVersionOfExte
         return ( this.extensionsWorkbenchService.local.some(l => this.isEnabled(l)));
     }
     async run() {
-        const extensionPick = await this.quickInputService.pick(this.getExtensionEntries(), { placeHolder: ( localize(7647, "Select Extension")), matchOnDetail: true });
+        const extensionPick = await this.quickInputService.pick(this.getExtensionEntries(), {
+            placeHolder: ( localize(7958, "Select Extension")),
+            matchOnDetail: true
+        });
         if (extensionPick && extensionPick.extension) {
             const action = this.instantiationService.createInstance(InstallAnotherVersionAction, extensionPick.extension, true);
             await action.run();
@@ -2842,21 +3483,24 @@ let InstallSpecificVersionOfExtensionAction = class InstallSpecificVersionOfExte
                     id: extension.identifier.id,
                     label: extension.displayName || extension.identifier.id,
                     description: extension.identifier.id,
-                    extension,
+                    extension
                 });
             }
         }
-        return entries.sort((e1, e2) => e1.extension.displayName.localeCompare(e2.extension.displayName));
+        return entries.sort(
+            (e1, e2) => e1.extension.displayName.localeCompare(e2.extension.displayName)
+        );
     }
 };
-InstallSpecificVersionOfExtensionAction = InstallSpecificVersionOfExtensionAction_1 = ( __decorate([
-    ( __param(2, IExtensionsWorkbenchService)),
-    ( __param(3, IQuickInputService)),
-    ( __param(4, IInstantiationService)),
-    ( __param(5, IWorkbenchExtensionEnablementService))
-], InstallSpecificVersionOfExtensionAction));
+InstallSpecificVersionOfExtensionAction = InstallSpecificVersionOfExtensionAction_1 = ( __decorate([( __param(2, IExtensionsWorkbenchService)), ( __param(3, IQuickInputService)), ( __param(4, IInstantiationService)), ( __param(5, IWorkbenchExtensionEnablementService))], InstallSpecificVersionOfExtensionAction));
 let AbstractInstallExtensionsInServerAction = class AbstractInstallExtensionsInServerAction extends Action {
-    constructor(id, extensionsWorkbenchService, quickInputService, notificationService, progressService) {
+    constructor(
+        id,
+        extensionsWorkbenchService,
+        quickInputService,
+        notificationService,
+        progressService
+    ) {
         super(id);
         this.extensionsWorkbenchService = extensionsWorkbenchService;
         this.quickInputService = quickInputService;
@@ -2900,19 +3544,20 @@ let AbstractInstallExtensionsInServerAction = class AbstractInstallExtensionsInS
         quickPick.busy = false;
         if (localExtensionsToInstall.length) {
             quickPick.title = this.getQuickPickTitle();
-            quickPick.placeholder = ( localize(7648, "Select extensions to install"));
+            quickPick.placeholder = ( localize(7959, "Select extensions to install"));
             quickPick.canSelectMany = true;
             localExtensionsToInstall.sort((e1, e2) => e1.displayName.localeCompare(e2.displayName));
-            quickPick.items = ( localExtensionsToInstall.map(
-                extension => ({ extension, label: extension.displayName, description: extension.version })
-            ));
-        }
-        else {
+            quickPick.items = ( localExtensionsToInstall.map(extension => ({
+                extension,
+                label: extension.displayName,
+                description: extension.version
+            })));
+        } else {
             quickPick.hide();
             quickPick.dispose();
             this.notificationService.notify({
                 severity: Severity$1.Info,
-                message: ( localize(7649, "There are no extensions to install."))
+                message: ( localize(7960, "There are no extensions to install."))
             });
         }
     }
@@ -2922,22 +3567,33 @@ let AbstractInstallExtensionsInServerAction = class AbstractInstallExtensionsInS
             if (localExtensionsToInstall.length) {
                 await this.progressService.withProgress({
                     location: ProgressLocation.Notification,
-                    title: ( localize(7650, "Installing Extensions..."))
+                    title: ( localize(7961, "Installing Extensions..."))
                 }, () => this.installExtensions(localExtensionsToInstall));
-                this.notificationService.info(( localize(7651, "Successfully installed extensions.")));
+                this.notificationService.info(( localize(7962, "Successfully installed extensions.")));
             }
         }
     }
 };
-AbstractInstallExtensionsInServerAction = ( __decorate([
-    ( __param(1, IExtensionsWorkbenchService)),
-    ( __param(2, IQuickInputService)),
-    ( __param(3, INotificationService)),
-    ( __param(4, IProgressService))
-], AbstractInstallExtensionsInServerAction));
+AbstractInstallExtensionsInServerAction = ( __decorate([( __param(1, IExtensionsWorkbenchService)), ( __param(2, IQuickInputService)), ( __param(3, INotificationService)), ( __param(4, IProgressService))], AbstractInstallExtensionsInServerAction));
 let InstallLocalExtensionsInRemoteAction = class InstallLocalExtensionsInRemoteAction extends AbstractInstallExtensionsInServerAction {
-    constructor(extensionsWorkbenchService, quickInputService, progressService, notificationService, extensionManagementServerService, extensionGalleryService, instantiationService, fileService, logService) {
-        super('workbench.extensions.actions.installLocalExtensionsInRemote', extensionsWorkbenchService, quickInputService, notificationService, progressService);
+    constructor(
+        extensionsWorkbenchService,
+        quickInputService,
+        progressService,
+        notificationService,
+        extensionManagementServerService,
+        extensionGalleryService,
+        instantiationService,
+        fileService,
+        logService
+    ) {
+        super(
+            "workbench.extensions.actions.installLocalExtensionsInRemote",
+            extensionsWorkbenchService,
+            quickInputService,
+            notificationService,
+            progressService
+        );
         this.extensionManagementServerService = extensionManagementServerService;
         this.extensionGalleryService = extensionGalleryService;
         this.instantiationService = instantiationService;
@@ -2947,16 +3603,16 @@ let InstallLocalExtensionsInRemoteAction = class InstallLocalExtensionsInRemoteA
     get label() {
         if (this.extensionManagementServerService && this.extensionManagementServerService.remoteExtensionManagementServer) {
             return localize(
-                7652,
+                7963,
                 "Install Local Extensions in '{0}'...",
                 this.extensionManagementServerService.remoteExtensionManagementServer.label
             );
         }
-        return '';
+        return "";
     }
     getQuickPickTitle() {
         return localize(
-            7653,
+            7964,
             "Install Local Extensions in '{0}'",
             this.extensionManagementServerService.remoteExtensionManagementServer.label
         );
@@ -2972,9 +3628,15 @@ let InstallLocalExtensionsInRemoteAction = class InstallLocalExtensionsInRemoteA
         const galleryExtensions = [];
         const vsixs = [];
         const targetPlatform = await this.extensionManagementServerService.remoteExtensionManagementServer.extensionManagementService.getTargetPlatform();
-        await Promises.settled(( localExtensionsToInstall.map(async (extension) => {
+        await Promises.settled(( localExtensionsToInstall.map(async extension => {
             if (this.extensionGalleryService.isEnabled()) {
-                const gallery = (await this.extensionGalleryService.getExtensions([{ ...extension.identifier, preRelease: !!extension.local?.preRelease }], { targetPlatform, compatible: true }, CancellationToken.None))[0];
+                const gallery = (await this.extensionGalleryService.getExtensions([{
+                    ...extension.identifier,
+                    preRelease: !!extension.local?.preRelease
+                }], {
+                    targetPlatform,
+                    compatible: true
+                }, CancellationToken.None))[0];
                 if (gallery) {
                     galleryExtensions.push(gallery);
                     return;
@@ -2990,55 +3652,66 @@ let InstallLocalExtensionsInRemoteAction = class InstallLocalExtensionsInRemoteA
             await Promises.settled(( vsixs.map(
                 vsix => this.extensionManagementServerService.remoteExtensionManagementServer.extensionManagementService.install(vsix)
             )));
-        }
-        finally {
+        } finally {
             try {
                 await Promise.allSettled(( vsixs.map(vsix => this.fileService.del(vsix))));
-            }
-            catch (error) {
+            } catch (error) {
                 this.logService.error(error);
             }
         }
     }
 };
-InstallLocalExtensionsInRemoteAction = ( __decorate([
-    ( __param(0, IExtensionsWorkbenchService)),
-    ( __param(1, IQuickInputService)),
-    ( __param(2, IProgressService)),
-    ( __param(3, INotificationService)),
-    ( __param(4, IExtensionManagementServerService)),
-    ( __param(5, IExtensionGalleryService)),
-    ( __param(6, IInstantiationService)),
-    ( __param(7, IFileService)),
-    ( __param(8, ILogService))
-], InstallLocalExtensionsInRemoteAction));
+InstallLocalExtensionsInRemoteAction = ( __decorate([( __param(0, IExtensionsWorkbenchService)), ( __param(1, IQuickInputService)), ( __param(2, IProgressService)), ( __param(3, INotificationService)), ( __param(4, IExtensionManagementServerService)), ( __param(5, IExtensionGalleryService)), ( __param(6, IInstantiationService)), ( __param(7, IFileService)), ( __param(8, ILogService))], InstallLocalExtensionsInRemoteAction));
 let InstallRemoteExtensionsInLocalAction = class InstallRemoteExtensionsInLocalAction extends AbstractInstallExtensionsInServerAction {
-    constructor(id, extensionsWorkbenchService, quickInputService, progressService, notificationService, extensionManagementServerService, extensionGalleryService, fileService, logService) {
-        super(id, extensionsWorkbenchService, quickInputService, notificationService, progressService);
+    constructor(
+        id,
+        extensionsWorkbenchService,
+        quickInputService,
+        progressService,
+        notificationService,
+        extensionManagementServerService,
+        extensionGalleryService,
+        fileService,
+        logService
+    ) {
+        super(
+            id,
+            extensionsWorkbenchService,
+            quickInputService,
+            notificationService,
+            progressService
+        );
         this.extensionManagementServerService = extensionManagementServerService;
         this.extensionGalleryService = extensionGalleryService;
         this.fileService = fileService;
         this.logService = logService;
     }
     get label() {
-        return localize(7654, "Install Remote Extensions Locally...");
+        return localize(7965, "Install Remote Extensions Locally...");
     }
     getQuickPickTitle() {
-        return localize(7655, "Install Remote Extensions Locally");
+        return localize(7966, "Install Remote Extensions Locally");
     }
     getExtensionsToInstall(local) {
-        return local.filter(extension => extension.type === ExtensionType.User && extension.server !== this.extensionManagementServerService.localExtensionManagementServer
-            && !( this.extensionsWorkbenchService.installed.some(
-            e => e.server === this.extensionManagementServerService.localExtensionManagementServer && areSameExtensions(e.identifier, extension.identifier)
-        )));
+        return local.filter(
+            extension => extension.type === ExtensionType.User && extension.server !== this.extensionManagementServerService.localExtensionManagementServer && !( this.extensionsWorkbenchService.installed.some(
+                e => e.server === this.extensionManagementServerService.localExtensionManagementServer && areSameExtensions(e.identifier, extension.identifier)
+            ))
+        );
     }
     async installExtensions(extensions) {
         const galleryExtensions = [];
         const vsixs = [];
         const targetPlatform = await this.extensionManagementServerService.localExtensionManagementServer.extensionManagementService.getTargetPlatform();
-        await Promises.settled(( extensions.map(async (extension) => {
+        await Promises.settled(( extensions.map(async extension => {
             if (this.extensionGalleryService.isEnabled()) {
-                const gallery = (await this.extensionGalleryService.getExtensions([{ ...extension.identifier, preRelease: !!extension.local?.preRelease }], { targetPlatform, compatible: true }, CancellationToken.None))[0];
+                const gallery = (await this.extensionGalleryService.getExtensions([{
+                    ...extension.identifier,
+                    preRelease: !!extension.local?.preRelease
+                }], {
+                    targetPlatform,
+                    compatible: true
+                }, CancellationToken.None))[0];
                 if (gallery) {
                     galleryExtensions.push(gallery);
                     return;
@@ -3054,100 +3727,116 @@ let InstallRemoteExtensionsInLocalAction = class InstallRemoteExtensionsInLocalA
             await Promises.settled(( vsixs.map(
                 vsix => this.extensionManagementServerService.localExtensionManagementServer.extensionManagementService.install(vsix)
             )));
-        }
-        finally {
+        } finally {
             try {
                 await Promise.allSettled(( vsixs.map(vsix => this.fileService.del(vsix))));
-            }
-            catch (error) {
+            } catch (error) {
                 this.logService.error(error);
             }
         }
     }
 };
-InstallRemoteExtensionsInLocalAction = ( __decorate([
-    ( __param(1, IExtensionsWorkbenchService)),
-    ( __param(2, IQuickInputService)),
-    ( __param(3, IProgressService)),
-    ( __param(4, INotificationService)),
-    ( __param(5, IExtensionManagementServerService)),
-    ( __param(6, IExtensionGalleryService)),
-    ( __param(7, IFileService)),
-    ( __param(8, ILogService))
-], InstallRemoteExtensionsInLocalAction));
-CommandsRegistry.registerCommand('workbench.extensions.action.showExtensionsForLanguage', function (accessor, fileExtension) {
-    const extensionsWorkbenchService = accessor.get(IExtensionsWorkbenchService);
-    return extensionsWorkbenchService.openSearch(`ext:${fileExtension.replace(/^\./, '')}`);
-});
-const showExtensionsWithIdsCommandId = 'workbench.extensions.action.showExtensionsWithIds';
-CommandsRegistry.registerCommand(showExtensionsWithIdsCommandId, function (accessor, extensionIds) {
+InstallRemoteExtensionsInLocalAction = ( __decorate([( __param(1, IExtensionsWorkbenchService)), ( __param(2, IQuickInputService)), ( __param(3, IProgressService)), ( __param(4, INotificationService)), ( __param(5, IExtensionManagementServerService)), ( __param(6, IExtensionGalleryService)), ( __param(7, IFileService)), ( __param(8, ILogService))], InstallRemoteExtensionsInLocalAction));
+CommandsRegistry.registerCommand(
+    "workbench.extensions.action.showExtensionsForLanguage",
+    function(accessor, fileExtension) {
+        const extensionsWorkbenchService = accessor.get(IExtensionsWorkbenchService);
+        return extensionsWorkbenchService.openSearch(`ext:${fileExtension.replace(/^\./, "")}`);
+    }
+);
+const showExtensionsWithIdsCommandId = "workbench.extensions.action.showExtensionsWithIds";
+CommandsRegistry.registerCommand(showExtensionsWithIdsCommandId, function(accessor, extensionIds) {
     const extensionsWorkbenchService = accessor.get(IExtensionsWorkbenchService);
-    return extensionsWorkbenchService.openSearch(( extensionIds.map(id => `@id:${id}`)).join(' '));
+    return extensionsWorkbenchService.openSearch(( extensionIds.map(id => `@id:${id}`)).join(" "));
 });
-registerColor('extensionButton.background', {
+registerColor("extensionButton.background", {
     dark: buttonSecondaryBackground,
     light: buttonSecondaryBackground,
     hcDark: null,
     hcLight: null
-}, ( localize(7656, "Button background color for extension actions.")));
-registerColor('extensionButton.foreground', {
+}, ( localize(7967, "Button background color for extension actions.")));
+registerColor("extensionButton.foreground", {
     dark: buttonSecondaryForeground,
     light: buttonSecondaryForeground,
     hcDark: null,
     hcLight: null
-}, ( localize(7657, "Button foreground color for extension actions.")));
-registerColor('extensionButton.hoverBackground', {
+}, ( localize(7968, "Button foreground color for extension actions.")));
+registerColor("extensionButton.hoverBackground", {
     dark: buttonSecondaryHoverBackground,
     light: buttonSecondaryHoverBackground,
     hcDark: null,
     hcLight: null
-}, ( localize(7658, "Button background hover color for extension actions.")));
-registerColor('extensionButton.separator', buttonSeparator, ( localize(7659, "Button separator color for extension actions")));
-const extensionButtonProminentBackground = registerColor('extensionButton.prominentBackground', {
+}, ( localize(7969, "Button background hover color for extension actions.")));
+registerColor("extensionButton.border", {
+    dark: buttonSecondaryBorder,
+    light: buttonSecondaryBorder,
+    hcDark: null,
+    hcLight: null
+}, ( localize(7970, "Button border color for extension actions.")));
+registerColor("extensionButton.separator", buttonSeparator, ( localize(7971, "Button separator color for extension actions")));
+const extensionButtonProminentBackground = registerColor("extensionButton.prominentBackground", {
     dark: buttonBackground,
     light: buttonBackground,
     hcDark: null,
     hcLight: null
 }, ( localize(
-    7660,
+    7972,
     "Button background color for extension actions that stand out (e.g. install button)."
 )));
-registerColor('extensionButton.prominentForeground', {
+registerColor("extensionButton.prominentForeground", {
     dark: buttonForeground,
     light: buttonForeground,
     hcDark: null,
     hcLight: null
 }, ( localize(
-    7661,
+    7973,
     "Button foreground color for extension actions that stand out (e.g. install button)."
 )));
-registerColor('extensionButton.prominentHoverBackground', {
+registerColor("extensionButton.prominentHoverBackground", {
     dark: buttonHoverBackground,
     light: buttonHoverBackground,
     hcDark: null,
     hcLight: null
 }, ( localize(
-    7662,
+    7974,
     "Button background hover color for extension actions that stand out (e.g. install button)."
 )));
 registerThemingParticipant((theme, collector) => {
     const errorColor = theme.getColor(editorErrorForeground);
     if (errorColor) {
-        collector.addRule(`.extension-editor .header .actions-status-container > .status ${ThemeIcon.asCSSSelector(errorIcon)} { color: ${errorColor}; }`);
-        collector.addRule(`.extension-editor .body .subcontent .runtime-status ${ThemeIcon.asCSSSelector(errorIcon)} { color: ${errorColor}; }`);
-        collector.addRule(`.monaco-hover.extension-hover .markdown-hover .hover-contents ${ThemeIcon.asCSSSelector(errorIcon)} { color: ${errorColor}; }`);
+        collector.addRule(
+            `.extension-editor .header .actions-status-container > .status ${ThemeIcon.asCSSSelector(errorIcon)} { color: ${errorColor}; }`
+        );
+        collector.addRule(
+            `.extension-editor .body .subcontent .runtime-status ${ThemeIcon.asCSSSelector(errorIcon)} { color: ${errorColor}; }`
+        );
+        collector.addRule(
+            `.monaco-hover.extension-hover .markdown-hover .hover-contents ${ThemeIcon.asCSSSelector(errorIcon)} { color: ${errorColor}; }`
+        );
     }
     const warningColor = theme.getColor(editorWarningForeground);
     if (warningColor) {
-        collector.addRule(`.extension-editor .header .actions-status-container > .status ${ThemeIcon.asCSSSelector(warningIcon)} { color: ${warningColor}; }`);
-        collector.addRule(`.extension-editor .body .subcontent .runtime-status ${ThemeIcon.asCSSSelector(warningIcon)} { color: ${warningColor}; }`);
-        collector.addRule(`.monaco-hover.extension-hover .markdown-hover .hover-contents ${ThemeIcon.asCSSSelector(warningIcon)} { color: ${warningColor}; }`);
+        collector.addRule(
+            `.extension-editor .header .actions-status-container > .status ${ThemeIcon.asCSSSelector(warningIcon)} { color: ${warningColor}; }`
+        );
+        collector.addRule(
+            `.extension-editor .body .subcontent .runtime-status ${ThemeIcon.asCSSSelector(warningIcon)} { color: ${warningColor}; }`
+        );
+        collector.addRule(
+            `.monaco-hover.extension-hover .markdown-hover .hover-contents ${ThemeIcon.asCSSSelector(warningIcon)} { color: ${warningColor}; }`
+        );
     }
     const infoColor = theme.getColor(editorInfoForeground);
     if (infoColor) {
-        collector.addRule(`.extension-editor .header .actions-status-container > .status ${ThemeIcon.asCSSSelector(infoIcon)} { color: ${infoColor}; }`);
-        collector.addRule(`.extension-editor .body .subcontent .runtime-status ${ThemeIcon.asCSSSelector(infoIcon)} { color: ${infoColor}; }`);
-        collector.addRule(`.monaco-hover.extension-hover .markdown-hover .hover-contents ${ThemeIcon.asCSSSelector(infoIcon)} { color: ${infoColor}; }`);
+        collector.addRule(
+            `.extension-editor .header .actions-status-container > .status ${ThemeIcon.asCSSSelector(infoIcon)} { color: ${infoColor}; }`
+        );
+        collector.addRule(
+            `.extension-editor .body .subcontent .runtime-status ${ThemeIcon.asCSSSelector(infoIcon)} { color: ${infoColor}; }`
+        );
+        collector.addRule(
+            `.monaco-hover.extension-hover .markdown-hover .hover-contents ${ThemeIcon.asCSSSelector(infoIcon)} { color: ${infoColor}; }`
+        );
     }
 });