@codingame/monaco-vscode-api 4.5.1 → 4.5.2

package/vscode/src/vs/workbench/browser/parts/editor/textEditor.js

@@ -15,17 +15,18 @@ import { IEditorGroupsService } from '../../../services/editor/common/editorGrou
 import { IEditorService } from '../../../services/editor/common/editorService.service.js';
 import { IFileService } from '../../../../platform/files/common/files.service.js';
 var AbstractTextEditor_1;
+const _moduleId = "vs/workbench/browser/parts/editor/textEditor";
 let AbstractTextEditor = class AbstractTextEditor extends AbstractEditorWithViewState {
     static { AbstractTextEditor_1 = this; }
     static { this.VIEW_STATE_PREFERENCE_KEY = 'textEditorViewState'; }
     constructor(id, group, telemetryService, instantiationService, storageService, textResourceConfigurationService, themeService, editorService, editorGroupService, fileService) {
         super(id, group, AbstractTextEditor_1.VIEW_STATE_PREFERENCE_KEY, telemetryService, instantiationService, storageService, textResourceConfigurationService, themeService, editorService, editorGroupService);
         this.fileService = fileService;
-        this._onDidChangeSelection = this._register(( new Emitter()));
+        this._onDidChangeSelection = this._register(( (new Emitter())));
         this.onDidChangeSelection = this._onDidChangeSelection.event;
-        this._onDidChangeScroll = this._register(( new Emitter()));
+        this._onDidChangeScroll = this._register(( (new Emitter())));
         this.onDidChangeScroll = this._onDidChangeScroll.event;
-        this.inputListener = this._register(( new MutableDisposable()));
+        this.inputListener = this._register(( (new MutableDisposable())));
         this._register(this.textResourceConfigurationService.onDidChangeConfiguration(e => this.handleConfigurationChangeEvent(e)));
         this._register(Event.any(this.editorGroupService.onDidAddGroup, this.editorGroupService.onDidRemoveGroup)(() => {
             const ariaLabel = this.computeAriaLabel();
@@ -63,7 +64,7 @@ let AbstractTextEditor = class AbstractTextEditor extends AbstractEditorWithView
         return editorConfiguration;
     }
     computeAriaLabel() {
-        return this.input ? computeEditorAriaLabel(this.input, undefined, this.group, this.editorGroupService.count) : ( localizeWithPath('vs/workbench/browser/parts/editor/textEditor', 'editor', "Editor"));
+        return this.input ? computeEditorAriaLabel(this.input, undefined, this.group, this.editorGroupService.count) : ( localizeWithPath(_moduleId, 0, "Editor"));
     }
     onDidChangeFileSystemProvider(scheme) {
         if (!this.input) {
@@ -124,7 +125,9 @@ let AbstractTextEditor = class AbstractTextEditor extends AbstractEditorWithView
         if (mainControl) {
             const selection = mainControl.getSelection();
             if (selection) {
-                return ( new TextEditorPaneSelection(selection));
+                return (
+                     (new TextEditorPaneSelection(selection))
+                );
             }
         }
         return undefined;
@@ -143,7 +146,7 @@ let AbstractTextEditor = class AbstractTextEditor extends AbstractEditorWithView
     getScrollPosition() {
         const editor = this.getMainControl();
         if (!editor) {
-            throw new Error('Control has not yet been initialized');
+            throw ( (new Error('Control has not yet been initialized')));
         }
         return {
             scrollTop: editor.getScrollTop() - editor.getTopForLineNumber(1),
@@ -153,7 +156,7 @@ let AbstractTextEditor = class AbstractTextEditor extends AbstractEditorWithView
     setScrollPosition(scrollPosition) {
         const editor = this.getMainControl();
         if (!editor) {
-            throw new Error('Control has not yet been initialized');
+            throw ( (new Error('Control has not yet been initialized')));
         }
         editor.setScrollTop(scrollPosition.scrollTop);
         if (scrollPosition.scrollLeft) {
@@ -182,7 +185,7 @@ let AbstractTextEditor = class AbstractTextEditor extends AbstractEditorWithView
         if (this.lastAppliedEditorOptions) {
             editorSettingsToApply = distinct(this.lastAppliedEditorOptions, editorSettingsToApply);
         }
-        if (( Object.keys(editorSettingsToApply)).length > 0) {
+        if (( (Object.keys(editorSettingsToApply))).length > 0) {
             this.lastAppliedEditorOptions = editorConfiguration;
             this.updateEditorControlOptions(editorSettingsToApply);
         }
@@ -205,16 +208,16 @@ let AbstractTextEditor = class AbstractTextEditor extends AbstractEditorWithView
         super.dispose();
     }
 };
-AbstractTextEditor = AbstractTextEditor_1 = ( __decorate([
-    ( __param(2, ITelemetryService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IStorageService)),
-    ( __param(5, ITextResourceConfigurationService)),
-    ( __param(6, IThemeService)),
-    ( __param(7, IEditorService)),
-    ( __param(8, IEditorGroupsService)),
-    ( __param(9, IFileService))
-], AbstractTextEditor));
+AbstractTextEditor = AbstractTextEditor_1 = ( (__decorate([
+    ( (__param(2, ITelemetryService))),
+    ( (__param(3, IInstantiationService))),
+    ( (__param(4, IStorageService))),
+    ( (__param(5, ITextResourceConfigurationService))),
+    ( (__param(6, IThemeService))),
+    ( (__param(7, IEditorService))),
+    ( (__param(8, IEditorGroupsService))),
+    ( (__param(9, IFileService)))
+], AbstractTextEditor)));
 class TextEditorPaneSelection {
     static { this.TEXT_EDITOR_SELECTION_THRESHOLD = 10; }
     constructor(textSelection) {

package/vscode/src/vs/workbench/browser/parts/editor/textResourceEditor.js

@@ -29,7 +29,7 @@ let AbstractTextResourceEditor = class AbstractTextResourceEditor extends Abstra
             return undefined;
         }
         if (!(resolvedModel instanceof BaseTextEditorModel)) {
-            throw new Error('Unable to open file as text');
+            throw ( new Error('Unable to open file as text'));
         }
         const control = assertIsDefined(this.editorControl);
         const textEditorModel = resolvedModel.textEditorModel;

package/vscode/src/vs/workbench/browser/parts/globalCompositeBar.js

@@ -40,14 +40,11 @@ import { isString } from '../../../base/common/types.js';
 import { ACTIVITY_BAR_BADGE_BACKGROUND, ACTIVITY_BAR_BADGE_FOREGROUND } from '../../common/theme.js';
 import { ICommandService } from '../../../platform/commands/common/commands.service.js';
 var GlobalCompositeBar_1;
+const _moduleId = "vs/workbench/browser/parts/globalCompositeBar";
 let GlobalCompositeBar = class GlobalCompositeBar extends Disposable {
     static { GlobalCompositeBar_1 = this; }
     static { this.ACCOUNTS_ACTION_INDEX = 0; }
-    static { this.ACCOUNTS_ICON = registerIcon('accounts-view-bar-icon', Codicon.account, ( localizeWithPath(
-        'vs/workbench/browser/parts/globalCompositeBar',
-        'accountsViewBarIcon',
-        "Accounts icon in the view bar."
-    ))); }
+    static { this.ACCOUNTS_ICON = registerIcon('accounts-view-bar-icon', Codicon.account, ( localizeWithPath(_moduleId, 0, "Accounts icon in the view bar."))); }
     constructor(contextMenuActionsProvider, colors, activityHoverOptions, configurationService, instantiationService, storageService, extensionService) {
         super();
         this.contextMenuActionsProvider = contextMenuActionsProvider;
@@ -56,14 +53,14 @@ let GlobalCompositeBar = class GlobalCompositeBar extends Disposable {
         this.instantiationService = instantiationService;
         this.storageService = storageService;
         this.extensionService = extensionService;
-        this.globalActivityAction = this._register(( new Action(GLOBAL_ACTIVITY_ID)));
-        this.accountAction = this._register(( new Action(ACCOUNTS_ACTIVITY_ID)));
+        this.globalActivityAction = this._register(( (new Action(GLOBAL_ACTIVITY_ID))));
+        this.accountAction = this._register(( (new Action(ACCOUNTS_ACTIVITY_ID))));
         this.element = document.createElement('div');
         const contextMenuAlignmentOptions = () => ({
             anchorAlignment: configurationService.getValue('workbench.sideBar.location') === 'left' ? 1  : 0 ,
             anchorAxisAlignment: 1
         });
-        this.globalActivityActionBar = this._register(( new ActionBar(this.element, {
+        this.globalActivityActionBar = this._register(( (new ActionBar(this.element, {
             actionViewItemProvider: (action, options) => {
                 if (action.id === GLOBAL_ACTIVITY_ID) {
                     return this.instantiationService.createInstance(GlobalActivityActionViewItem, this.contextMenuActionsProvider, { ...options, colors: this.colors, hoverOptions: this.activityHoverOptions }, contextMenuAlignmentOptions);
@@ -75,21 +72,17 @@ let GlobalCompositeBar = class GlobalCompositeBar extends Disposable {
                         hoverOptions: this.activityHoverOptions
                     }, contextMenuAlignmentOptions, (actions) => {
                         actions.unshift(...[
-                            toAction({ id: 'hideAccounts', label: ( localizeWithPath(
-                                'vs/workbench/browser/parts/globalCompositeBar',
-                                'hideAccounts',
-                                "Hide Accounts"
-                            )), run: () => this.storageService.store(AccountsActivityActionViewItem.ACCOUNTS_VISIBILITY_PREFERENCE_KEY, false, 0 , 0 ) }),
-                            ( new Separator())
+                            toAction({ id: 'hideAccounts', label: ( localizeWithPath(_moduleId, 1, "Hide Accounts")), run: () => this.storageService.store(AccountsActivityActionViewItem.ACCOUNTS_VISIBILITY_PREFERENCE_KEY, false, 0 , 0 ) }),
+                            ( (new Separator()))
                         ]);
                     });
                 }
-                throw new Error(`No view item for action '${action.id}'`);
+                throw ( (new Error(`No view item for action '${action.id}'`)));
             },
             orientation: 1 ,
-            ariaLabel: ( localizeWithPath('vs/workbench/browser/parts/globalCompositeBar', 'manage', "Manage")),
+            ariaLabel: ( localizeWithPath(_moduleId, 2, "Manage")),
             preventLoopNavigation: true
-        })));
+        }))));
         if (this.accountsVisibilityPreference) {
             this.globalActivityActionBar.push(this.accountAction, { index: GlobalCompositeBar_1.ACCOUNTS_ACTION_INDEX });
         }
@@ -113,7 +106,7 @@ let GlobalCompositeBar = class GlobalCompositeBar extends Disposable {
         return this.globalActivityActionBar.viewItems.length;
     }
     getContextMenuActions() {
-        return [toAction({ id: 'toggleAccountsVisibility', label: ( localizeWithPath('vs/workbench/browser/parts/globalCompositeBar', 'accounts', "Accounts")), checked: this.accountsVisibilityPreference, run: () => this.accountsVisibilityPreference = !this.accountsVisibilityPreference })];
+        return [toAction({ id: 'toggleAccountsVisibility', label: ( localizeWithPath(_moduleId, 3, "Accounts")), checked: this.accountsVisibilityPreference, run: () => this.accountsVisibilityPreference = !this.accountsVisibilityPreference })];
     }
     toggleAccountsActivity() {
         if (this.globalActivityActionBar.length() === 2 && this.accountsVisibilityPreference) {
@@ -133,12 +126,12 @@ let GlobalCompositeBar = class GlobalCompositeBar extends Disposable {
         this.storageService.store(AccountsActivityActionViewItem.ACCOUNTS_VISIBILITY_PREFERENCE_KEY, value, 0 , 0 );
     }
 };
-GlobalCompositeBar = GlobalCompositeBar_1 = ( __decorate([
-    ( __param(3, IConfigurationService)),
-    ( __param(4, IInstantiationService)),
-    ( __param(5, IStorageService)),
-    ( __param(6, IExtensionService))
-], GlobalCompositeBar));
+GlobalCompositeBar = GlobalCompositeBar_1 = ( (__decorate([
+    ( (__param(3, IConfigurationService))),
+    ( (__param(4, IInstantiationService))),
+    ( (__param(5, IStorageService))),
+    ( (__param(6, IExtensionService)))
+], GlobalCompositeBar)));
 let AbstractGlobalActivityActionViewItem = class AbstractGlobalActivityActionViewItem extends CompositeBarActionViewItem {
     constructor(menuId, action, options, contextMenuActionsProvider, contextMenuAlignmentOptions, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, keybindingService, activityService) {
         super(action, { draggable: false, icon: true, hasPopup: true, ...options }, () => true, themeService, hoverService, configurationService, keybindingService);
@@ -180,7 +173,9 @@ let AbstractGlobalActivityActionViewItem = class AbstractGlobalActivityActionVie
                 return result;
             }, '');
         };
-        return ( new NumberBadge(number, descriptorFn));
+        return (
+             (new NumberBadge(number, descriptorFn))
+        );
     }
     render(container) {
         super.render(container);
@@ -192,9 +187,9 @@ let AbstractGlobalActivityActionViewItem = class AbstractGlobalActivityActionVie
             }
         }));
         this._register(addDisposableListener(this.container, EventType.CONTEXT_MENU, async (e) => {
-            const disposables = ( new DisposableStore());
+            const disposables = ( (new DisposableStore()));
             const actions = await this.resolveContextMenuActions(disposables);
-            const event = ( new StandardMouseEvent(getWindow(this.container), e));
+            const event = ( (new StandardMouseEvent(getWindow(this.container), e)));
             this.contextMenuService.showContextMenu({
                 getAnchor: () => event,
                 getActions: () => actions,
@@ -202,7 +197,7 @@ let AbstractGlobalActivityActionViewItem = class AbstractGlobalActivityActionVie
             });
         }));
         this._register(addDisposableListener(this.container, EventType.KEY_UP, (e) => {
-            const event = ( new StandardKeyboardEvent(e));
+            const event = ( (new StandardKeyboardEvent(e)));
             if (event.equals(3 ) || event.equals(10 )) {
                 EventHelper.stop(e, true);
                 this.run();
@@ -217,7 +212,7 @@ let AbstractGlobalActivityActionViewItem = class AbstractGlobalActivityActionVie
         return this.contextMenuActionsProvider();
     }
     async run() {
-        const disposables = ( new DisposableStore());
+        const disposables = ( (new DisposableStore()));
         const menu = disposables.add(this.menuService.createMenu(this.menuId, this.contextKeyService));
         const actions = await this.resolveMainMenuActions(menu, disposables);
         const { anchorAlignment, anchorAxisAlignment } = this.contextMenuAlignmentOptions() ?? { anchorAlignment: undefined, anchorAxisAlignment: undefined };
@@ -236,22 +231,22 @@ let AbstractGlobalActivityActionViewItem = class AbstractGlobalActivityActionVie
         return actions;
     }
 };
-AbstractGlobalActivityActionViewItem = ( __decorate([
-    ( __param(5, IThemeService)),
-    ( __param(6, IHoverService)),
-    ( __param(7, IMenuService)),
-    ( __param(8, IContextMenuService)),
-    ( __param(9, IContextKeyService)),
-    ( __param(10, IConfigurationService)),
-    ( __param(11, IKeybindingService)),
-    ( __param(12, IActivityService))
-], AbstractGlobalActivityActionViewItem));
+AbstractGlobalActivityActionViewItem = ( (__decorate([
+    ( (__param(5, IThemeService))),
+    ( (__param(6, IHoverService))),
+    ( (__param(7, IMenuService))),
+    ( (__param(8, IContextMenuService))),
+    ( (__param(9, IContextKeyService))),
+    ( (__param(10, IConfigurationService))),
+    ( (__param(11, IKeybindingService))),
+    ( (__param(12, IActivityService)))
+], AbstractGlobalActivityActionViewItem)));
 let AccountsActivityActionViewItem = class AccountsActivityActionViewItem extends AbstractGlobalActivityActionViewItem {
     static { this.ACCOUNTS_VISIBILITY_PREFERENCE_KEY = 'workbench.activity.showAccounts'; }
     constructor(contextMenuActionsProvider, options, contextMenuAlignmentOptions, fillContextMenuActions, themeService, lifecycleService, hoverService, contextMenuService, menuService, contextKeyService, authenticationService, environmentService, productService, configurationService, keybindingService, secretStorageService, logService, activityService, instantiationService, commandService) {
         const action = instantiationService.createInstance(CompositeBarAction, {
             id: ACCOUNTS_ACTIVITY_ID,
-            name: ( localizeWithPath('vs/workbench/browser/parts/globalCompositeBar', 'accounts', "Accounts")),
+            name: ( localizeWithPath(_moduleId, 3, "Accounts")),
             classNames: ThemeIcon.asClassNameArray(GlobalCompositeBar.ACCOUNTS_ICON)
         });
         super(MenuId.AccountsContext, action, options, contextMenuActionsProvider, contextMenuAlignmentOptions, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, keybindingService, activityService);
@@ -262,12 +257,12 @@ let AccountsActivityActionViewItem = class AccountsActivityActionViewItem extend
         this.secretStorageService = secretStorageService;
         this.logService = logService;
         this.commandService = commandService;
-        this.groupedAccounts = ( new Map());
-        this.problematicProviders = ( new Set());
+        this.groupedAccounts = ( (new Map()));
+        this.problematicProviders = ( (new Set()));
         this.initialized = false;
-        this.sessionFromEmbedder = ( new Lazy(
+        this.sessionFromEmbedder = ( (new Lazy(
             () => getCurrentAuthenticationSessionInfo(this.secretStorageService, this.productService)
-        ));
+        )));
         this._register(action);
         this.registerListeners();
         this.initialize();
@@ -308,7 +303,7 @@ let AccountsActivityActionViewItem = class AccountsActivityActionViewItem extend
     }
     async doInitialize() {
         const providerIds = this.authenticationService.getProviderIds();
-        const results = await Promise.allSettled(( providerIds.map(providerId => this.addAccountsFromProvider(providerId))));
+        const results = await Promise.allSettled(( (providerIds.map(providerId => this.addAccountsFromProvider(providerId)))));
         for (const result of results) {
             if (result.status === 'rejected') {
                 this.logService.error(result.reason);
@@ -323,20 +318,15 @@ let AccountsActivityActionViewItem = class AccountsActivityActionViewItem extend
         let menus = [];
         for (const providerId of providers) {
             if (!this.initialized) {
-                const noAccountsAvailableAction = disposables.add(( new Action('noAccountsAvailable', ( localizeWithPath('vs/workbench/browser/parts/globalCompositeBar', 'loading', "Loading...")), undefined, false)));
+                const noAccountsAvailableAction = disposables.add(( (new Action('noAccountsAvailable', ( localizeWithPath(_moduleId, 4, "Loading...")), undefined, false))));
                 menus.push(noAccountsAvailableAction);
                 break;
             }
             const providerLabel = this.authenticationService.getProvider(providerId).label;
             const accounts = this.groupedAccounts.get(providerId);
             if (!accounts) {
-                if (( this.problematicProviders.has(providerId))) {
-                    const providerUnavailableAction = disposables.add(( new Action('providerUnavailable', ( localizeWithPath(
-                        'vs/workbench/browser/parts/globalCompositeBar',
-                        'authProviderUnavailable',
-                        '{0} is currently unavailable',
-                        providerLabel
-                    )), undefined, false)));
+                if (( (this.problematicProviders.has(providerId)))) {
+                    const providerUnavailableAction = disposables.add(( (new Action('providerUnavailable', ( localizeWithPath(_moduleId, 5, '{0} is currently unavailable', providerLabel)), undefined, false))));
                     menus.push(providerUnavailableAction);
                     try {
                         await this.addAccountsFromProvider(providerId);
@@ -350,11 +340,7 @@ let AccountsActivityActionViewItem = class AccountsActivityActionViewItem extend
             for (const account of accounts) {
                 const manageExtensionsAction = toAction({
                     id: `configureSessions${account.label}`,
-                    label: ( localizeWithPath(
-                        'vs/workbench/browser/parts/globalCompositeBar',
-                        'manageTrustedExtensions',
-                        "Manage Trusted Extensions"
-                    )),
+                    label: ( localizeWithPath(_moduleId, 6, "Manage Trusted Extensions")),
                     enabled: true,
                     run: () => this.commandService.executeCommand('_manageTrustedExtensionsForAccount', { providerId, accountLabel: account.label })
                 });
@@ -362,35 +348,31 @@ let AccountsActivityActionViewItem = class AccountsActivityActionViewItem extend
                 if (account.canSignOut) {
                     providerSubMenuActions.push(toAction({
                         id: 'signOut',
-                        label: ( localizeWithPath('vs/workbench/browser/parts/globalCompositeBar', 'signOut', "Sign Out")),
+                        label: ( localizeWithPath(_moduleId, 7, "Sign Out")),
                         enabled: true,
                         run: () => this.commandService.executeCommand('_signOutOfAccount', { providerId, accountLabel: account.label })
                     }));
                 }
-                const providerSubMenu = ( new SubmenuAction(
+                const providerSubMenu = ( (new SubmenuAction(
                     'activitybar.submenu',
                     `${account.label} (${providerLabel})`,
                     providerSubMenuActions
-                ));
+                )));
                 menus.push(providerSubMenu);
             }
         }
         if (providers.length && !menus.length) {
-            const noAccountsAvailableAction = disposables.add(( new Action('noAccountsAvailable', ( localizeWithPath(
-                'vs/workbench/browser/parts/globalCompositeBar',
-                'noAccounts',
-                "You are not signed in to any accounts"
-            )), undefined, false)));
+            const noAccountsAvailableAction = disposables.add(( (new Action('noAccountsAvailable', ( localizeWithPath(_moduleId, 8, "You are not signed in to any accounts")), undefined, false))));
             menus.push(noAccountsAvailableAction);
         }
         if (menus.length && otherCommands.length) {
-            menus.push(( new Separator()));
+            menus.push(( (new Separator())));
         }
         otherCommands.forEach((group, i) => {
             const actions = group[1];
             menus = menus.concat(actions);
             if (i !== otherCommands.length - 1) {
-                menus.push(( new Separator()));
+                menus.push(( (new Separator())));
             }
         });
         return menus;
@@ -410,9 +392,9 @@ let AccountsActivityActionViewItem = class AccountsActivityActionViewItem extend
         let canSignOut = true;
         if (sessionFromEmbedder
             && !sessionFromEmbedder.canSignOut
-            && ( (await this.authenticationService.getSessions(providerId))
+            && ( ((await this.authenticationService.getSessions(providerId))
                 .some(s => s.id === sessionFromEmbedder.id
-                && s.account.id === account.id))) {
+                && s.account.id === account.id)))) {
             canSignOut = false;
         }
         const existingAccount = accounts.find(a => a.label === account.label);
@@ -458,29 +440,29 @@ let AccountsActivityActionViewItem = class AccountsActivityActionViewItem extend
         }
     }
 };
-AccountsActivityActionViewItem = ( __decorate([
-    ( __param(4, IThemeService)),
-    ( __param(5, ILifecycleService)),
-    ( __param(6, IHoverService)),
-    ( __param(7, IContextMenuService)),
-    ( __param(8, IMenuService)),
-    ( __param(9, IContextKeyService)),
-    ( __param(10, IAuthenticationService)),
-    ( __param(11, IWorkbenchEnvironmentService)),
-    ( __param(12, IProductService)),
-    ( __param(13, IConfigurationService)),
-    ( __param(14, IKeybindingService)),
-    ( __param(15, ISecretStorageService)),
-    ( __param(16, ILogService)),
-    ( __param(17, IActivityService)),
-    ( __param(18, IInstantiationService)),
-    ( __param(19, ICommandService))
-], AccountsActivityActionViewItem));
+AccountsActivityActionViewItem = ( (__decorate([
+    ( (__param(4, IThemeService))),
+    ( (__param(5, ILifecycleService))),
+    ( (__param(6, IHoverService))),
+    ( (__param(7, IContextMenuService))),
+    ( (__param(8, IMenuService))),
+    ( (__param(9, IContextKeyService))),
+    ( (__param(10, IAuthenticationService))),
+    ( (__param(11, IWorkbenchEnvironmentService))),
+    ( (__param(12, IProductService))),
+    ( (__param(13, IConfigurationService))),
+    ( (__param(14, IKeybindingService))),
+    ( (__param(15, ISecretStorageService))),
+    ( (__param(16, ILogService))),
+    ( (__param(17, IActivityService))),
+    ( (__param(18, IInstantiationService))),
+    ( (__param(19, ICommandService)))
+], AccountsActivityActionViewItem)));
 let GlobalActivityActionViewItem = class GlobalActivityActionViewItem extends AbstractGlobalActivityActionViewItem {
     constructor(contextMenuActionsProvider, options, contextMenuAlignmentOptions, userDataProfileService, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, environmentService, keybindingService, instantiationService, activityService) {
         const action = instantiationService.createInstance(CompositeBarAction, {
             id: GLOBAL_ACTIVITY_ID,
-            name: ( localizeWithPath('vs/workbench/browser/parts/globalCompositeBar', 'manage', "Manage")),
+            name: ( localizeWithPath(_moduleId, 2, "Manage")),
             classNames: ThemeIcon.asClassNameArray(userDataProfileService.currentProfile.icon ? ThemeIcon.fromId(userDataProfileService.currentProfile.icon) : DEFAULT_ICON)
         });
         super(MenuId.GlobalActivity, action, options, contextMenuActionsProvider, contextMenuAlignmentOptions, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, keybindingService, activityService);
@@ -525,26 +507,26 @@ let GlobalActivityActionViewItem = class GlobalActivityActionViewItem extends Ab
     }
     computeTitle() {
         return this.userDataProfileService.currentProfile.isDefault ? super.computeTitle() : ( localizeWithPath(
-            'vs/workbench/browser/parts/globalCompositeBar',
-            'manage profile',
+            _moduleId,
+            9,
             "Manage {0} (Profile)",
             this.userDataProfileService.currentProfile.name
         ));
     }
 };
-GlobalActivityActionViewItem = ( __decorate([
-    ( __param(3, IUserDataProfileService)),
-    ( __param(4, IThemeService)),
-    ( __param(5, IHoverService)),
-    ( __param(6, IMenuService)),
-    ( __param(7, IContextMenuService)),
-    ( __param(8, IContextKeyService)),
-    ( __param(9, IConfigurationService)),
-    ( __param(10, IWorkbenchEnvironmentService)),
-    ( __param(11, IKeybindingService)),
-    ( __param(12, IInstantiationService)),
-    ( __param(13, IActivityService))
-], GlobalActivityActionViewItem));
+GlobalActivityActionViewItem = ( (__decorate([
+    ( (__param(3, IUserDataProfileService))),
+    ( (__param(4, IThemeService))),
+    ( (__param(5, IHoverService))),
+    ( (__param(6, IMenuService))),
+    ( (__param(7, IContextMenuService))),
+    ( (__param(8, IContextKeyService))),
+    ( (__param(9, IConfigurationService))),
+    ( (__param(10, IWorkbenchEnvironmentService))),
+    ( (__param(11, IKeybindingService))),
+    ( (__param(12, IInstantiationService))),
+    ( (__param(13, IActivityService)))
+], GlobalActivityActionViewItem)));
 let SimpleAccountActivityActionViewItem = class SimpleAccountActivityActionViewItem extends AccountsActivityActionViewItem {
     constructor(hoverOptions, options, themeService, lifecycleService, hoverService, contextMenuService, menuService, contextKeyService, authenticationService, environmentService, productService, configurationService, keybindingService, secretStorageService, logService, activityService, instantiationService, commandService) {
         super(() => [], {
@@ -558,24 +540,24 @@ let SimpleAccountActivityActionViewItem = class SimpleAccountActivityActionViewI
         }, () => undefined, actions => actions, themeService, lifecycleService, hoverService, contextMenuService, menuService, contextKeyService, authenticationService, environmentService, productService, configurationService, keybindingService, secretStorageService, logService, activityService, instantiationService, commandService);
     }
 };
-SimpleAccountActivityActionViewItem = ( __decorate([
-    ( __param(2, IThemeService)),
-    ( __param(3, ILifecycleService)),
-    ( __param(4, IHoverService)),
-    ( __param(5, IContextMenuService)),
-    ( __param(6, IMenuService)),
-    ( __param(7, IContextKeyService)),
-    ( __param(8, IAuthenticationService)),
-    ( __param(9, IWorkbenchEnvironmentService)),
-    ( __param(10, IProductService)),
-    ( __param(11, IConfigurationService)),
-    ( __param(12, IKeybindingService)),
-    ( __param(13, ISecretStorageService)),
-    ( __param(14, ILogService)),
-    ( __param(15, IActivityService)),
-    ( __param(16, IInstantiationService)),
-    ( __param(17, ICommandService))
-], SimpleAccountActivityActionViewItem));
+SimpleAccountActivityActionViewItem = ( (__decorate([
+    ( (__param(2, IThemeService))),
+    ( (__param(3, ILifecycleService))),
+    ( (__param(4, IHoverService))),
+    ( (__param(5, IContextMenuService))),
+    ( (__param(6, IMenuService))),
+    ( (__param(7, IContextKeyService))),
+    ( (__param(8, IAuthenticationService))),
+    ( (__param(9, IWorkbenchEnvironmentService))),
+    ( (__param(10, IProductService))),
+    ( (__param(11, IConfigurationService))),
+    ( (__param(12, IKeybindingService))),
+    ( (__param(13, ISecretStorageService))),
+    ( (__param(14, ILogService))),
+    ( (__param(15, IActivityService))),
+    ( (__param(16, IInstantiationService))),
+    ( (__param(17, ICommandService)))
+], SimpleAccountActivityActionViewItem)));
 let SimpleGlobalActivityActionViewItem = class SimpleGlobalActivityActionViewItem extends GlobalActivityActionViewItem {
     constructor(hoverOptions, options, userDataProfileService, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, environmentService, keybindingService, instantiationService, activityService) {
         super(() => [], {
@@ -589,17 +571,17 @@ let SimpleGlobalActivityActionViewItem = class SimpleGlobalActivityActionViewIte
         }, () => undefined, userDataProfileService, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, environmentService, keybindingService, instantiationService, activityService);
     }
 };
-SimpleGlobalActivityActionViewItem = ( __decorate([
-    ( __param(2, IUserDataProfileService)),
-    ( __param(3, IThemeService)),
-    ( __param(4, IHoverService)),
-    ( __param(5, IMenuService)),
-    ( __param(6, IContextMenuService)),
-    ( __param(7, IContextKeyService)),
-    ( __param(8, IConfigurationService)),
-    ( __param(9, IWorkbenchEnvironmentService)),
-    ( __param(10, IKeybindingService)),
-    ( __param(11, IInstantiationService)),
-    ( __param(12, IActivityService))
-], SimpleGlobalActivityActionViewItem));
+SimpleGlobalActivityActionViewItem = ( (__decorate([
+    ( (__param(2, IUserDataProfileService))),
+    ( (__param(3, IThemeService))),
+    ( (__param(4, IHoverService))),
+    ( (__param(5, IMenuService))),
+    ( (__param(6, IContextMenuService))),
+    ( (__param(7, IContextKeyService))),
+    ( (__param(8, IConfigurationService))),
+    ( (__param(9, IWorkbenchEnvironmentService))),
+    ( (__param(10, IKeybindingService))),
+    ( (__param(11, IInstantiationService))),
+    ( (__param(12, IActivityService)))
+], SimpleGlobalActivityActionViewItem)));
 export { AccountsActivityActionViewItem, GlobalActivityActionViewItem, GlobalCompositeBar, SimpleAccountActivityActionViewItem, SimpleGlobalActivityActionViewItem };