@codingame/monaco-vscode-api 26.2.1 → 27.0.0

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

@@ -0,0 +1,407 @@
+
+import { registerCss } from '../../../../../../../css.js';
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as modalEditorPart from './media/modalEditorPart.css';
+import { $, addDisposableListener, EventType, EventHelper, append, hide, show, isHTMLElement } from '../../../../base/browser/dom.js';
+import { StandardKeyboardEvent } from '../../../../base/browser/keyboardEvent.js';
+import { Button } from '../../../../base/browser/ui/button/button.js';
+import { KeyCode } from '../../../../base/common/keyCodes.js';
+import { Event, Emitter } from '../../../../base/common/event.js';
+import { DisposableStore, toDisposable, MutableDisposable } from '../../../../base/common/lifecycle.js';
+import { MenuId } from '../../../../platform/actions/common/actions.js';
+import { MenuWorkbenchToolBar, HiddenItemStrategy } from '../../../../platform/actions/browser/toolbar.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ServiceCollection } from '../../../../platform/instantiation/common/serviceCollection.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
+import { ResultKind } from '../../../../platform/keybinding/common/keybindingResolver.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.service.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.service.js';
+import { EditorPart } from './editorPart.js';
+import { GroupActivationReason, GroupsOrder, GroupDirection } from '../../../services/editor/common/editorGroupsService.js';
+import { IEditorService } from '../../../services/editor/common/editorService.service.js';
+import { EditorPartModalContext, EditorPartModalMaximizedContext, EditorPartModalNavigationContext } from '../../../common/contextkeys.js';
+import { Verbosity, EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
+import { ResourceLabel } from '../../labels.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.service.js';
+import { IHostService } from '../../../services/host/browser/host.service.js';
+import { Parts } from '../../../services/layout/browser/layoutService.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.service.js';
+import { mainWindow } from '../../../../base/browser/window.js';
+import { localize } from '../../../../nls.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { CLOSE_MODAL_EDITOR_COMMAND_ID, MOVE_MODAL_EDITOR_TO_MAIN_COMMAND_ID, MOVE_MODAL_EDITOR_TO_WINDOW_COMMAND_ID, TOGGLE_MODAL_EDITOR_MAXIMIZED_COMMAND_ID, NAVIGATE_MODAL_EDITOR_PREVIOUS_COMMAND_ID, NAVIGATE_MODAL_EDITOR_NEXT_COMMAND_ID } from './editorCommands.js';
+
+var ModalEditorPartImpl_1;
+registerCss(modalEditorPart);
+const defaultModalEditorAllowableCommands = ( new Set([
+    "workbench.action.quit",
+    "workbench.action.reloadWindow",
+    "workbench.action.closeActiveEditor",
+    "workbench.action.closeAllEditors",
+    "workbench.action.files.save",
+    "workbench.action.files.saveAll",
+    CLOSE_MODAL_EDITOR_COMMAND_ID,
+    MOVE_MODAL_EDITOR_TO_MAIN_COMMAND_ID,
+    MOVE_MODAL_EDITOR_TO_WINDOW_COMMAND_ID,
+    TOGGLE_MODAL_EDITOR_MAXIMIZED_COMMAND_ID,
+    NAVIGATE_MODAL_EDITOR_PREVIOUS_COMMAND_ID,
+    NAVIGATE_MODAL_EDITOR_NEXT_COMMAND_ID
+]));
+let ModalEditorPart = class ModalEditorPart {
+    constructor(
+        editorPartsView,
+        instantiationService,
+        editorService,
+        layoutService,
+        keybindingService,
+        hostService,
+        environmentService
+    ) {
+        this.editorPartsView = editorPartsView;
+        this.instantiationService = instantiationService;
+        this.editorService = editorService;
+        this.layoutService = layoutService;
+        this.keybindingService = keybindingService;
+        this.hostService = hostService;
+        this.environmentService = environmentService;
+    }
+    async create(options) {
+        const disposables = ( new DisposableStore());
+        const modalElement = $(".monaco-modal-editor-block");
+        this.layoutService.mainContainer.appendChild(modalElement);
+        disposables.add(toDisposable(() => modalElement.remove()));
+        disposables.add(addDisposableListener(modalElement, EventType.MOUSE_DOWN, e => {
+            if (e.target === modalElement) {
+                EventHelper.stop(e, true);
+                editorPart.close();
+            }
+        }));
+        disposables.add(addDisposableListener(modalElement, EventType.KEY_DOWN, e => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.equals(KeyCode.Escape)) {
+                EventHelper.stop(event, true);
+                editorPart.close();
+            }
+            else if (!this.environmentService.isSessionsWindow) {
+                const resolved = this.keybindingService.softDispatch(event, this.layoutService.mainContainer);
+                if (resolved.kind === ResultKind.KbFound && resolved.commandId) {
+                    if (resolved.commandId.startsWith("workbench.") && !( defaultModalEditorAllowableCommands.has(resolved.commandId))) {
+                        EventHelper.stop(event, true);
+                    }
+                }
+            }
+        }));
+        const shadowElement = modalElement.appendChild($(".modal-editor-shadow"));
+        const titleId = "modal-editor-title";
+        const editorPartContainer = $(".part.editor.modal-editor-part", {
+            role: "dialog",
+            "aria-modal": "true",
+            "aria-labelledby": titleId,
+            tabIndex: -1
+        });
+        shadowElement.appendChild(editorPartContainer);
+        const headerElement = editorPartContainer.appendChild($(".modal-editor-header"));
+        const titleElement = append(headerElement, $("div.modal-editor-title.show-file-icons"));
+        titleElement.id = titleId;
+        titleElement.textContent = "";
+        const navigationContainer = append(headerElement, $("div.modal-editor-navigation"));
+        hide(navigationContainer);
+        disposables.add(
+            addDisposableListener(navigationContainer, EventType.DBLCLICK, e => EventHelper.stop(e, true))
+        );
+        const previousButton = disposables.add(( new Button(navigationContainer, {
+            title: ( localize(3561, "Previous"))
+        })));
+        previousButton.icon = Codicon.chevronLeft;
+        previousButton.element.classList.add("modal-editor-nav-button");
+        disposables.add(previousButton.onDidClick(() => {
+            const navigation = editorPart.navigation;
+            if (navigation && navigation.current > 0) {
+                navigation.navigate(navigation.current - 1);
+            }
+        }));
+        const navigationLabel = append(navigationContainer, $("span.modal-editor-nav-label"));
+        navigationLabel.setAttribute("aria-live", "polite");
+        const nextButton = disposables.add(( new Button(navigationContainer, {
+            title: ( localize(3562, "Next"))
+        })));
+        nextButton.icon = Codicon.chevronRight;
+        nextButton.element.classList.add("modal-editor-nav-button");
+        disposables.add(nextButton.onDidClick(() => {
+            const navigation = editorPart.navigation;
+            if (navigation && navigation.current < navigation.total - 1) {
+                navigation.navigate(navigation.current + 1);
+            }
+        }));
+        const actionBarContainer = append(headerElement, $("div.modal-editor-action-container"));
+        const editorPart = disposables.add(this.instantiationService.createInstance(
+            ModalEditorPartImpl,
+            mainWindow.vscodeWindowId,
+            this.editorPartsView,
+            modalElement,
+            options
+        ));
+        disposables.add(this.editorPartsView.registerPart(editorPart));
+        editorPart.create(editorPartContainer);
+        disposables.add(Event.once(editorPart.onWillClose)(() => disposables.dispose()));
+        disposables.add(Event.runAndSubscribe(editorPart.onDidChangeNavigation, (navigation => {
+            if (navigation && navigation.total > 1) {
+                show(navigationContainer);
+                navigationLabel.textContent = ( localize(3563, "{0} of {1}", navigation.current + 1, navigation.total));
+                previousButton.enabled = navigation.current > 0;
+                nextButton.enabled = navigation.current < navigation.total - 1;
+            } else {
+                hide(navigationContainer);
+            }
+        }), editorPart.navigation));
+        const modalEditorService = this.editorService.createScoped(editorPart, disposables);
+        const scopedInstantiationService = disposables.add(editorPart.scopedInstantiationService.createChild(( new ServiceCollection([IEditorService, modalEditorService]))));
+        disposables.add(
+            scopedInstantiationService.createInstance(MenuWorkbenchToolBar, actionBarContainer, MenuId.ModalEditorTitle, {
+                hiddenItemStrategy: HiddenItemStrategy.NoHide,
+                highlightToggledItems: true,
+                menuOptions: {
+                    shouldForwardArgs: true
+                }
+            })
+        );
+        const label = disposables.add(scopedInstantiationService.createInstance(ResourceLabel, titleElement, {}));
+        disposables.add(Event.runAndSubscribe(modalEditorService.onDidActiveEditorChange, () => {
+            const activeEditor = editorPart.activeGroup.activeEditor;
+            if (activeEditor) {
+                const {
+                    labelFormat
+                } = editorPart.partOptions;
+                label.element.setResource({
+                    resource: EditorResourceAccessor.getOriginalUri(activeEditor, {
+                        supportSideBySide: SideBySideEditor.BOTH
+                    }),
+                    name: activeEditor.getName(),
+                    description: activeEditor.getDescription(
+                        labelFormat === "short" ? Verbosity.SHORT : labelFormat === "long" ? Verbosity.LONG : Verbosity.MEDIUM
+                    ) || ""
+                }, {
+                    icon: activeEditor.getIcon(),
+                    extraClasses: activeEditor.getLabelExtraClasses()
+                });
+            } else {
+                label.element.clear();
+            }
+            editorPart.notifyActiveEditorChanged();
+        }));
+        disposables.add(addDisposableListener(headerElement, EventType.DBLCLICK, e => {
+            EventHelper.stop(e);
+            editorPart.toggleMaximized();
+        }));
+        const layoutModal = () => {
+            const containerDimension = this.layoutService.mainContainerDimension;
+            const titleBarOffset = this.layoutService.mainContainerOffset.top;
+            const availableHeight = Math.max(containerDimension.height - titleBarOffset, 0);
+            let width;
+            let height;
+            if (editorPart.maximized) {
+                const horizontalPadding = 16;
+                const verticalPadding = Math.max(
+                    titleBarOffset,
+                    16
+                );
+                width = Math.max(containerDimension.width - horizontalPadding, 0);
+                height = Math.max(availableHeight - verticalPadding, 0);
+            } else {
+                const maxWidth = 1400;
+                const maxHeight = 900;
+                const targetWidth = containerDimension.width * 0.8;
+                const targetHeight = availableHeight * 0.8;
+                width = Math.min(targetWidth, maxWidth, containerDimension.width);
+                height = Math.min(targetHeight, maxHeight, availableHeight);
+            }
+            height = Math.min(height, availableHeight);
+            editorPartContainer.style.width = `${width}px`;
+            editorPartContainer.style.height = `${height}px`;
+            const borderSize = 2;
+            const headerHeight = 32 + 1 ;
+            editorPart.layout(width - borderSize, height - borderSize - headerHeight, 0, 0);
+        };
+        disposables.add(
+            Event.runAndSubscribe(this.layoutService.onDidLayoutMainContainer, layoutModal)
+        );
+        disposables.add(editorPart.onDidChangeMaximized(() => layoutModal()));
+        this.hostService.setWindowDimmed(mainWindow, true);
+        disposables.add(toDisposable(() => this.hostService.setWindowDimmed(mainWindow, false)));
+        editorPartContainer.focus();
+        return {
+            part: editorPart,
+            instantiationService: scopedInstantiationService,
+            disposables
+        };
+    }
+};
+ModalEditorPart = ( __decorate([( __param(1, IInstantiationService)), ( __param(2, IEditorService)), ( __param(3, IWorkbenchLayoutService)), ( __param(4, IKeybindingService)), ( __param(5, IHostService)), ( __param(6, IWorkbenchEnvironmentService))], ModalEditorPart));
+let ModalEditorPartImpl = class ModalEditorPartImpl extends EditorPart {
+    static {
+        ModalEditorPartImpl_1 = this;
+    }
+    static {
+        this.COUNTER = 1;
+    }
+    get maximized() {
+        return this._maximized;
+    }
+    get navigation() {
+        return this._navigation;
+    }
+    constructor(
+        windowId,
+        editorPartsView,
+        modalElement,
+        options,
+        instantiationService,
+        themeService,
+        configurationService,
+        storageService,
+        layoutService,
+        hostService,
+        contextKeyService
+    ) {
+        const id = ModalEditorPartImpl_1.COUNTER++;
+        super(editorPartsView, `workbench.parts.modalEditor.${id}`, ( localize(3564, "Modal Editor Area")), windowId, instantiationService, themeService, configurationService, storageService, layoutService, hostService, contextKeyService);
+        this.modalElement = modalElement;
+        this._onWillClose = this._register(( new Emitter()));
+        this.onWillClose = this._onWillClose.event;
+        this._onDidChangeMaximized = this._register(( new Emitter()));
+        this.onDidChangeMaximized = this._onDidChangeMaximized.event;
+        this._onDidChangeNavigation = this._register(( new Emitter()));
+        this.onDidChangeNavigation = this._onDidChangeNavigation.event;
+        this.optionsDisposable = this._register(( new MutableDisposable()));
+        this.previousMainWindowActiveElement = null;
+        this._maximized = options?.maximized ?? false;
+        this._navigation = options?.navigation;
+        this.enforceModalPartOptions();
+    }
+    create(parent, options) {
+        this.previousMainWindowActiveElement = mainWindow.document.activeElement;
+        super.create(parent, options);
+    }
+    enforceModalPartOptions() {
+        const editorCount = this.groups.reduce((count, group) => count + group.count, 0);
+        this.optionsDisposable.value = this.enforcePartOptions({
+            showTabs: editorCount > 1 ? "multiple" : "none",
+            enablePreview: true,
+            closeEmptyGroups: true,
+            tabActionCloseVisibility: editorCount > 1,
+            editorActionsLocation: "default",
+            tabHeight: "default",
+            wrapTabs: false,
+            allowDropIntoGroup: false
+        });
+    }
+    notifyActiveEditorChanged() {
+        this.enforceModalPartOptions();
+    }
+    updateOptions(options) {
+        if (typeof options?.maximized === "boolean" && options.maximized !== this._maximized) {
+            this.toggleMaximized();
+        }
+        this._navigation = options?.navigation;
+        this._onDidChangeNavigation.fire(options?.navigation);
+    }
+    toggleMaximized() {
+        this._maximized = !this._maximized;
+        this._onDidChangeMaximized.fire(this._maximized);
+    }
+    handleContextKeys() {
+        const isModalEditorPartContext = EditorPartModalContext.bindTo(this.scopedContextKeyService);
+        isModalEditorPartContext.set(true);
+        const isMaximizedContext = EditorPartModalMaximizedContext.bindTo(this.scopedContextKeyService);
+        isMaximizedContext.set(this._maximized);
+        this._register(this.onDidChangeMaximized(maximized => isMaximizedContext.set(maximized)));
+        const hasNavigationContext = EditorPartModalNavigationContext.bindTo(this.scopedContextKeyService);
+        hasNavigationContext.set(!!this._navigation && this._navigation.total > 1);
+        this._register(this.onDidChangeNavigation(
+            navigation => hasNavigationContext.set(!!navigation && navigation.total > 1)
+        ));
+        super.handleContextKeys();
+    }
+    removeGroup(group, preserveFocus) {
+        const groupView = this.assertGroupView(group);
+        if (this.count === 1 && this.activeGroup === groupView) {
+            this.doRemoveLastGroup();
+        }
+        else {
+            super.removeGroup(group, preserveFocus);
+        }
+    }
+    doRemoveLastGroup() {
+        const activeMainGroup = this.editorPartsView.mainPart.activeGroup;
+        this.editorPartsView.mainPart.activateGroup(activeMainGroup, undefined, GroupActivationReason.PART_CLOSE);
+        const mainEditorPartContainer = this.layoutService.getContainer(mainWindow, Parts.EDITOR_PART);
+        if (
+        !isHTMLElement(this.previousMainWindowActiveElement) || !this.previousMainWindowActiveElement.isConnected || mainEditorPartContainer?.contains(this.previousMainWindowActiveElement)) {
+            activeMainGroup.focus();
+        } else {
+            this.previousMainWindowActiveElement.focus();
+        }
+        this.doClose({
+            mergeConfirmingEditorsToMainPart: false
+        });
+    }
+    saveState() {
+        return;
+    }
+    close(options) {
+        return this.doClose({
+            ...options,
+            mergeConfirmingEditorsToMainPart: true
+        });
+    }
+    doClose(options) {
+        let result = true;
+        if (options?.mergeConfirmingEditorsToMainPart) {
+            if (!options.mergeAllEditorsToMainPart) {
+                for (const group of this.groups) {
+                    group.closeAllEditors({
+                        excludeConfirming: true
+                    });
+                }
+            }
+            result = this.mergeGroupsToMainPart();
+            if (!result) {
+                return false;
+            }
+        }
+        this._onWillClose.fire();
+        return result;
+    }
+    mergeGroupsToMainPart() {
+        if (!( this.groups.some(group => group.count > 0))) {
+            return true;
+        }
+        let targetGroup = undefined;
+        for (const group of this.editorPartsView.mainPart.getGroups(GroupsOrder.MOST_RECENTLY_ACTIVE)) {
+            if (!group.isLocked) {
+                targetGroup = group;
+                break;
+            }
+        }
+        if (!targetGroup) {
+            targetGroup = this.editorPartsView.mainPart.addGroup(
+                this.editorPartsView.mainPart.activeGroup,
+                this.partOptions.openSideBySideDirection === "right" ? GroupDirection.RIGHT : GroupDirection.DOWN
+            );
+        }
+        const result = this.mergeAllGroups(targetGroup, {
+            preserveExistingIndex: true
+        });
+        targetGroup.focus();
+        return result;
+    }
+    dispose() {
+        this._navigation = undefined;
+        super.dispose();
+    }
+};
+ModalEditorPartImpl = ModalEditorPartImpl_1 = ( __decorate([( __param(4, IInstantiationService)), ( __param(5, IThemeService)), ( __param(6, IConfigurationService)), ( __param(7, IStorageService)), ( __param(8, IWorkbenchLayoutService)), ( __param(9, IHostService)), ( __param(10, IContextKeyService))], ModalEditorPartImpl));
+
+export { ModalEditorPart };

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

