@codingame/monaco-vscode-api 4.5.0 → 4.5.2

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

@@ -86,6 +86,7 @@ import { Registry } from '../../../../platform/registry/common/platform.js';
 import { IUpdateService } from '../../../../platform/update/common/update.service.js';
 import Severity$1 from '../../../../base/common/severity.js';
 var InstallAction_1, InstallInOtherServerAction_1, UninstallAction_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, ReinstallAction_1, InstallSpecificVersionOfExtensionAction_1;
+const _moduleId = "vs/workbench/contrib/extensions/browser/extensionsActions";
 let PromptExtensionInstallFailureAction = class PromptExtensionInstallFailureAction extends Action {
     constructor(extension, version, installOperation, error, productService, openerService, notificationService, dialogService, commandService, logService, extensionManagementServerService, instantiationService, galleryService, extensionManifestPropertiesService) {
         super('extension.promptExtensionInstallFailure');
@@ -110,15 +111,10 @@ let PromptExtensionInstallFailureAction = class PromptExtensionInstallFailureAct
         }
         this.logService.error(this.error);
         if (this.error.name === ExtensionManagementErrorCode.Unsupported) {
-            const productName = isWeb ? ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'VS Code for Web',
-                "{0} for the Web",
-                this.productService.nameLong
-            )) : this.productService.nameLong;
+            const productName = isWeb ? ( localizeWithPath(_moduleId, 0, "{0} for the Web", this.productService.nameLong)) : this.productService.nameLong;
             const message = ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'cannot be installed',
+                _moduleId,
+                1,
                 "The '{0}' extension is not available in {1}. Click 'More Information' to learn more.",
                 this.extension.displayName || this.extension.identifier.id,
                 productName
@@ -126,19 +122,11 @@ let PromptExtensionInstallFailureAction = class PromptExtensionInstallFailureAct
             const { confirmed } = await this.dialogService.confirm({
                 type: Severity$1.Info,
                 message,
-                primaryButton: ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    { key: 'more information', comment: ['&& denotes a mnemonic'] },
-                    "&&More Information"
-                )),
-                cancelButton: ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'close',
-                    "Close"
-                ))
+                primaryButton: ( localizeWithPath(_moduleId, 2, "&&More Information")),
+                cancelButton: ( localizeWithPath(_moduleId, 3, "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;
         }
@@ -147,22 +135,14 @@ let PromptExtensionInstallFailureAction = class PromptExtensionInstallFailureAct
                 type: 'error',
                 message: getErrorMessage(this.error),
                 buttons: [{
-                        label: ( localizeWithPath(
-                            'vs/workbench/contrib/extensions/browser/extensionsActions',
-                            'install prerelease',
-                            "Install Pre-Release"
-                        )),
+                        label: ( localizeWithPath(_moduleId, 4, "Install Pre-Release")),
                         run: () => {
                             const installAction = this.instantiationService.createInstance(InstallAction, { installPreReleaseVersion: true });
                             installAction.extension = this.extension;
                             return installAction.run();
                         }
                     }],
-                cancelButton: ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'cancel',
-                    "Cancel"
-                ))
+                cancelButton: ( localizeWithPath(_moduleId, 5, "Cancel"))
             });
             return;
         }
@@ -174,41 +154,33 @@ let PromptExtensionInstallFailureAction = class PromptExtensionInstallFailureAct
             await this.dialogService.prompt({
                 type: 'error',
                 message: ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'signature verification failed',
+                    _moduleId,
+                    6,
                     "{0} cannot verify the '{1}' extension. Are you sure you want to install it?",
                     this.productService.nameLong,
                     this.extension.displayName || this.extension.identifier.id
                 )),
                 buttons: [{
-                        label: ( localizeWithPath(
-                            'vs/workbench/contrib/extensions/browser/extensionsActions',
-                            'install anyway',
-                            "Install Anyway"
-                        )),
+                        label: ( localizeWithPath(_moduleId, 7, "Install Anyway")),
                         run: () => {
                             const installAction = this.instantiationService.createInstance(InstallAction, { donotVerifySignature: true });
                             installAction.extension = this.extension;
                             return installAction.run();
                         }
                     }],
-                cancelButton: ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'cancel',
-                    "Cancel"
-                ))
+                cancelButton: ( localizeWithPath(_moduleId, 5, "Cancel"))
             });
             return;
         }
         const operationMessage = this.installOperation === 3  ? ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'update operation',
+            _moduleId,
+            8,
             "Error while updating '{0}' extension.",
             this.extension.displayName || this.extension.identifier.id
         ))
             : ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'install operation',
+            _moduleId,
+            9,
             "Error while installing '{0}' extension.",
             this.extension.displayName || this.extension.identifier.id
         ));
@@ -217,29 +189,21 @@ let PromptExtensionInstallFailureAction = class PromptExtensionInstallFailureAct
         const downloadUrl = await this.getDownloadUrl();
         if (downloadUrl) {
             additionalMessage = ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'check logs',
+                _moduleId,
+                10,
                 "Please check the [log]({0}) for more details.",
                 `command:${showWindowLogActionId}`
             ));
             promptChoices.push({
-                label: ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'download',
-                    "Try Downloading Manually..."
-                )),
+                label: ( localizeWithPath(_moduleId, 11, "Try Downloading Manually...")),
                 run: () => this.openerService.open(downloadUrl).then(() => {
                     this.notificationService.prompt(Severity$1.Info, ( localizeWithPath(
-                        'vs/workbench/contrib/extensions/browser/extensionsActions',
-                        'install vsix',
+                        _moduleId,
+                        12,
                         'Once downloaded, please manually install the downloaded VSIX of \'{0}\'.',
                         this.extension.identifier.id
                     )), [{
-                            label: ( localizeWithPath(
-                                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                                'installVSIX',
-                                "Install from VSIX..."
-                            )),
+                            label: ( localizeWithPath(_moduleId, 13, "Install from VSIX...")),
                             run: () => this.commandService.executeCommand(SELECT_INSTALL_VSIX_EXTENSION_COMMAND_ID)
                         }]);
                 })
@@ -277,23 +241,25 @@ let PromptExtensionInstallFailureAction = class PromptExtensionInstallFailureAct
         if (targetPlatform === "unknown" ) {
             return undefined;
         }
-        return ( URI.parse(
-            `${this.productService.extensionsGallery.serviceUrl}/publishers/${this.extension.publisher}/vsextensions/${this.extension.name}/${this.version}/vspackage${targetPlatform !== "undefined"  ? `?targetPlatform=${targetPlatform}` : ''}`
-        ));
+        return (
+             (URI.parse(
+                `${this.productService.extensionsGallery.serviceUrl}/publishers/${this.extension.publisher}/vsextensions/${this.extension.name}/${this.version}/vspackage${targetPlatform !== "undefined"  ? `?targetPlatform=${targetPlatform}` : ''}`
+            ))
+        );
     }
 };
-PromptExtensionInstallFailureAction = ( __decorate([
-    ( __param(4, IProductService)),
-    ( __param(5, IOpenerService)),
-    ( __param(6, INotificationService)),
-    ( __param(7, IDialogService)),
-    ( __param(8, ICommandService)),
-    ( __param(9, ILogService)),
-    ( __param(10, IExtensionManagementServerService)),
-    ( __param(11, IInstantiationService)),
-    ( __param(12, IExtensionGalleryService)),
-    ( __param(13, IExtensionManifestPropertiesService))
-], PromptExtensionInstallFailureAction));
+PromptExtensionInstallFailureAction = ( (__decorate([
+    ( (__param(4, IProductService))),
+    ( (__param(5, IOpenerService))),
+    ( (__param(6, INotificationService))),
+    ( (__param(7, IDialogService))),
+    ( (__param(8, ICommandService))),
+    ( (__param(9, ILogService))),
+    ( (__param(10, IExtensionManagementServerService))),
+    ( (__param(11, IInstantiationService))),
+    ( (__param(12, IExtensionGalleryService))),
+    ( (__param(13, IExtensionManifestPropertiesService)))
+], PromptExtensionInstallFailureAction)));
 class ExtensionAction extends Action {
     constructor() {
         super(...arguments);
@@ -321,18 +287,18 @@ class ActionWithDropDownAction extends ExtensionAction {
         this._menuActions = [];
         this.extensionActions = flatten(actionsGroups);
         this.update();
-        this._register(Event.any(...( this.extensionActions.map(a => a.onDidChange)))(() => this.update(true)));
+        this._register(Event.any(...( (this.extensionActions.map(a => a.onDidChange))))(() => this.update(true)));
         this.extensionActions.forEach(a => this._register(a));
     }
     update(donotUpdateActions) {
         if (!donotUpdateActions) {
             this.extensionActions.forEach(a => a.update());
         }
-        const enabledActionsGroups = ( this.actionsGroups.map(actionsGroup => actionsGroup.filter(a => a.enabled)));
+        const enabledActionsGroups = ( (this.actionsGroups.map(actionsGroup => actionsGroup.filter(a => a.enabled))));
         let actions = [];
         for (const enabledActions of enabledActionsGroups) {
             if (enabledActions.length) {
-                actions = [...actions, ...enabledActions, ( new Separator())];
+                actions = [...actions, ...enabledActions, ( (new Separator()))];
             }
         }
         actions = actions.length ? actions.slice(0, actions.length - 1) : actions;
@@ -366,11 +332,7 @@ let InstallAction = class InstallAction extends ExtensionAction {
         this.updateLabel();
     }
     constructor(options, extensionsWorkbenchService, instantiationService, runtimeExtensionService, workbenchThemeService, labelService, dialogService, preferencesService, telemetryService, contextService) {
-        super('extensions.install', ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'install',
-            "Install"
-        )), InstallAction_1.Class, false);
+        super('extensions.install', ( localizeWithPath(_moduleId, 14, "Install")), InstallAction_1.Class, false);
         this.extensionsWorkbenchService = extensionsWorkbenchService;
         this.instantiationService = instantiationService;
         this.runtimeExtensionService = runtimeExtensionService;
@@ -381,7 +343,7 @@ let InstallAction = class InstallAction extends ExtensionAction {
         this.telemetryService = telemetryService;
         this.contextService = contextService;
         this._manifest = null;
-        this.updateThrottler = ( new Throttler());
+        this.updateThrottler = ( (new Throttler()));
         this.options = { ...options, isMachineScoped: false };
         this.update();
         this._register(this.labelService.onDidChangeFormatters(() => this.updateLabel(), this));
@@ -411,39 +373,35 @@ let InstallAction = class InstallAction extends ExtensionAction {
         }
         if (this.extension.deprecationInfo) {
             let detail = ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'deprecated message',
+                _moduleId,
+                15,
                 "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 = {})));
+            })(DeprecationChoice || (DeprecationChoice = {}))));
             const buttons = [
                 {
-                    label: ( localizeWithPath(
-                        'vs/workbench/contrib/extensions/browser/extensionsActions',
-                        'install anyway',
-                        "Install Anyway"
-                    )),
+                    label: ( localizeWithPath(_moduleId, 7, "Install Anyway")),
                     run: () => DeprecationChoice.InstallAnyway
                 }
             ];
             if (this.extension.deprecationInfo.extension) {
                 detail = ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'deprecated with alternate extension message',
+                    _moduleId,
+                    16,
                     "This extension is deprecated. Use the {0} extension instead.",
                     this.extension.deprecationInfo.extension.displayName
                 ));
                 const alternateExtension = this.extension.deprecationInfo.extension;
                 buttons.push({
                     label: ( localizeWithPath(
-                        'vs/workbench/contrib/extensions/browser/extensionsActions',
-                        { key: 'Show alternate extension', comment: ['&& denotes a mnemonic'] },
+                        _moduleId,
+                        17,
                         "&&Open {0}",
                         this.extension.deprecationInfo.extension.displayName
                     )),
@@ -456,31 +414,27 @@ let InstallAction = class InstallAction extends ExtensionAction {
             }
             else if (this.extension.deprecationInfo.settings) {
                 detail = ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'deprecated with alternate settings message',
+                    _moduleId,
+                    18,
                     "This extension is deprecated as this functionality is now built-in to VS Code."
                 ));
                 const settings = this.extension.deprecationInfo.settings;
                 buttons.push({
-                    label: ( localizeWithPath(
-                        'vs/workbench/contrib/extensions/browser/extensionsActions',
-                        { key: 'configure in settings', comment: ['&& denotes a mnemonic'] },
-                        "&&Configure Settings"
-                    )),
+                    label: ( localizeWithPath(_moduleId, 19, "&&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) {
-                detail = ( new MarkdownString(`${detail} ${this.extension.deprecationInfo.additionalInfo}`));
+                detail = ( (new MarkdownString(`${detail} ${this.extension.deprecationInfo.additionalInfo}`)));
             }
             const { result } = await this.dialogService.prompt({
                 type: Severity$1.Warning,
                 message: ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'install confirmation',
+                    _moduleId,
+                    20,
                     "Are you sure you want to install '{0}'?",
                     this.extension.displayName
                 )),
@@ -501,8 +455,8 @@ let InstallAction = class InstallAction extends ExtensionAction {
         }
         this.extensionsWorkbenchService.open(this.extension, { showPreReleaseVersion: this.options.installPreReleaseVersion });
         alert(( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'installExtensionStart',
+            _moduleId,
+            21,
             "Installing extension {0} started. An editor is now open with more details on this extension",
             this.extension.displayName
         )));
@@ -510,13 +464,13 @@ let InstallAction = class InstallAction extends ExtensionAction {
         const extension = await this.install(this.extension);
         if (extension?.local) {
             alert(( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'installExtensionComplete',
+                _moduleId,
+                22,
                 "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;
@@ -532,15 +486,15 @@ let InstallAction = class InstallAction extends ExtensionAction {
     }
     async getThemeAction(extension) {
         const colorThemes = await this.workbenchThemeService.getColorThemes();
-        if (( colorThemes.some(theme => isThemeFromExtension(theme, extension)))) {
+        if (( (colorThemes.some(theme => isThemeFromExtension(theme, extension))))) {
             return this.instantiationService.createInstance(SetColorThemeAction);
         }
         const fileIconThemes = await this.workbenchThemeService.getFileIconThemes();
-        if (( fileIconThemes.some(theme => isThemeFromExtension(theme, extension)))) {
+        if (( (fileIconThemes.some(theme => isThemeFromExtension(theme, extension))))) {
             return this.instantiationService.createInstance(SetFileIconThemeAction);
         }
         const productIconThemes = await this.workbenchThemeService.getProductIconThemes();
-        if (( productIconThemes.some(theme => isThemeFromExtension(theme, extension)))) {
+        if (( (productIconThemes.some(theme => isThemeFromExtension(theme, extension))))) {
             return this.instantiationService.createInstance(SetProductIconThemeAction);
         }
         return undefined;
@@ -560,15 +514,17 @@ let InstallAction = class InstallAction extends ExtensionAction {
             return runningExtension;
         }
         if (this.runtimeExtensionService.canAddExtension(toExtensionDescription(extension))) {
-            return ( new Promise((c, e) => {
-                const disposable = this.runtimeExtensionService.onDidChangeExtensions(async () => {
-                    const runningExtension = await this.runtimeExtensionService.getExtension(extension.identifier.id);
-                    if (runningExtension) {
-                        disposable.dispose();
-                        c(runningExtension);
-                    }
-                });
-            }));
+            return (
+                 (new Promise((c, e) => {
+                    const disposable = this.runtimeExtensionService.onDidChangeExtensions(async () => {
+                        const runningExtension = await this.runtimeExtensionService.getExtension(extension.identifier.id);
+                        if (runningExtension) {
+                            disposable.dispose();
+                            c(runningExtension);
+                        }
+                    });
+                }))
+            );
         }
         return null;
     }
@@ -577,52 +533,28 @@ let InstallAction = class InstallAction extends ExtensionAction {
     }
     getLabel(primary) {
         if (this.extension?.isWorkspaceScoped && this.extension.resourceExtension && this.contextService.isInsideWorkspace(this.extension.resourceExtension.location)) {
-            return ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'install workspace version',
-                "Install Workspace Extension"
-            ));
+            return ( localizeWithPath(_moduleId, 23, "Install Workspace Extension"));
         }
         if (this.options.installPreReleaseVersion && this.extension?.hasPreReleaseVersion) {
-            return primary ? ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'install pre-release',
-                "Install Pre-Release"
-            )) : ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'install pre-release version',
-                "Install Pre-Release Version"
-            ));
+            return primary ? ( localizeWithPath(_moduleId, 24, "Install Pre-Release")) : ( localizeWithPath(_moduleId, 25, "Install Pre-Release Version"));
         }
         if (this.extension?.hasPreReleaseVersion) {
-            return primary ? ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'install',
-                "Install"
-            )) : ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'install release version',
-                "Install Release Version"
-            ));
+            return primary ? ( localizeWithPath(_moduleId, 14, "Install")) : ( localizeWithPath(_moduleId, 26, "Install Release Version"));
         }
-        return ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'install',
-            "Install"
-        ));
+        return ( localizeWithPath(_moduleId, 14, "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))
-], 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)))
+], InstallAction)));
 let InstallDropdownAction = class InstallDropdownAction extends ActionWithDropDownAction {
     set manifest(manifest) {
         this.extensionActions.forEach(a => a.manifest = manifest);
@@ -640,16 +572,12 @@ let InstallDropdownAction = class InstallDropdownAction extends ActionWithDropDo
         return action.getLabel(true);
     }
 };
