@codingame/monaco-vscode-api 11.1.0 → 11.1.2

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalEditorInput.js

@@ -0,0 +1,200 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localize } from '../../../../nls.js';
+import Severity$1 from '../../../../base/common/severity.js';
+import { toDisposable, dispose } from '../../../../base/common/lifecycle.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.service.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { EditorInput } from '../../../common/editor/editorInput.js';
+import { terminalEditorId } from './terminal.js';
+import { ITerminalInstanceService } from './terminal.service.js';
+import { getColorClass, getUriClasses } from './terminalIcon.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { TerminalLocation, TerminalExitReason } from '../../../../platform/terminal/common/terminal.js';
+import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.service.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { TerminalContextKeys } from '../common/terminalContextKey.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.service.js';
+import { Emitter } from '../../../../base/common/event.js';
+
+var TerminalEditorInput_1;
+let TerminalEditorInput = class TerminalEditorInput extends EditorInput {
+    static { TerminalEditorInput_1 = this; }
+    static { this.ID = 'workbench.editors.terminal'; }
+    setGroup(group) {
+        this._group = group;
+        if (group?.scopedContextKeyService) {
+            this._terminalInstance?.setParentContextKeyService(group.scopedContextKeyService);
+        }
+    }
+    get group() {
+        return this._group;
+    }
+    get typeId() {
+        return TerminalEditorInput_1.ID;
+    }
+    get editorId() {
+        return terminalEditorId;
+    }
+    get capabilities() {
+        return 2  | 8  | 128  | 64 ;
+    }
+    setTerminalInstance(instance) {
+        if (this._terminalInstance) {
+            throw ( (new Error('cannot set instance that has already been set')));
+        }
+        this._terminalInstance = instance;
+        this._setupInstanceListeners();
+    }
+    copy() {
+        const instance = this._terminalInstanceService.createInstance(this._copyLaunchConfig || {}, TerminalLocation.Editor);
+        instance.focusWhenReady();
+        this._copyLaunchConfig = undefined;
+        return this._instantiationService.createInstance(TerminalEditorInput_1, instance.resource, instance);
+    }
+    setCopyLaunchConfig(launchConfig) {
+        this._copyLaunchConfig = launchConfig;
+    }
+    get terminalInstance() {
+        return this._isDetached ? undefined : this._terminalInstance;
+    }
+    showConfirm() {
+        if (this._isReverted) {
+            return false;
+        }
+        const confirmOnKill = this._configurationService.getValue("terminal.integrated.confirmOnKill" );
+        if (confirmOnKill === 'editor' || confirmOnKill === 'always') {
+            return this._terminalInstance?.hasChildProcesses || false;
+        }
+        return false;
+    }
+    async confirm(terminals) {
+        const { confirmed } = await this._dialogService.confirm({
+            type: Severity$1.Warning,
+            message: ( localize(9092, "Do you want to terminate running processes?")),
+            primaryButton: ( localize(9093, "&&Terminate")),
+            detail: terminals.length > 1 ?
+                ( (terminals.map(terminal => terminal.editor.getName()))).join('\n') + '\n\n' + ( localize(9094, "Closing will terminate the running processes in the terminals.")) :
+                ( localize(9095, "Closing will terminate the running processes in this terminal."))
+        });
+        return confirmed ? 1  : 2 ;
+    }
+    async revert() {
+        this._isReverted = true;
+    }
+    constructor(resource, _terminalInstance, _themeService, _terminalInstanceService, _instantiationService, _configurationService, _lifecycleService, _contextKeyService, _dialogService) {
+        super();
+        this.resource = resource;
+        this._terminalInstance = _terminalInstance;
+        this._themeService = _themeService;
+        this._terminalInstanceService = _terminalInstanceService;
+        this._instantiationService = _instantiationService;
+        this._configurationService = _configurationService;
+        this._lifecycleService = _lifecycleService;
+        this._contextKeyService = _contextKeyService;
+        this._dialogService = _dialogService;
+        this.closeHandler = this;
+        this._isDetached = false;
+        this._isShuttingDown = false;
+        this._isReverted = false;
+        this._onDidRequestAttach = this._register(( (new Emitter())));
+        this.onDidRequestAttach = this._onDidRequestAttach.event;
+        this._terminalEditorFocusContextKey = TerminalContextKeys.editorFocus.bindTo(_contextKeyService);
+        if (_terminalInstance) {
+            this._setupInstanceListeners();
+        }
+    }
+    _setupInstanceListeners() {
+        const instance = this._terminalInstance;
+        if (!instance) {
+            return;
+        }
+        const instanceOnDidFocusListener = instance.onDidFocus(() => this._terminalEditorFocusContextKey.set(true));
+        const instanceOnDidBlurListener = instance.onDidBlur(() => this._terminalEditorFocusContextKey.reset());
+        this._register(toDisposable(() => {
+            if (!this._isDetached && !this._isShuttingDown) {
+                instance.dispose(TerminalExitReason.User);
+            }
+            dispose([instanceOnDidFocusListener, instanceOnDidBlurListener]);
+        }));
+        const disposeListeners = [
+            instance.onExit((e) => {
+                if (!instance.waitOnExit) {
+                    this.dispose();
+                }
+            }),
+            instance.onDisposed(() => this.dispose()),
+            instance.onTitleChanged(() => this._onDidChangeLabel.fire()),
+            instance.onIconChanged(() => this._onDidChangeLabel.fire()),
+            instanceOnDidFocusListener,
+            instanceOnDidBlurListener,
+            instance.statusList.onDidChangePrimaryStatus(() => this._onDidChangeLabel.fire())
+        ];
+        this._lifecycleService.onWillShutdown((e) => {
+            this._isShuttingDown = true;
+            dispose(disposeListeners);
+            const shouldPersistTerminals = this._configurationService.getValue("terminal.integrated.enablePersistentSessions" ) && e.reason === 3 ;
+            if (shouldPersistTerminals) {
+                instance.detachProcessAndDispose(TerminalExitReason.Shutdown);
+            }
+            else {
+                instance.dispose(TerminalExitReason.Shutdown);
+            }
+        });
+    }
+    getName() {
+        return this._terminalInstance?.title || this.resource.fragment;
+    }
+    getIcon() {
+        if (!this._terminalInstance || !ThemeIcon.isThemeIcon(this._terminalInstance.icon)) {
+            return undefined;
+        }
+        return this._terminalInstance.icon;
+    }
+    getLabelExtraClasses() {
+        if (!this._terminalInstance) {
+            return [];
+        }
+        const extraClasses = ['terminal-tab', 'predefined-file-icon'];
+        const colorClass = getColorClass(this._terminalInstance);
+        if (colorClass) {
+            extraClasses.push(colorClass);
+        }
+        const uriClasses = getUriClasses(this._terminalInstance, this._themeService.getColorTheme().type);
+        if (uriClasses) {
+            extraClasses.push(...uriClasses);
+        }
+        return extraClasses;
+    }
+    detachInstance() {
+        if (!this._isShuttingDown) {
+            this._terminalInstance?.detachFromElement();
+            this._terminalInstance?.setParentContextKeyService(this._contextKeyService);
+            this._isDetached = true;
+        }
+    }
+    getDescription() {
+        return this._terminalInstance?.description;
+    }
+    toUntyped() {
+        return {
+            resource: this.resource,
+            options: {
+                override: terminalEditorId,
+                pinned: true,
+                forceReload: true
+            }
+        };
+    }
+};
+TerminalEditorInput = TerminalEditorInput_1 = ( (__decorate([
+    ( (__param(2, IThemeService))),
+    ( (__param(3, ITerminalInstanceService))),
+    ( (__param(4, IInstantiationService))),
+    ( (__param(5, IConfigurationService))),
+    ( (__param(6, ILifecycleService))),
+    ( (__param(7, IContextKeyService))),
+    ( (__param(8, IDialogService)))
+], TerminalEditorInput)));
+
+export { TerminalEditorInput };

