@codingame/monaco-vscode-api 37.1.0 → 37.3.0

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

@@ -0,0 +1,1643 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { isMouseEvent, getActiveWindow, isPointerEvent, isKeyboardEvent } from '../../../../base/browser/dom.js';
+import { Action } from '../../../../base/common/actions.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { Iterable } from '../../../../base/common/iterator.js';
+import { KeyMod as KeyMod$1, KeyCode, KeyChord } from '../../../../base/common/keyCodes.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { isAbsolute } from '../../../../base/common/path.js';
+import { isWindows } from '../../../../base/common/platform.js';
+import { dirname } from '../../../../base/common/resources.js';
+import { isObject, hasKey, isString } from '../../../../base/common/types.js';
+import { URI } from '../../../../base/common/uri.js';
+import { ICodeEditorService } from '../../../../editor/browser/services/codeEditorService.service.js';
+import { ILanguageService } from '../../../../editor/common/languages/language.service.js';
+import { EndOfLinePreference } from '../../../../editor/common/model.js';
+import { getIconClasses } from '../../../../editor/common/services/getIconClasses.js';
+import { IModelService } from '../../../../editor/common/services/model.service.js';
+import { localize, localize2 } from '../../../../nls.js';
+import { AccessibleViewProviderId } from '../../../../platform/accessibility/browser/accessibleView.js';
+import { CONTEXT_ACCESSIBILITY_MODE_ENABLED } from '../../../../platform/accessibility/common/accessibility.js';
+import { registerAction2, Action2, MenuId } from '../../../../platform/actions/common/actions.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.service.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { FileKind } from '../../../../platform/files/common/files.js';
+import { KeybindingWeight } from '../../../../platform/keybinding/common/keybindingsRegistry.js';
+import { ILabelService } from '../../../../platform/label/common/label.service.js';
+import { IListService } from '../../../../platform/list/browser/listService.service.js';
+import '../../../../platform/notification/common/notification.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.service.js';
+import { IOpenerService } from '../../../../platform/opener/common/opener.service.js';
+import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.service.js';
+import { TerminalCapability } from '../../../../platform/terminal/common/capabilities/capabilities.js';
+import { TerminalLocation, TerminalExitReason, TerminalSettingId } from '../../../../platform/terminal/common/terminal.js';
+import { createProfileSchemaEnums } from '../../../../platform/terminal/common/terminalProfiles.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.service.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.service.js';
+import { PICK_WORKSPACE_FOLDER_COMMAND_ID } from '../../../browser/actions/workspaceCommands.js';
+import { CLOSE_EDITOR_COMMAND_ID } from '../../../browser/parts/editor/editorCommands.js';
+import { IConfigurationResolverService } from '../../../services/configurationResolver/common/configurationResolver.service.js';
+import { ConfigurationResolverExpression } from '../../../services/configurationResolver/common/configurationResolverExpression.js';
+import { editorGroupToColumn } from '../../../services/editor/common/editorGroupColumn.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.service.js';
+import { ACTIVE_GROUP, SIDE_GROUP, AUX_WINDOW_GROUP } from '../../../services/editor/common/editorService.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.service.js';
+import { IPreferencesService } from '../../../services/preferences/common/preferences.service.js';
+import { IRemoteAgentService } from '../../../services/remote/common/remoteAgentService.service.js';
+import { accessibleViewOnLastLine, accessibleViewCurrentProviderId, accessibleViewIsShown } from '../../accessibility/browser/accessibilityConfiguration.js';
+import { TerminalCommandId, TERMINAL_VIEW_ID } from '../common/terminal.js';
+import { ITerminalProfileResolverService, ITerminalProfileService } from '../common/terminal.service.js';
+import { TerminalContextKeys } from '../common/terminalContextKey.js';
+import { terminalStrings } from '../common/terminalStrings.js';
+import { Direction } from './terminal.js';
+import { ITerminalEditingService, ITerminalEditorService, ITerminalInstanceService, ITerminalGroupService, ITerminalConfigurationService, ITerminalService } from './terminal.service.js';
+import { isAuxiliaryWindow } from '../../../../base/browser/window.js';
+import { InstanceContext } from './terminalContextMenu.js';
+import { getIconId, getColorClass, getUriClasses } from './terminalIcon.js';
+import { newTerminalIcon, killTerminalIcon } from './terminalIcons.js';
+import { TerminalTabList } from './terminalTabsList.js';
+import { ResourceContextKey } from '../../../common/contextkeys.js';
+import { SeparatorSelectOption } from '../../../../base/browser/ui/selectBox/selectBox.js';
+import Severity$1 from '../../../../base/common/severity.js';
+
+const switchTerminalShowTabsTitle = ( localize(18963, "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(18964, "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(18965, "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(18966, "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(18967, "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(18967, "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(18968, "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$1.CtrlCmd | KeyMod$1.Shift | KeyMod$1.Alt | KeyCode.Backquote,
+            mac: {
+                primary: KeyMod$1.WinCtrl | KeyMod$1.Shift | KeyMod$1.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(18969, "Focus Previous Terminal in Terminal Group")),
+        keybinding: {
+            primary: KeyMod$1.Alt | KeyCode.LeftArrow,
+            secondary: [KeyMod$1.Alt | KeyCode.UpArrow],
+            mac: {
+                primary: KeyMod$1.Alt | KeyMod$1.CtrlCmd | KeyCode.LeftArrow,
+                secondary: [KeyMod$1.Alt | KeyMod$1.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(18970, "Focus Next Terminal in Terminal Group")),
+        keybinding: {
+            primary: KeyMod$1.Alt | KeyCode.RightArrow,
+            secondary: [KeyMod$1.Alt | KeyCode.DownArrow],
+            mac: {
+                primary: KeyMod$1.Alt | KeyMod$1.CtrlCmd | KeyCode.RightArrow,
+                secondary: [KeyMod$1.Alt | KeyMod$1.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(18971, "Resize Terminal Left")),
+        keybinding: {
+            linux: {
+                primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.LeftArrow
+            },
+            mac: {
+                primary: KeyMod$1.CtrlCmd | KeyMod$1.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(18972, "Resize Terminal Right")),
+        keybinding: {
+            linux: {
+                primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.RightArrow
+            },
+            mac: {
+                primary: KeyMod$1.CtrlCmd | KeyMod$1.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(18973, "Resize Terminal Up")),
+        keybinding: {
+            mac: {
+                primary: KeyMod$1.CtrlCmd | KeyMod$1.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(18974, "Resize Terminal Down")),
+        keybinding: {
+            mac: {
+                primary: KeyMod$1.CtrlCmd | KeyMod$1.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$1.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(18975, "Focus Terminal Tabs View")),
+        keybinding: {
+            primary: KeyMod$1.CtrlCmd | KeyMod$1.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(18976, "Focus Next Terminal Group")),
+        precondition: sharedWhenClause.terminalAvailable,
+        keybinding: {
+            primary: KeyMod$1.CtrlCmd | KeyCode.PageDown,
+            mac: {
+                primary: KeyMod$1.CtrlCmd | KeyMod$1.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(18977, "Focus Previous Terminal Group")),
+        precondition: sharedWhenClause.terminalAvailable,
+        keybinding: {
+            primary: KeyMod$1.CtrlCmd | KeyCode.PageUp,
+            mac: {
+                primary: KeyMod$1.CtrlCmd | KeyMod$1.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(18978, "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(18979, "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(18980, "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(18981, "Scroll Down (Line)")),
+        keybinding: {
+            primary: KeyMod$1.CtrlCmd | KeyMod$1.Alt | KeyCode.PageDown,
+            linux: {
+                primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.DownArrow
+            },
+            when: sharedWhenClause.focusInAny_and_normalBuffer,
+            weight: KeybindingWeight.WorkbenchContrib
+        },
+        precondition: sharedWhenClause.terminalAvailable,
+        run: xterm => xterm.scrollDownLine()
+    });
+    registerActiveXtermAction({
+        id: TerminalCommandId.ScrollDownPage,
+        title: ( localize2(18982, "Scroll Down (Page)")),
+        keybinding: {
+            primary: KeyMod$1.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(18983, "Scroll to Bottom")),
+        keybinding: {
+            primary: KeyMod$1.CtrlCmd | KeyCode.End,
+            linux: {
+                primary: KeyMod$1.Shift | KeyCode.End
+            },
+            when: sharedWhenClause.focusInAny_and_normalBuffer,
+            weight: KeybindingWeight.WorkbenchContrib
+        },
+        precondition: sharedWhenClause.terminalAvailable,
+        run: xterm => xterm.scrollToBottom()
+    });
+    registerActiveXtermAction({
+        id: TerminalCommandId.ScrollUpLine,
+        title: ( localize2(18984, "Scroll Up (Line)")),
+        keybinding: {
+            primary: KeyMod$1.CtrlCmd | KeyMod$1.Alt | KeyCode.PageUp,
+            linux: {
+                primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.UpArrow
+            },
+            when: sharedWhenClause.focusInAny_and_normalBuffer,
+            weight: KeybindingWeight.WorkbenchContrib
+        },
+        precondition: sharedWhenClause.terminalAvailable,
+        run: xterm => xterm.scrollUpLine()
+    });
+    registerActiveXtermAction({
+        id: TerminalCommandId.ScrollUpPage,
+        title: ( localize2(18985, "Scroll Up (Page)")),
+        f1: true,
+        keybinding: {
+            primary: KeyMod$1.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(18986, "Scroll to Top")),
+        keybinding: {
+            primary: KeyMod$1.CtrlCmd | KeyCode.Home,
+            linux: {
+                primary: KeyMod$1.Shift | KeyCode.Home
+            },
+            when: sharedWhenClause.focusInAny_and_normalBuffer,
+            weight: KeybindingWeight.WorkbenchContrib
+        },
+        precondition: sharedWhenClause.terminalAvailable,
+        run: xterm => xterm.scrollToTop()
+    });
+    registerActiveXtermAction({
+        id: TerminalCommandId.ClearSelection,
+        title: ( localize2(18987, "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(18988, "Detach Session")),
+        run: activeInstance => activeInstance.detachProcessAndDispose(TerminalExitReason.User)
+    });
+    registerTerminalAction({
+        id: TerminalCommandId.AttachToSession,
+        title: ( localize2(18989, "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(18990, "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$1.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$1.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(18991, "Select to Previous Command")),
+        keybinding: {
+            primary: KeyMod$1.CtrlCmd | KeyMod$1.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(18992, "Select to Next Command")),
+        keybinding: {
+            primary: KeyMod$1.CtrlCmd | KeyMod$1.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(18993, "Select to Previous Line")),
+        precondition: sharedWhenClause.terminalAvailable,
+        run: async (xterm, _, instance) => {
+            xterm.markTracker.selectToPreviousLine();
+            (instance || xterm).focus();
+        }
+    });
+    registerActiveXtermAction({
+        id: TerminalCommandId.SelectToNextLine,
+        title: ( localize2(18994, "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(18995, "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(18996, "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(18997, "No name argument provided")));
+                return;
+            }
+            activeInstance.rename(name);
+        }
+    });
+    registerActiveInstanceAction({
+        id: TerminalCommandId.Relaunch,
+        title: ( localize2(18998, "Relaunch Active Terminal")),
+        run: activeInstance => activeInstance.relaunch()
+    });
+    registerTerminalAction({
+        id: TerminalCommandId.Split,
+        title: terminalStrings.split,
+        precondition: ( ContextKeyExpr.or(
+            TerminalContextKeys.processSupported,
+            TerminalContextKeys.webExtensionContributedProfile
+        )),
+        keybinding: {
+            primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.Digit5,
+            weight: KeybindingWeight.WorkbenchContrib,
+            mac: {
+                primary: KeyMod$1.CtrlCmd | KeyCode.Backslash,
+                secondary: [KeyMod$1.WinCtrl | KeyMod$1.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$1.CtrlCmd | KeyMod$1.Shift | KeyCode.Digit5,
+            mac: {
+                primary: KeyMod$1.CtrlCmd | KeyCode.Backslash,
+                secondary: [KeyMod$1.WinCtrl | KeyMod$1.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(18999, "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(19000, "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(19001, "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(19002, "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(19003, "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(19004, "Select All")),
+        precondition: sharedWhenClause.terminalAvailable,
+        keybinding: [{
+            primary: 0,
+            mac: {
+                primary: KeyMod$1.CtrlCmd | KeyCode.KeyA
+            },
+            weight: KeybindingWeight.WorkbenchContrib,
+            when: TerminalContextKeys.focusInAny
+        }],
+        run: xterm => xterm.selectAll()
+    });
+    registerTerminalAction({
+        id: TerminalCommandId.New,
+        title: ( localize2(19005, "Create New Terminal")),
+        precondition: ( ContextKeyExpr.or(
+            TerminalContextKeys.processSupported,
+            TerminalContextKeys.webExtensionContributedProfile
+        )),
+        icon: newTerminalIcon,
+        keybinding: {
+            primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.Backquote,
+            mac: {
+                primary: KeyMod$1.WinCtrl | KeyMod$1.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(19006, "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(19007, "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(19008, "Kill the Active Terminal in Editor Area")),
+        precondition: sharedWhenClause.terminalAvailable,
+        keybinding: {
+            primary: KeyMod$1.CtrlCmd | KeyCode.KeyW,
+            win: {
+                primary: KeyMod$1.CtrlCmd | KeyCode.F4,
+                secondary: [KeyMod$1.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$1.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$1.CtrlCmd | KeyCode.KeyK, KeyMod$1.CtrlCmd | KeyCode.KeyI),
+            weight: KeybindingWeight.WorkbenchContrib,
+            when: ( ContextKeyExpr.or(TerminalContextKeys.tabsFocus, TerminalContextKeys.focus))
+        },
+        run: c => c.groupService.focusHover()
+    });
+    registerActiveInstanceAction({
+        id: TerminalCommandId.Clear,
+        title: ( localize2(19009, "Clear")),
+        precondition: sharedWhenClause.terminalAvailable,
+        keybinding: [{
+            primary: 0,
+            mac: {
+                primary: KeyMod$1.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(19010, "Select Default Profile")),
+        run: c => c.service.showProfileQuickPick("setDefault")
+    });
+    registerTerminalAction({
+        id: TerminalCommandId.ConfigureTerminalSettings,
+        title: ( localize2(19011, "Configure Terminal Settings")),
+        precondition: sharedWhenClause.terminalAvailable,
+        run: (c, accessor) => accessor.get(IPreferencesService).openSettings({
+            jsonEditor: false,
+            query: "@feature:terminal"
+        })
+    });
+    registerActiveInstanceAction({
+        id: TerminalCommandId.SetDimensions,
+        title: ( localize2(19012, "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$1.Alt | KeyCode.KeyZ,
+            weight: KeybindingWeight.WorkbenchContrib,
+            when: TerminalContextKeys.focus
+        },
+        run: instance => instance.toggleSizeToContentWidth()
+    });
+    registerTerminalAction({
+        id: TerminalCommandId.SwitchTerminal,
+        title: ( localize2(19013, "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(19014, "Providing no name will reset it to the default value")),
+            severity: Severity$1.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(19015, "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(19016, "The name of the profile to create")),
+                                    type: "string",
+                                    enum: profileEnum.values,
+                                    markdownEnumDescriptions: profileEnum.markdownDescriptions
+                                },
+                                location: {
+                                    description: ( localize(19017, "Where to create the terminal")),
+                                    type: "string",
+                                    enum: ["view", "editor"],
+                                    enumDescriptions: [( localize(19018, "Create the terminal in the terminal view")), ( localize(19019, "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(18964, "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(19020, "(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(18964, "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(19021, "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 };