-InstallDropdownAction = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IExtensionsWorkbenchService))
-], InstallDropdownAction));
+InstallDropdownAction = ( (__decorate([
+    ( (__param(0, IInstantiationService))),
+    ( (__param(1, IExtensionsWorkbenchService)))
+], InstallDropdownAction)));
 class InstallingLabelAction extends ExtensionAction {
-    static { this.LABEL = ( localizeWithPath(
-        'vs/workbench/contrib/extensions/browser/extensionsActions',
-        'installing',
-        "Installing"
-    )); }
+    static { this.LABEL = ( localizeWithPath(_moduleId, 27, "Installing")); }
     static { this.CLASS = `${ExtensionAction.LABEL_ACTION_CLASS} install installing`; }
     constructor() {
         super('extension.installing', InstallingLabelAction.LABEL, InstallingLabelAction.CLASS, false);
@@ -660,16 +588,8 @@ class InstallingLabelAction extends ExtensionAction {
 }
 let InstallInOtherServerAction = class InstallInOtherServerAction extends ExtensionAction {
     static { InstallInOtherServerAction_1 = this; }
-    static { this.INSTALL_LABEL = ( localizeWithPath(
-        'vs/workbench/contrib/extensions/browser/extensionsActions',
-        'install',
-        "Install"
-    )); }
-    static { this.INSTALLING_LABEL = ( localizeWithPath(
-        'vs/workbench/contrib/extensions/browser/extensionsActions',
-        'installing',
-        "Installing"
-    )); }
+    static { this.INSTALL_LABEL = ( localizeWithPath(_moduleId, 14, "Install")); }
+    static { this.INSTALLING_LABEL = ( localizeWithPath(_moduleId, 27, "Installing")); }
     static { this.Class = `${ExtensionAction.LABEL_ACTION_CLASS} prominent install`; }
     static { this.InstallingClass = `${ExtensionAction.LABEL_ACTION_CLASS} install installing`; }
     constructor(id, server, canInstallAnyWhere, extensionsWorkbenchService, extensionManagementServerService, extensionManifestPropertiesService) {
@@ -743,19 +663,19 @@ let InstallInOtherServerAction = class InstallInOtherServerAction extends Extens
         }
         this.extensionsWorkbenchService.open(this.extension);
         alert(( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'installExtensionStart',
+            _moduleId,
+            21,
             "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);
@@ -763,65 +683,49 @@ let RemoteInstallAction = class RemoteInstallAction extends InstallInOtherServer
     getInstallLabel() {
         return this.extensionManagementServerService.remoteExtensionManagementServer
             ? ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            { key: 'install in remote', comment: ['This is the name of the action to install an extension in remote server. Placeholder is for the name of remote server.'] },
+            _moduleId,
+            28,
             "Install in {0}",
             this.extensionManagementServerService.remoteExtensionManagementServer.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);
     }
     getInstallLabel() {
-        return ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'install locally',
-            "Install Locally"
-        ));
+        return ( localizeWithPath(_moduleId, 29, "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);
     }
     getInstallLabel() {
-        return ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'install browser',
-            "Install in Browser"
-        ));
+        return ( localizeWithPath(_moduleId, 30, "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 = ( localizeWithPath(
-        'vs/workbench/contrib/extensions/browser/extensionsActions',
-        'uninstallAction',
-        "Uninstall"
-    )); }
-    static { this.UninstallingLabel = ( localizeWithPath(
-        'vs/workbench/contrib/extensions/browser/extensionsActions',
-        'Uninstalling',
-        "Uninstalling"
-    )); }
+    static { this.UninstallLabel = ( localizeWithPath(_moduleId, 31, "Uninstall")); }
+    static { this.UninstallingLabel = ( localizeWithPath(_moduleId, 32, "Uninstalling")); }
     static { this.UninstallClass = `${ExtensionAction.LABEL_ACTION_CLASS} uninstall`; }
     static { this.UnInstallingClass = `${ExtensionAction.LABEL_ACTION_CLASS} uninstall uninstalling`; }
     constructor(extensionsWorkbenchService, dialogService) {
@@ -860,16 +764,16 @@ let UninstallAction = class UninstallAction extends ExtensionAction {
             return;
         }
         alert(( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'uninstallExtensionStart',
+            _moduleId,
+            33,
             "Uninstalling extension {0} started.",
             this.extension.displayName
         )));
         try {
             await this.extensionsWorkbenchService.uninstall(this.extension);
             alert(( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'uninstallExtensionComplete',
+                _moduleId,
+                34,
                 "Please reload Visual Studio Code to complete the uninstallation of the extension {0}.",
                 this.extension.displayName
             )));
@@ -879,17 +783,17 @@ let UninstallAction = class UninstallAction extends ExtensionAction {
         }
     }
 };
-UninstallAction = UninstallAction_1 = ( __decorate([
-    ( __param(0, IExtensionsWorkbenchService)),
-    ( __param(1, IDialogService))
-], UninstallAction));
+UninstallAction = UninstallAction_1 = ( (__decorate([
+    ( (__param(0, IExtensionsWorkbenchService))),
+    ( (__param(1, IDialogService)))
+], UninstallAction)));
 class AbstractUpdateAction extends ExtensionAction {
     static { this.EnabledClass = `${ExtensionAction.LABEL_ACTION_CLASS} prominent update`; }
     static { this.DisabledClass = `${AbstractUpdateAction.EnabledClass} disabled`; }
     constructor(id, label, extensionsWorkbenchService) {
         super(id, label, AbstractUpdateAction.DisabledClass, false);
         this.extensionsWorkbenchService = extensionsWorkbenchService;
-        this.updateThrottler = ( new Throttler());
+        this.updateThrottler = ( (new Throttler()));
         this.update();
     }
     update() {
@@ -912,27 +816,14 @@ class AbstractUpdateAction extends ExtensionAction {
 }
 let UpdateAction = class UpdateAction extends AbstractUpdateAction {
     constructor(verbose, extensionsWorkbenchService, instantiationService) {
-        super(`extensions.update`, ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'update',
-            "Update"
-        )), extensionsWorkbenchService);
+        super(`extensions.update`, ( localizeWithPath(_moduleId, 35, "Update")), extensionsWorkbenchService);
         this.verbose = verbose;
         this.instantiationService = instantiationService;
     }
     update() {
         super.update();
         if (this.extension) {
-            this.label = this.verbose ? ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'update to',
-                "Update to v{0}",
-                this.extension.latestVersion
-            )) : ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'update',
-                "Update"
-            ));
+            this.label = this.verbose ? ( localizeWithPath(_moduleId, 36, "Update to v{0}", this.extension.latestVersion)) : ( localizeWithPath(_moduleId, 35, "Update"));
         }
     }
     async run() {
@@ -940,8 +831,8 @@ let UpdateAction = class UpdateAction extends AbstractUpdateAction {
             return;
         }
         alert(( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'updateExtensionStart',
+            _moduleId,
+            37,
             "Updating extension {0} to version {1} started.",
             this.extension.displayName,
             this.extension.latestVersion
@@ -952,8 +843,8 @@ let UpdateAction = class UpdateAction extends AbstractUpdateAction {
         try {
             await this.extensionsWorkbenchService.install(extension, extension.local?.preRelease ? { installPreReleaseVersion: true } : undefined);
             alert(( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'updateExtensionComplete',
+                _moduleId,
+                38,
                 "Updating extension {0} to version {1} completed.",
                 extension.displayName,
                 extension.latestVersion
@@ -964,18 +855,14 @@ let UpdateAction = class UpdateAction extends AbstractUpdateAction {
         }
     }
 };
-UpdateAction = ( __decorate([
-    ( __param(1, IExtensionsWorkbenchService)),
-    ( __param(2, IInstantiationService))
-], UpdateAction));
+UpdateAction = ( (__decorate([
+    ( (__param(1, IExtensionsWorkbenchService))),
+    ( (__param(2, IInstantiationService)))
+], UpdateAction)));
 let ToggleAutoUpdateForExtensionAction = class ToggleAutoUpdateForExtensionAction extends ExtensionAction {
     static { ToggleAutoUpdateForExtensionAction_1 = this; }
     static { this.ID = 'workbench.extensions.action.toggleAutoUpdateForExtension'; }
-    static { this.LABEL = ( localize2WithPath(
-        'vs/workbench/contrib/extensions/browser/extensionsActions',
-        'enableAutoUpdateLabel',
-        "Auto Update"
-    )); }
+    static { this.LABEL = ( localize2WithPath(_moduleId, 39, "Auto Update")); }
     static { this.EnabledClass = `${ExtensionAction.EXTENSION_ACTION_CLASS} auto-update`; }
     static { this.DisabledClass = `${ToggleAutoUpdateForExtensionAction_1.EnabledClass} hide`; }
     constructor(enableWhenOutdated, enableWhenAutoUpdateValue, extensionsWorkbenchService, configurationService) {
@@ -1016,35 +903,21 @@ let ToggleAutoUpdateForExtensionAction = class ToggleAutoUpdateForExtensionActio
         const enableAutoUpdate = !this.extensionsWorkbenchService.isAutoUpdateEnabledFor(this.extension);
         await this.extensionsWorkbenchService.updateAutoUpdateEnablementFor(this.extension, enableAutoUpdate);
         if (enableAutoUpdate) {
-            alert(( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'enableAutoUpdate',
-                "Enabled auto updates for",
-                this.extension.displayName
-            )));
+            alert(( localizeWithPath(_moduleId, 40, "Enabled auto updates for", this.extension.displayName)));
         }
         else {
-            alert(( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'disableAutoUpdate',
-                "Disabled auto updates for",
-                this.extension.displayName
-            )));
+            alert(( localizeWithPath(_moduleId, 41, "Disabled auto updates for", this.extension.displayName)));
         }
     }
 };
-ToggleAutoUpdateForExtensionAction = ToggleAutoUpdateForExtensionAction_1 = ( __decorate([
-    ( __param(2, IExtensionsWorkbenchService)),
-    ( __param(3, IConfigurationService))
-], ToggleAutoUpdateForExtensionAction));
+ToggleAutoUpdateForExtensionAction = ToggleAutoUpdateForExtensionAction_1 = ( (__decorate([
+    ( (__param(2, IExtensionsWorkbenchService))),
+    ( (__param(3, IConfigurationService)))
+], ToggleAutoUpdateForExtensionAction)));
 let ToggleAutoUpdatesForPublisherAction = class ToggleAutoUpdatesForPublisherAction extends ExtensionAction {
     static { ToggleAutoUpdatesForPublisherAction_1 = this; }
     static { this.ID = 'workbench.extensions.action.toggleAutoUpdatesForPublisher'; }
-    static { this.LABEL = ( localizeWithPath(
-        'vs/workbench/contrib/extensions/browser/extensionsActions',
-        'toggleAutoUpdatesForPublisherLabel',
-        "Auto Update All (From Publisher)"
-    )); }
+    static { this.LABEL = ( localizeWithPath(_moduleId, 42, "Auto Update All (From Publisher)")); }
     constructor(extensionsWorkbenchService) {
         super(ToggleAutoUpdatesForPublisherAction_1.ID, ToggleAutoUpdatesForPublisherAction_1.LABEL);
         this.extensionsWorkbenchService = extensionsWorkbenchService;
@@ -1055,44 +928,30 @@ let ToggleAutoUpdatesForPublisherAction = class ToggleAutoUpdatesForPublisherAct
             return;
         }
         alert(( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'ignoreExtensionUpdatePublisher',
+            _moduleId,
+            43,
             "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(( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'enableAutoUpdate',
-                "Enabled auto updates for",
-                this.extension.displayName
-            )));
+            alert(( localizeWithPath(_moduleId, 40, "Enabled auto updates for", this.extension.displayName)));
         }
         else {
-            alert(( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'disableAutoUpdate',
-                "Disabled auto updates for",
-                this.extension.displayName
-            )));
+            alert(( localizeWithPath(_moduleId, 41, "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 = `${MigrateDeprecatedExtensionAction_1.EnabledClass} disabled`; }
     constructor(small, extensionsWorkbenchService) {
-        super('extensionsAction.migrateDeprecatedExtension', ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'migrateExtension',
-            "Migrate"
-        )), MigrateDeprecatedExtensionAction_1.DisabledClass, false);
+        super('extensionsAction.migrateDeprecatedExtension', ( localizeWithPath(_moduleId, 44, "Migrate")), MigrateDeprecatedExtensionAction_1.DisabledClass, false);
         this.small = small;
         this.extensionsWorkbenchService = extensionsWorkbenchService;
         this.update();
@@ -1110,22 +969,18 @@ 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 = ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'migrate to',
+            _moduleId,
+            45,
             "Migrate to {0}",
             this.extension.deprecationInfo.extension.displayName
         ));
-        this.label = this.small ? ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'migrate',
-            "Migrate"
-        )) : this.tooltip;
+        this.label = this.small ? ( localizeWithPath(_moduleId, 46, "Migrate")) : this.tooltip;
     }
     async run() {
         if (!this.extension?.deprecationInfo?.extension) {
@@ -1137,9 +992,9 @@ let MigrateDeprecatedExtensionAction = class MigrateDeprecatedExtensionAction ex
         await this.extensionsWorkbenchService.install(extension, { isMachineScoped: local?.isMachineScoped });
     }
 };
