@codingame/monaco-vscode-api 11.1.0 → 11.1.1

package/vscode/src/vs/workbench/contrib/tasks/common/taskService.js

@@ -2,19 +2,19 @@ import { localize } from '../../../../nls.js';
 import { RawContextKey, ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
 
 const CustomExecutionSupportedContext = ( (new RawContextKey('customExecutionSupported', false, ( localize(
-  6564,
+  6499,
   "Whether CustomExecution tasks are supported. Consider using in the when clause of a \'taskDefinition\' contribution."
 )))));
 const ShellExecutionSupportedContext = ( (new RawContextKey('shellExecutionSupported', false, ( localize(
-  6565,
+  6500,
   "Whether ShellExecution tasks are supported. Consider using in the when clause of a \'taskDefinition\' contribution."
 )))));
-const TaskCommandsRegistered = ( (new RawContextKey('taskCommandsRegistered', false, ( localize(6566, "Whether the task commands have been registered yet")))));
+const TaskCommandsRegistered = ( (new RawContextKey('taskCommandsRegistered', false, ( localize(6501, "Whether the task commands have been registered yet")))));
 const ProcessExecutionSupportedContext = ( (new RawContextKey('processExecutionSupported', false, ( localize(
-  6567,
+  6502,
   "Whether ProcessExecution tasks are supported. Consider using in the when clause of a \'taskDefinition\' contribution."
 )))));
-const ServerlessWebContext = ( (new RawContextKey('serverlessWebContext', false, ( localize(6568, "True when in the web with no remote authority.")))));
+const ServerlessWebContext = ( (new RawContextKey('serverlessWebContext', false, ( localize(6503, "True when in the web with no remote authority.")))));
 const TaskExecutionSupportedContext = ( (ContextKeyExpr.or(
    (ContextKeyExpr.and(ShellExecutionSupportedContext, ProcessExecutionSupportedContext)),
   CustomExecutionSupportedContext

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

@@ -6,8 +6,8 @@ import { RawContextKey } from '../../../../platform/contextkey/common/contextkey
 import { TaskDefinitionRegistry } from './taskDefinitionRegistry.js';
 
 const USER_TASKS_GROUP_KEY = 'settings';
-const TASK_RUNNING_STATE = ( (new RawContextKey('taskRunning', false, ( localize(3866, "Whether a task is currently running.")))));
-const TASKS_CATEGORY = ( localize2(3867, "Tasks"));
+const TASK_RUNNING_STATE = ( (new RawContextKey('taskRunning', false, ( localize(4649, "Whether a task is currently running.")))));
+const TASKS_CATEGORY = ( localize2(4650, "Tasks"));
 var ShellQuoting;
 ( ((function(ShellQuoting) {
     ShellQuoting[ShellQuoting["Escape"] = 1] = "Escape";
@@ -705,7 +705,7 @@ var TaskDefinition;
                             break;
                         default:
                             reporter.error(( localize(
-                                3868,
+                                4651,
                                 'Error: the task identifier \'{0}\' is missing the required property \'{1}\'. The task identifier will be ignored.',
                                 JSON.stringify(external, undefined, 0),
                                 property

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

@@ -5,9 +5,9 @@ import { onUnexpectedError } from '../../../../base/common/errors.js';
 import { Disposable } from '../../../../base/common/lifecycle.js';
 import { MicrotaskDelay } from '../../../../base/common/symbols.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-import { TerminalCapabilityStore } from '@codingame/monaco-vscode-chat-extensions-notebook-terminal-testing-common/vscode/vs/platform/terminal/common/capabilities/terminalCapabilityStore';
-import { TerminalExtensionsRegistry } from '@codingame/monaco-vscode-chat-extensions-notebook-terminal-testing-common/vscode/vs/workbench/contrib/terminal/browser/terminalExtensions';
-import { TerminalWidgetManager } from '@codingame/monaco-vscode-chat-extensions-notebook-terminal-testing-common/vscode/vs/workbench/contrib/terminal/browser/widgets/widgetManager';
+import { TerminalCapabilityStore } from '@codingame/monaco-vscode-chat-notebook-terminal-testing-common/vscode/vs/platform/terminal/common/capabilities/terminalCapabilityStore';
+import { TerminalExtensionsRegistry } from '@codingame/monaco-vscode-chat-notebook-terminal-testing-common/vscode/vs/workbench/contrib/terminal/browser/terminalExtensions';
+import { TerminalWidgetManager } from '@codingame/monaco-vscode-chat-notebook-terminal-testing-common/vscode/vs/workbench/contrib/terminal/browser/widgets/widgetManager';
 
 let DetachedTerminal = class DetachedTerminal extends Disposable {
     get xterm() {

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

@@ -0,0 +1,6 @@
+const isDetachedTerminalInstance = (t) => typeof t.instanceId !== 'number';
+class TerminalLinkQuickPickEvent extends MouseEvent {
+}
+const terminalEditorId = 'terminalEditor';
+
+export { TerminalLinkQuickPickEvent, isDetachedTerminalInstance, terminalEditorId };

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(8996, "Do you want to terminate running processes?")),
+            primaryButton: ( localize(8997, "&&Terminate")),
+            detail: terminals.length > 1 ?
+                ( (terminals.map(terminal => terminal.editor.getName()))).join('\n') + '\n\n' + ( localize(8998, "Closing will terminate the running processes in the terminals.")) :
+                ( localize(8999, "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,
+    9193,
     '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(9194, 'The foreground color of the terminal.')));
+const TERMINAL_CURSOR_FOREGROUND_COLOR = registerColor('terminalCursor.foreground', null, ( localize(9195, 'The foreground color of the terminal cursor.')));
 const TERMINAL_CURSOR_BACKGROUND_COLOR = registerColor('terminalCursor.background', null, ( localize(
-    9381,
+    9196,
     '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(9197, '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,
+    9198,
     '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,
+    9199,
     '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(9200, '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,
+    9201,
     '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,
+    9202,
     '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(9203, 'The overview ruler cursor color.')));
 registerColor('terminal.border', PANEL_BORDER, ( localize(
-    9389,
+    9204,
     '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(9205, '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,
+    9206,
     '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(9207, '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(9208, '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,
+    9209,
     '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(9207, '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(9210, 'Overview ruler marker color for find matches in the terminal.')));
 registerColor('terminal.dropBackground', EDITOR_DRAG_AND_DROP_BACKGROUND, ( localize(
-    9396,
+    9211,
     "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,
+    9212,
     '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(9213, '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(9214, '\'{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(9000, "Whether the terminal is focused."))
+    )));
+    TerminalContextKeys.focusInAny = ( (new RawContextKey(
+        "terminalFocusInAny" ,
+        false,
+        ( localize(
+            9001,
+            "Whether any terminal is focused, including detached terminals used in other UI."
+        ))
+    )));
+    TerminalContextKeys.editorFocus = ( (new RawContextKey(
+        "terminalEditorFocus" ,
+        false,
+        ( localize(9002, "Whether a terminal in the editor area is focused."))
+    )));
+    TerminalContextKeys.count = ( (new RawContextKey("terminalCount" , 0, ( localize(9003, "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(9004, "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(
+            9005,
+            "The shell type of the active terminal, this is set if the type can be detected."
+        )) }
+    )));
+    TerminalContextKeys.altBufferActive = ( (new RawContextKey(
+        "terminalAltBufferActive" ,
+        false,
+        ( localize(9006, "Whether the terminal's alt buffer is active."))
+    )));
+    TerminalContextKeys.suggestWidgetVisible = ( (new RawContextKey(
+        "terminalSuggestWidgetVisible" ,
+        false,
+        ( localize(9007, "Whether the terminal's suggest widget is visible."))
+    )));
+    TerminalContextKeys.notFocus = ( (TerminalContextKeys.focus.toNegated()));
+    TerminalContextKeys.viewShowing = ( (new RawContextKey(
+        "terminalViewShowing" ,
+        false,
+        ( localize(9008, "Whether the terminal view is showing"))
+    )));
+    TerminalContextKeys.textSelected = ( (new RawContextKey(
+        "terminalTextSelected" ,
+        false,
+        ( localize(9009, "Whether text is selected in the active terminal."))
+    )));
+    TerminalContextKeys.textSelectedInFocused = ( (new RawContextKey(
+        "terminalTextSelectedInFocused" ,
+        false,
+        ( localize(9010, "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(
+            9011,
+            "Whether terminal processes can be launched in the current workspace."
+        ))
+    )));
+    TerminalContextKeys.tabsSingularSelection = ( (new RawContextKey(
+        "terminalTabsSingularSelection" ,
+        false,
+        ( localize(9012, "Whether one terminal is selected in the terminal tabs list."))
+    )));
+    TerminalContextKeys.splitTerminal = ( (new RawContextKey(
+        "terminalSplitTerminal" ,
+        false,
+        ( localize(9013, "Whether the focused tab's terminal is a split terminal."))
+    )));
+    TerminalContextKeys.inTerminalRunCommandPicker = ( (new RawContextKey(
+        "inTerminalRunCommandPicker" ,
+        false,
+        ( localize(9014, "Whether the terminal run command picker is currently open."))
+    )));
+    TerminalContextKeys.terminalShellIntegrationEnabled = ( (new RawContextKey(
+        "terminalShellIntegrationEnabled" ,
+        false,
+        ( localize(9015, "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/testing/common/testResult.js

@@ -154,7 +154,7 @@ let LiveTestResult = class LiveTestResult extends Disposable {
         this.onEndTask = this.endTaskEmitter.event;
         this.tasks = [];
         this.name = ( localize(
-            8267,
+            8231,
             'Test run at {0}',
             ( (new Date())).toLocaleString(language)
         ));
@@ -383,7 +383,7 @@ class HydratedTestResult {
         this.completedAt = serialized.completedAt;
         this.tasks = ( (serialized.tasks.map((task, i) => ({
             id: task.id,
-            name: task.name || ( localize(8268, 'Unnamed Task')),
+            name: task.name || ( localize(8232, 'Unnamed Task')),
             ctrlId: task.ctrlId,
             running: false,
             coverage: observableValue(this, undefined),

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(4687, '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(4688, '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(4689, '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(4690, '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(4691, 'Trust all domains (disables link protection)')),
         toTrust: '*',
         id: 'trust'
     });
     options.push({
         type: 'item',
-        label: ( localize(4670, 'Manage Trusted Domains')),
+        label: ( localize(4692, 'Manage Trusted Domains')),
         id: 'manage'
     });
     const pickedResult = await quickInputService.pick(options, { activeItem: options[0] });