package/vscode/src/vs/workbench/contrib/terminal/common/terminalColorRegistry.js

@@ -15,7 +15,7 @@ import { PANEL_BORDER, EDITOR_DRAG_AND_DROP_BACKGROUND, TAB_ACTIVE_BORDER } from
 
 const ansiColorIdentifiers = [];
 const TERMINAL_BACKGROUND_COLOR = registerColor('terminal.background', null, ( localize(
-    9378,
+    9287,
     'The background color of the terminal, this allows coloring the terminal differently to the panel.'
 )));
 const TERMINAL_FOREGROUND_COLOR = registerColor('terminal.foreground', {
@@ -23,20 +23,20 @@ const TERMINAL_FOREGROUND_COLOR = registerColor('terminal.foreground', {
     dark: '#CCCCCC',
     hcDark: '#FFFFFF',
     hcLight: '#292929'
-}, ( localize(9379, 'The foreground color of the terminal.')));
-const TERMINAL_CURSOR_FOREGROUND_COLOR = registerColor('terminalCursor.foreground', null, ( localize(9380, 'The foreground color of the terminal cursor.')));
+}, ( localize(9288, 'The foreground color of the terminal.')));
+const TERMINAL_CURSOR_FOREGROUND_COLOR = registerColor('terminalCursor.foreground', null, ( localize(9289, 'The foreground color of the terminal cursor.')));
 const TERMINAL_CURSOR_BACKGROUND_COLOR = registerColor('terminalCursor.background', null, ( localize(
-    9381,
+    9290,
     'The background color of the terminal cursor. Allows customizing the color of a character overlapped by a block cursor.'
 )));