-MigrateDeprecatedExtensionAction = MigrateDeprecatedExtensionAction_1 = ( __decorate([
-    ( __param(1, IExtensionsWorkbenchService))
-], MigrateDeprecatedExtensionAction));
+MigrateDeprecatedExtensionAction = MigrateDeprecatedExtensionAction_1 = ( (__decorate([
+    ( (__param(1, IExtensionsWorkbenchService)))
+], MigrateDeprecatedExtensionAction)));
 class ExtensionActionWithDropdownActionViewItem extends ActionWithDropdownActionViewItem {
     constructor(action, options, contextMenuProvider) {
         super(null, action, options, contextMenuProvider);
@@ -1171,9 +1026,9 @@ let ExtensionDropDownAction = class ExtensionDropDownAction extends ExtensionAct
         return Promise.resolve();
     }
 };
-ExtensionDropDownAction = ( __decorate([
-    ( __param(4, IInstantiationService))
-], ExtensionDropDownAction));
+ExtensionDropDownAction = ( (__decorate([
+    ( (__param(4, IInstantiationService)))
+], ExtensionDropDownAction)));
 let DropDownMenuActionViewItem = class DropDownMenuActionViewItem extends ActionViewItem {
     constructor(action, options, contextMenuService) {
         super(null, action, { ...options, icon: true, label: true });
@@ -1197,14 +1052,14 @@ let DropDownMenuActionViewItem = class DropDownMenuActionViewItem extends Action
     getActions(menuActionGroups) {
         let actions = [];
         for (const menuActions of menuActionGroups) {
-            actions = [...actions, ...menuActions, ( new Separator())];
+            actions = [...actions, ...menuActions, ( (new Separator()))];
         }
         return actions.length ? actions.slice(0, actions.length - 1) : actions;
     }
 };
-DropDownMenuActionViewItem = ( __decorate([
-    ( __param(2, IContextMenuService))
-], DropDownMenuActionViewItem));
+DropDownMenuActionViewItem = ( (__decorate([
+    ( (__param(2, IContextMenuService)))
+], DropDownMenuActionViewItem)));
 async function getContextMenuActionsGroups(extension, contextKeyService, instantiationService) {
     return instantiationService.invokeFunction(async (accessor) => {
         const extensionsWorkbenchService = accessor.get(IExtensionsWorkbenchService);
@@ -1227,7 +1082,7 @@ async function getContextMenuActionsGroups(extension, contextKeyService, instant
             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 === 0 ]);
-            cksOverlay.push(['isUserIgnoredRecommendation', ( extensionIgnoredRecommendationsService.globalIgnoredRecommendations.some(e => e === extension.identifier.id.toLowerCase()))]);
+            cksOverlay.push(['isUserIgnoredRecommendation', ( (extensionIgnoredRecommendationsService.globalIgnoredRecommendations.some(e => e === extension.identifier.id.toLowerCase())))]);
             if (extension.state === 1 ) {
                 cksOverlay.push(['extensionStatus', 'installed']);
             }
@@ -1237,9 +1092,9 @@ async function getContextMenuActionsGroups(extension, contextKeyService, instant
             cksOverlay.push(['galleryExtensionHasPreReleaseVersion', extension.gallery?.hasPreReleaseVersion]);
             cksOverlay.push(['extensionHasReleaseVersion', extension.hasReleaseVersion]);
             const [colorThemes, fileIconThemes, productIconThemes] = await Promise.all([workbenchThemeService.getColorThemes(), workbenchThemeService.getFileIconThemes(), workbenchThemeService.getProductIconThemes()]);
-            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(['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(['canSetLanguage', extensionsWorkbenchService.canSetLanguage(extension)]);
             cksOverlay.push(['isActiveLanguagePackExtension', extension.gallery && language === getLocale(extension.gallery)]);
         }
@@ -1252,12 +1107,12 @@ async function getContextMenuActionsGroups(extension, contextKeyService, instant
 function toActions(actionsGroups, instantiationService) {
     const result = [];
     for (const [, actions] of actionsGroups) {
-        result.push(( actions.map(action => {
+        result.push(( (actions.map(action => {
             if (action instanceof SubmenuAction) {
                 return action;
             }
             return instantiationService.createInstance(MenuItemExtensionAction, action);
-        })));
+        }))));
     }
     return result;
 }
@@ -1274,11 +1129,7 @@ let ManageExtensionAction = class ManageExtensionAction extends ExtensionDropDow
         super(ManageExtensionAction_1.ID, '', '', true, instantiationService);
         this.extensionService = extensionService;
         this.contextKeyService = contextKeyService;
-        this.tooltip = ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'manage',
-            "Manage"
-        ));
+        this.tooltip = ( localizeWithPath(_moduleId, 47, "Manage"));
         this.update();
     }
     async getActionGroups() {
@@ -1340,20 +1191,16 @@ let ManageExtensionAction = class ManageExtensionAction extends ExtensionDropDow
         }
     }
 };
-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 ExtensionDropDownAction {
     constructor(contextKeyService, instantiationService) {
         super('extensionEditor.manageExtension', '', `${ExtensionAction.ICON_ACTION_CLASS} manage ${ThemeIcon.asClassName(manageExtensionIcon)}`, true, instantiationService);
         this.contextKeyService = contextKeyService;
-        this.tooltip = ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'manage',
-            "Manage"
-        ));
+        this.tooltip = ( localizeWithPath(_moduleId, 47, "Manage"));
     }
     update() { }
     async run() {
@@ -1398,17 +1245,13 @@ 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 = ( localizeWithPath(
-        'vs/workbench/contrib/extensions/browser/extensionsActions',
-        'togglePreRleaseLabel',
-        "Pre-Release"
-    )); }
+    static { this.LABEL = ( localizeWithPath(_moduleId, 48, "Pre-Release")); }
     static { this.EnabledClass = `${ExtensionAction.LABEL_ACTION_CLASS} pre-release`; }
     static { this.DisabledClass = `${TogglePreReleaseExtensionAction_1.EnabledClass} hide`; }
     constructor(extensionsWorkbenchService) {
@@ -1443,26 +1286,14 @@ let TogglePreReleaseExtensionAction = class TogglePreReleaseExtensionAction exte
         this.enabled = true;
         this.class = TogglePreReleaseExtensionAction_1.EnabledClass;
         if (this.extension.preRelease) {
-            this.label = ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'togglePreRleaseDisableLabel',
-                "Switch to Release Version"
-            ));
-            this.tooltip = ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'togglePreRleaseDisableTooltip',
-                "This will switch and enable updates to release versions"
-            ));
+            this.label = ( localizeWithPath(_moduleId, 49, "Switch to Release Version"));
+            this.tooltip = ( localizeWithPath(_moduleId, 50, "This will switch and enable updates to release versions"));
         }
         else {
-            this.label = ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'switchToPreReleaseLabel',
-                "Switch to Pre-Release Version"
-            ));
+            this.label = ( localizeWithPath(_moduleId, 51, "Switch to Pre-Release Version"));
             this.tooltip = ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'switchToPreReleaseTooltip',
+                _moduleId,
+                52,
                 "This will switch to pre-release version and enable updates to latest version always"
             ));
         }
@@ -1475,17 +1306,13 @@ let TogglePreReleaseExtensionAction = class TogglePreReleaseExtensionAction exte
         await this.extensionsWorkbenchService.togglePreRelease(this.extension);
     }
 };
-TogglePreReleaseExtensionAction = TogglePreReleaseExtensionAction_1 = ( __decorate([
-    ( __param(0, IExtensionsWorkbenchService))
-], TogglePreReleaseExtensionAction));
+TogglePreReleaseExtensionAction = TogglePreReleaseExtensionAction_1 = ( (__decorate([
+    ( (__param(0, IExtensionsWorkbenchService)))
+], TogglePreReleaseExtensionAction)));
 let InstallAnotherVersionAction = class InstallAnotherVersionAction extends ExtensionAction {
     static { InstallAnotherVersionAction_1 = this; }
     static { this.ID = 'workbench.extensions.action.install.anotherVersion'; }
-    static { this.LABEL = ( localizeWithPath(
-        'vs/workbench/contrib/extensions/browser/extensionsActions',
-        'install another version',
-        "Install Another Version..."
-    )); }
+    static { this.LABEL = ( localizeWithPath(_moduleId, 53, "Install Another Version...")); }
     constructor(extensionsWorkbenchService, extensionGalleryService, quickInputService, instantiationService, dialogService) {
         super(InstallAnotherVersionAction_1.ID, InstallAnotherVersionAction_1.LABEL, ExtensionAction.LABEL_ACTION_CLASS);
         this.extensionsWorkbenchService = extensionsWorkbenchService;
@@ -1505,37 +1332,21 @@ let InstallAnotherVersionAction = class InstallAnotherVersionAction extends Exte
         const targetPlatform = await this.extension.server.extensionManagementService.getTargetPlatform();
         const allVersions = await this.extensionGalleryService.getAllCompatibleVersions(this.extension.gallery, this.extension.local.preRelease, targetPlatform);
         if (!allVersions.length) {
-            await this.dialogService.info(( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'no versions',
-                "This extension has no other versions."
-            )));
+            await this.dialogService.info(( localizeWithPath(_moduleId, 54, "This extension has no other versions.")));
             return;
         }
-        const picks = ( allVersions.map((v, i) => {
+        const picks = ( (allVersions.map((v, i) => {
             return {
                 id: v.version,
                 label: v.version,
-                description: `${fromNow(( new Date(Date.parse(v.date))), true)}${v.isPreReleaseVersion ? ` (${( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'pre-release',
-                    "pre-release"
-                ))})` : ''}${v.version === this.extension.version ? ` (${( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'current',
-                    "current"
-                ))})` : ''}`,
+                description: `${fromNow(( (new Date(Date.parse(v.date)))), true)}${v.isPreReleaseVersion ? ` (${( localizeWithPath(_moduleId, 55, "pre-release"))})` : ''}${v.version === this.extension.version ? ` (${( localizeWithPath(_moduleId, 56, "current"))})` : ''}`,
                 latest: i === 0,
                 ariaLabel: `${v.isPreReleaseVersion ? 'Pre-Release version' : 'Release version'} ${v.version}`,
                 isPreReleaseVersion: v.isPreReleaseVersion
             };
-        }));
+        })));
         const pick = await this.quickInputService.pick(picks, {
-            placeHolder: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'selectVersion',
-                "Select Version to Install"
-            )),
+            placeHolder: ( localizeWithPath(_moduleId, 57, "Select Version to Install")),
             matchOnDetail: true
         });
         if (pick) {
@@ -1558,30 +1369,22 @@ let InstallAnotherVersionAction = class InstallAnotherVersionAction extends Exte
         return null;
     }
 };
