@codingame/monaco-vscode-xterm-common 37.2.0 → 37.3.0

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

@@ -1,1643 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { isMouseEvent, getActiveWindow, isPointerEvent, isKeyboardEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
-import { Action } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
-import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
-import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
-import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
-import { KeyMod, KeyCode, KeyChord } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
-import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
-import { isAbsolute } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
-import { isWindows } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
-import { dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
-import { isObject, hasKey, isString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
-import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
-import { ICodeEditorService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service';
-import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
-import { EndOfLinePreference } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
-import { getIconClasses } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/getIconClasses';
-import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
-import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { AccessibleViewProviderId } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/browser/accessibleView';
-import { CONTEXT_ACCESSIBILITY_MODE_ENABLED } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/common/accessibility';
-import { registerAction2, Action2, MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
-import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
-import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
-import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
-import { FileKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
-import { KeybindingWeight } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
-import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
-import { IListService } from '@codingame/monaco-vscode-api/vscode/vs/platform/list/browser/listService.service';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification';
-import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
-import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
-import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
-import { TerminalCapability } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities';
-import { TerminalLocation, TerminalExitReason, TerminalSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal';
-import { createProfileSchemaEnums } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminalProfiles';
-import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
-import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
-import { PICK_WORKSPACE_FOLDER_COMMAND_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/actions/workspaceCommands';
-import { CLOSE_EDITOR_COMMAND_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/editor/editorCommands';
-import { IConfigurationResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/configurationResolver/common/configurationResolver.service';
-import { ConfigurationResolverExpression } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/configurationResolver/common/configurationResolverExpression';
-import { editorGroupToColumn } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupColumn';
-import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
-import { ACTIVE_GROUP, SIDE_GROUP, AUX_WINDOW_GROUP } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService';
-import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
-import { IPreferencesService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/preferences/common/preferences.service';
-import { IRemoteAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
-import { accessibleViewOnLastLine, accessibleViewCurrentProviderId, accessibleViewIsShown } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
-import { TerminalCommandId, TERMINAL_VIEW_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal';
-import { ITerminalProfileResolverService, ITerminalProfileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal.service';
-import { TerminalContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminalContextKey';
-import { terminalStrings } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminalStrings';
-import { Direction } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal';
-import { ITerminalEditingService, ITerminalEditorService, ITerminalInstanceService, ITerminalGroupService, ITerminalConfigurationService, ITerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
-import { isAuxiliaryWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/window';
-import { InstanceContext } from './terminalContextMenu.js';
-import { getIconId, getColorClass, getUriClasses } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminalIcon';
-import { newTerminalIcon, killTerminalIcon } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminalIcons';
-import { TerminalTabList } from './terminalTabsList.js';
-import { ResourceContextKey } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
-import { SeparatorSelectOption } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/selectBox/selectBox';
-import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
-
-const switchTerminalShowTabsTitle = ( localize(16820, "Show Tabs"));
-const category = terminalStrings.actionCategory;
-const sharedWhenClause = (() => {
-    const terminalAvailable = ( ContextKeyExpr.or(
-        TerminalContextKeys.processSupported,
-        TerminalContextKeys.terminalHasBeenCreated
-    ));
-    return {
-        terminalAvailable,
-        terminalAvailable_and_opened: ( ContextKeyExpr.and(terminalAvailable, TerminalContextKeys.isOpen)),
-        terminalAvailable_and_editorActive: ( ContextKeyExpr.and(terminalAvailable, TerminalContextKeys.terminalEditorActive)),
-        terminalAvailable_and_singularSelection: ( ContextKeyExpr.and(terminalAvailable, TerminalContextKeys.tabsSingularSelection)),
-        focusInAny_and_normalBuffer: ( ContextKeyExpr.and(TerminalContextKeys.focusInAny, ( TerminalContextKeys.altBufferActive.negate())))
-    };
-})();
-async function getCwdForSplit(instance, folders, commandService, configService) {
-    switch (configService.config.splitCwd) {
-    case "workspaceRoot":
-        if (folders !== undefined && commandService !== undefined) {
-            if (folders.length === 1) {
-                return folders[0].uri;
-            } else if (folders.length > 1) {
-                const options = {
-                    placeHolder: ( localize(16821, "Select current working directory for new terminal"))
-                };
-                const workspace = await commandService.executeCommand(PICK_WORKSPACE_FOLDER_COMMAND_ID, [options]);
-                if (!workspace) {
-                    return undefined;
-                }
-                return Promise.resolve(workspace.uri);
-            }
-        }
-        return "";
-    case "initial":
-        return instance.getInitialCwd();
-    case "inherited":
-        return instance.getSpeculativeCwd();
-    }
-}
-let TerminalLaunchHelpAction = class TerminalLaunchHelpAction extends Action {
-    constructor(_openerService) {
-        super("workbench.action.terminal.launchHelp", ( localize(16822, "Open Help")));
-        this._openerService = _openerService;
-    }
-    async run() {
-        this._openerService.open("https://aka.ms/vscode-troubleshoot-terminal-launch");
-    }
-};
-TerminalLaunchHelpAction = ( __decorate([( __param(0, IOpenerService))], TerminalLaunchHelpAction));
-function registerTerminalAction(options) {
-    options.f1 = options.f1 ?? true;
-    options.category = options.category ?? category;
-    options.precondition = options.precondition ?? TerminalContextKeys.processSupported;
-    const runFunc = options.run;
-    const strictOptions = options;
-    delete strictOptions["run"];
-    return registerAction2(class extends Action2 {
-        constructor() {
-            super(strictOptions);
-        }
-        run(accessor, args, args2) {
-            return runFunc(getTerminalServices(accessor), accessor, args, args2);
-        }
-    });
-}
-function parseActionArgs(args) {
-    if (Array.isArray(args)) {
-        if (args.every(e => e instanceof InstanceContext)) {
-            return args;
-        }
-    } else if (args instanceof InstanceContext) {
-        return [args];
-    }
-    return undefined;
-}
-function registerContextualInstanceAction(options) {
-    const originalRun = options.run;
-    return registerTerminalAction({
-        ...options,
-        run: async (c, accessor, focusedInstanceArgs, allInstanceArgs) => {
-            let instances = getSelectedViewInstances2(accessor, allInstanceArgs);
-            if (!instances) {
-                const activeInstance = (options.activeInstanceType === "view" ? c.groupService : options.activeInstanceType === "editor" ? c.editorService : c.service).activeInstance;
-                if (!activeInstance) {
-                    return;
-                }
-                instances = [activeInstance];
-            }
-            const results = [];
-            for (const instance of instances) {
-                results.push(originalRun(instance, c, accessor, focusedInstanceArgs));
-            }
-            await Promise.all(results);
-            if (options.runAfter) {
-                options.runAfter(instances, c, accessor, focusedInstanceArgs);
-            }
-        }
-    });
-}
-function registerActiveInstanceAction(options) {
-    const originalRun = options.run;
-    return registerTerminalAction({
-        ...options,
-        run: (c, accessor, args) => {
-            const activeInstance = c.service.activeInstance;
-            if (activeInstance) {
-                return originalRun(activeInstance, c, accessor, args);
-            }
-        }
-    });
-}
-function registerActiveXtermAction(options) {
-    const originalRun = options.run;
-    return registerTerminalAction({
-        ...options,
-        run: (c, accessor, args) => {
-            const activeDetached = Iterable.find(c.service.detachedInstances, d => d.xterm.isFocused);
-            if (activeDetached) {
-                return originalRun(activeDetached.xterm, accessor, activeDetached, args);
-            }
-            const activeInstance = c.service.activeInstance;
-            if (activeInstance?.xterm) {
-                return originalRun(activeInstance.xterm, accessor, activeInstance, args);
-            }
-        }
-    });
-}
-function getTerminalServices(accessor) {
-    return {
-        service: accessor.get(ITerminalService),
-        configService: accessor.get(ITerminalConfigurationService),
-        groupService: accessor.get(ITerminalGroupService),
-        instanceService: accessor.get(ITerminalInstanceService),
-        editorService: accessor.get(ITerminalEditorService),
-        editingService: accessor.get(ITerminalEditingService),
-        profileService: accessor.get(ITerminalProfileService),
-        profileResolverService: accessor.get(ITerminalProfileResolverService)
-    };
-}
-function registerTerminalActions() {
-    registerTerminalAction({
-        id: TerminalCommandId.NewInActiveWorkspace,
-        title: ( localize2(16823, "Create New Terminal (In Active Workspace)")),
-        run: async c => {
-            if (c.service.isProcessSupportRegistered) {
-                const instance = await c.service.createTerminal({
-                    location: c.configService.defaultLocation
-                });
-                if (!instance) {
-                    return;
-                }
-                c.service.setActiveInstance(instance);
-                await focusActiveTerminal(instance, c);
-            }
-        }
-    });
-    refreshTerminalActions([]);
-    registerTerminalAction({
-        id: TerminalCommandId.CreateTerminalEditor,
-        title: ( localize2(16824, "Create New Terminal in Editor Area")),
-        run: async (c, _, args) => {
-            function isCreateTerminalOptions(obj) {
-                return isObject(obj) && "location" in obj;
-            }
-            const options = isCreateTerminalOptions(args) ? args : {
-                location: {
-                    viewColumn: ACTIVE_GROUP
-                }
-            };
-            const instance = await c.service.createTerminal(options);
-            await instance.focusWhenReady();
-        }
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.CreateTerminalEditorSameGroup,
-        title: ( localize2(16824, "Create New Terminal in Editor Area")),
-        f1: false,
-        run: async (c, accessor, args) => {
-            const editorGroupsService = accessor.get(IEditorGroupsService);
-            const instance = await c.service.createTerminal({
-                location: {
-                    viewColumn: editorGroupToColumn(editorGroupsService, editorGroupsService.activeGroup)
-                }
-            });
-            await instance.focusWhenReady();
-        }
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.CreateTerminalEditorSide,
-        title: ( localize2(16825, "Create New Terminal in Editor Area to the Side")),
-        run: async c => {
-            const instance = await c.service.createTerminal({
-                location: {
-                    viewColumn: SIDE_GROUP
-                }
-            });
-            await instance.focusWhenReady();
-        }
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.NewInNewWindow,
-        title: terminalStrings.newInNewWindow,
-        precondition: sharedWhenClause.terminalAvailable,
-        keybinding: {
-            primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyMod.Alt | KeyCode.Backquote,
-            mac: {
-                primary: KeyMod.WinCtrl | KeyMod.Shift | KeyMod.Alt | KeyCode.Backquote
-            },
-            weight: KeybindingWeight.WorkbenchContrib
-        },
-        run: async c => {
-            const instance = await c.service.createTerminal({
-                location: {
-                    viewColumn: AUX_WINDOW_GROUP,
-                    auxiliary: {
-                        compact: true
-                    }
-                }
-            });
-            await instance.focusWhenReady();
-        }
-    });
-    registerContextualInstanceAction({
-        id: TerminalCommandId.MoveToEditor,
-        title: terminalStrings.moveToEditor,
-        precondition: sharedWhenClause.terminalAvailable_and_opened,
-        activeInstanceType: "view",
-        run: (instance, c) => c.service.moveToEditor(instance),
-        runAfter: instances => instances.at(-1)?.focus()
-    });
-    registerContextualInstanceAction({
-        id: TerminalCommandId.MoveIntoNewWindow,
-        title: terminalStrings.moveIntoNewWindow,
-        precondition: sharedWhenClause.terminalAvailable_and_opened,
-        run: (instance, c) => c.service.moveIntoNewEditor(instance),
-        runAfter: instances => instances.at(-1)?.focus()
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.MoveToTerminalPanel,
-        title: terminalStrings.moveToTerminalPanel,
-        precondition: sharedWhenClause.terminalAvailable_and_editorActive,
-        run: (c, _, args) => {
-            const source = toOptionalUri(args) ?? c.editorService.activeInstance;
-            if (source) {
-                c.service.moveToTerminalView(source);
-            }
-        }
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.FocusPreviousPane,
-        title: ( localize2(16826, "Focus Previous Terminal in Terminal Group")),
-        keybinding: {
-            primary: KeyMod.Alt | KeyCode.LeftArrow,
-            secondary: [KeyMod.Alt | KeyCode.UpArrow],
-            mac: {
-                primary: KeyMod.Alt | KeyMod.CtrlCmd | KeyCode.LeftArrow,
-                secondary: [KeyMod.Alt | KeyMod.CtrlCmd | KeyCode.UpArrow]
-            },
-            when: ( ContextKeyExpr.and(TerminalContextKeys.focus, TerminalContextKeys.splitTerminalActive)),
-            weight: KeybindingWeight.WorkbenchContrib + 1
-        },
-        precondition: sharedWhenClause.terminalAvailable,
-        run: async c => {
-            c.groupService.activeGroup?.focusPreviousPane();
-            await c.groupService.showPanel(true);
-        }
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.FocusNextPane,
-        title: ( localize2(16827, "Focus Next Terminal in Terminal Group")),
-        keybinding: {
-            primary: KeyMod.Alt | KeyCode.RightArrow,
-            secondary: [KeyMod.Alt | KeyCode.DownArrow],
-            mac: {
-                primary: KeyMod.Alt | KeyMod.CtrlCmd | KeyCode.RightArrow,
-                secondary: [KeyMod.Alt | KeyMod.CtrlCmd | KeyCode.DownArrow]
-            },
-            when: ( ContextKeyExpr.and(TerminalContextKeys.focus, TerminalContextKeys.splitTerminalActive)),
-            weight: KeybindingWeight.WorkbenchContrib + 1
-        },
-        precondition: sharedWhenClause.terminalAvailable,
-        run: async c => {
-            c.groupService.activeGroup?.focusNextPane();
-            await c.groupService.showPanel(true);
-        }
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.ResizePaneLeft,
-        title: ( localize2(16828, "Resize Terminal Left")),
-        keybinding: {
-            linux: {
-                primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.LeftArrow
-            },
-            mac: {
-                primary: KeyMod.CtrlCmd | KeyMod.WinCtrl | KeyCode.LeftArrow
-            },
-            when: TerminalContextKeys.focus,
-            weight: KeybindingWeight.WorkbenchContrib
-        },
-        precondition: sharedWhenClause.terminalAvailable,
-        run: c => c.groupService.activeGroup?.resizePane(Direction.Left)
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.ResizePaneRight,
-        title: ( localize2(16829, "Resize Terminal Right")),
-        keybinding: {
-            linux: {
-                primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.RightArrow
-            },
-            mac: {
-                primary: KeyMod.CtrlCmd | KeyMod.WinCtrl | KeyCode.RightArrow
-            },
-            when: TerminalContextKeys.focus,
-            weight: KeybindingWeight.WorkbenchContrib
-        },
-        precondition: sharedWhenClause.terminalAvailable,
-        run: c => c.groupService.activeGroup?.resizePane(Direction.Right)
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.ResizePaneUp,
-        title: ( localize2(16830, "Resize Terminal Up")),
-        keybinding: {
-            mac: {
-                primary: KeyMod.CtrlCmd | KeyMod.WinCtrl | KeyCode.UpArrow
-            },
-            when: TerminalContextKeys.focus,
-            weight: KeybindingWeight.WorkbenchContrib
-        },
-        precondition: sharedWhenClause.terminalAvailable,
-        run: c => c.groupService.activeGroup?.resizePane(Direction.Up)
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.ResizePaneDown,
-        title: ( localize2(16831, "Resize Terminal Down")),
-        keybinding: {
-            mac: {
-                primary: KeyMod.CtrlCmd | KeyMod.WinCtrl | KeyCode.DownArrow
-            },
-            when: TerminalContextKeys.focus,
-            weight: KeybindingWeight.WorkbenchContrib
-        },
-        precondition: sharedWhenClause.terminalAvailable,
-        run: c => c.groupService.activeGroup?.resizePane(Direction.Down)
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.Focus,
-        title: terminalStrings.focus,
-        keybinding: {
-            when: ( ContextKeyExpr.and(
-                CONTEXT_ACCESSIBILITY_MODE_ENABLED,
-                accessibleViewOnLastLine,
-                ( accessibleViewCurrentProviderId.isEqualTo(AccessibleViewProviderId.Terminal))
-            )),
-            primary: KeyMod.CtrlCmd | KeyCode.DownArrow,
-            weight: KeybindingWeight.WorkbenchContrib
-        },
-        precondition: sharedWhenClause.terminalAvailable,
-        run: async c => {
-            const instance = c.service.activeInstance || (await c.service.createTerminal({
-                location: TerminalLocation.Panel
-            }));
-            if (!instance) {
-                return;
-            }
-            c.service.setActiveInstance(instance);
-            await focusActiveTerminal(instance, c);
-        }
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.FocusTabs,
-        title: ( localize2(16832, "Focus Terminal Tabs View")),
-        keybinding: {
-            primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.Backslash,
-            weight: KeybindingWeight.WorkbenchContrib,
-            when: ( ContextKeyExpr.or(TerminalContextKeys.tabsFocus, TerminalContextKeys.focus))
-        },
-        precondition: sharedWhenClause.terminalAvailable,
-        run: c => c.groupService.focusTabs()
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.FocusNext,
-        title: ( localize2(16833, "Focus Next Terminal Group")),
-        precondition: sharedWhenClause.terminalAvailable,
-        keybinding: {
-            primary: KeyMod.CtrlCmd | KeyCode.PageDown,
-            mac: {
-                primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.BracketRight
-            },
-            when: ( ContextKeyExpr.and(TerminalContextKeys.focus, ( TerminalContextKeys.editorFocus.negate()))),
-            weight: KeybindingWeight.WorkbenchContrib
-        },
-        run: async c => {
-            c.groupService.setActiveGroupToNext();
-            await c.groupService.showPanel(true);
-        }
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.FocusPrevious,
-        title: ( localize2(16834, "Focus Previous Terminal Group")),
-        precondition: sharedWhenClause.terminalAvailable,
-        keybinding: {
-            primary: KeyMod.CtrlCmd | KeyCode.PageUp,
-            mac: {
-                primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.BracketLeft
-            },
-            when: ( ContextKeyExpr.and(TerminalContextKeys.focus, ( TerminalContextKeys.editorFocus.negate()))),
-            weight: KeybindingWeight.WorkbenchContrib
-        },
-        run: async c => {
-            c.groupService.setActiveGroupToPrevious();
-            await c.groupService.showPanel(true);
-        }
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.RunSelectedText,
-        title: ( localize2(16835, "Run Selected Text In Active Terminal")),
-        run: async (c, accessor) => {
-            const codeEditorService = accessor.get(ICodeEditorService);
-            const editor = codeEditorService.getActiveCodeEditor();
-            if (!editor || !editor.hasModel()) {
-                return;
-            }
-            const instance = await c.service.getActiveOrCreateInstance({
-                acceptsInput: true
-            });
-            const selection = editor.getSelection();
-            let text;
-            if (selection.isEmpty()) {
-                text = editor.getModel().getLineContent(selection.selectionStartLineNumber).trim();
-            } else {
-                const endOfLinePreference = isWindows ? EndOfLinePreference.LF : EndOfLinePreference.CRLF;
-                text = editor.getModel().getValueInRange(selection, endOfLinePreference);
-            }
-            instance.sendText(text, true, true);
-            await c.service.revealActiveTerminal(true);
-        }
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.RunActiveFile,
-        title: ( localize2(16836, "Run Active File In Active Terminal")),
-        precondition: sharedWhenClause.terminalAvailable,
-        run: async (c, accessor) => {
-            const codeEditorService = accessor.get(ICodeEditorService);
-            const notificationService = accessor.get(INotificationService);
-            const workbenchEnvironmentService = accessor.get(IWorkbenchEnvironmentService);
-            const editor = codeEditorService.getActiveCodeEditor();
-            if (!editor || !editor.hasModel()) {
-                return;
-            }
-            const instance = await c.service.getActiveOrCreateInstance({
-                acceptsInput: true
-            });
-            const isRemote = instance ? instance.hasRemoteAuthority : (workbenchEnvironmentService.remoteAuthority ? true : false);
-            const uri = editor.getModel().uri;
-            if ((!isRemote && uri.scheme !== Schemas.file && uri.scheme !== Schemas.vscodeUserData) || (isRemote && uri.scheme !== Schemas.vscodeRemote)) {
-                notificationService.warn(( localize(16837, "Only files on disk can be run in the terminal")));
-                return;
-            }
-            await instance.sendPath(uri, true);
-            return c.groupService.showPanel();
-        }
-    });
-    registerActiveXtermAction({
-        id: TerminalCommandId.ScrollDownLine,
-        title: ( localize2(16838, "Scroll Down (Line)")),
-        keybinding: {
-            primary: KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.PageDown,
-            linux: {
-                primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.DownArrow
-            },
-            when: sharedWhenClause.focusInAny_and_normalBuffer,
-            weight: KeybindingWeight.WorkbenchContrib
-        },
-        precondition: sharedWhenClause.terminalAvailable,
-        run: xterm => xterm.scrollDownLine()
-    });
-    registerActiveXtermAction({
-        id: TerminalCommandId.ScrollDownPage,
-        title: ( localize2(16839, "Scroll Down (Page)")),
-        keybinding: {
-            primary: KeyMod.Shift | KeyCode.PageDown,
-            mac: {
-                primary: KeyCode.PageDown
-            },
-            when: sharedWhenClause.focusInAny_and_normalBuffer,
-            weight: KeybindingWeight.WorkbenchContrib
-        },
-        precondition: sharedWhenClause.terminalAvailable,
-        run: xterm => xterm.scrollDownPage()
-    });
-    registerActiveXtermAction({
-        id: TerminalCommandId.ScrollToBottom,
-        title: ( localize2(16840, "Scroll to Bottom")),
-        keybinding: {
-            primary: KeyMod.CtrlCmd | KeyCode.End,
-            linux: {
-                primary: KeyMod.Shift | KeyCode.End
-            },
-            when: sharedWhenClause.focusInAny_and_normalBuffer,
-            weight: KeybindingWeight.WorkbenchContrib
-        },
-        precondition: sharedWhenClause.terminalAvailable,
-        run: xterm => xterm.scrollToBottom()
-    });
-    registerActiveXtermAction({
-        id: TerminalCommandId.ScrollUpLine,
-        title: ( localize2(16841, "Scroll Up (Line)")),
-        keybinding: {
-            primary: KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.PageUp,
-            linux: {
-                primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.UpArrow
-            },
-            when: sharedWhenClause.focusInAny_and_normalBuffer,
-            weight: KeybindingWeight.WorkbenchContrib
-        },
-        precondition: sharedWhenClause.terminalAvailable,
-        run: xterm => xterm.scrollUpLine()
-    });
-    registerActiveXtermAction({
-        id: TerminalCommandId.ScrollUpPage,
-        title: ( localize2(16842, "Scroll Up (Page)")),
-        f1: true,
-        keybinding: {
-            primary: KeyMod.Shift | KeyCode.PageUp,
-            mac: {
-                primary: KeyCode.PageUp
-            },
-            when: sharedWhenClause.focusInAny_and_normalBuffer,
-            weight: KeybindingWeight.WorkbenchContrib
-        },
-        precondition: sharedWhenClause.terminalAvailable,
-        run: xterm => xterm.scrollUpPage()
-    });
-    registerActiveXtermAction({
-        id: TerminalCommandId.ScrollToTop,
-        title: ( localize2(16843, "Scroll to Top")),
-        keybinding: {
-            primary: KeyMod.CtrlCmd | KeyCode.Home,
-            linux: {
-                primary: KeyMod.Shift | KeyCode.Home
-            },
-            when: sharedWhenClause.focusInAny_and_normalBuffer,
-            weight: KeybindingWeight.WorkbenchContrib
-        },
-        precondition: sharedWhenClause.terminalAvailable,
-        run: xterm => xterm.scrollToTop()
-    });
-    registerActiveXtermAction({
-        id: TerminalCommandId.ClearSelection,
-        title: ( localize2(16844, "Clear Selection")),
-        keybinding: {
-            primary: KeyCode.Escape,
-            when: ( ContextKeyExpr.and(
-                TerminalContextKeys.focusInAny,
-                TerminalContextKeys.textSelected,
-                TerminalContextKeys.notFindVisible
-            )),
-            weight: KeybindingWeight.WorkbenchContrib
-        },
-        precondition: sharedWhenClause.terminalAvailable,
-        run: xterm => {
-            if (xterm.hasSelection()) {
-                xterm.clearSelection();
-            }
-        }
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.ChangeIcon,
-        title: terminalStrings.changeIcon,
-        precondition: sharedWhenClause.terminalAvailable,
-        run: (c, _, args) => getResourceOrActiveInstance(c, args)?.changeIcon()
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.ChangeIconActiveTab,
-        title: terminalStrings.changeIcon,
-        f1: false,
-        precondition: sharedWhenClause.terminalAvailable_and_singularSelection,
-        run: async (c, accessor, args) => {
-            let icon;
-            if (c.groupService.lastAccessedMenu === "inline-tab") {
-                getResourceOrActiveInstance(c, args)?.changeIcon();
-                return;
-            }
-            for (const terminal of getSelectedViewInstances(accessor) ?? []) {
-                icon = await terminal.changeIcon(icon);
-            }
-        }
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.ChangeColor,
-        title: terminalStrings.changeColor,
-        precondition: sharedWhenClause.terminalAvailable,
-        run: (c, _, args) => getResourceOrActiveInstance(c, args)?.changeColor()
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.ChangeColorActiveTab,
-        title: terminalStrings.changeColor,
-        f1: false,
-        precondition: sharedWhenClause.terminalAvailable_and_singularSelection,
-        run: async (c, accessor, args) => {
-            let color;
-            let i = 0;
-            if (c.groupService.lastAccessedMenu === "inline-tab") {
-                getResourceOrActiveInstance(c, args)?.changeColor();
-                return;
-            }
-            for (const terminal of getSelectedViewInstances(accessor) ?? []) {
-                const skipQuickPick = i !== 0;
-                color = await terminal.changeColor(color, skipQuickPick);
-                i++;
-            }
-        }
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.Rename,
-        title: terminalStrings.rename,
-        precondition: sharedWhenClause.terminalAvailable,
-        run: (c, accessor, args) => renameWithQuickPick(c, accessor, args)
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.RenameActiveTab,
-        title: terminalStrings.rename,
-        f1: false,
-        keybinding: {
-            primary: KeyCode.F2,
-            mac: {
-                primary: KeyCode.Enter
-            },
-            when: ( ContextKeyExpr.and(TerminalContextKeys.tabsFocus)),
-            weight: KeybindingWeight.WorkbenchContrib
-        },
-        precondition: sharedWhenClause.terminalAvailable_and_singularSelection,
-        run: async (c, accessor) => {
-            const terminalGroupService = accessor.get(ITerminalGroupService);
-            const notificationService = accessor.get(INotificationService);
-            const instances = getSelectedViewInstances(accessor);
-            const firstInstance = instances?.[0];
-            if (!firstInstance) {
-                return;
-            }
-            if (terminalGroupService.lastAccessedMenu === "inline-tab") {
-                return renameWithQuickPick(c, accessor, firstInstance);
-            }
-            c.editingService.setEditingTerminal(firstInstance);
-            c.editingService.setEditable(firstInstance, {
-                validationMessage: value => validateTerminalName(value),
-                onFinish: async (value, success) => {
-                    c.editingService.setEditable(firstInstance, null);
-                    c.editingService.setEditingTerminal(undefined);
-                    if (success) {
-                        const promises = [];
-                        for (const instance of instances) {
-                            promises.push((async () => {
-                                await instance.rename(value);
-                            })());
-                        }
-                        try {
-                            await Promise.all(promises);
-                        } catch (e) {
-                            notificationService.error(e);
-                        }
-                    }
-                }
-            });
-        }
-    });
-    registerActiveInstanceAction({
-        id: TerminalCommandId.DetachSession,
-        title: ( localize2(16845, "Detach Session")),
-        run: activeInstance => activeInstance.detachProcessAndDispose(TerminalExitReason.User)
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.AttachToSession,
-        title: ( localize2(16846, "Attach to Session")),
-        run: async (c, accessor) => {
-            const quickInputService = accessor.get(IQuickInputService);
-            const labelService = accessor.get(ILabelService);
-            const remoteAgentService = accessor.get(IRemoteAgentService);
-            const notificationService = accessor.get(INotificationService);
-            const remoteAuthority = remoteAgentService.getConnection()?.remoteAuthority ?? undefined;
-            const backend = await accessor.get(ITerminalInstanceService).getBackend(remoteAuthority);
-            if (!backend) {
-                throw ( new Error(`No backend registered for remote authority '${remoteAuthority}'`));
-            }
-            const terms = await backend.listProcesses();
-            backend.reduceConnectionGraceTime();
-            const unattachedTerms = terms.filter(term => !c.service.isAttachedToTerminal(term));
-            const items = ( unattachedTerms.map(term => {
-                const cwdLabel = labelService.getUriLabel(URI.file(term.cwd));
-                return {
-                    label: term.title,
-                    detail: term.workspaceName ? `${term.workspaceName} \u2E31 ${cwdLabel}` : cwdLabel,
-                    description: term.pid ? String(term.pid) : "",
-                    term
-                };
-            }));
-            if (items.length === 0) {
-                notificationService.info(( localize(16847, "There are no unattached terminals to attach to")));
-                return;
-            }
-            const selected = await quickInputService.pick(items, {
-                canPickMany: false
-            });
-            if (selected) {
-                const instance = await c.service.createTerminal({
-                    config: {
-                        attachPersistentProcess: selected.term
-                    }
-                });
-                c.service.setActiveInstance(instance);
-                await focusActiveTerminal(instance, c);
-            }
-        }
-    });
-    registerActiveInstanceAction({
-        id: TerminalCommandId.ScrollToPreviousCommand,
-        title: terminalStrings.scrollToPreviousCommand,
-        keybinding: {
-            primary: KeyMod.CtrlCmd | KeyCode.UpArrow,
-            when: ( ContextKeyExpr.and(TerminalContextKeys.focus, ( CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate()))),
-            weight: KeybindingWeight.WorkbenchContrib
-        },
-        precondition: sharedWhenClause.terminalAvailable,
-        icon: Codicon.arrowUp,
-        menu: [{
-            id: MenuId.ViewTitle,
-            group: "navigation",
-            order: 4,
-            when: ( ContextKeyExpr.equals("view", TERMINAL_VIEW_ID)),
-            isHiddenByDefault: true
-        }, ...( [MenuId.EditorTitle, MenuId.CompactWindowEditorTitle].map(id => ({
-            id,
-            group: "1_shellIntegration",
-            order: 4,
-            when: ( ResourceContextKey.Scheme.isEqualTo(Schemas.vscodeTerminal)),
-            isHiddenByDefault: true
-        })))],
-        run: activeInstance => activeInstance.xterm?.markTracker.scrollToPreviousMark(undefined, undefined, ( activeInstance.capabilities.has(TerminalCapability.CommandDetection)))
-    });
-    registerActiveInstanceAction({
-        id: TerminalCommandId.ScrollToNextCommand,
-        title: terminalStrings.scrollToNextCommand,
-        keybinding: {
-            primary: KeyMod.CtrlCmd | KeyCode.DownArrow,
-            when: ( ContextKeyExpr.and(TerminalContextKeys.focus, ( CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate()))),
-            weight: KeybindingWeight.WorkbenchContrib
-        },
-        precondition: sharedWhenClause.terminalAvailable,
-        icon: Codicon.arrowDown,
-        menu: [{
-            id: MenuId.ViewTitle,
-            group: "navigation",
-            order: 5,
-            when: ( ContextKeyExpr.equals("view", TERMINAL_VIEW_ID)),
-            isHiddenByDefault: true
-        }, ...( [MenuId.EditorTitle, MenuId.CompactWindowEditorTitle].map(id => ({
-            id,
-            group: "1_shellIntegration",
-            order: 5,
-            when: ( ResourceContextKey.Scheme.isEqualTo(Schemas.vscodeTerminal)),
-            isHiddenByDefault: true
-        })))],
-        run: activeInstance => {
-            activeInstance.xterm?.markTracker.scrollToNextMark();
-            activeInstance.focus();
-        }
-    });
-    registerActiveInstanceAction({
-        id: TerminalCommandId.SelectToPreviousCommand,
-        title: ( localize2(16848, "Select to Previous Command")),
-        keybinding: {
-            primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.UpArrow,
-            when: TerminalContextKeys.focus,
-            weight: KeybindingWeight.WorkbenchContrib
-        },
-        precondition: sharedWhenClause.terminalAvailable,
-        run: activeInstance => {
-            activeInstance.xterm?.markTracker.selectToPreviousMark();
-            activeInstance.focus();
-        }
-    });
-    registerActiveInstanceAction({
-        id: TerminalCommandId.SelectToNextCommand,
-        title: ( localize2(16849, "Select to Next Command")),
-        keybinding: {
-            primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.DownArrow,
-            when: TerminalContextKeys.focus,
-            weight: KeybindingWeight.WorkbenchContrib
-        },
-        precondition: sharedWhenClause.terminalAvailable,
-        run: activeInstance => {
-            activeInstance.xterm?.markTracker.selectToNextMark();
-            activeInstance.focus();
-        }
-    });
-    registerActiveXtermAction({
-        id: TerminalCommandId.SelectToPreviousLine,
-        title: ( localize2(16850, "Select to Previous Line")),
-        precondition: sharedWhenClause.terminalAvailable,
-        run: async (xterm, _, instance) => {
-            xterm.markTracker.selectToPreviousLine();
-            (instance || xterm).focus();
-        }
-    });
-    registerActiveXtermAction({
-        id: TerminalCommandId.SelectToNextLine,
-        title: ( localize2(16851, "Select to Next Line")),
-        precondition: sharedWhenClause.terminalAvailable,
-        run: async (xterm, _, instance) => {
-            xterm.markTracker.selectToNextLine();
-            (instance || xterm).focus();
-        }
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.NewWithCwd,
-        title: terminalStrings.newWithCwd,
-        metadata: {
-            description: terminalStrings.newWithCwd.value,
-            args: [{
-                name: "args",
-                schema: {
-                    type: "object",
-                    required: ["cwd"],
-                    properties: {
-                        cwd: {
-                            description: ( localize(16852, "The directory to start the terminal at")),
-                            type: "string"
-                        }
-                    }
-                }
-            }]
-        },
-        run: async (c, _, args) => {
-            const cwd = args ? toOptionalString(args.cwd) : undefined;
-            const instance = await c.service.createTerminal({
-                cwd
-            });
-            if (!instance) {
-                return;
-            }
-            c.service.setActiveInstance(instance);
-            await focusActiveTerminal(instance, c);
-        }
-    });
-    registerActiveInstanceAction({
-        id: TerminalCommandId.RenameWithArgs,
-        title: terminalStrings.renameWithArgs,
-        metadata: {
-            description: terminalStrings.renameWithArgs.value,
-            args: [{
-                name: "args",
-                schema: {
-                    type: "object",
-                    required: ["name"],
-                    properties: {
-                        name: {
-                            description: ( localize(16853, "The new name for the terminal")),
-                            type: "string",
-                            minLength: 1
-                        }
-                    }
-                }
-            }]
-        },
-        precondition: sharedWhenClause.terminalAvailable,
-        f1: false,
-        run: async (activeInstance, c, accessor, args) => {
-            const notificationService = accessor.get(INotificationService);
-            const name = args ? toOptionalString(args.name) : undefined;
-            if (!name) {
-                notificationService.warn(( localize(16854, "No name argument provided")));
-                return;
-            }
-            activeInstance.rename(name);
-        }
-    });
-    registerActiveInstanceAction({
-        id: TerminalCommandId.Relaunch,
-        title: ( localize2(16855, "Relaunch Active Terminal")),
-        run: activeInstance => activeInstance.relaunch()
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.Split,
-        title: terminalStrings.split,
-        precondition: ( ContextKeyExpr.or(
-            TerminalContextKeys.processSupported,
-            TerminalContextKeys.webExtensionContributedProfile
-        )),
-        keybinding: {
-            primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.Digit5,
-            weight: KeybindingWeight.WorkbenchContrib,
-            mac: {
-                primary: KeyMod.CtrlCmd | KeyCode.Backslash,
-                secondary: [KeyMod.WinCtrl | KeyMod.Shift | KeyCode.Digit5]
-            },
-            when: TerminalContextKeys.focus
-        },
-        icon: Codicon.splitHorizontal,
-        run: async (c, accessor, args) => {
-            const optionsOrProfile = isObject(args) ? args : undefined;
-            const commandService = accessor.get(ICommandService);
-            const workspaceContextService = accessor.get(IWorkspaceContextService);
-            const options = convertOptionsOrProfileToOptions(optionsOrProfile);
-            const activeInstance = (await c.service.getInstanceHost(options?.location)).activeInstance;
-            if (!activeInstance) {
-                return;
-            }
-            const cwd = await getCwdForSplit(
-                activeInstance,
-                workspaceContextService.getWorkspace().folders,
-                commandService,
-                c.configService
-            );
-            if (cwd === undefined) {
-                return;
-            }
-            const instance = await c.service.createTerminal({
-                location: {
-                    parentTerminal: activeInstance
-                },
-                config: options?.config,
-                cwd
-            });
-            await focusActiveTerminal(instance, c);
-        }
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.SplitActiveTab,
-        title: terminalStrings.split,
-        f1: false,
-        keybinding: {
-            primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.Digit5,
-            mac: {
-                primary: KeyMod.CtrlCmd | KeyCode.Backslash,
-                secondary: [KeyMod.WinCtrl | KeyMod.Shift | KeyCode.Digit5]
-            },
-            weight: KeybindingWeight.WorkbenchContrib,
-            when: TerminalContextKeys.tabsFocus
-        },
-        run: async (c, accessor) => {
-            const instances = getSelectedViewInstances(accessor);
-            if (instances) {
-                const promises = [];
-                for (const t of instances) {
-                    promises.push((async () => {
-                        await c.service.createTerminal({
-                            location: {
-                                parentTerminal: t
-                            }
-                        });
-                        await c.groupService.showPanel(true);
-                    })());
-                }
-                await Promise.all(promises);
-            }
-        }
-    });
-    registerContextualInstanceAction({
-        id: TerminalCommandId.Unsplit,
-        title: terminalStrings.unsplit,
-        precondition: sharedWhenClause.terminalAvailable,
-        run: async (instance, c) => {
-            const group = c.groupService.getGroupForInstance(instance);
-            if (group && group?.terminalInstances.length > 1) {
-                c.groupService.unsplitInstance(instance);
-            }
-        }
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.JoinActiveTab,
-        title: ( localize2(16856, "Join Terminals")),
-        precondition: ( ContextKeyExpr.and(sharedWhenClause.terminalAvailable, ( TerminalContextKeys.tabsSingularSelection.toNegated()))),
-        run: async (c, accessor) => {
-            const instances = getSelectedViewInstances(accessor);
-            if (instances && instances.length > 1) {
-                c.groupService.joinInstances(instances);
-            }
-        }
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.Join,
-        title: ( localize2(16857, "Join Terminals...")),
-        precondition: sharedWhenClause.terminalAvailable,
-        run: async (c, accessor) => {
-            const themeService = accessor.get(IThemeService);
-            const notificationService = accessor.get(INotificationService);
-            const quickInputService = accessor.get(IQuickInputService);
-            const picks = [];
-            if (c.groupService.instances.length <= 1) {
-                notificationService.warn(( localize(16858, "Insufficient terminals for the join action")));
-                return;
-            }
-            const otherInstances = c.groupService.instances.filter(i => i.instanceId !== c.groupService.activeInstance?.instanceId);
-            for (const terminal of otherInstances) {
-                const group = c.groupService.getGroupForInstance(terminal);
-                if (group?.terminalInstances.length === 1) {
-                    const iconId = getIconId(accessor, terminal);
-                    const label = `$(${iconId}): ${terminal.title}`;
-                    const iconClasses = [];
-                    const colorClass = getColorClass(terminal);
-                    if (colorClass) {
-                        iconClasses.push(colorClass);
-                    }
-                    const uriClasses = getUriClasses(terminal, themeService.getColorTheme().type);
-                    if (uriClasses) {
-                        iconClasses.push(...uriClasses);
-                    }
-                    picks.push({
-                        terminal,
-                        label,
-                        iconClasses
-                    });
-                }
-            }
-            if (picks.length === 0) {
-                notificationService.warn(( localize(16859, "All terminals are joined already")));
-                return;
-            }
-            const result = await quickInputService.pick(picks, {});
-            if (result) {
-                c.groupService.joinInstances([result.terminal, c.groupService.activeInstance]);
-            }
-        }
-    });
-    registerActiveInstanceAction({
-        id: TerminalCommandId.SplitInActiveWorkspace,
-        title: ( localize2(16860, "Split Terminal (In Active Workspace)")),
-        run: async (instance, c) => {
-            const newInstance = await c.service.createTerminal({
-                location: {
-                    parentTerminal: instance
-                }
-            });
-            if (newInstance?.target !== TerminalLocation.Editor) {
-                await c.groupService.showPanel(true);
-            }
-        }
-    });
-    registerActiveXtermAction({
-        id: TerminalCommandId.SelectAll,
-        title: ( localize2(16861, "Select All")),
-        precondition: sharedWhenClause.terminalAvailable,
-        keybinding: [{
-            primary: 0,
-            mac: {
-                primary: KeyMod.CtrlCmd | KeyCode.KeyA
-            },
-            weight: KeybindingWeight.WorkbenchContrib,
-            when: TerminalContextKeys.focusInAny
-        }],
-        run: xterm => xterm.selectAll()
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.New,
-        title: ( localize2(16862, "Create New Terminal")),
-        precondition: ( ContextKeyExpr.or(
-            TerminalContextKeys.processSupported,
-            TerminalContextKeys.webExtensionContributedProfile
-        )),
-        icon: newTerminalIcon,
-        keybinding: {
-            primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.Backquote,
-            mac: {
-                primary: KeyMod.WinCtrl | KeyMod.Shift | KeyCode.Backquote
-            },
-            weight: KeybindingWeight.WorkbenchContrib
-        },
-        run: async (c, accessor, args) => {
-            let eventOrOptions = isObject(args) ? args : undefined;
-            const workspaceContextService = accessor.get(IWorkspaceContextService);
-            const commandService = accessor.get(ICommandService);
-            const editorGroupsService = accessor.get(IEditorGroupsService);
-            const folders = workspaceContextService.getWorkspace().folders;
-            if (eventOrOptions && isMouseEvent(eventOrOptions) && (eventOrOptions.altKey || eventOrOptions.ctrlKey)) {
-                await c.service.createTerminal({
-                    location: {
-                        splitActiveTerminal: true
-                    }
-                });
-                return;
-            }
-            if (c.service.isProcessSupportRegistered) {
-                eventOrOptions = !eventOrOptions || isMouseEvent(eventOrOptions) ? {} : eventOrOptions;
-                if (isAuxiliaryWindow(getActiveWindow()) && !eventOrOptions.location) {
-                    eventOrOptions.location = {
-                        viewColumn: editorGroupToColumn(editorGroupsService, editorGroupsService.activeGroup)
-                    };
-                }
-                let instance;
-                if (folders.length <= 1) {
-                    instance = await c.service.createTerminal(eventOrOptions);
-                } else {
-                    const cwd = (await pickTerminalCwd(accessor))?.cwd;
-                    if (!cwd) {
-                        return;
-                    }
-                    eventOrOptions.cwd = cwd;
-                    instance = await c.service.createTerminal(eventOrOptions);
-                }
-                c.service.setActiveInstance(instance);
-                await focusActiveTerminal(instance, c);
-            } else {
-                if (c.profileService.contributedProfiles.length > 0) {
-                    commandService.executeCommand(TerminalCommandId.NewWithProfile);
-                } else {
-                    commandService.executeCommand(TerminalCommandId.Toggle);
-                }
-            }
-        }
-    });
-    async function killInstance(c, instance) {
-        if (!instance) {
-            return;
-        }
-        await c.service.safeDisposeTerminal(instance);
-        if (c.groupService.instances.length > 0) {
-            await c.groupService.showPanel(true);
-        }
-    }
-    registerTerminalAction({
-        id: TerminalCommandId.Kill,
-        title: ( localize2(16863, "Kill the Active Terminal Instance")),
-        precondition: ( ContextKeyExpr.or(sharedWhenClause.terminalAvailable, TerminalContextKeys.isOpen)),
-        icon: killTerminalIcon,
-        run: async c => killInstance(c, c.groupService.activeInstance)
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.KillViewOrEditor,
-        title: terminalStrings.kill,
-        f1: false,
-        precondition: ( ContextKeyExpr.or(sharedWhenClause.terminalAvailable, TerminalContextKeys.isOpen)),
-        run: async c => killInstance(c, c.service.activeInstance)
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.KillAll,
-        title: ( localize2(16864, "Kill All Terminals")),
-        precondition: ( ContextKeyExpr.or(sharedWhenClause.terminalAvailable, TerminalContextKeys.isOpen)),
-        icon: Codicon.trash,
-        run: async c => {
-            const disposePromises = [];
-            for (const instance of c.service.instances) {
-                disposePromises.push(c.service.safeDisposeTerminal(instance));
-            }
-            await Promise.all(disposePromises);
-        }
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.KillEditor,
-        title: ( localize2(16865, "Kill the Active Terminal in Editor Area")),
-        precondition: sharedWhenClause.terminalAvailable,
-        keybinding: {
-            primary: KeyMod.CtrlCmd | KeyCode.KeyW,
-            win: {
-                primary: KeyMod.CtrlCmd | KeyCode.F4,
-                secondary: [KeyMod.CtrlCmd | KeyCode.KeyW]
-            },
-            weight: KeybindingWeight.WorkbenchContrib,
-            when: ( ContextKeyExpr.and(TerminalContextKeys.focus, TerminalContextKeys.editorFocus))
-        },
-        run: (c, accessor) => accessor.get(ICommandService).executeCommand(CLOSE_EDITOR_COMMAND_ID)
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.KillActiveTab,
-        title: terminalStrings.kill,
-        f1: false,
-        precondition: ( ContextKeyExpr.or(sharedWhenClause.terminalAvailable, TerminalContextKeys.isOpen)),
-        keybinding: {
-            primary: KeyCode.Delete,
-            mac: {
-                primary: KeyMod.CtrlCmd | KeyCode.Backspace,
-                secondary: [KeyCode.Delete]
-            },
-            weight: KeybindingWeight.WorkbenchContrib,
-            when: TerminalContextKeys.tabsFocus
-        },
-        run: async (c, accessor) => {
-            const disposePromises = [];
-            for (const terminal of getSelectedViewInstances(accessor) ?? []) {
-                disposePromises.push(c.service.safeDisposeTerminal(terminal));
-            }
-            await Promise.all(disposePromises);
-            c.groupService.focusTabs();
-        }
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.FocusHover,
-        title: terminalStrings.focusHover,
-        precondition: ( ContextKeyExpr.or(sharedWhenClause.terminalAvailable, TerminalContextKeys.isOpen)),
-        keybinding: {
-            primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyCode.KeyI),
-            weight: KeybindingWeight.WorkbenchContrib,
-            when: ( ContextKeyExpr.or(TerminalContextKeys.tabsFocus, TerminalContextKeys.focus))
-        },
-        run: c => c.groupService.focusHover()
-    });
-    registerActiveInstanceAction({
-        id: TerminalCommandId.Clear,
-        title: ( localize2(16866, "Clear")),
-        precondition: sharedWhenClause.terminalAvailable,
-        keybinding: [{
-            primary: 0,
-            mac: {
-                primary: KeyMod.CtrlCmd | KeyCode.KeyK
-            },
-            weight: KeybindingWeight.WorkbenchContrib + 1,
-            when: ( ContextKeyExpr.or(( ContextKeyExpr.and(TerminalContextKeys.focus, ( CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate()))), ( ContextKeyExpr.and(CONTEXT_ACCESSIBILITY_MODE_ENABLED, accessibleViewIsShown, ( accessibleViewCurrentProviderId.isEqualTo(AccessibleViewProviderId.Terminal))))))
-        }],
-        run: activeInstance => activeInstance.clearBuffer()
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.SelectDefaultProfile,
-        title: ( localize2(16867, "Select Default Profile")),
-        run: c => c.service.showProfileQuickPick("setDefault")
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.ConfigureTerminalSettings,
-        title: ( localize2(16868, "Configure Terminal Settings")),
-        precondition: sharedWhenClause.terminalAvailable,
-        run: (c, accessor) => accessor.get(IPreferencesService).openSettings({
-            jsonEditor: false,
-            query: "@feature:terminal"
-        })
-    });
-    registerActiveInstanceAction({
-        id: TerminalCommandId.SetDimensions,
-        title: ( localize2(16869, "Set Fixed Dimensions")),
-        precondition: sharedWhenClause.terminalAvailable_and_opened,
-        run: activeInstance => activeInstance.setFixedDimensions()
-    });
-    registerContextualInstanceAction({
-        id: TerminalCommandId.SizeToContentWidth,
-        title: terminalStrings.toggleSizeToContentWidth,
-        precondition: sharedWhenClause.terminalAvailable_and_opened,
-        keybinding: {
-            primary: KeyMod.Alt | KeyCode.KeyZ,
-            weight: KeybindingWeight.WorkbenchContrib,
-            when: TerminalContextKeys.focus
-        },
-        run: instance => instance.toggleSizeToContentWidth()
-    });
-    registerTerminalAction({
-        id: TerminalCommandId.SwitchTerminal,
-        title: ( localize2(16870, "Switch Terminal")),
-        precondition: sharedWhenClause.terminalAvailable,
-        run: async (c, accessor, args) => {
-            const item = toOptionalString(args);
-            if (!item) {
-                return;
-            }
-            if (item === SeparatorSelectOption.text) {
-                c.service.refreshActiveGroup();
-                return;
-            }
-            if (item === switchTerminalShowTabsTitle) {
-                accessor.get(IConfigurationService).updateValue(TerminalSettingId.TabsEnabled, true);
-                return;
-            }
-            const terminalIndexRe = /^([0-9]+): /;
-            const indexMatches = terminalIndexRe.exec(item);
-            if (indexMatches) {
-                c.groupService.setActiveGroupByIndex(Number(indexMatches[1]) - 1);
-                return c.groupService.showPanel(true);
-            }
-            const quickSelectProfiles = c.profileService.availableProfiles;
-            const profileSelection = item.substring(4);
-            if (quickSelectProfiles) {
-                const profile = quickSelectProfiles.find(profile => profile.profileName === profileSelection);
-                if (profile) {
-                    const instance = await c.service.createTerminal({
-                        config: profile
-                    });
-                    c.service.setActiveInstance(instance);
-                } else {
-                    console.warn(`No profile with name "${profileSelection}"`);
-                }
-            } else {
-                console.warn(`Unmatched terminal item: "${item}"`);
-            }
-        }
-    });
-}
-function getSelectedViewInstances2(accessor, args) {
-    const terminalService = accessor.get(ITerminalService);
-    const result = [];
-    const context = parseActionArgs(args);
-    if (context && context.length > 0) {
-        for (const instanceContext of context) {
-            const instance = terminalService.getInstanceFromId(instanceContext.instanceId);
-            if (instance) {
-                result.push(instance);
-            }
-        }
-        if (result.length > 0) {
-            return result;
-        }
-    }
-    return undefined;
-}
-function getSelectedViewInstances(accessor, args, args2) {
-    const listService = accessor.get(IListService);
-    const terminalGroupService = accessor.get(ITerminalGroupService);
-    const result = [];
-    const list = listService.lastFocusedList instanceof TerminalTabList ? listService.lastFocusedList : undefined;
-    const selections = list?.getSelection();
-    if (terminalGroupService.lastAccessedMenu === "inline-tab" && !selections?.length) {
-        const instance = terminalGroupService.activeInstance;
-        return instance ? [terminalGroupService.activeInstance] : undefined;
-    }
-    if (!list || !selections) {
-        return undefined;
-    }
-    const focused = list.getFocus();
-    const viewInstances = terminalGroupService.instances;
-    if (focused.length === 1 && !selections.includes(focused[0])) {
-        result.push(viewInstances[focused[0]]);
-        return result;
-    }
-    for (const selection of selections) {
-        result.push(viewInstances[selection]);
-    }
-    return result.filter(r => !!r);
-}
-function validateTerminalName(name) {
-    if (!name || name.trim().length === 0) {
-        return {
-            content: ( localize(16871, "Providing no name will reset it to the default value")),
-            severity: Severity.Info
-        };
-    }
-    return null;
-}
-function isTerminalProfile(obj) {
-    return isObject(obj) && "profileName" in obj;
-}
-function convertOptionsOrProfileToOptions(optionsOrProfile) {
-    if (isTerminalProfile(optionsOrProfile)) {
-        return {
-            config: optionsOrProfile,
-            location: optionsOrProfile.location
-        };
-    }
-    return optionsOrProfile;
-}
-let newWithProfileAction;
-function refreshTerminalActions(detectedProfiles) {
-    const profileEnum = createProfileSchemaEnums(detectedProfiles);
-    newWithProfileAction?.dispose();
-    newWithProfileAction = registerAction2(class extends Action2 {
-        constructor() {
-            super({
-                id: TerminalCommandId.NewWithProfile,
-                title: ( localize2(16872, "Create New Terminal (With Profile)")),
-                f1: true,
-                precondition: ( ContextKeyExpr.or(
-                    TerminalContextKeys.processSupported,
-                    TerminalContextKeys.webExtensionContributedProfile
-                )),
-                metadata: {
-                    description: TerminalCommandId.NewWithProfile,
-                    args: [{
-                        name: "args",
-                        schema: {
-                            type: "object",
-                            required: ["profileName"],
-                            properties: {
-                                profileName: {
-                                    description: ( localize(16873, "The name of the profile to create")),
-                                    type: "string",
-                                    enum: profileEnum.values,
-                                    markdownEnumDescriptions: profileEnum.markdownDescriptions
-                                },
-                                location: {
-                                    description: ( localize(16874, "Where to create the terminal")),
-                                    type: "string",
-                                    enum: ["view", "editor"],
-                                    enumDescriptions: [( localize(16875, "Create the terminal in the terminal view")), ( localize(16876, "Create the terminal in the editor"))]
-                                }
-                            }
-                        }
-                    }]
-                }
-            });
-        }
-        async run(accessor, eventOrOptionsOrProfile, profile) {
-            const c = getTerminalServices(accessor);
-            const workspaceContextService = accessor.get(IWorkspaceContextService);
-            const commandService = accessor.get(ICommandService);
-            let event;
-            let options;
-            let instance;
-            let cwd;
-            if (isObject(eventOrOptionsOrProfile) && eventOrOptionsOrProfile && hasKey(eventOrOptionsOrProfile, {
-                profileName: true
-            })) {
-                const config = c.profileService.availableProfiles.find(profile => profile.profileName === eventOrOptionsOrProfile.profileName);
-                if (!config) {
-                    throw ( new Error(`Could not find terminal profile "${eventOrOptionsOrProfile.profileName}"`));
-                }
-                options = {
-                    config
-                };
-                function isSimpleArgs(obj) {
-                    return isObject(obj) && "location" in obj;
-                }
-                if (isSimpleArgs(eventOrOptionsOrProfile)) {
-                    switch (eventOrOptionsOrProfile.location) {
-                    case "editor":
-                        options.location = TerminalLocation.Editor;
-                        break;
-                    case "view":
-                        options.location = TerminalLocation.Panel;
-                        break;
-                    }
-                }
-            } else if (isMouseEvent(eventOrOptionsOrProfile) || isPointerEvent(eventOrOptionsOrProfile) || isKeyboardEvent(eventOrOptionsOrProfile)) {
-                event = eventOrOptionsOrProfile;
-                options = profile ? {
-                    config: profile
-                } : undefined;
-            } else {
-                options = convertOptionsOrProfileToOptions(eventOrOptionsOrProfile);
-            }
-            if (event && (event.altKey || event.ctrlKey)) {
-                const parentTerminal = c.service.activeInstance;
-                if (parentTerminal) {
-                    await c.service.createTerminal({
-                        location: {
-                            parentTerminal
-                        },
-                        config: options?.config
-                    });
-                    return;
-                }
-            }
-            const folders = workspaceContextService.getWorkspace().folders;
-            if (folders.length > 1) {
-                const options = {
-                    placeHolder: ( localize(16821, "Select current working directory for new terminal"))
-                };
-                const workspace = await commandService.executeCommand(PICK_WORKSPACE_FOLDER_COMMAND_ID, [options]);
-                if (!workspace) {
-                    return;
-                }
-                cwd = workspace.uri;
-            }
-            if (options) {
-                options.cwd = cwd;
-                instance = await c.service.createTerminal(options);
-            } else {
-                instance = await c.service.showProfileQuickPick("createInstance", cwd);
-            }
-            if (instance) {
-                c.service.setActiveInstance(instance);
-                await focusActiveTerminal(instance, c);
-            }
-        }
-    });
-    return newWithProfileAction;
-}
-function getResourceOrActiveInstance(c, resource) {
-    return c.service.getInstanceFromResource(toOptionalUri(resource)) || c.service.activeInstance;
-}
-async function pickTerminalCwd(accessor, cancel) {
-    const quickInputService = accessor.get(IQuickInputService);
-    const labelService = accessor.get(ILabelService);
-    const contextService = accessor.get(IWorkspaceContextService);
-    const modelService = accessor.get(IModelService);
-    const languageService = accessor.get(ILanguageService);
-    const configurationService = accessor.get(IConfigurationService);
-    const configurationResolverService = accessor.get(IConfigurationResolverService);
-    const folders = contextService.getWorkspace().folders;
-    if (!folders.length) {
-        return;
-    }
-    const folderCwdPairs = await Promise.all(( folders.map(
-        e => resolveWorkspaceFolderCwd(e, configurationService, configurationResolverService)
-    )));
-    const shrinkedPairs = shrinkWorkspaceFolderCwdPairs(folderCwdPairs);
-    if (shrinkedPairs.length === 1) {
-        return shrinkedPairs[0];
-    }
-    const folderPicks = ( shrinkedPairs.map(pair => {
-        const label = pair.folder.name;
-        const description = pair.isOverridden ? ( localize(16877, "(Overridden) {0}", labelService.getUriLabel(pair.cwd, {
-            relative: !pair.isAbsolute
-        }))) : labelService.getUriLabel(dirname(pair.cwd), {
-            relative: true
-        });
-        return {
-            label,
-            description: description !== label ? description : undefined,
-            pair: pair,
-            iconClasses: getIconClasses(modelService, languageService, pair.cwd, FileKind.ROOT_FOLDER)
-        };
-    }));
-    const options = {
-        placeHolder: ( localize(16821, "Select current working directory for new terminal")),
-        matchOnDescription: true,
-        canPickMany: false
-    };
-    const token = CancellationToken.None;
-    const pick = await quickInputService.pick(folderPicks, options, token);
-    return pick?.pair;
-}
-async function resolveWorkspaceFolderCwd(folder, configurationService, configurationResolverService) {
-    const cwdConfig = configurationService.getValue(TerminalSettingId.Cwd, {
-        resource: folder.uri
-    });
-    if (!isString(cwdConfig) || cwdConfig.length === 0) {
-        return {
-            folder,
-            cwd: folder.uri,
-            isAbsolute: false,
-            isOverridden: false
-        };
-    }
-    const resolvedCwdConfig = await configurationResolverService.resolveAsync(folder, cwdConfig);
-    return isAbsolute(resolvedCwdConfig) || resolvedCwdConfig.startsWith(ConfigurationResolverExpression.VARIABLE_LHS) ? {
-        folder,
-        isAbsolute: true,
-        isOverridden: true,
-        cwd: ( URI.from({
-            ...folder.uri,
-            path: resolvedCwdConfig
-        }))
-    } : {
-        folder,
-        isAbsolute: false,
-        isOverridden: true,
-        cwd: URI.joinPath(folder.uri, resolvedCwdConfig)
-    };
-}
-function shrinkWorkspaceFolderCwdPairs(pairs) {
-    const map = ( new Map());
-    for (const pair of pairs) {
-        const key = ( pair.cwd.toString());
-        const value = map.get(key);
-        if (!value || key === ( pair.folder.uri.toString())) {
-            map.set(key, pair);
-        }
-    }
-    const selectedPairs = ( new Set(( map.values())));
-    const selectedPairsInOrder = pairs.filter(x => ( selectedPairs.has(x)));
-    return selectedPairsInOrder;
-}
-async function focusActiveTerminal(instance, c) {
-    const target = instance ?? c.service.activeInstance ?? c.editorService.activeInstance ?? c.groupService.activeInstance;
-    if (!target) {
-        if (c.groupService.instances.length > 0) {
-            await c.groupService.showPanel(true);
-        }
-        return;
-    }
-    await c.service.focusInstance(target);
-}
-async function renameWithQuickPick(c, accessor, resource) {
-    let instance = resource;
-    if (!instance || !instance?.rename) {
-        instance = getResourceOrActiveInstance(c, resource);
-    }
-    if (instance) {
-        const title = await accessor.get(IQuickInputService).input({
-            value: instance.title,
-            prompt: ( localize(16878, "Enter terminal name"))
-        });
-        if (title) {
-            instance.rename(title);
-        }
-    }
-}
-function toOptionalUri(obj) {
-    return URI.isUri(obj) ? obj : undefined;
-}
-function toOptionalString(obj) {
-    return isString(obj) ? obj : undefined;
-}
-
-export { TerminalLaunchHelpAction, getCwdForSplit, refreshTerminalActions, registerActiveInstanceAction, registerActiveXtermAction, registerContextualInstanceAction, registerTerminalAction, registerTerminalActions, sharedWhenClause, shrinkWorkspaceFolderCwdPairs, switchTerminalShowTabsTitle, validateTerminalName };