-const TERMINAL_SELECTION_BACKGROUND_COLOR = registerColor('terminal.selectionBackground', editorSelectionBackground, ( localize(9382, 'The selection background color of the terminal.')));
+const TERMINAL_SELECTION_BACKGROUND_COLOR = registerColor('terminal.selectionBackground', editorSelectionBackground, ( localize(9291, 'The selection background color of the terminal.')));
 const TERMINAL_INACTIVE_SELECTION_BACKGROUND_COLOR = registerColor('terminal.inactiveSelectionBackground', {
     light: ( (transparent(TERMINAL_SELECTION_BACKGROUND_COLOR, 0.5))),
     dark: ( (transparent(TERMINAL_SELECTION_BACKGROUND_COLOR, 0.5))),
     hcDark: ( (transparent(TERMINAL_SELECTION_BACKGROUND_COLOR, 0.7))),
     hcLight: ( (transparent(TERMINAL_SELECTION_BACKGROUND_COLOR, 0.5)))
 }, ( localize(
-    9383,
+    9292,
     'The selection background color of the terminal when it does not have focus.'
 )));
 const TERMINAL_SELECTION_FOREGROUND_COLOR = registerColor('terminal.selectionForeground', {
@@ -45,7 +45,7 @@ const TERMINAL_SELECTION_FOREGROUND_COLOR = registerColor('terminal.selectionFor
     hcDark: '#000000',
     hcLight: '#ffffff'
 }, ( localize(
-    9384,
+    9293,
     'The selection foreground color of the terminal. When this is null the selection foreground will be retained and have the minimum contrast ratio feature applied.'
 )));
 const TERMINAL_COMMAND_DECORATION_DEFAULT_BACKGROUND_COLOR = registerColor('terminalCommandDecoration.defaultBackground', {
@@ -53,14 +53,14 @@ const TERMINAL_COMMAND_DECORATION_DEFAULT_BACKGROUND_COLOR = registerColor('term
     dark: '#ffffff40',
     hcDark: '#ffffff80',
     hcLight: '#00000040',
-}, ( localize(9385, 'The default terminal command decoration background color.')));
+}, ( localize(9294, 'The default terminal command decoration background color.')));
 const TERMINAL_COMMAND_DECORATION_SUCCESS_BACKGROUND_COLOR = registerColor('terminalCommandDecoration.successBackground', {
     dark: '#1B81A8',
     light: '#2090D3',
     hcDark: '#1B81A8',
     hcLight: '#007100'
 }, ( localize(
-    9386,
+    9295,
     'The terminal command decoration background color for successful commands.'
 )));
 const TERMINAL_COMMAND_DECORATION_ERROR_BACKGROUND_COLOR = registerColor('terminalCommandDecoration.errorBackground', {
@@ -69,38 +69,38 @@ const TERMINAL_COMMAND_DECORATION_ERROR_BACKGROUND_COLOR = registerColor('termin
     hcDark: '#F14C4C',
     hcLight: '#B5200D'
 }, ( localize(
-    9387,
+    9296,
     'The terminal command decoration background color for error commands.'
 )));
-const TERMINAL_OVERVIEW_RULER_CURSOR_FOREGROUND_COLOR = registerColor('terminalOverviewRuler.cursorForeground', '#A0A0A0CC', ( localize(9388, 'The overview ruler cursor color.')));
+const TERMINAL_OVERVIEW_RULER_CURSOR_FOREGROUND_COLOR = registerColor('terminalOverviewRuler.cursorForeground', '#A0A0A0CC', ( localize(9297, 'The overview ruler cursor color.')));
 registerColor('terminal.border', PANEL_BORDER, ( localize(
-    9389,
+    9298,
     'The color of the border that separates split panes within the terminal. This defaults to panel.border.'
 )));
-const TERMINAL_OVERVIEW_RULER_BORDER_COLOR = registerColor('terminalOverviewRuler.border', editorOverviewRulerBorder, ( localize(9390, 'The overview ruler left-side border color.')));
+const TERMINAL_OVERVIEW_RULER_BORDER_COLOR = registerColor('terminalOverviewRuler.border', editorOverviewRulerBorder, ( localize(9299, 'The overview ruler left-side border color.')));
 const TERMINAL_FIND_MATCH_BACKGROUND_COLOR = registerColor('terminal.findMatchBackground', {
     dark: editorFindMatch,
     light: editorFindMatch,
     hcDark: null,
     hcLight: '#0F4A85'
 }, ( localize(
-    9391,
+    9300,
     'Color of the current search match in the terminal. The color must not be opaque so as not to hide underlying terminal content.'
 )), true);
-registerColor('terminal.hoverHighlightBackground', ( (transparent(editorHoverHighlight, 0.5))), ( localize(9392, 'Border color of the other search matches in the terminal.')));
+registerColor('terminal.hoverHighlightBackground', ( (transparent(editorHoverHighlight, 0.5))), ( localize(9301, 'Border color of the other search matches in the terminal.')));
 const TERMINAL_FIND_MATCH_BORDER_COLOR = registerColor('terminal.findMatchBorder', {
     dark: null,
     light: null,
     hcDark: '#f38518',
     hcLight: '#0F4A85'
-}, ( localize(9393, 'Border color of the current search match in the terminal.')));
+}, ( localize(9302, 'Border color of the current search match in the terminal.')));
 const TERMINAL_FIND_MATCH_HIGHLIGHT_BACKGROUND_COLOR = registerColor('terminal.findMatchHighlightBackground', {
     dark: editorFindMatchHighlight,
     light: editorFindMatchHighlight,
     hcDark: null,
     hcLight: null
 }, ( localize(
-    9394,
+    9303,
     'Color of the other search matches in the terminal. The color must not be opaque so as not to hide underlying terminal content.'
 )), true);
 const TERMINAL_FIND_MATCH_HIGHLIGHT_BORDER_COLOR = registerColor('terminal.findMatchHighlightBorder', {
@@ -108,19 +108,19 @@ const TERMINAL_FIND_MATCH_HIGHLIGHT_BORDER_COLOR = registerColor('terminal.findM
     light: null,
     hcDark: '#f38518',
     hcLight: '#0F4A85'
-}, ( localize(9392, 'Border color of the other search matches in the terminal.')));
+}, ( localize(9301, 'Border color of the other search matches in the terminal.')));
 const TERMINAL_OVERVIEW_RULER_FIND_MATCH_FOREGROUND_COLOR = registerColor('terminalOverviewRuler.findMatchForeground', {
     dark: overviewRulerFindMatchForeground,
     light: overviewRulerFindMatchForeground,
     hcDark: '#f38518',
     hcLight: '#0F4A85'
-}, ( localize(9395, 'Overview ruler marker color for find matches in the terminal.')));
+}, ( localize(9304, 'Overview ruler marker color for find matches in the terminal.')));
 registerColor('terminal.dropBackground', EDITOR_DRAG_AND_DROP_BACKGROUND, ( localize(
-    9396,
+    9305,
     "Background color when dragging on top of terminals. The color should have transparency so that the terminal contents can still shine through."
 )), true);
 registerColor('terminal.tab.activeBorder', TAB_ACTIVE_BORDER, ( localize(
-    9397,
+    9306,
     'Border on the side of the terminal tab in the panel. This defaults to tab.activeBorder.'
 )));
 registerColor('terminal.initialHintForeground', {
@@ -128,7 +128,7 @@ registerColor('terminal.initialHintForeground', {
     light: '#0007',
     hcDark: null,
     hcLight: null
-}, ( localize(9398, 'Foreground color of the terminal initial hint.')));
+}, ( localize(9307, 'Foreground color of the terminal initial hint.')));
 const ansiColorMap = {
     'terminal.ansiBlack': {
         index: 0,
@@ -279,7 +279,7 @@ function registerColors() {
     for (const id in ansiColorMap) {
         const entry = ansiColorMap[id];
         const colorName = id.substring(13);
-        ansiColorIdentifiers[entry.index] = registerColor(id, entry.defaults, ( localize(9399, '\'{0}\' ANSI color in the terminal.', colorName)));
+        ansiColorIdentifiers[entry.index] = registerColor(id, entry.defaults, ( localize(9308, '\'{0}\' ANSI color in the terminal.', colorName)));
     }
 }
 

package/vscode/src/vs/workbench/contrib/terminal/common/terminalContextKey.js

@@ -0,0 +1,170 @@
+import { localize } from '../../../../nls.js';
+import { RawContextKey, ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { TERMINAL_VIEW_ID } from '@codingame/monaco-vscode-chat-extensions-notebook-task-terminal-testing-common/vscode/vs/workbench/contrib/terminal/common/terminal';
+
+var TerminalContextKeys;
+( ((function(TerminalContextKeys) {
+    TerminalContextKeys.isOpen = ( (new RawContextKey("terminalIsOpen" , false, true)));
+    TerminalContextKeys.focus = ( (new RawContextKey(
+        "terminalFocus" ,
+        false,
+        ( localize(9114, "Whether the terminal is focused."))
+    )));
+    TerminalContextKeys.focusInAny = ( (new RawContextKey(
+        "terminalFocusInAny" ,
+        false,
+        ( localize(
+            9115,
+            "Whether any terminal is focused, including detached terminals used in other UI."
+        ))
+    )));
+    TerminalContextKeys.editorFocus = ( (new RawContextKey(
+        "terminalEditorFocus" ,
+        false,
+        ( localize(9116, "Whether a terminal in the editor area is focused."))
+    )));
+    TerminalContextKeys.count = ( (new RawContextKey("terminalCount" , 0, ( localize(9117, "The current number of terminals.")))));
+    TerminalContextKeys.groupCount = ( (new RawContextKey("terminalGroupCount" , 0, true)));
+    TerminalContextKeys.tabsNarrow = ( (new RawContextKey(
+        "isTerminalTabsNarrow" ,
+        false,
+        true
+    )));
+    TerminalContextKeys.terminalHasFixedWidth = ( (new RawContextKey(
+        "terminalHasFixedWidth" ,
+        false,
+        true
+    )));
+    TerminalContextKeys.tabsFocus = ( (new RawContextKey(
+        "terminalTabsFocus" ,
+        false,
+        ( localize(9118, "Whether the terminal tabs widget is focused."))
+    )));
+    TerminalContextKeys.webExtensionContributedProfile = ( (new RawContextKey(
+        "terminalWebExtensionContributedProfile" ,
+        false,
+        true
+    )));
+    TerminalContextKeys.terminalHasBeenCreated = ( (new RawContextKey(
+        "terminalHasBeenCreated" ,
+        false,
+        true
+    )));
+    TerminalContextKeys.terminalEditorActive = ( (new RawContextKey(
+        "terminalEditorActive" ,
+        false,
+        true
+    )));
+    TerminalContextKeys.tabsMouse = ( (new RawContextKey("terminalTabsMouse" , false, true)));
+    TerminalContextKeys.shellType = ( (new RawContextKey(
+        "terminalShellType" ,
+        undefined,
+        { type: 'string', description: ( localize(
+            9119,
+            "The shell type of the active terminal, this is set if the type can be detected."
+        )) }
+    )));
+    TerminalContextKeys.altBufferActive = ( (new RawContextKey(
+        "terminalAltBufferActive" ,
+        false,
+        ( localize(9120, "Whether the terminal's alt buffer is active."))
+    )));
+    TerminalContextKeys.suggestWidgetVisible = ( (new RawContextKey(
+        "terminalSuggestWidgetVisible" ,
+        false,
+        ( localize(9121, "Whether the terminal's suggest widget is visible."))
+    )));
+    TerminalContextKeys.notFocus = ( (TerminalContextKeys.focus.toNegated()));
+    TerminalContextKeys.viewShowing = ( (new RawContextKey(
+        "terminalViewShowing" ,
+        false,
+        ( localize(9122, "Whether the terminal view is showing"))
+    )));
+    TerminalContextKeys.textSelected = ( (new RawContextKey(
+        "terminalTextSelected" ,
+        false,
+        ( localize(9123, "Whether text is selected in the active terminal."))
+    )));
+    TerminalContextKeys.textSelectedInFocused = ( (new RawContextKey(
+        "terminalTextSelectedInFocused" ,
+        false,
+        ( localize(9124, "Whether text is selected in a focused terminal."))
+    )));
+    TerminalContextKeys.notTextSelected = ( (TerminalContextKeys.textSelected.toNegated()));
+    TerminalContextKeys.findVisible = ( (new RawContextKey(
+        "terminalFindVisible" ,
+        false,
+        true
+    )));
+    TerminalContextKeys.notFindVisible = ( (TerminalContextKeys.findVisible.toNegated()));
+    TerminalContextKeys.findInputFocus = ( (new RawContextKey(
+        "terminalFindInputFocused" ,
+        false,
+        true
+    )));
+    TerminalContextKeys.findFocus = ( (new RawContextKey(
+        "terminalFindFocused" ,
+        false,
+        true
+    )));
+    TerminalContextKeys.notFindFocus = ( (TerminalContextKeys.findInputFocus.toNegated()));
+    TerminalContextKeys.processSupported = ( (new RawContextKey(
+        "terminalProcessSupported" ,
+        false,
+        ( localize(
+            9125,
+            "Whether terminal processes can be launched in the current workspace."
+        ))
+    )));
+    TerminalContextKeys.tabsSingularSelection = ( (new RawContextKey(
+        "terminalTabsSingularSelection" ,
+        false,
+        ( localize(9126, "Whether one terminal is selected in the terminal tabs list."))
+    )));
+    TerminalContextKeys.splitTerminal = ( (new RawContextKey(
+        "terminalSplitTerminal" ,
+        false,
+        ( localize(9127, "Whether the focused tab's terminal is a split terminal."))
+    )));
+    TerminalContextKeys.inTerminalRunCommandPicker = ( (new RawContextKey(
+        "inTerminalRunCommandPicker" ,
+        false,
+        ( localize(9128, "Whether the terminal run command picker is currently open."))
+    )));
+    TerminalContextKeys.terminalShellIntegrationEnabled = ( (new RawContextKey(
+        "terminalShellIntegrationEnabled" ,
+        false,
+        ( localize(9129, "Whether shell integration is enabled in the active terminal"))
+    )));
+    TerminalContextKeys.shouldShowViewInlineActions = ( (ContextKeyExpr.and(
+         (ContextKeyExpr.equals('view', TERMINAL_VIEW_ID)),
+         (ContextKeyExpr.notEquals(
+            `config.${"terminal.integrated.tabs.hideCondition" }`,
+            'never'
+        )),
+         (ContextKeyExpr.or(
+            ContextKeyExpr.not(`config.${"terminal.integrated.tabs.enabled" }`),
+             (ContextKeyExpr.and( (ContextKeyExpr.equals(
+                `config.${"terminal.integrated.tabs.showActions" }`,
+                'singleTerminal'
+            )),  (ContextKeyExpr.equals("terminalGroupCount", 1)))),
+             (ContextKeyExpr.and( (ContextKeyExpr.equals(
+                `config.${"terminal.integrated.tabs.showActions" }`,
+                'singleTerminalOrNarrow'
+            )),  (ContextKeyExpr.or(
+                 (ContextKeyExpr.equals("terminalGroupCount", 1)),
+                 (ContextKeyExpr.has("isTerminalTabsNarrow" ))
+            )))),
+             (ContextKeyExpr.and( (ContextKeyExpr.equals(
+                `config.${"terminal.integrated.tabs.showActions" }`,
+                'singleGroup'
+            )),  (ContextKeyExpr.equals("terminalGroupCount", 1)))),
+             (ContextKeyExpr.equals(
+                `config.${"terminal.integrated.tabs.showActions" }`,
+                'always'
+            ))
+        ))
+    )));
+})(TerminalContextKeys || (TerminalContextKeys = {}))));
+
+export { TerminalContextKeys };

package/vscode/src/vs/workbench/contrib/url/browser/trustedDomains.js

@@ -11,7 +11,7 @@ const TRUSTED_DOMAINS_CONTENT_STORAGE_KEY = 'http.linkProtectionTrustedDomainsCo
 const manageTrustedDomainSettingsCommand = {
     id: 'workbench.action.manageTrustedDomain',
     description: {
-        description: ( localize2(4665, 'Manage Trusted Domains')),
+        description: ( localize2(4786, 'Manage Trusted Domains')),
         args: []
     },
     handler: async (accessor) => {
@@ -28,7 +28,7 @@ async function configureOpenerTrustedDomainsHandler(trustedDomains, domainToConf
     const options = [];
     options.push({
         type: 'item',
-        label: ( localize(4666, 'Trust {0}', domainToConfigure)),
+        label: ( localize(4787, 'Trust {0}', domainToConfigure)),
         id: 'trust',
         toTrust: domainToConfigure,
         picked: true
@@ -40,7 +40,7 @@ async function configureOpenerTrustedDomainsHandler(trustedDomains, domainToConf
             const base = parsedDomainToConfigure.authority.split(':')[0];
             options.push({
                 type: 'item',
-                label: ( localize(4667, 'Trust {0} on all ports', base)),
+                label: ( localize(4788, 'Trust {0} on all ports', base)),
                 toTrust: base + ':*',
                 id: 'trust'
             });
@@ -49,20 +49,20 @@ async function configureOpenerTrustedDomainsHandler(trustedDomains, domainToConf
     else {
         options.push({
             type: 'item',
-            label: ( localize(4668, 'Trust {0} and all its subdomains', domainEnd)),
+            label: ( localize(4789, 'Trust {0} and all its subdomains', domainEnd)),
             toTrust: topLevelDomain,
             id: 'trust'
         });
     }
     options.push({
         type: 'item',
-        label: ( localize(4669, 'Trust all domains (disables link protection)')),
+        label: ( localize(4790, 'Trust all domains (disables link protection)')),
         toTrust: '*',
         id: 'trust'
     });
     options.push({
         type: 'item',
-        label: ( localize(4670, 'Manage Trusted Domains')),
+        label: ( localize(4791, 'Manage Trusted Domains')),
         id: 'manage'
     });
     const pickedResult = await quickInputService.pick(options, { activeItem: options[0] });

package/vscode/src/vs/workbench/contrib/webview/browser/webview.contribution.js

@@ -38,7 +38,7 @@ if (CutAction) {
     MenuRegistry.appendMenuItem(MenuId.WebviewContext, {
         command: {
             id: CutAction.id,
-            title: ( localize(4454, "Cut")),
+            title: ( localize(4441, "Cut")),
         },
         group: '5_cutcopypaste',
         order: 1,
@@ -49,7 +49,7 @@ if (CopyAction) {
     MenuRegistry.appendMenuItem(MenuId.WebviewContext, {
         command: {
             id: CopyAction.id,
-            title: ( localize(4455, "Copy")),
+            title: ( localize(4442, "Copy")),
         },
         group: '5_cutcopypaste',
         order: 2,
@@ -60,7 +60,7 @@ if (PasteAction) {
     MenuRegistry.appendMenuItem(MenuId.WebviewContext, {
         command: {
             id: PasteAction.id,
-            title: ( localize(4456, "Paste")),
+            title: ( localize(4443, "Paste")),
         },
         group: '5_cutcopypaste',
         order: 3,

package/vscode/src/vs/workbench/contrib/workspace/common/workspace.js

@@ -2,8 +2,8 @@ import { localize } from '../../../../nls.js';
 import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
 
 const WorkspaceTrustContext = {
-    IsEnabled: ( (new RawContextKey('isWorkspaceTrustEnabled', false, ( localize(6371, "Whether the workspace trust feature is enabled."))))),
-    IsTrusted: ( (new RawContextKey('isWorkspaceTrusted', false, ( localize(6372, "Whether the current workspace has been trusted by the user.")))))
+    IsEnabled: ( (new RawContextKey('isWorkspaceTrustEnabled', false, ( localize(6606, "Whether the workspace trust feature is enabled."))))),
+    IsTrusted: ( (new RawContextKey('isWorkspaceTrusted', false, ( localize(6607, "Whether the current workspace has been trusted by the user.")))))
 };
 const MANAGE_TRUST_COMMAND_ID = 'workbench.trust.manage';
 

package/vscode/src/vs/workbench/services/activity/common/activity.js

@@ -45,9 +45,9 @@ class WarningBadge extends IconBadge {
         }));
     }
 }
-const activityWarningBadgeForeground = registerColor('activityWarningBadge.foreground', { dark: ( (Color.black.lighten(0.2))), light: Color.white, hcDark: null, hcLight: ( (Color.black.lighten(0.2))) }, ( localize(5348, 'Foreground color of the warning activity badge')));
-const activityWarningBadgeBackground = registerColor('activityWarningBadge.background', { dark: '#CCA700', light: '#BF8803', hcDark: null, hcLight: '#CCA700' }, ( localize(5349, 'Background color of the warning activity badge')));
-registerColor('activityErrorBadge.foreground', { dark: ( (Color.black.lighten(0.2))), light: Color.white, hcDark: null, hcLight: ( (Color.black.lighten(0.2))) }, ( localize(5350, 'Foreground color of the error activity badge')));
-registerColor('activityErrorBadge.background', { dark: '#F14C4C', light: '#E51400', hcDark: null, hcLight: '#F14C4C' }, ( localize(5351, 'Background color of the error activity badge')));
+const activityWarningBadgeForeground = registerColor('activityWarningBadge.foreground', { dark: ( (Color.black.lighten(0.2))), light: Color.white, hcDark: null, hcLight: ( (Color.black.lighten(0.2))) }, ( localize(5319, 'Foreground color of the warning activity badge')));
+const activityWarningBadgeBackground = registerColor('activityWarningBadge.background', { dark: '#CCA700', light: '#BF8803', hcDark: null, hcLight: '#CCA700' }, ( localize(5320, 'Background color of the warning activity badge')));
+registerColor('activityErrorBadge.foreground', { dark: ( (Color.black.lighten(0.2))), light: Color.white, hcDark: null, hcLight: ( (Color.black.lighten(0.2))) }, ( localize(5321, 'Foreground color of the error activity badge')));
+registerColor('activityErrorBadge.background', { dark: '#F14C4C', light: '#E51400', hcDark: null, hcLight: '#F14C4C' }, ( localize(5322, 'Background color of the error activity badge')));
 
 export { IconBadge, NumberBadge, ProgressBadge, WarningBadge };

package/vscode/src/vs/workbench/services/authentication/browser/authenticationService.js

@@ -70,14 +70,14 @@ let AuthenticationService = class AuthenticationService extends Disposable {
     }
     registerDeclaredAuthenticationProvider(provider) {
         if (isFalsyOrWhitespace(provider.id)) {
-            throw ( new Error(localize(2154, 'An authentication contribution must specify an id.')));
+            throw ( new Error(localize(2247, 'An authentication contribution must specify an id.')));
         }
         if (isFalsyOrWhitespace(provider.label)) {
-            throw ( new Error(localize(2155, 'An authentication contribution must specify a label.')));
+            throw ( new Error(localize(2248, 'An authentication contribution must specify a label.')));
         }
         if (( this.declaredProviders.some(p => p.id === provider.id))) {
             throw ( new Error(localize(
-                2156,
+                2249,
                 "This authentication id '{0}' has already been registered",
                 provider.id
             )));