-InstallAnotherVersionAction = InstallAnotherVersionAction_1 = ( __decorate([
-    ( __param(0, IExtensionsWorkbenchService)),
-    ( __param(1, IExtensionGalleryService)),
-    ( __param(2, IQuickInputService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IDialogService))
-], InstallAnotherVersionAction));
+InstallAnotherVersionAction = InstallAnotherVersionAction_1 = ( (__decorate([
+    ( (__param(0, IExtensionsWorkbenchService))),
+    ( (__param(1, IExtensionGalleryService))),
+    ( (__param(2, IQuickInputService))),
+    ( (__param(3, IInstantiationService))),
+    ( (__param(4, IDialogService)))
+], InstallAnotherVersionAction)));
 let EnableForWorkspaceAction = class EnableForWorkspaceAction extends ExtensionAction {
     static { EnableForWorkspaceAction_1 = this; }
     static { this.ID = 'extensions.enableForWorkspace'; }
-    static { this.LABEL = ( localizeWithPath(
-        'vs/workbench/contrib/extensions/browser/extensionsActions',
-        'enableForWorkspaceAction',
-        "Enable (Workspace)"
-    )); }
+    static { this.LABEL = ( localizeWithPath(_moduleId, 58, "Enable (Workspace)")); }
     constructor(extensionsWorkbenchService, extensionEnablementService) {
         super(EnableForWorkspaceAction_1.ID, EnableForWorkspaceAction_1.LABEL, ExtensionAction.LABEL_ACTION_CLASS);
         this.extensionsWorkbenchService = extensionsWorkbenchService;
         this.extensionEnablementService = extensionEnablementService;
-        this.tooltip = ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'enableForWorkspaceActionToolTip',
-            "Enable this extension only in this workspace"
-        ));
+        this.tooltip = ( localizeWithPath(_moduleId, 59, "Enable this extension only in this workspace"));
         this.update();
     }
     update() {
@@ -1599,27 +1402,19 @@ let EnableForWorkspaceAction = class EnableForWorkspaceAction extends ExtensionA
         return this.extensionsWorkbenchService.setEnablement(this.extension, 9 );
     }
 };
-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 = ( localizeWithPath(
-        'vs/workbench/contrib/extensions/browser/extensionsActions',
-        'enableGloballyAction',
-        "Enable"
-    )); }
+    static { this.LABEL = ( localizeWithPath(_moduleId, 60, "Enable")); }
     constructor(extensionsWorkbenchService, extensionEnablementService) {
         super(EnableGloballyAction_1.ID, EnableGloballyAction_1.LABEL, ExtensionAction.LABEL_ACTION_CLASS);
         this.extensionsWorkbenchService = extensionsWorkbenchService;
         this.extensionEnablementService = extensionEnablementService;
-        this.tooltip = ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'enableGloballyActionToolTip',
-            "Enable this extension"
-        ));
+        this.tooltip = ( localizeWithPath(_moduleId, 61, "Enable this extension"));
         this.update();
     }
     update() {
@@ -1637,37 +1432,29 @@ let EnableGloballyAction = class EnableGloballyAction extends ExtensionAction {
         return this.extensionsWorkbenchService.setEnablement(this.extension, 8 );
     }
 };
-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 = ( localizeWithPath(
-        'vs/workbench/contrib/extensions/browser/extensionsActions',
-        'disableForWorkspaceAction',
-        "Disable (Workspace)"
-    )); }
+    static { this.LABEL = ( localizeWithPath(_moduleId, 62, "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 = ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'disableForWorkspaceActionToolTip',
-            "Disable this extension only in this workspace"
-        ));
+        this.tooltip = ( localizeWithPath(_moduleId, 63, "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(
+        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() !== 1
-        ))) {
+        )))) {
             this.enabled = this.extension.state === 1
                 && ((this.extension.enablementState === 8  || this.extension.enablementState === 9) )
                 && this.extensionEnablementService.canChangeWorkspaceEnablement(this.extension.local);
@@ -1680,38 +1467,30 @@ let DisableForWorkspaceAction = class DisableForWorkspaceAction extends Extensio
         return this.extensionsWorkbenchService.setEnablement(this.extension, 7 );
     }
 };
-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 = ( localizeWithPath(
-        'vs/workbench/contrib/extensions/browser/extensionsActions',
-        'disableGloballyAction',
-        "Disable"
-    )); }
+    static { this.LABEL = ( localizeWithPath(_moduleId, 64, "Disable")); }
     constructor(extensionsWorkbenchService, extensionEnablementService, extensionService) {
         super(DisableGloballyAction_1.ID, DisableGloballyAction_1.LABEL, ExtensionAction.LABEL_ACTION_CLASS);
         this.extensionsWorkbenchService = extensionsWorkbenchService;
         this.extensionEnablementService = extensionEnablementService;
         this.extensionService = extensionService;
-        this.tooltip = ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'disableGloballyActionToolTip',
-            "Disable this extension"
-        ));
+        this.tooltip = ( localizeWithPath(_moduleId, 65, "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(
+        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 === 1
                 && ((this.extension.enablementState === 8  || this.extension.enablementState === 9) )
                 && this.extensionEnablementService.canChangeEnablement(this.extension.local);
@@ -1724,18 +1503,14 @@ let DisableGloballyAction = class DisableGloballyAction extends ExtensionAction
         return this.extensionsWorkbenchService.setEnablement(this.extension, 6 );
     }
 };