@@ -651,7 +651,7 @@ let MultiEditorTabsControl = class MultiEditorTabsControl extends EditorTabsCont
             }
         }));
         const tabActionBar = ( new ActionBar(tabActionsContainer, {
-            ariaLabel: ( localize(3510, "Tab actions")),
+            ariaLabel: ( localize(3565, "Tab actions")),
             actionRunner: tabActionRunner
         }));
         const tabActionListener = tabActionBar.onWillRun(e => {

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

@@ -208,7 +208,7 @@ let SideBySideEditor = class SideBySideEditor extends AbstractEditorWithViewStat
         if (this.input) {
             return this.input.getName();
         }
-        return localize(3511, "Side by Side Editor");
+        return localize(3566, "Side by Side Editor");
     }
     async setInput(input, options, context, token) {
         const oldInput = this.input;

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

@@ -20,7 +20,7 @@ class AbstractTextCodeEditor extends AbstractTextEditor {
         if (this.input) {
             return this.input.getName();
         }
-        return localize(3512, "Text Editor");
+        return localize(3567, "Text Editor");
     }
     createEditorControl(parent, initialOptions) {
         this.editorControl = this._register(this.instantiationService.createInstance(

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

@@ -78,7 +78,7 @@ let TextDiffEditor = class TextDiffEditor extends AbstractTextEditor {
         if (this.input) {
             return this.input.getName();
         }
-        return localize(3513, "Text Diff Editor");
+        return localize(3568, "Text Diff Editor");
     }
     createEditorControl(parent, configuration) {
         this.diffEditorControl = this._register(
@@ -142,13 +142,13 @@ let TextDiffEditor = class TextDiffEditor extends AbstractTextEditor {
             let message;
             if (error instanceof TooLargeFileOperationError) {
                 message = ( localize(
-                    3514,
+                    3569,
                     "At least one file is not displayed in the text compare editor because it is very large ({0}).",
                     ByteSize.formatSize(error.size)
                 ));
             } else {
                 message = ( localize(
-                    3515,
+                    3570,
                     "At least one file is not displayed in the text compare editor because it is very large."
                 ));
             }

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

@@ -103,7 +103,7 @@ let AbstractTextEditor = class AbstractTextEditor extends AbstractEditorWithView
         return editorConfiguration;
     }
     computeAriaLabel() {
-        return this.input ? computeEditorAriaLabel(this.input, undefined, this.group, this.editorGroupService.count) : ( localize(3516, "Editor"));
+        return this.input ? computeEditorAriaLabel(this.input, undefined, this.group, this.editorGroupService.count) : ( localize(3571, "Editor"));
     }
     onDidChangeFileSystemProvider(scheme) {
         if (!this.input) {

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

@@ -21,7 +21,7 @@ import { $, addDisposableListener, EventType, EventHelper, getWindow, runWhenWin
 import { StandardKeyboardEvent } from '../../../base/browser/keyboardEvent.js';
 import { StandardMouseEvent } from '../../../base/browser/mouseEvent.js';
 import { EventType as EventType$1 } from '../../../base/browser/touch.js';
-import { AnchorAxisAlignment, AnchorAlignment } from '../../../base/browser/ui/contextview/contextview.js';
+import '../../../base/browser/ui/contextview/contextview.js';
 import { Lazy } from '../../../base/common/lazy.js';
 import { getActionBarActions } from '../../../platform/actions/browser/menuEntryActionViewItem.js';
 import { IConfigurationService } from '../../../platform/configuration/common/configuration.service.js';
@@ -44,6 +44,7 @@ import { isString } from '../../../base/common/types.js';
 import { KeyCode } from '../../../base/common/keyCodes.js';
 import { ACTIVITY_BAR_BADGE_FOREGROUND, ACTIVITY_BAR_BADGE_BACKGROUND } from '../../common/theme.js';
 import { ICommandService } from '../../../platform/commands/common/commands.service.js';
+import { AnchorAxisAlignment, AnchorAlignment } from '../../../base/common/layout.js';
 
 var GlobalCompositeBar_1;
 let GlobalCompositeBar = class GlobalCompositeBar extends Disposable {
@@ -54,7 +55,7 @@ let GlobalCompositeBar = class GlobalCompositeBar extends Disposable {
         this.ACCOUNTS_ACTION_INDEX = 0;
     }
     static {
-        this.ACCOUNTS_ICON = registerIcon("accounts-view-bar-icon", Codicon.account, ( localize(3517, "Accounts icon in the view bar.")));
+        this.ACCOUNTS_ICON = registerIcon("accounts-view-bar-icon", Codicon.account, ( localize(3572, "Accounts icon in the view bar.")));
     }
     constructor(
         contextMenuActionsProvider,
@@ -96,7 +97,7 @@ let GlobalCompositeBar = class GlobalCompositeBar extends Disposable {
                     }, contextMenuAlignmentOptions, actions => {
                         actions.unshift(...[toAction({
                             id: "hideAccounts",
-                            label: ( localize(3518, "Hide Accounts")),
+                            label: ( localize(3573, "Hide Accounts")),
                             run: () => setAccountsActionVisible(storageService, false)
                         }), ( new Separator())]);
                     });
@@ -104,7 +105,7 @@ let GlobalCompositeBar = class GlobalCompositeBar extends Disposable {
                 throw ( new Error(`No view item for action '${action.id}'`));
             },
             orientation: ActionsOrientation.VERTICAL,
-            ariaLabel: ( localize(3519, "Manage")),
+            ariaLabel: ( localize(3574, "Manage")),
             preventLoopNavigation: true
         })));
         if (this.accountsVisibilityPreference) {
@@ -138,7 +139,7 @@ let GlobalCompositeBar = class GlobalCompositeBar extends Disposable {
     getContextMenuActions() {
         return [toAction({
             id: "toggleAccountsVisibility",
-            label: ( localize(3520, "Accounts")),
+            label: ( localize(3575, "Accounts")),
             checked: this.accountsVisibilityPreference,
             run: () => this.accountsVisibilityPreference = !this.accountsVisibilityPreference
         })];
@@ -294,7 +295,7 @@ let AccountsActivityActionViewItem = class AccountsActivityActionViewItem extend
     ) {
         const action = instantiationService.createInstance(CompositeBarAction, {
             id: ACCOUNTS_ACTIVITY_ID,
-            name: ( localize(3520, "Accounts")),
+            name: ( localize(3575, "Accounts")),
             classNames: ThemeIcon.asClassNameArray(GlobalCompositeBar.ACCOUNTS_ICON)
         });
         super(
@@ -386,7 +387,7 @@ let AccountsActivityActionViewItem = class AccountsActivityActionViewItem extend
             providerId => this.authenticationService.isDynamicAuthenticationProvider(providerId)
         );
         if (!this.initialized) {
-            const noAccountsAvailableAction = disposables.add(( new Action("noAccountsAvailable", ( localize(3521, "Loading...")), undefined, false)));
+            const noAccountsAvailableAction = disposables.add(( new Action("noAccountsAvailable", ( localize(3576, "Loading...")), undefined, false)));
             menus.push(noAccountsAvailableAction);
         } else {
             for (const providerId of registeredProviders) {
@@ -394,7 +395,7 @@ let AccountsActivityActionViewItem = class AccountsActivityActionViewItem extend
                 const accounts = this.groupedAccounts.get(providerId);
                 if (!accounts) {
                     if (( this.problematicProviders.has(providerId))) {
-                        const providerUnavailableAction = disposables.add(( new Action("providerUnavailable", ( localize(3522, "{0} is currently unavailable", provider.label)), undefined, false)));
+                        const providerUnavailableAction = disposables.add(( new Action("providerUnavailable", ( localize(3577, "{0} is currently unavailable", provider.label)), undefined, false)));
                         menus.push(providerUnavailableAction);
                         try {
                             await this.addAccountsFromProvider(providerId);
@@ -408,7 +409,7 @@ let AccountsActivityActionViewItem = class AccountsActivityActionViewItem extend
                 for (const account of accounts) {
                     const manageExtensionsAction = toAction({
                         id: `configureSessions${account.label}`,
-                        label: ( localize(3523, "Manage Trusted Extensions")),
+                        label: ( localize(3578, "Manage Trusted Extensions")),
                         enabled: true,
                         run: () => this.commandService.executeCommand("_manageTrustedExtensionsForAccount", {
                             providerId,
@@ -419,7 +420,7 @@ let AccountsActivityActionViewItem = class AccountsActivityActionViewItem extend
                     if (canUseMcp) {
                         const manageMCPAction = toAction({
                             id: `configureSessions${account.label}`,
-                            label: ( localize(3524, "Manage Trusted MCP Servers")),
+                            label: ( localize(3579, "Manage Trusted MCP Servers")),
                             enabled: true,
                             run: () => this.commandService.executeCommand("_manageTrustedMCPServersForAccount", {
                                 providerId,
@@ -431,7 +432,7 @@ let AccountsActivityActionViewItem = class AccountsActivityActionViewItem extend
                     if (account.canSignOut) {
                         providerSubMenuActions.push(toAction({
                             id: "signOut",
-                            label: ( localize(3525, "Sign Out")),
+                            label: ( localize(3580, "Sign Out")),
                             enabled: true,
                             run: () => this.commandService.executeCommand("_signOutOfAccount", {
                                 providerId,
@@ -455,13 +456,13 @@ let AccountsActivityActionViewItem = class AccountsActivityActionViewItem extend
                 const accounts = this.groupedAccounts.get(providerId);
                 const manageDynamicAuthProvidersAction = toAction({
                     id: "manageDynamicAuthProviders",
-                    label: ( localize(3526, "Manage Dynamic Authentication Providers...")),
+                    label: ( localize(3581, "Manage Dynamic Authentication Providers...")),
                     enabled: true,
                     run: () => this.commandService.executeCommand("workbench.action.removeDynamicAuthenticationProviders")
                 });
                 if (!accounts) {
                     if (( this.problematicProviders.has(providerId))) {
-                        const providerUnavailableAction = disposables.add(( new Action("providerUnavailable", ( localize(3522, "{0} is currently unavailable", provider.label)), undefined, false)));
+                        const providerUnavailableAction = disposables.add(( new Action("providerUnavailable", ( localize(3577, "{0} is currently unavailable", provider.label)), undefined, false)));
                         menus.push(providerUnavailableAction);
                         try {
                             await this.addAccountsFromProvider(providerId);
@@ -476,7 +477,7 @@ let AccountsActivityActionViewItem = class AccountsActivityActionViewItem extend
                     const providerSubMenuActions = [];
                     const manageMCPAction = toAction({
                         id: `configureSessions${account.label}`,
-                        label: ( localize(3524, "Manage Trusted MCP Servers")),
+                        label: ( localize(3579, "Manage Trusted MCP Servers")),
                         enabled: true,
                         run: () => this.commandService.executeCommand("_manageTrustedMCPServersForAccount", {
                             providerId,
@@ -488,7 +489,7 @@ let AccountsActivityActionViewItem = class AccountsActivityActionViewItem extend
                     if (account.canSignOut) {
                         providerSubMenuActions.push(toAction({
                             id: "signOut",
-                            label: ( localize(3525, "Sign Out")),
+                            label: ( localize(3580, "Sign Out")),
                             enabled: true,
                             run: () => this.commandService.executeCommand("_signOutOfAccount", {
                                 providerId,
@@ -598,7 +599,7 @@ let GlobalActivityActionViewItem = class GlobalActivityActionViewItem extends Ab
     ) {
         const action = instantiationService.createInstance(CompositeBarAction, {
             id: GLOBAL_ACTIVITY_ID,
-            name: ( localize(3519, "Manage")),
+            name: ( localize(3574, "Manage")),
             classNames: ThemeIcon.asClassNameArray(
                 userDataProfileService.currentProfile.icon ? ThemeIcon.fromId(userDataProfileService.currentProfile.icon) : DEFAULT_ICON
             )
@@ -660,7 +661,7 @@ let GlobalActivityActionViewItem = class GlobalActivityActionViewItem extends Ab
     }
     computeTitle() {
         return this.userDataProfileService.currentProfile.isDefault ? super.computeTitle() : ( localize(
-            3527,
+            3582,
             "Manage {0} (Profile)",
             this.userDataProfileService.currentProfile.name
         ));
@@ -735,18 +736,18 @@ function simpleActivityContextMenuActions(storageService, isAccount) {
     if (isAccount) {
         currentElementContextMenuActions.push(toAction({
             id: "hideAccounts",
-            label: ( localize(3518, "Hide Accounts")),
+            label: ( localize(3573, "Hide Accounts")),
             run: () => setAccountsActionVisible(storageService, false)
         }), ( new Separator()));
     }
     return [...currentElementContextMenuActions, toAction({
         id: "toggle.hideAccounts",
-        label: ( localize(3520, "Accounts")),
+        label: ( localize(3575, "Accounts")),
         checked: isAccountsActionVisible(storageService),
         run: () => setAccountsActionVisible(storageService, !isAccountsActionVisible(storageService))
     }), toAction({
         id: "toggle.hideManage",
-        label: ( localize(3519, "Manage")),
+        label: ( localize(3574, "Manage")),
         checked: true,
         enabled: false,
         run: () => {