-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 ActionWithDropDownAction {
     constructor(instantiationService) {
-        super('extensions.enable', ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'enableAction',
-            "Enable"
-        )), [
+        super('extensions.enable', ( localizeWithPath(_moduleId, 66, "Enable")), [
             [
                 instantiationService.createInstance(EnableGloballyAction),
                 instantiationService.createInstance(EnableForWorkspaceAction)
@@ -1743,24 +1518,20 @@ let EnableDropDownAction = class EnableDropDownAction extends ActionWithDropDown
         ]);
     }
 };
-EnableDropDownAction = ( __decorate([
-    ( __param(0, IInstantiationService))
-], EnableDropDownAction));
+EnableDropDownAction = ( (__decorate([
+    ( (__param(0, IInstantiationService)))
+], EnableDropDownAction)));
 let DisableDropDownAction = class DisableDropDownAction extends ActionWithDropDownAction {
     constructor(instantiationService) {
-        super('extensions.disable', ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'disableAction',
-            "Disable"
-        )), [[
+        super('extensions.disable', ( localizeWithPath(_moduleId, 67, "Disable")), [[
                 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`; }
@@ -1798,27 +1569,10 @@ let ExtensionRuntimeStateAction = class ExtensionRuntimeStateAction extends Exte
         this.enabled = true;
         this.class = ExtensionRuntimeStateAction_1.EnabledClass;
         this.tooltip = runtimeState.reason;
-        this.label = runtimeState.action === "reloadWindow"  ? ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'reload window',
-            'Reload Window'
-        ))
-            : runtimeState.action === "restartExtensions"  ? ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'restart extensions',
-            'Restart Extensions'
-        ))
-                : runtimeState.action === "quitAndInstall"  ? ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'restart product',
-            'Restart to Update'
-        ))
-                    : runtimeState.action === "applyUpdate"  || runtimeState.action === "downloadUpdate"  ? ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'update product',
-            'Update {0}',
-            this.productService.nameShort
-        )) : '';
+        this.label = runtimeState.action === "reloadWindow"  ? ( localizeWithPath(_moduleId, 68, 'Reload Window'))
+            : runtimeState.action === "restartExtensions"  ? ( localizeWithPath(_moduleId, 69, 'Restart Extensions'))
+                : runtimeState.action === "quitAndInstall"  ? ( localizeWithPath(_moduleId, 70, 'Restart to Update'))
+                    : runtimeState.action === "applyUpdate"  || runtimeState.action === "downloadUpdate"  ? ( localizeWithPath(_moduleId, 71, 'Update {0}', this.productService.nameShort)) : '';
     }
     async run() {
         const runtimeState = this.extension?.runtimeState;
@@ -1845,14 +1599,14 @@ let ExtensionRuntimeStateAction = class ExtensionRuntimeStateAction extends Exte
         }
     }
 };
-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));
 }
@@ -1864,11 +1618,7 @@ function getQuickPickEntries(themes, currentTheme, extension, showCurrentTheme)
         }
     }
     if (showCurrentTheme) {
-        picks.push({ type: 'separator', label: ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'current',
-            "current"
-        )) });
+        picks.push({ type: 'separator', label: ( localizeWithPath(_moduleId, 56, "current")) });
         picks.push({ label: currentTheme.label, id: currentTheme.id });
     }
     return picks;
@@ -1876,11 +1626,7 @@ function getQuickPickEntries(themes, currentTheme, extension, showCurrentTheme)
 let SetColorThemeAction = class SetColorThemeAction extends ExtensionAction {
     static { SetColorThemeAction_1 = this; }
     static { this.ID = 'workbench.extensions.action.setColorTheme'; }
-    static { this.TITLE = ( localize2WithPath(
-        'vs/workbench/contrib/extensions/browser/extensionsActions',
-        'workbench.extensions.action.setColorTheme',
-        'Set Color Theme'
-    )); }
+    static { this.TITLE = ( localize2WithPath(_moduleId, 72, 'Set Color Theme')); }
     static { this.EnabledClass = `${ExtensionAction.LABEL_ACTION_CLASS} theme`; }
     static { this.DisabledClass = `${SetColorThemeAction_1.EnabledClass} disabled`; }
     constructor(extensionService, workbenchThemeService, quickInputService, extensionEnablementService) {
@@ -1898,7 +1644,7 @@ let SetColorThemeAction = class SetColorThemeAction extends ExtensionAction {
         });
     }
     computeEnablement(colorThemes) {
-        return !!this.extension && this.extension.state === 1  && this.extensionEnablementService.isEnabledEnablementState(this.extension.enablementState) && ( colorThemes.some(th => isThemeFromExtension(th, this.extension)));
+        return !!this.extension && this.extension.state === 1  && this.extensionEnablementService.isEnabledEnablementState(this.extension.enablementState) && ( (colorThemes.some(th => isThemeFromExtension(th, this.extension))));
     }
     async run({ showCurrentTheme, ignoreFocusLost } = { showCurrentTheme: false, ignoreFocusLost: false }) {
         const colorThemes = await this.workbenchThemeService.getColorThemes();
@@ -1906,34 +1652,26 @@ let SetColorThemeAction = class SetColorThemeAction extends ExtensionAction {
             return;
         }
         const currentTheme = this.workbenchThemeService.getColorTheme();
-        const delayer = ( new Delayer(100));
+        const delayer = ( (new Delayer(100)));
         const picks = getQuickPickEntries(colorThemes, currentTheme, this.extension, showCurrentTheme);
         const pickedTheme = await this.quickInputService.pick(picks, {
-            placeHolder: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'select color theme',
-                "Select Color Theme"
-            )),
+            placeHolder: ( localizeWithPath(_moduleId, 73, "Select Color Theme")),
             onDidFocus: item => delayer.trigger(() => this.workbenchThemeService.setColorTheme(item.id, undefined)),
             ignoreFocusLost
         });
         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 = ( localize2WithPath(
-        'vs/workbench/contrib/extensions/browser/extensionsActions',
-        'workbench.extensions.action.setFileIconTheme',
-        'Set File Icon Theme'
-    )); }
+    static { this.TITLE = ( localize2WithPath(_moduleId, 74, 'Set File Icon Theme')); }
     static { this.EnabledClass = `${ExtensionAction.LABEL_ACTION_CLASS} theme`; }
     static { this.DisabledClass = `${SetFileIconThemeAction_1.EnabledClass} disabled`; }
     constructor(extensionService, workbenchThemeService, quickInputService, extensionEnablementService) {
@@ -1951,7 +1689,7 @@ let SetFileIconThemeAction = class SetFileIconThemeAction extends ExtensionActio
         });
     }
     computeEnablement(colorThemfileIconThemess) {
-        return !!this.extension && this.extension.state === 1  && this.extensionEnablementService.isEnabledEnablementState(this.extension.enablementState) && ( colorThemfileIconThemess.some(th => isThemeFromExtension(th, this.extension)));
+        return !!this.extension && this.extension.state === 1  && this.extensionEnablementService.isEnabledEnablementState(this.extension.enablementState) && ( (colorThemfileIconThemess.some(th => isThemeFromExtension(th, this.extension))));
     }
     async run({ showCurrentTheme, ignoreFocusLost } = { showCurrentTheme: false, ignoreFocusLost: false }) {
         const fileIconThemes = await this.workbenchThemeService.getFileIconThemes();
@@ -1959,34 +1697,26 @@ let SetFileIconThemeAction = class SetFileIconThemeAction extends ExtensionActio
             return;
         }
         const currentTheme = this.workbenchThemeService.getFileIconTheme();
-        const delayer = ( new Delayer(100));
+        const delayer = ( (new Delayer(100)));
         const picks = getQuickPickEntries(fileIconThemes, currentTheme, this.extension, showCurrentTheme);
         const pickedTheme = await this.quickInputService.pick(picks, {
-            placeHolder: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'select file icon theme',
-                "Select File Icon Theme"
-            )),
+            placeHolder: ( localizeWithPath(_moduleId, 75, "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');
     }
 };
-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 = ( localize2WithPath(
-        'vs/workbench/contrib/extensions/browser/extensionsActions',
-        'workbench.extensions.action.setProductIconTheme',
-        'Set Product Icon Theme'
-    )); }
+    static { this.TITLE = ( localize2WithPath(_moduleId, 76, 'Set Product Icon Theme')); }
     static { this.EnabledClass = `${ExtensionAction.LABEL_ACTION_CLASS} theme`; }
     static { this.DisabledClass = `${SetProductIconThemeAction_1.EnabledClass} disabled`; }
     constructor(extensionService, workbenchThemeService, quickInputService, extensionEnablementService) {
@@ -2004,7 +1734,7 @@ let SetProductIconThemeAction = class SetProductIconThemeAction extends Extensio
         });
     }
     computeEnablement(productIconThemes) {
-        return !!this.extension && this.extension.state === 1  && this.extensionEnablementService.isEnabledEnablementState(this.extension.enablementState) && ( productIconThemes.some(th => isThemeFromExtension(th, this.extension)));
+        return !!this.extension && this.extension.state === 1  && this.extensionEnablementService.isEnabledEnablementState(this.extension.enablementState) && ( (productIconThemes.some(th => isThemeFromExtension(th, this.extension))));
     }
     async run({ showCurrentTheme, ignoreFocusLost } = { showCurrentTheme: false, ignoreFocusLost: false }) {
         const productIconThemes = await this.workbenchThemeService.getProductIconThemes();
@@ -2012,34 +1742,26 @@ let SetProductIconThemeAction = class SetProductIconThemeAction extends Extensio
             return;
         }
         const currentTheme = this.workbenchThemeService.getProductIconTheme();
-        const delayer = ( new Delayer(100));
+        const delayer = ( (new Delayer(100)));
         const picks = getQuickPickEntries(productIconThemes, currentTheme, this.extension, showCurrentTheme);
         const pickedTheme = await this.quickInputService.pick(picks, {
-            placeHolder: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'select product icon theme',
-                "Select Product Icon Theme"
-            )),
+            placeHolder: ( localizeWithPath(_moduleId, 77, "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');
     }
 };
-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 = ( localize2WithPath(
-        'vs/workbench/contrib/extensions/browser/extensionsActions',
-        'workbench.extensions.action.setDisplayLanguage',
-        'Set Display Language'
-    )); }
+    static { this.TITLE = ( localize2WithPath(_moduleId, 78, 'Set Display Language')); }
     static { this.EnabledClass = `${ExtensionAction.LABEL_ACTION_CLASS} language`; }
     static { this.DisabledClass = `${SetLanguageAction_1.EnabledClass} disabled`; }
     constructor(extensionsWorkbenchService) {
@@ -2066,17 +1788,13 @@ 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 = ( localize2WithPath(
-        'vs/workbench/contrib/extensions/browser/extensionsActions',
-        'workbench.extensions.action.clearLanguage',
-        'Clear Display Language'
-    )); }
+    static { this.TITLE = ( localize2WithPath(_moduleId, 79, 'Clear Display Language')); }
     static { this.EnabledClass = `${ExtensionAction.LABEL_ACTION_CLASS} language`; }
     static { this.DisabledClass = `${ClearLanguageAction_1.EnabledClass} disabled`; }
     constructor(extensionsWorkbenchService, localeService) {
@@ -2104,18 +1822,14 @@ 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 = ( localizeWithPath(
-        'vs/workbench/contrib/extensions/browser/extensionsActions',
-        'showRecommendedExtension',
-        "Show Recommended Extension"
-    )); }
+    static { this.LABEL = ( localizeWithPath(_moduleId, 80, "Show Recommended Extension")); }
     constructor(extensionId, paneCompositeService, extensionWorkbenchService) {
         super(ShowRecommendedExtensionAction_1.ID, ShowRecommendedExtensionAction_1.LABEL, undefined, false);
         this.paneCompositeService = paneCompositeService;
@@ -2134,18 +1848,14 @@ let ShowRecommendedExtensionAction = class ShowRecommendedExtensionAction extend
         return null;
     }
 };
-ShowRecommendedExtensionAction = ShowRecommendedExtensionAction_1 = ( __decorate([
-    ( __param(1, IPaneCompositePartService)),
-    ( __param(2, IExtensionsWorkbenchService))
-], ShowRecommendedExtensionAction));
+ShowRecommendedExtensionAction = ShowRecommendedExtensionAction_1 = ( (__decorate([
+    ( (__param(1, IPaneCompositePartService))),
+    ( (__param(2, IExtensionsWorkbenchService)))
+], ShowRecommendedExtensionAction)));
 let InstallRecommendedExtensionAction = class InstallRecommendedExtensionAction extends Action {
     static { InstallRecommendedExtensionAction_1 = this; }
     static { this.ID = 'workbench.extensions.action.installRecommendedExtension'; }
-    static { this.LABEL = ( localizeWithPath(
-        'vs/workbench/contrib/extensions/browser/extensionsActions',
-        'installRecommendedExtension',
-        "Install Recommended Extension"
-    )); }
+    static { this.LABEL = ( localizeWithPath(_moduleId, 81, "Install Recommended Extension")); }
     constructor(extensionId, paneCompositeService, instantiationService, extensionWorkbenchService) {
         super(InstallRecommendedExtensionAction_1.ID, InstallRecommendedExtensionAction_1.LABEL, undefined, false);
         this.paneCompositeService = paneCompositeService;
@@ -2170,11 +1880,11 @@ let InstallRecommendedExtensionAction = class InstallRecommendedExtensionAction
         }
     }
 };
-InstallRecommendedExtensionAction = InstallRecommendedExtensionAction_1 = ( __decorate([
-    ( __param(1, IPaneCompositePartService)),
-    ( __param(2, IInstantiationService)),
-    ( __param(3, IExtensionsWorkbenchService))
-], InstallRecommendedExtensionAction));
+InstallRecommendedExtensionAction = InstallRecommendedExtensionAction_1 = ( (__decorate([
+    ( (__param(1, IPaneCompositePartService))),
+    ( (__param(2, IInstantiationService))),
+    ( (__param(3, IExtensionsWorkbenchService)))
+], InstallRecommendedExtensionAction)));
 let IgnoreExtensionRecommendationAction = class IgnoreExtensionRecommendationAction extends Action {
     static { IgnoreExtensionRecommendationAction_1 = this; }
     static { this.ID = 'extensions.ignore'; }
@@ -2184,11 +1894,7 @@ let IgnoreExtensionRecommendationAction = class IgnoreExtensionRecommendationAct
         this.extension = extension;
         this.extensionRecommendationsManagementService = extensionRecommendationsManagementService;
         this.class = IgnoreExtensionRecommendationAction_1.Class;
-        this.tooltip = ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'ignoreExtensionRecommendation',
-            "Do not recommend this extension again"
-        ));
+        this.tooltip = ( localizeWithPath(_moduleId, 82, "Do not recommend this extension again"));
         this.enabled = true;
     }
     run() {
@@ -2196,9 +1902,9 @@ 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'; }
@@ -2208,11 +1914,7 @@ let UndoIgnoreExtensionRecommendationAction = class UndoIgnoreExtensionRecommend
         this.extension = extension;
         this.extensionRecommendationsManagementService = extensionRecommendationsManagementService;
         this.class = UndoIgnoreExtensionRecommendationAction_1.Class;
-        this.tooltip = ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'undo',
-            "Undo"
-        ));
+        this.tooltip = ( localizeWithPath(_moduleId, 83, "Undo"));
         this.enabled = true;
     }
     run() {
@@ -2220,16 +1922,12 @@ let UndoIgnoreExtensionRecommendationAction = class UndoIgnoreExtensionRecommend
         return Promise.resolve();
     }
 };
-UndoIgnoreExtensionRecommendationAction = UndoIgnoreExtensionRecommendationAction_1 = ( __decorate([
-    ( __param(1, IExtensionIgnoredRecommendationsService))
-], UndoIgnoreExtensionRecommendationAction));
+UndoIgnoreExtensionRecommendationAction = UndoIgnoreExtensionRecommendationAction_1 = ( (__decorate([
+    ( (__param(1, IExtensionIgnoredRecommendationsService)))
+], UndoIgnoreExtensionRecommendationAction)));
 let SearchExtensionsAction = class SearchExtensionsAction extends Action {
     constructor(searchValue, paneCompositeService) {
-        super('extensions.searchExtensions', ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'search recommendations',
-            "Search Extensions"
-        )), undefined, true);
+        super('extensions.searchExtensions', ( localizeWithPath(_moduleId, 84, "Search Extensions")), undefined, true);
         this.searchValue = searchValue;
         this.paneCompositeService = paneCompositeService;
     }
@@ -2239,9 +1937,9 @@ let SearchExtensionsAction = class SearchExtensionsAction extends Action {
         viewPaneContainer.focus();
     }
 };
-SearchExtensionsAction = ( __decorate([
-    ( __param(1, IPaneCompositePartService))
-], SearchExtensionsAction));
+SearchExtensionsAction = ( (__decorate([
+    ( (__param(1, IPaneCompositePartService)))
+], SearchExtensionsAction)));
 let AbstractConfigureRecommendedExtensionsAction = class AbstractConfigureRecommendedExtensionsAction extends Action {
     constructor(id, label, contextService, fileService, textFileService, editorService, jsonEditingService, textModelResolverService) {
         super(id, label);
@@ -2261,16 +1959,16 @@ let AbstractConfigureRecommendedExtensionsAction = class AbstractConfigureRecomm
                 pinned: created,
                 selection
             }
-        })), error => Promise.reject(( new Error(( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'OpenExtensionsFile.failed',
+        })), error => Promise.reject(( (new Error(( localizeWithPath(
+            _moduleId,
+            85,
             "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(content => this.getSelectionPosition(( (content.value.toString())), content.resource, ['extensions', 'recommendations']))
             .then(selection => this.editorService.openEditor({
             resource: workspaceConfigurationFile,
             options: {
@@ -2282,7 +1980,7 @@ let AbstractConfigureRecommendedExtensionsAction = class AbstractConfigureRecomm
     getOrUpdateWorkspaceConfigurationFile(workspaceConfigurationFile) {
         return Promise.resolve(this.fileService.readFile(workspaceConfigurationFile))
             .then(content => {
-            const workspaceRecommendations = parse(( content.value.toString()))['extensions'];
+            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));
@@ -2313,7 +2011,7 @@ 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 };
@@ -2321,21 +2019,17 @@ let AbstractConfigureRecommendedExtensionsAction = class AbstractConfigureRecomm
         });
     }
 };
-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 = ( localizeWithPath(
-        'vs/workbench/contrib/extensions/browser/extensionsActions',
-        'configureWorkspaceRecommendedExtensions',
-        "Configure Recommended Extensions (Workspace)"
-    )); }
+    static { this.LABEL = ( localizeWithPath(_moduleId, 86, "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));
@@ -2354,21 +2048,17 @@ let ConfigureWorkspaceRecommendedExtensionsAction = class ConfigureWorkspaceReco
         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 = ( localizeWithPath(
-        'vs/workbench/contrib/extensions/browser/extensionsActions',
-        'configureWorkspaceFolderRecommendedExtensions',
-        "Configure Recommended Extensions (Workspace Folder)"
-    )); }
+    static { this.LABEL = ( localizeWithPath(_moduleId, 87, "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;
@@ -2385,15 +2075,15 @@ 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`; }
@@ -2458,41 +2148,21 @@ let ExtensionStatusLabelAction = class ExtensionStatusLabelAction extends Action
         };
         if (currentStatus !== null) {
             if (currentStatus === 0  && this.status === 1 ) {
-                return canAddExtension() ? this.initialStatus === 1  && this.version !== currentVersion ? ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'updated',
-                    "Updated"
-                )) : ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'installed',
-                    "Installed"
-                )) : null;
+                return canAddExtension() ? this.initialStatus === 1  && this.version !== currentVersion ? ( localizeWithPath(_moduleId, 88, "Updated")) : ( localizeWithPath(_moduleId, 89, "Installed")) : null;
             }
             if (currentStatus === 2  && this.status === 3 ) {
                 this.initialStatus = this.status;
-                return canRemoveExtension() ? ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'uninstalled',
-                    "Uninstalled"
-                )) : null;
+                return canRemoveExtension() ? ( localizeWithPath(_moduleId, 90, "Uninstalled")) : null;
             }
         }
         if (currentEnablementState !== null) {
             const currentlyEnabled = this.extensionEnablementService.isEnabledEnablementState(currentEnablementState);
             const enabled = this.extensionEnablementService.isEnabledEnablementState(this.enablementState);
             if (!currentlyEnabled && enabled) {
-                return canAddExtension() ? ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'enabled',
-                    "Enabled"
-                )) : null;
+                return canAddExtension() ? ( localizeWithPath(_moduleId, 91, "Enabled")) : null;
             }
             if (currentlyEnabled && !enabled) {
-                return canRemoveExtension() ? ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'disabled',
-                    "Disabled"
-                )) : null;
+                return canRemoveExtension() ? ( localizeWithPath(_moduleId, 92, "Disabled")) : null;
             }
         }
         return null;
@@ -2501,11 +2171,11 @@ 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 ExtensionDropDownAction {
     static { ToggleSyncExtensionAction_1 = this; }
     static { this.IGNORED_SYNC_CLASS = `${ExtensionAction.ICON_ACTION_CLASS} extension-sync ${ThemeIcon.asClassName(syncIgnoredIcon)}`; }
@@ -2524,47 +2194,31 @@ let ToggleSyncExtensionAction = class ToggleSyncExtensionAction extends Extensio
         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 ? ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'ignored',
-                "This extension is ignored during sync"
-            )) : ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'synced',
-                "This extension is synced"
-            ));
+            this.tooltip = isIgnored ? ( localizeWithPath(_moduleId, 93, "This extension is ignored during sync")) : ( localizeWithPath(_moduleId, 94, "This extension is synced"));
         }
     }
     async run() {
         return super.run({
             actionGroups: [
                 [
-                    ( new Action(
-                        'extensions.syncignore',
-                        this.extensionsWorkbenchService.isExtensionIgnoredToSync(this.extension) ? ( localizeWithPath(
-                            'vs/workbench/contrib/extensions/browser/extensionsActions',
-                            'sync',
-                            "Sync this extension"
-                        )) : ( localizeWithPath(
-                            'vs/workbench/contrib/extensions/browser/extensionsActions',
-                            'do not sync',
-                            "Do not sync this extension"
-                        )),
-                        undefined,
-                        true,
-                        () => this.extensionsWorkbenchService.toggleExtensionIgnoredToSync(this.extension)
-                    ))
+                    ( (new Action(
+                    'extensions.syncignore',
+                    this.extensionsWorkbenchService.isExtensionIgnoredToSync(this.extension) ? ( localizeWithPath(_moduleId, 95, "Sync this extension")) : ( localizeWithPath(_moduleId, 96, "Do not sync this extension")),
+                    undefined,
+                    true,
+                    () => this.extensionsWorkbenchService.toggleExtensionIgnoredToSync(this.extension)
+                )))
                 ]
             ], disposeActionsOnHide: true
         });
     }
 };
-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`; }
@@ -2584,9 +2238,9 @@ let ExtensionStatusAction = class ExtensionStatusAction extends ExtensionAction
         this.workbenchExtensionEnablementService = workbenchExtensionEnablementService;
         this.extensionFeaturesManagementService = extensionFeaturesManagementService;
         this.updateWhenCounterExtensionChanges = true;
-        this._onDidChangeStatus = this._register(( new Emitter()));
+        this._onDidChangeStatus = this._register(( (new Emitter())));
         this.onDidChangeStatus = this._onDidChangeStatus.event;
-        this.updateThrottler = ( new Throttler());
+        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()));
@@ -2602,46 +2256,38 @@ let ExtensionStatusAction = class ExtensionStatusAction extends ExtensionAction
             return;
         }
         if (this.extension.isMalicious) {
-            this.updateStatus({ icon: warningIcon, message: ( new MarkdownString(( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'malicious tooltip',
-                "This extension was reported to be problematic."
-            )))) }, true);
+            this.updateStatus({ icon: warningIcon, message: ( (new MarkdownString(( localizeWithPath(_moduleId, 97, "This extension was reported to be problematic."))))) }, true);
             return;
         }
         if (this.extension.deprecationInfo) {
             if (this.extension.deprecationInfo.extension) {
-                const link = `[${this.extension.deprecationInfo.extension.displayName}](${( URI.parse(
+                const link = `[${this.extension.deprecationInfo.extension.displayName}](${( (URI.parse(
                     `command:extension.open?${encodeURIComponent(JSON.stringify([this.extension.deprecationInfo.extension.id]))}`
-                ))})`;
-                this.updateStatus({ icon: warningIcon, message: ( new MarkdownString(( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'deprecated with alternate extension tooltip',
+                )))})`;
+                this.updateStatus({ icon: warningIcon, message: ( (new MarkdownString(( localizeWithPath(
+                    _moduleId,
+                    98,
                     "This extension is deprecated. Use the {0} extension instead.",
                     link
-                )))) }, true);
+                ))))) }, true);
             }
             else if (this.extension.deprecationInfo.settings) {
-                const link = `[${( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'settings',
-                    "settings"
-                ))}](${( URI.parse(
-                    `command:workbench.action.openSettings?${encodeURIComponent(JSON.stringify([( this.extension.deprecationInfo.settings.map(setting => `@id:${setting}`)).join(' ')]))}`
-                ))})`;
-                this.updateStatus({ icon: warningIcon, message: ( new MarkdownString(( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'deprecated with alternate settings tooltip',
+                const link = `[${( localizeWithPath(_moduleId, 99, "settings"))}](${( (URI.parse(
+                    `command:workbench.action.openSettings?${encodeURIComponent(JSON.stringify([( (this.extension.deprecationInfo.settings.map(setting => `@id:${setting}`))).join(' ')]))}`
+                )))})`;
+                this.updateStatus({ icon: warningIcon, message: ( (new MarkdownString(( localizeWithPath(
+                    _moduleId,
+                    100,
                     "This extension is deprecated as this functionality is now built-in to VS Code. Configure these {0} to use this functionality.",
                     link
-                )))) }, true);
+                ))))) }, true);
             }
             else {
-                const message = ( new MarkdownString(( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'deprecated tooltip',
+                const message = ( (new MarkdownString(( localizeWithPath(
+                    _moduleId,
+                    101,
                     "This extension is deprecated as it is no longer being maintained."
-                ))));
+                )))));
                 if (this.extension.deprecationInfo.additionalInfo) {
                     message.appendMarkdown(` ${this.extension.deprecationInfo.additionalInfo}`);
                 }
@@ -2655,39 +2301,26 @@ let ExtensionStatusAction = class ExtensionStatusAction extends ExtensionAction
         if (this.extension.gallery && this.extension.state === 3  && !(await this.extensionsWorkbenchService.canInstall(this.extension))) {
             if (this.extensionManagementServerService.localExtensionManagementServer || this.extensionManagementServerService.remoteExtensionManagementServer) {
                 const targetPlatform = await (this.extensionManagementServerService.localExtensionManagementServer ? this.extensionManagementServerService.localExtensionManagementServer.extensionManagementService.getTargetPlatform() : this.extensionManagementServerService.remoteExtensionManagementServer.extensionManagementService.getTargetPlatform());
-                const message = ( new MarkdownString(`${( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'incompatible platform',
+                const message = ( (new MarkdownString(`${( localizeWithPath(
+                    _moduleId,
+                    102,
                     "The '{0}' extension is not available in {1} for {2}.",
                     this.extension.displayName || this.extension.identifier.id,
                     this.productService.nameLong,
                     TargetPlatformToString(targetPlatform)
-                ))} [${( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'learn more',
-                    "Learn More"
-                ))}](https://aka.ms/vscode-platform-specific-extensions)`));
+                ))} [${( localizeWithPath(_moduleId, 103, "Learn More"))}](https://aka.ms/vscode-platform-specific-extensions)`)));
                 this.updateStatus({ icon: warningIcon, message }, true);
                 return;
             }
             if (this.extensionManagementServerService.webExtensionManagementServer) {
-                const productName = ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'VS Code for Web',
-                    "{0} for the Web",
-                    this.productService.nameLong
-                ));
-                const message = ( new MarkdownString(`${( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'not web tooltip',
+                const productName = ( localizeWithPath(_moduleId, 0, "{0} for the Web", this.productService.nameLong));
+                const message = ( (new MarkdownString(`${( localizeWithPath(
+                    _moduleId,
+                    104,
                     "The '{0}' extension is not available in {1}.",
                     this.extension.displayName || this.extension.identifier.id,
                     productName
-                ))} [${( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'learn why',
-                    "Learn Why"
-                ))}](https://aka.ms/vscode-web-extensions-guide)`));
+                ))} [${( localizeWithPath(_moduleId, 105, "Learn Why"))}](https://aka.ms/vscode-web-extensions-guide)`)));
                 this.updateStatus({ icon: warningIcon, message }, true);
                 return;
             }
@@ -2698,39 +2331,35 @@ let ExtensionStatusAction = class ExtensionStatusAction extends ExtensionAction
             return;
         }
         if (this.extension.enablementState === 2 ) {
-            this.updateStatus({ message: ( new MarkdownString(( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'disabled by environment',
-                "This extension is disabled by the environment."
-            )))) }, true);
+            this.updateStatus({ message: ( (new MarkdownString(( localizeWithPath(_moduleId, 106, "This extension is disabled by the environment."))))) }, true);
             return;
         }
         if (this.extension.enablementState === 3 ) {
-            this.updateStatus({ message: ( new MarkdownString(( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'enabled by environment',
+            this.updateStatus({ message: ( (new MarkdownString(( localizeWithPath(
+                _moduleId,
+                107,
                 "This extension is enabled because it is required in the current environment."
-            )))) }, true);
+            ))))) }, true);
             return;
         }
         if (this.extension.enablementState === 4 ) {
             const details = getWorkspaceSupportTypeMessage(this.extension.local.manifest.capabilities?.virtualWorkspaces);
-            this.updateStatus({ icon: infoIcon, message: ( new MarkdownString(details ? escapeMarkdownSyntaxTokens(details) : ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'disabled because of virtual workspace',
+            this.updateStatus({ icon: infoIcon, message: ( (new MarkdownString(details ? escapeMarkdownSyntaxTokens(details) : ( localizeWithPath(
+                _moduleId,
+                108,
                 "This extension has been disabled because it does not support virtual workspaces."
-            )))) }, true);
+            ))))) }, 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) : ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'extension limited because of virtual workspace',
+                this.updateStatus({ icon: warningIcon, message: ( (new MarkdownString(details ? escapeMarkdownSyntaxTokens(details) : ( localizeWithPath(
+                    _moduleId,
+                    109,
                     "This extension has limited features because the current workspace is virtual."
-                )))) }, true);
+                ))))) }, true);
                 return;
             }
         }
@@ -2738,13 +2367,13 @@ let ExtensionStatusAction = class ExtensionStatusAction extends ExtensionAction
             (this.extension.enablementState === 5  && this.workbenchExtensionEnablementService.getDependenciesEnablementStates(this.extension.local).every(([, enablementState]) => this.workbenchExtensionEnablementService.isEnabledEnablementState(enablementState) || enablementState === 0 ))) {
             this.enabled = true;
             const untrustedDetails = getWorkspaceSupportTypeMessage(this.extension.local.manifest.capabilities?.untrustedWorkspaces);
-            this.updateStatus({ icon: trustIcon, message: ( new MarkdownString(
+            this.updateStatus({ icon: trustIcon, message: ( (new MarkdownString(
                 untrustedDetails ? escapeMarkdownSyntaxTokens(untrustedDetails) : ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'extension disabled because of trust requirement',
+                    _moduleId,
+                    110,
                     "This extension has been disabled because the current workspace is not trusted."
                 ))
-            )) }, true);
+            ))) }, true);
             return;
         }
         if (this.workspaceTrustEnablementService.isWorkspaceTrustEnabled() && !this.workspaceTrustService.isWorkspaceTrusted()) {
@@ -2752,76 +2381,60 @@ let ExtensionStatusAction = class ExtensionStatusAction extends ExtensionAction
             const untrustedDetails = getWorkspaceSupportTypeMessage(this.extension.local.manifest.capabilities?.untrustedWorkspaces);
             if (untrustedSupportType === 'limited' || untrustedDetails) {
                 this.enabled = true;
-                this.updateStatus({ icon: trustIcon, message: ( new MarkdownString(
+                this.updateStatus({ icon: trustIcon, message: ( (new MarkdownString(
                     untrustedDetails ? escapeMarkdownSyntaxTokens(untrustedDetails) : ( localizeWithPath(
-                        'vs/workbench/contrib/extensions/browser/extensionsActions',
-                        'extension limited because of trust requirement',
+                        _moduleId,
+                        111,
                         "This extension has limited features because the current workspace is not trusted."
                     ))
-                )) }, true);
+                ))) }, true);
                 return;
             }
         }
         if (this.extension.enablementState === 1 ) {
-            if (!( this.extensionsWorkbenchService.installed.some(
+            if (!( (this.extensionsWorkbenchService.installed.some(
                 e => areSameExtensions(e.identifier, this.extension.identifier) && e.server !== this.extension.server
-            ))) {
+            )))) {
                 let message;
                 if (this.extensionManagementServerService.localExtensionManagementServer === this.extension.server) {
                     if (this.extensionManifestPropertiesService.prefersExecuteOnWorkspace(this.extension.local.manifest)) {
                         if (this.extensionManagementServerService.remoteExtensionManagementServer) {
-                            message = ( new MarkdownString(`${( localizeWithPath(
-                                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                                'Install in remote server to enable',
+                            message = ( (new MarkdownString(`${( localizeWithPath(
+                                _moduleId,
+                                112,
                                 "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
-                            ))} [${( localizeWithPath(
-                                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                                'learn more',
-                                "Learn More"
-                            ))}](https://aka.ms/vscode-remote/developing-extensions/architecture)`));
+                            ))} [${( localizeWithPath(_moduleId, 103, "Learn More"))}](https://aka.ms/vscode-remote/developing-extensions/architecture)`)));
                         }
                     }
                 }
                 else if (this.extensionManagementServerService.remoteExtensionManagementServer === this.extension.server) {
                     if (this.extensionManifestPropertiesService.prefersExecuteOnUI(this.extension.local.manifest)) {
                         if (this.extensionManagementServerService.localExtensionManagementServer) {
-                            message = ( new MarkdownString(`${( localizeWithPath(
-                                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                                'Install in local server to enable',
+                            message = ( (new MarkdownString(`${( localizeWithPath(
+                                _moduleId,
+                                113,
                                 "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
-                            ))} [${( localizeWithPath(
-                                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                                'learn more',
-                                "Learn More"
-                            ))}](https://aka.ms/vscode-remote/developing-extensions/architecture)`));
+                            ))} [${( localizeWithPath(_moduleId, 103, "Learn More"))}](https://aka.ms/vscode-remote/developing-extensions/architecture)`)));
                         }
                         else if (isWeb) {
-                            message = ( new MarkdownString(`${( localizeWithPath(
-                                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                                'Defined to run in desktop',
+                            message = ( (new MarkdownString(`${( localizeWithPath(
+                                _moduleId,
+                                114,
                                 "This extension is disabled because it is defined to run only in {0} for the Desktop.",
                                 this.productService.nameLong
-                            ))} [${( localizeWithPath(
-                                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                                'learn more',
-                                "Learn More"
-                            ))}](https://aka.ms/vscode-remote/developing-extensions/architecture)`));
+                            ))} [${( localizeWithPath(_moduleId, 103, "Learn More"))}](https://aka.ms/vscode-remote/developing-extensions/architecture)`)));
                         }
                     }
                 }
                 else if (this.extensionManagementServerService.webExtensionManagementServer === this.extension.server) {
-                    message = ( new MarkdownString(`${( localizeWithPath(
-                        'vs/workbench/contrib/extensions/browser/extensionsActions',
-                        'Cannot be enabled',
+                    message = ( (new MarkdownString(`${( localizeWithPath(
+                        _moduleId,
+                        115,
                         "This extension is disabled because it is not supported in {0} for the Web.",
                         this.productService.nameLong
-                    ))} [${( localizeWithPath(
-                        'vs/workbench/contrib/extensions/browser/extensionsActions',
-                        'learn more',
-                        "Learn More"
-                    ))}](https://aka.ms/vscode-remote/developing-extensions/architecture)`));
+                    ))} [${( localizeWithPath(_moduleId, 103, "Learn More"))}](https://aka.ms/vscode-remote/developing-extensions/architecture)`)));
                 }
                 if (message) {
                     this.updateStatus({ icon: warningIcon, message }, true);
@@ -2829,43 +2442,39 @@ let ExtensionStatusAction = class ExtensionStatusAction extends ExtensionAction
                 return;
             }
         }
-        const extensionId = ( new ExtensionIdentifier(this.extension.identifier.id));
-        const features = ( Registry.as(Extensions.ExtensionFeaturesRegistry)).getExtensionFeatures();
+        const extensionId = ( (new ExtensionIdentifier(this.extension.identifier.id)));
+        const features = ( (Registry.as(Extensions.ExtensionFeaturesRegistry))).getExtensionFeatures();
         for (const feature of features) {
             const status = this.extensionFeaturesManagementService.getAccessData(extensionId, feature.id)?.current?.status;
-            const manageAccessLink = `[${( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'manage access',
-                'Manage Access'
-            ))}](${( URI.parse(
+            const manageAccessLink = `[${( localizeWithPath(_moduleId, 116, 'Manage Access'))}](${( (URI.parse(
                 `command:extension.open?${encodeURIComponent(JSON.stringify([this.extension.identifier.id, "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;
             }
         }
         if (this.extensionManagementServerService.remoteExtensionManagementServer) {
             if (isLanguagePackExtension(this.extension.local.manifest)) {
-                if (!( this.extensionsWorkbenchService.installed.some(
+                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(( localizeWithPath(
-                        'vs/workbench/contrib/extensions/browser/extensionsActions',
-                        'Install language pack also in remote server',
+                        ? ( (new MarkdownString(( localizeWithPath(
+                        _moduleId,
+                        117,
                         "Install the language pack extension on '{0}' to enable it there also.",
                         this.extensionManagementServerService.remoteExtensionManagementServer.label
-                    ))))
-                        : ( new MarkdownString(( localizeWithPath(
-                        'vs/workbench/contrib/extensions/browser/extensionsActions',
-                        'Install language pack also locally',
+                    )))))
+                        : ( (new MarkdownString(( localizeWithPath(
+                        _moduleId,
+                        118,
                         "Install the language pack extension locally to enable it there also."
-                    ))));
+                    )))));
                     this.updateStatus({ icon: infoIcon, message }, true);
                 }
                 return;
@@ -2874,109 +2483,89 @@ let ExtensionStatusAction = class ExtensionStatusAction extends ExtensionAction
             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(`${( localizeWithPath(
-                        'vs/workbench/contrib/extensions/browser/extensionsActions',
-                        'enabled remotely',
+                    this.updateStatus({ icon: infoIcon, message: ( (new MarkdownString(`${( localizeWithPath(
+                        _moduleId,
+                        119,
                         "This extension is enabled in the Remote Extension Host because it prefers to run there."
-                    ))} [${( localizeWithPath(
-                        'vs/workbench/contrib/extensions/browser/extensionsActions',
-                        'learn more',
-                        "Learn More"
-                    ))}](https://aka.ms/vscode-remote/developing-extensions/architecture)`)) }, true);
+                    ))} [${( localizeWithPath(_moduleId, 103, "Learn More"))}](https://aka.ms/vscode-remote/developing-extensions/architecture)`))) }, 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(`${( localizeWithPath(
-                        'vs/workbench/contrib/extensions/browser/extensionsActions',
-                        'enabled locally',
+                    this.updateStatus({ icon: infoIcon, message: ( (new MarkdownString(`${( localizeWithPath(
+                        _moduleId,
+                        120,
                         "This extension is enabled in the Local Extension Host because it prefers to run there."
-                    ))} [${( localizeWithPath(
-                        'vs/workbench/contrib/extensions/browser/extensionsActions',
-                        'learn more',
-                        "Learn More"
-                    ))}](https://aka.ms/vscode-remote/developing-extensions/architecture)`)) }, true);
+                    ))} [${( localizeWithPath(_moduleId, 103, "Learn More"))}](https://aka.ms/vscode-remote/developing-extensions/architecture)`))) }, 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(`${( localizeWithPath(
-                        'vs/workbench/contrib/extensions/browser/extensionsActions',
-                        'enabled in web worker',
+                    this.updateStatus({ icon: infoIcon, message: ( (new MarkdownString(`${( localizeWithPath(
+                        _moduleId,
+                        121,
                         "This extension is enabled in the Web Worker Extension Host because it prefers to run there."
-                    ))} [${( localizeWithPath(
-                        'vs/workbench/contrib/extensions/browser/extensionsActions',
-                        'learn more',
-                        "Learn More"
-                    ))}](https://aka.ms/vscode-remote/developing-extensions/architecture)`)) }, true);
+                    ))} [${( localizeWithPath(_moduleId, 103, "Learn More"))}](https://aka.ms/vscode-remote/developing-extensions/architecture)`))) }, true);
                 }
                 return;
             }
         }
         if (this.extension.enablementState === 5 ) {
-            this.updateStatus({ icon: warningIcon, message: ( new MarkdownString(( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'extension disabled because of dependency',
+            this.updateStatus({ icon: warningIcon, message: ( (new MarkdownString(( localizeWithPath(
+                _moduleId,
+                122,
                 "This extension has been disabled because it depends on an extension that is disabled."
-            )))) }, true);
+            ))))) }, true);
             return;
         }
         const isEnabled = this.workbenchExtensionEnablementService.isEnabled(this.extension.local);
-        const isRunning = ( this.extensionService.extensions.some(
+        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 === 9 ) {
-                this.updateStatus({ message: ( new MarkdownString(( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'workspace enabled',
+                this.updateStatus({ message: ( (new MarkdownString(( localizeWithPath(
+                    _moduleId,
+                    123,
                     "This extension is enabled for this workspace by the user."
-                )))) }, true);
+                ))))) }, true);
                 return;
             }
             if (this.extensionManagementServerService.localExtensionManagementServer && this.extensionManagementServerService.remoteExtensionManagementServer) {
                 if (this.extension.server === this.extensionManagementServerService.remoteExtensionManagementServer) {
-                    this.updateStatus({ message: ( new MarkdownString(( localizeWithPath(
-                        'vs/workbench/contrib/extensions/browser/extensionsActions',
-                        'extension enabled on remote',
+                    this.updateStatus({ message: ( (new MarkdownString(( localizeWithPath(
+                        _moduleId,
+                        124,
                         "Extension is enabled on '{0}'",
                         this.extension.server.label
-                    )))) }, true);
+                    ))))) }, true);
                     return;
                 }
             }
             if (this.extension.enablementState === 8 ) {
-                this.updateStatus({ message: ( new MarkdownString(( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'globally enabled',
-                    "This extension is enabled globally."
-                )))) }, true);
+                this.updateStatus({ message: ( (new MarkdownString(( localizeWithPath(_moduleId, 125, "This extension is enabled globally."))))) }, true);
                 return;
             }
         }
         if (!isEnabled && !isRunning) {
             if (this.extension.enablementState === 6 ) {
-                this.updateStatus({ message: ( new MarkdownString(( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'globally disabled',
-                    "This extension is disabled globally by the user."
-                )))) }, true);
+                this.updateStatus({ message: ( (new MarkdownString(( localizeWithPath(_moduleId, 126, "This extension is disabled globally by the user."))))) }, true);
                 return;
             }
             if (this.extension.enablementState === 7 ) {
-                this.updateStatus({ message: ( new MarkdownString(( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'workspace disabled',
+                this.updateStatus({ message: ( (new MarkdownString(( localizeWithPath(
+                    _moduleId,
+                    127,
                     "This extension is disabled for this workspace by the user."
-                )))) }, true);
+                ))))) }, true);
                 return;
             }
         }
         if (isEnabled && !isRunning && !this.extension.local.isValid) {
-            const errors = ( this.extension.local.validations.filter(([severity]) => severity === Severity$1.Error).map(([, message]) => message));
-            this.updateStatus({ icon: errorIcon, message: ( new MarkdownString(errors.join(' ').trim())) }, true);
+            const errors = ( (this.extension.local.validations.filter(([severity]) => severity === Severity$1.Error).map(([, message]) => message)));
+            this.updateStatus({ icon: errorIcon, message: ( (new MarkdownString(errors.join(' ').trim()))) }, true);
         }
     }
     updateStatus(status, updateClass) {
@@ -3012,28 +2601,24 @@ let ExtensionStatusAction = class ExtensionStatusAction extends ExtensionAction
         }
     }
 };
-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, IWorkbenchExtensionEnablementService)),
-    ( __param(11, IExtensionFeaturesManagementService))
-], 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, IWorkbenchExtensionEnablementService))),
+    ( (__param(11, IExtensionFeaturesManagementService)))
+], ExtensionStatusAction)));
 let ReinstallAction = class ReinstallAction extends Action {
     static { ReinstallAction_1 = this; }
     static { this.ID = 'workbench.extensions.action.reinstall'; }
-    static { this.LABEL = ( localizeWithPath(
-        'vs/workbench/contrib/extensions/browser/extensionsActions',
-        'reinstall',
-        "Reinstall Extension..."
-    )); }
+    static { this.LABEL = ( localizeWithPath(_moduleId, 128, "Reinstall Extension...")); }
     constructor(id = ReinstallAction_1.ID, label = ReinstallAction_1.LABEL, extensionsWorkbenchService, extensionManagementServerService, quickInputService, notificationService, hostService, instantiationService, extensionService) {
         super(id, label);
         this.extensionsWorkbenchService = extensionsWorkbenchService;
@@ -3048,17 +2633,13 @@ let ReinstallAction = class ReinstallAction extends Action {
         return this.extensionsWorkbenchService.local.filter(l => !l.isBuiltin && l.local).length > 0;
     }
     run() {
-        return this.quickInputService.pick(this.getEntries(), { placeHolder: ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'selectExtensionToReinstall',
-            "Select Extension to Reinstall"
-        )) })
+        return this.quickInputService.pick(this.getEntries(), { placeHolder: ( localizeWithPath(_moduleId, 129, "Select Extension to Reinstall")) })
             .then(pick => pick && this.reinstallExtension(pick.extension));
     }
     getEntries() {
         return this.extensionsWorkbenchService.queryLocal()
             .then(local => {
-            const entries = ( local
+            const entries = ( (local
                 .filter(extension => !extension.isBuiltin && extension.server !== this.extensionManagementServerService.webExtensionManagementServer)
                 .map(extension => {
                 return {
@@ -3067,7 +2648,7 @@ let ReinstallAction = class ReinstallAction extends Action {
                     description: extension.identifier.id,
                     extension,
                 };
-            }));
+            })));
             return entries;
         });
     }
@@ -3078,23 +2659,19 @@ let ReinstallAction = class ReinstallAction extends Action {
                 .then(extension => {
                 const requireReload = !(extension.local && this.extensionService.canAddExtension(toExtensionDescription(extension.local)));
                 const message = requireReload ? ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'ReinstallAction.successReload',
+                    _moduleId,
+                    130,
                     "Please reload Visual Studio Code to complete reinstalling the extension {0}.",
                     extension.identifier.id
                 ))
                     : ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'ReinstallAction.success',
+                    _moduleId,
+                    131,
                     "Reinstalling the extension {0} is completed.",
                     extension.identifier.id
                 ));
                 const actions = requireReload ? [{
-                        label: ( localizeWithPath(
-                            'vs/workbench/contrib/extensions/browser/extensionsActions',
-                            'InstallVSIXAction.reloadNow',
-                            "Reload Now"
-                        )),
+                        label: ( localizeWithPath(_moduleId, 132, "Reload Now")),
                         run: () => this.hostService.reload()
                     }] : [];
                 this.notificationService.prompt(Severity$1.Info, message, actions, { sticky: true });
@@ -3102,23 +2679,19 @@ let ReinstallAction = class ReinstallAction extends Action {
         });
     }
 };
-ReinstallAction = ReinstallAction_1 = ( __decorate([
-    ( __param(2, IExtensionsWorkbenchService)),
-    ( __param(3, IExtensionManagementServerService)),
-    ( __param(4, IQuickInputService)),
-    ( __param(5, INotificationService)),
-    ( __param(6, IHostService)),
-    ( __param(7, IInstantiationService)),
-    ( __param(8, IExtensionService))
-], ReinstallAction));
+ReinstallAction = ReinstallAction_1 = ( (__decorate([
+    ( (__param(2, IExtensionsWorkbenchService))),
+    ( (__param(3, IExtensionManagementServerService))),
+    ( (__param(4, IQuickInputService))),
+    ( (__param(5, INotificationService))),
+    ( (__param(6, IHostService))),
+    ( (__param(7, IInstantiationService))),
+    ( (__param(8, IExtensionService)))
+], ReinstallAction)));
 let InstallSpecificVersionOfExtensionAction = class InstallSpecificVersionOfExtensionAction extends Action {
     static { InstallSpecificVersionOfExtensionAction_1 = this; }
     static { this.ID = 'workbench.extensions.action.install.specificVersion'; }
-    static { this.LABEL = ( localizeWithPath(
-        'vs/workbench/contrib/extensions/browser/extensionsActions',
-        'install previous version',
-        "Install Specific Version of Extension..."
-    )); }
+    static { this.LABEL = ( localizeWithPath(_moduleId, 133, "Install Specific Version of Extension...")); }
     constructor(id = InstallSpecificVersionOfExtensionAction_1.ID, label = InstallSpecificVersionOfExtensionAction_1.LABEL, extensionsWorkbenchService, quickInputService, instantiationService, extensionEnablementService) {
         super(id, label);
         this.extensionsWorkbenchService = extensionsWorkbenchService;
@@ -3127,14 +2700,12 @@ let InstallSpecificVersionOfExtensionAction = class InstallSpecificVersionOfExte
         this.extensionEnablementService = extensionEnablementService;
     }
     get enabled() {
-        return ( this.extensionsWorkbenchService.local.some(l => this.isEnabled(l)));
+        return (
+             (this.extensionsWorkbenchService.local.some(l => this.isEnabled(l)))
+        );
     }
     async run() {
-        const extensionPick = await this.quickInputService.pick(this.getExtensionEntries(), { placeHolder: ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'selectExtension',
-            "Select Extension"
-        )), matchOnDetail: true });
+        const extensionPick = await this.quickInputService.pick(this.getExtensionEntries(), { placeHolder: ( localizeWithPath(_moduleId, 134, "Select Extension")), matchOnDetail: true });
         if (extensionPick && extensionPick.extension) {
             const action = this.instantiationService.createInstance(InstallAnotherVersionAction);
             action.extension = extensionPick.extension;
@@ -3163,12 +2734,12 @@ let InstallSpecificVersionOfExtensionAction = class InstallSpecificVersionOfExte
         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) {
         super(id);
@@ -3214,57 +2785,41 @@ let AbstractInstallExtensionsInServerAction = class AbstractInstallExtensionsInS
         quickPick.busy = false;
         if (localExtensionsToInstall.length) {
             quickPick.title = this.getQuickPickTitle();
-            quickPick.placeholder = ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'select extensions to install',
-                "Select extensions to install"
-            ));
+            quickPick.placeholder = ( localizeWithPath(_moduleId, 135, "Select extensions to install"));
             quickPick.canSelectMany = true;
             localExtensionsToInstall.sort((e1, e2) => e1.displayName.localeCompare(e2.displayName));
-            quickPick.items = ( localExtensionsToInstall.map(
+            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: ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'no local extensions',
-                    "There are no extensions to install."
-                ))
+                message: ( localizeWithPath(_moduleId, 136, "There are no extensions to install."))
             });
         }
     }
     async onDidAccept(selectedItems) {
         if (selectedItems.length) {
-            const localExtensionsToInstall = ( selectedItems.filter(r => !!r.extension).map(r => r.extension));
+            const localExtensionsToInstall = ( (selectedItems.filter(r => !!r.extension).map(r => r.extension)));
             if (localExtensionsToInstall.length) {
                 await this.progressService.withProgress({
                     location: 15 ,
-                    title: ( localizeWithPath(
-                        'vs/workbench/contrib/extensions/browser/extensionsActions',
-                        'installing extensions',
-                        "Installing Extensions..."
-                    ))
+                    title: ( localizeWithPath(_moduleId, 137, "Installing Extensions..."))
                 }, () => this.installExtensions(localExtensionsToInstall));
-                this.notificationService.info(( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensionsActions',
-                    'finished installing',
-                    "Successfully installed extensions."
-                )));
+                this.notificationService.info(( localizeWithPath(_moduleId, 138, "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);
@@ -3277,8 +2832,8 @@ let InstallLocalExtensionsInRemoteAction = class InstallLocalExtensionsInRemoteA
     get label() {
         if (this.extensionManagementServerService && this.extensionManagementServerService.remoteExtensionManagementServer) {
             return ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensionsActions',
-                'select and install local extensions',
+                _moduleId,
+                139,
                 "Install Local Extensions in '{0}'...",
                 this.extensionManagementServerService.remoteExtensionManagementServer.label
             ));
@@ -3287,8 +2842,8 @@ let InstallLocalExtensionsInRemoteAction = class InstallLocalExtensionsInRemoteA
     }
     getQuickPickTitle() {
         return ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'install local extensions title',
+            _moduleId,
+            140,
             "Install Local Extensions in '{0}'",
             this.extensionManagementServerService.remoteExtensionManagementServer.label
         ));
@@ -3304,7 +2859,7 @@ 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];
                 if (gallery) {
@@ -3314,18 +2869,18 @@ let InstallLocalExtensionsInRemoteAction = class InstallLocalExtensionsInRemoteA
             }
             const vsix = await this.extensionManagementServerService.localExtensionManagementServer.extensionManagementService.zip(extension.local);
             vsixs.push(vsix);
-        })));
-        await Promises.settled(( galleryExtensions.map(
+        }))));
+        await Promises.settled(( (galleryExtensions.map(
             gallery => this.extensionManagementServerService.remoteExtensionManagementServer.extensionManagementService.installFromGallery(gallery)
-        )));
+        ))));
         try {
-            await Promises.settled(( vsixs.map(
+            await Promises.settled(( (vsixs.map(
                 vsix => this.extensionManagementServerService.remoteExtensionManagementServer.extensionManagementService.install(vsix)
-            )));
+            ))));
         }
         finally {
             try {
-                await Promise.allSettled(( vsixs.map(vsix => this.fileService.del(vsix))));
+                await Promise.allSettled(( (vsixs.map(vsix => this.fileService.del(vsix)))));
             }
             catch (error) {
                 this.logService.error(error);
@@ -3333,17 +2888,17 @@ let InstallLocalExtensionsInRemoteAction = class InstallLocalExtensionsInRemoteA
         }
     }
 };
-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);
@@ -3353,30 +2908,22 @@ let InstallRemoteExtensionsInLocalAction = class InstallRemoteExtensionsInLocalA
         this.logService = logService;
     }
     get label() {
-        return ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'select and install remote extensions',
-            "Install Remote Extensions Locally..."
-        ));
+        return ( localizeWithPath(_moduleId, 141, "Install Remote Extensions Locally..."));
     }
     getQuickPickTitle() {
-        return ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsActions',
-            'install remote extensions',
-            "Install Remote Extensions Locally"
-        ));
+        return ( localizeWithPath(_moduleId, 142, "Install Remote Extensions Locally"));
     }
     getExtensionsToInstall(local) {
         return local.filter(extension => extension.type === 1  && extension.server !== this.extensionManagementServerService.localExtensionManagementServer
-            && !( this.extensionsWorkbenchService.installed.some(
+            && !( (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];
                 if (gallery) {
@@ -3386,18 +2933,18 @@ let InstallRemoteExtensionsInLocalAction = class InstallRemoteExtensionsInLocalA
             }
             const vsix = await this.extensionManagementServerService.remoteExtensionManagementServer.extensionManagementService.zip(extension.local);
             vsixs.push(vsix);
-        })));
-        await Promises.settled(( galleryExtensions.map(
+        }))));
+        await Promises.settled(( (galleryExtensions.map(
             gallery => this.extensionManagementServerService.localExtensionManagementServer.extensionManagementService.installFromGallery(gallery)
-        )));
+        ))));
         try {
-            await Promises.settled(( vsixs.map(
+            await Promises.settled(( (vsixs.map(
                 vsix => this.extensionManagementServerService.localExtensionManagementServer.extensionManagementService.install(vsix)
-            )));
+            ))));
         }
         finally {
             try {
-                await Promise.allSettled(( vsixs.map(vsix => this.fileService.del(vsix))));
+                await Promise.allSettled(( (vsixs.map(vsix => this.fileService.del(vsix)))));
             }
             catch (error) {
                 this.logService.error(error);
@@ -3405,16 +2952,16 @@ let InstallRemoteExtensionsInLocalAction = class InstallRemoteExtensionsInLocalA
         }
     }
 };
-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));
+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 paneCompositeService = accessor.get(IPaneCompositePartService);
     return paneCompositeService.openPaneComposite(VIEWLET_ID, 0 , true)
@@ -3429,8 +2976,8 @@ CommandsRegistry.registerCommand('workbench.extensions.action.showExtensionsWith
     return paneCompositeService.openPaneComposite(VIEWLET_ID, 0 , true)
         .then(viewlet => viewlet?.getViewPaneContainer())
         .then(viewlet => {
-        const query = ( extensionIds
-            .map(id => `@id:${id}`))
+        const query = ( (extensionIds
+            .map(id => `@id:${id}`)))
             .join(' ');
         viewlet.search(query);
         viewlet.focus();
@@ -3441,49 +2988,33 @@ registerColor('extensionButton.background', {
     light: buttonBackground,
     hcDark: null,
     hcLight: null
-}, ( localizeWithPath(
-    'vs/workbench/contrib/extensions/browser/extensionsActions',
-    'extensionButtonBackground',
-    "Button background color for extension actions."
-)));
+}, ( localizeWithPath(_moduleId, 143, "Button background color for extension actions.")));
 registerColor('extensionButton.foreground', {
     dark: buttonForeground,
     light: buttonForeground,
     hcDark: null,
     hcLight: null
-}, ( localizeWithPath(
-    'vs/workbench/contrib/extensions/browser/extensionsActions',
-    'extensionButtonForeground',
-    "Button foreground color for extension actions."
-)));
+}, ( localizeWithPath(_moduleId, 144, "Button foreground color for extension actions.")));
 registerColor('extensionButton.hoverBackground', {
     dark: buttonHoverBackground,
     light: buttonHoverBackground,
     hcDark: null,
     hcLight: null
-}, ( localizeWithPath(
-    'vs/workbench/contrib/extensions/browser/extensionsActions',
-    'extensionButtonHoverBackground',
-    "Button background hover color for extension actions."
-)));
+}, ( localizeWithPath(_moduleId, 145, "Button background hover color for extension actions.")));
 registerColor('extensionButton.separator', {
     dark: buttonSeparator,
     light: buttonSeparator,
     hcDark: buttonSeparator,
     hcLight: buttonSeparator
-}, ( localizeWithPath(
-    'vs/workbench/contrib/extensions/browser/extensionsActions',
-    'extensionButtonSeparator',
-    "Button separator color for extension actions"
-)));
+}, ( localizeWithPath(_moduleId, 146, "Button separator color for extension actions")));
 const extensionButtonProminentBackground = registerColor('extensionButton.prominentBackground', {
     dark: buttonBackground,
     light: buttonBackground,
     hcDark: null,
     hcLight: null
 }, ( localizeWithPath(
-    'vs/workbench/contrib/extensions/browser/extensionsActions',
-    'extensionButtonProminentBackground',
+    _moduleId,
+    147,
     "Button background color for extension actions that stand out (e.g. install button)."
 )));
 registerColor('extensionButton.prominentForeground', {
@@ -3492,8 +3023,8 @@ registerColor('extensionButton.prominentForeground', {
     hcDark: null,
     hcLight: null
 }, ( localizeWithPath(
-    'vs/workbench/contrib/extensions/browser/extensionsActions',
-    'extensionButtonProminentForeground',
+    _moduleId,
+    148,
     "Button foreground color for extension actions that stand out (e.g. install button)."
 )));
 registerColor('extensionButton.prominentHoverBackground', {
@@ -3502,8 +3033,8 @@ registerColor('extensionButton.prominentHoverBackground', {
     hcDark: null,
     hcLight: null
 }, ( localizeWithPath(
-    'vs/workbench/contrib/extensions/browser/extensionsActions',
-    'extensionButtonProminentHoverBackground',
+    _moduleId,
+    149,
     "Button background hover color for extension actions that stand out (e.g. install button)."
 )));
 registerThemingParticipant((theme, collector) => {