@codingame/monaco-vscode-api 9.0.2 → 10.0.0

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

@@ -0,0 +1,1770 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { BrowserFeatures } from '../../../../base/browser/canIUse.js';
+import { Action } from '../../../../base/common/actions.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { KeyChord } from '../../../../base/common/keyCodes.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { isLinux, isWindows } from '../../../../base/common/platform.js';
+import { isString, isObject } from '../../../../base/common/types.js';
+import { URI } from '../../../../base/common/uri.js';
+import { ICodeEditorService } from '../../../../editor/browser/services/codeEditorService.js';
+import { localize, localize2 } from '../../../../nls.js';
+import { CONTEXT_ACCESSIBILITY_MODE_ENABLED } from '../../../../platform/accessibility/common/accessibility.js';
+import { registerAction2, MenuId, Action2 } 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 { 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 { TerminalLocation, TerminalExitReason } from '../../../../platform/terminal/common/terminal.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 { ITerminalGroupService, ITerminalInstanceService, ITerminalService, ITerminalConfigurationService, ITerminalEditorService } from './terminal.service.js';
+import { TerminalQuickAccessProvider } from './terminalQuickAccess.js';
+import { TERMINAL_VIEW_ID } from '../common/terminal.js';
+import { ITerminalProfileService, ITerminalProfileResolverService } from '../common/terminal.service.js';
+import { TerminalContextKeys } from '../common/terminalContextKey.js';
+import { createProfileSchemaEnums } from '../../../../platform/terminal/common/terminalProfiles.js';
+import { terminalStrings } from '../common/terminalStrings.js';
+import { IConfigurationResolverService } from '../../../services/configurationResolver/common/configurationResolver.service.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.service.js';
+import { IHistoryService } from '../../../services/history/common/history.service.js';
+import { IPreferencesService } from '../../../services/preferences/common/preferences.service.js';
+import { IRemoteAgentService } from '../../../services/remote/common/remoteAgentService.service.js';
+import { SIDE_GROUP } from '../../../services/editor/common/editorService.js';
+import { isAbsolute } from '../../../../base/common/path.js';
+import { AbstractVariableResolverService } from '../../../services/configurationResolver/common/variableResolver.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.service.js';
+import { getIconId, getColorClass, getUriClasses } from './terminalIcon.js';
+import { getCommandHistory, clearShellFileHistory } from '../common/history.js';
+import { IModelService } from '../../../../editor/common/services/model.js';
+import { ILanguageService } from '../../../../editor/common/languages/language.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { dirname } from '../../../../base/common/resources.js';
+import { getIconClasses } from '../../../../editor/common/services/getIconClasses.js';
+import { FileKind } from '../../../../platform/files/common/files.js';
+import { IClipboardService } from '../../../../platform/clipboard/common/clipboardService.service.js';
+import { newTerminalIcon, killTerminalIcon } from './terminalIcons.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.service.js';
+import { Iterable } from '../../../../base/common/iterator.js';
+import { accessibleViewIsShown, accessibleViewCurrentProviderId, accessibleViewOnLastLine } from '../../accessibility/browser/accessibilityConfiguration.js';
+import { isMouseEvent, isPointerEvent, isKeyboardEvent } from '../../../../base/browser/dom.js';
+import { editorGroupToColumn } from '../../../services/editor/common/editorGroupColumn.js';
+import { InstanceContext } from './terminalContextMenu.js';
+import Severity$1 from '../../../../base/common/severity.js';
+const switchTerminalActionViewItemSeparator = '\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500';
+const switchTerminalShowTabsTitle = ( localize(8939, "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(8940, "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.getCwd();
+    }
+}
+const terminalSendSequenceCommand = async (accessor, args) => {
+    const instance = accessor.get(ITerminalService).activeInstance;
+    if (instance) {
+        const text = isObject(args) && 'text' in args ? toOptionalString(args.text) : undefined;
+        if (!text) {
+            return;
+        }
+        const configurationResolverService = accessor.get(IConfigurationResolverService);
+        const workspaceContextService = accessor.get(IWorkspaceContextService);
+        const historyService = accessor.get(IHistoryService);
+        const activeWorkspaceRootUri = historyService.getLastActiveWorkspaceRoot(instance.isRemote ? Schemas.vscodeRemote : Schemas.file);
+        const lastActiveWorkspaceRoot = activeWorkspaceRootUri ? workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri) ?? undefined : undefined;
+        const resolvedText = await configurationResolverService.resolveAsync(lastActiveWorkspaceRoot, text);
+        instance.sendText(resolvedText, false);
+    }
+};
+let TerminalLaunchHelpAction = class TerminalLaunchHelpAction extends Action {
+    constructor(_openerService) {
+        super('workbench.action.terminal.launchHelp', ( localize(8941, "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 = getSelectedInstances2(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),
+        profileService: accessor.get(ITerminalProfileService),
+        profileResolverService: accessor.get(ITerminalProfileResolverService)
+    };
+}
+function registerTerminalActions() {
+    registerTerminalAction({
+        id: "workbench.action.terminal.newInActiveWorkspace" ,
+        title: ( localize2(8942, 'Create New Terminal (In Active Workspace)')),
+        run: async (c) => {
+            if (c.service.isProcessSupportRegistered) {
+                const instance = await c.service.createTerminal({ location: c.service.defaultLocation });
+                if (!instance) {
+                    return;
+                }
+                c.service.setActiveInstance(instance);
+            }
+            await c.groupService.showPanel(true);
+        }
+    });
+    refreshTerminalActions([]);
+    registerTerminalAction({
+        id: "workbench.action.createTerminalEditor" ,
+        title: ( localize2(8943, 'Create New Terminal in Editor Area')),
+        run: async (c, _, args) => {
+            const options = (isObject(args) && 'location' in args) ? args : { location: TerminalLocation.Editor };
+            const instance = await c.service.createTerminal(options);
+            await instance.focusWhenReady();
+        }
+    });
+    registerTerminalAction({
+        id: "workbench.action.createTerminalEditorSameGroup" ,
+        title: ( localize2(8943, '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: "workbench.action.createTerminalEditorSide" ,
+        title: ( localize2(8944, '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();
+        }
+    });
+    registerContextualInstanceAction({
+        id: "workbench.action.terminal.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: "workbench.action.terminal.moveIntoNewWindow" ,
+        title: terminalStrings.moveIntoNewWindow,
+        precondition: sharedWhenClause.terminalAvailable_and_opened,
+        run: (instance, c) => c.service.moveIntoNewEditor(instance),
+        runAfter: (instances) => instances.at(-1)?.focus()
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.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: "workbench.action.terminal.focusPreviousPane" ,
+        title: ( localize2(8945, 'Focus Previous Terminal in Terminal Group')),
+        keybinding: {
+            primary: 512  | 15 ,
+            secondary: [512  | 16 ],
+            mac: {
+                primary: 512  | 2048  | 15 ,
+                secondary: [512  | 2048  | 16 ]
+            },
+            when: TerminalContextKeys.focus,
+            weight: 200
+        },
+        precondition: sharedWhenClause.terminalAvailable,
+        run: async (c) => {
+            c.groupService.activeGroup?.focusPreviousPane();
+            await c.groupService.showPanel(true);
+        }
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.focusNextPane" ,
+        title: ( localize2(8946, 'Focus Next Terminal in Terminal Group')),
+        keybinding: {
+            primary: 512  | 17 ,
+            secondary: [512  | 18 ],
+            mac: {
+                primary: 512  | 2048  | 17 ,
+                secondary: [512  | 2048  | 18 ]
+            },
+            when: TerminalContextKeys.focus,
+            weight: 200
+        },
+        precondition: sharedWhenClause.terminalAvailable,
+        run: async (c) => {
+            c.groupService.activeGroup?.focusNextPane();
+            await c.groupService.showPanel(true);
+        }
+    });
+    registerActiveInstanceAction({
+        id: "workbench.action.terminal.runRecentCommand" ,
+        title: ( localize2(8947, 'Run Recent Command...')),
+        precondition: sharedWhenClause.terminalAvailable,
+        keybinding: [
+            {
+                primary: 2048  | 48 ,
+                when: ( (ContextKeyExpr.and(
+                    CONTEXT_ACCESSIBILITY_MODE_ENABLED,
+                     (ContextKeyExpr.or(TerminalContextKeys.focus,  (ContextKeyExpr.and(
+                        accessibleViewIsShown,
+                         (accessibleViewCurrentProviderId.isEqualTo("terminal" ))
+                    ))))
+                ))),
+                weight: 200
+            },
+            {
+                primary: 2048  | 512  | 48 ,
+                mac: { primary: 256  | 512  | 48  },
+                when: ( (ContextKeyExpr.and(
+                    TerminalContextKeys.focus,
+                     (CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate())
+                ))),
+                weight: 200
+            }
+        ],
+        run: async (activeInstance, c) => {
+            await activeInstance.runRecent('command');
+            if (activeInstance?.target === TerminalLocation.Editor) {
+                await c.editorService.revealActiveEditor();
+            }
+            else {
+                await c.groupService.showPanel(false);
+            }
+        }
+    });
+    registerActiveInstanceAction({
+        id: "workbench.action.terminal.copyLastCommand" ,
+        title: ( localize2(8948, "Copy Last Command")),
+        precondition: sharedWhenClause.terminalAvailable,
+        run: async (instance, c, accessor) => {
+            const clipboardService = accessor.get(IClipboardService);
+            const commands = instance.capabilities.get(2 )?.commands;
+            if (!commands || commands.length === 0) {
+                return;
+            }
+            const command = commands[commands.length - 1];
+            if (!command.command) {
+                return;
+            }
+            await clipboardService.writeText(command.command);
+        }
+    });
+    registerActiveInstanceAction({
+        id: "workbench.action.terminal.copyLastCommandOutput" ,
+        title: ( localize2(8949, "Copy Last Command Output")),
+        precondition: sharedWhenClause.terminalAvailable,
+        run: async (instance, c, accessor) => {
+            const clipboardService = accessor.get(IClipboardService);
+            const commands = instance.capabilities.get(2 )?.commands;
+            if (!commands || commands.length === 0) {
+                return;
+            }
+            const command = commands[commands.length - 1];
+            if (!command?.hasOutput()) {
+                return;
+            }
+            const output = command.getOutput();
+            if (isString(output)) {
+                await clipboardService.writeText(output);
+            }
+        }
+    });
+    registerActiveInstanceAction({
+        id: "workbench.action.terminal.copyLastCommandAndLastCommandOutput" ,
+        title: ( localize2(8950, "Copy Last Command and Output")),
+        precondition: sharedWhenClause.terminalAvailable,
+        run: async (instance, c, accessor) => {
+            const clipboardService = accessor.get(IClipboardService);
+            const commands = instance.capabilities.get(2 )?.commands;
+            if (!commands || commands.length === 0) {
+                return;
+            }
+            const command = commands[commands.length - 1];
+            if (!command?.hasOutput()) {
+                return;
+            }
+            const output = command.getOutput();
+            if (isString(output)) {
+                await clipboardService.writeText(`${command.command !== '' ? command.command + '\n' : ''}${output}`);
+            }
+        }
+    });
+    registerActiveInstanceAction({
+        id: "workbench.action.terminal.goToRecentDirectory" ,
+        title: ( localize2(8951, 'Go to Recent Directory...')),
+        metadata: {
+            description: ( localize2(8952, 'Goes to a recent folder')),
+        },
+        precondition: sharedWhenClause.terminalAvailable,
+        keybinding: {
+            primary: 2048  | 37 ,
+            when: TerminalContextKeys.focus,
+            weight: 200
+        },
+        run: async (activeInstance, c) => {
+            await activeInstance.runRecent('cwd');
+            if (activeInstance?.target === TerminalLocation.Editor) {
+                await c.editorService.revealActiveEditor();
+            }
+            else {
+                await c.groupService.showPanel(false);
+            }
+        }
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.resizePaneLeft" ,
+        title: ( localize2(8953, 'Resize Terminal Left')),
+        keybinding: {
+            linux: { primary: 2048  | 1024  | 15  },
+            mac: { primary: 2048  | 256  | 15  },
+            when: TerminalContextKeys.focus,
+            weight: 200
+        },
+        precondition: sharedWhenClause.terminalAvailable,
+        run: (c) => c.groupService.activeGroup?.resizePane(0 )
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.resizePaneRight" ,
+        title: ( localize2(8954, 'Resize Terminal Right')),
+        keybinding: {
+            linux: { primary: 2048  | 1024  | 17  },
+            mac: { primary: 2048  | 256  | 17  },
+            when: TerminalContextKeys.focus,
+            weight: 200
+        },
+        precondition: sharedWhenClause.terminalAvailable,
+        run: (c) => c.groupService.activeGroup?.resizePane(1 )
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.resizePaneUp" ,
+        title: ( localize2(8955, 'Resize Terminal Up')),
+        keybinding: {
+            mac: { primary: 2048  | 256  | 16  },
+            when: TerminalContextKeys.focus,
+            weight: 200
+        },
+        precondition: sharedWhenClause.terminalAvailable,
+        run: (c) => c.groupService.activeGroup?.resizePane(2 )
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.resizePaneDown" ,
+        title: ( localize2(8956, 'Resize Terminal Down')),
+        keybinding: {
+            mac: { primary: 2048  | 256  | 18  },
+            when: TerminalContextKeys.focus,
+            weight: 200
+        },
+        precondition: sharedWhenClause.terminalAvailable,
+        run: (c) => c.groupService.activeGroup?.resizePane(3 )
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.focus" ,
+        title: terminalStrings.focus,
+        keybinding: {
+            when: ( (ContextKeyExpr.and(
+                CONTEXT_ACCESSIBILITY_MODE_ENABLED,
+                accessibleViewOnLastLine,
+                 (accessibleViewCurrentProviderId.isEqualTo("terminal" ))
+            ))),
+            primary: 2048  | 18 ,
+            weight: 200
+        },
+        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);
+            focusActiveTerminal(instance, c);
+        }
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.focusTabs" ,
+        title: ( localize2(8957, 'Focus Terminal Tabs View')),
+        keybinding: {
+            primary: 2048  | 1024  | 93 ,
+            weight: 200 ,
+            when: ( (ContextKeyExpr.or(TerminalContextKeys.tabsFocus, TerminalContextKeys.focus))),
+        },
+        precondition: sharedWhenClause.terminalAvailable,
+        run: (c) => c.groupService.focusTabs()
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.focusNext" ,
+        title: ( localize2(8958, 'Focus Next Terminal Group')),
+        precondition: sharedWhenClause.terminalAvailable,
+        keybinding: {
+            primary: 2048  | 12 ,
+            mac: {
+                primary: 2048  | 1024  | 94
+            },
+            when: ( (ContextKeyExpr.and(
+                TerminalContextKeys.focus,
+                 (TerminalContextKeys.editorFocus.negate())
+            ))),
+            weight: 200
+        },
+        run: async (c) => {
+            c.groupService.setActiveGroupToNext();
+            await c.groupService.showPanel(true);
+        }
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.focusPrevious" ,
+        title: ( localize2(8959, 'Focus Previous Terminal Group')),
+        precondition: sharedWhenClause.terminalAvailable,
+        keybinding: {
+            primary: 2048  | 11 ,
+            mac: {
+                primary: 2048  | 1024  | 92
+            },
+            when: ( (ContextKeyExpr.and(
+                TerminalContextKeys.focus,
+                 (TerminalContextKeys.editorFocus.negate())
+            ))),
+            weight: 200
+        },
+        run: async (c) => {
+            c.groupService.setActiveGroupToPrevious();
+            await c.groupService.showPanel(true);
+        }
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.runSelectedText" ,
+        title: ( localize2(8960, '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 ? 1  : 2 ;
+                text = editor.getModel().getValueInRange(selection, endOfLinePreference);
+            }
+            instance.sendText(text, true, true);
+            await c.service.revealActiveTerminal(true);
+        }
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.runActiveFile" ,
+        title: ( localize2(8961, '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.isRemote : (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(8962, 'Only files on disk can be run in the terminal')));
+                return;
+            }
+            await instance.sendPath(uri, true);
+            return c.groupService.showPanel();
+        }
+    });
+    registerActiveXtermAction({
+        id: "workbench.action.terminal.scrollDown" ,
+        title: ( localize2(8963, 'Scroll Down (Line)')),
+        keybinding: {
+            primary: 2048  | 512  | 12 ,
+            linux: { primary: 2048  | 1024  | 18  },
+            when: sharedWhenClause.focusInAny_and_normalBuffer,
+            weight: 200
+        },
+        precondition: sharedWhenClause.terminalAvailable,
+        run: (xterm) => xterm.scrollDownLine()
+    });
+    registerActiveXtermAction({
+        id: "workbench.action.terminal.scrollDownPage" ,
+        title: ( localize2(8964, 'Scroll Down (Page)')),
+        keybinding: {
+            primary: 1024  | 12 ,
+            mac: { primary: 12  },
+            when: sharedWhenClause.focusInAny_and_normalBuffer,
+            weight: 200
+        },
+        precondition: sharedWhenClause.terminalAvailable,
+        run: (xterm) => xterm.scrollDownPage()
+    });
+    registerActiveXtermAction({
+        id: "workbench.action.terminal.scrollToBottom" ,
+        title: ( localize2(8965, 'Scroll to Bottom')),
+        keybinding: {
+            primary: 2048  | 13 ,
+            linux: { primary: 1024  | 13  },
+            when: sharedWhenClause.focusInAny_and_normalBuffer,
+            weight: 200
+        },
+        precondition: sharedWhenClause.terminalAvailable,
+        run: (xterm) => xterm.scrollToBottom()
+    });
+    registerActiveXtermAction({
+        id: "workbench.action.terminal.scrollUp" ,
+        title: ( localize2(8966, 'Scroll Up (Line)')),
+        keybinding: {
+            primary: 2048  | 512  | 11 ,
+            linux: { primary: 2048  | 1024  | 16  },
+            when: sharedWhenClause.focusInAny_and_normalBuffer,
+            weight: 200
+        },
+        precondition: sharedWhenClause.terminalAvailable,
+        run: (xterm) => xterm.scrollUpLine()
+    });
+    registerActiveXtermAction({
+        id: "workbench.action.terminal.scrollUpPage" ,
+        title: ( localize2(8967, 'Scroll Up (Page)')),
+        f1: true,
+        category,
+        keybinding: {
+            primary: 1024  | 11 ,
+            mac: { primary: 11  },
+            when: sharedWhenClause.focusInAny_and_normalBuffer,
+            weight: 200
+        },
+        precondition: sharedWhenClause.terminalAvailable,
+        run: (xterm) => xterm.scrollUpPage()
+    });
+    registerActiveXtermAction({
+        id: "workbench.action.terminal.scrollToTop" ,
+        title: ( localize2(8968, 'Scroll to Top')),
+        keybinding: {
+            primary: 2048  | 14 ,
+            linux: { primary: 1024  | 14  },
+            when: sharedWhenClause.focusInAny_and_normalBuffer,
+            weight: 200
+        },
+        precondition: sharedWhenClause.terminalAvailable,
+        run: (xterm) => xterm.scrollToTop()
+    });
+    registerActiveXtermAction({
+        id: "workbench.action.terminal.clearSelection" ,
+        title: ( localize2(8969, 'Clear Selection')),
+        keybinding: {
+            primary: 9 ,
+            when: ( (ContextKeyExpr.and(
+                TerminalContextKeys.focusInAny,
+                TerminalContextKeys.textSelected,
+                TerminalContextKeys.notFindVisible
+            ))),
+            weight: 200
+        },
+        precondition: sharedWhenClause.terminalAvailable,
+        run: (xterm) => {
+            if (xterm.hasSelection()) {
+                xterm.clearSelection();
+            }
+        }
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.changeIcon" ,
+        title: terminalStrings.changeIcon,
+        precondition: sharedWhenClause.terminalAvailable,
+        run: (c, _, args) => getResourceOrActiveInstance(c, args)?.changeIcon()
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.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 getSelectedInstances(accessor) ?? []) {
+                icon = await terminal.changeIcon(icon);
+            }
+        }
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.changeColor" ,
+        title: terminalStrings.changeColor,
+        precondition: sharedWhenClause.terminalAvailable,
+        run: (c, _, args) => getResourceOrActiveInstance(c, args)?.changeColor()
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.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 getSelectedInstances(accessor) ?? []) {
+                const skipQuickPick = i !== 0;
+                color = await terminal.changeColor(color, skipQuickPick);
+                i++;
+            }
+        }
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.rename" ,
+        title: terminalStrings.rename,
+        precondition: sharedWhenClause.terminalAvailable,
+        run: (c, accessor, args) => renameWithQuickPick(c, accessor, args)
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.renameActiveTab" ,
+        title: terminalStrings.rename,
+        f1: false,
+        keybinding: {
+            primary: 60 ,
+            mac: {
+                primary: 3
+            },
+            when: ( (ContextKeyExpr.and(TerminalContextKeys.tabsFocus))),
+            weight: 200
+        },
+        precondition: sharedWhenClause.terminalAvailable_and_singularSelection,
+        run: async (c, accessor) => {
+            const terminalGroupService = accessor.get(ITerminalGroupService);
+            const notificationService = accessor.get(INotificationService);
+            const instances = getSelectedInstances(accessor);
+            const firstInstance = instances?.[0];
+            if (!firstInstance) {
+                return;
+            }
+            if (terminalGroupService.lastAccessedMenu === 'inline-tab') {
+                return renameWithQuickPick(c, accessor, firstInstance);
+            }
+            c.service.setEditingTerminal(firstInstance);
+            c.service.setEditable(firstInstance, {
+                validationMessage: value => validateTerminalName(value),
+                onFinish: async (value, success) => {
+                    c.service.setEditable(firstInstance, null);
+                    c.service.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: "workbench.action.terminal.detachSession" ,
+        title: ( localize2(8970, 'Detach Session')),
+        run: (activeInstance) => activeInstance.detachProcessAndDispose(TerminalExitReason.User)
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.attachToSession" ,
+        title: ( localize2(8971, '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(8972, '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);
+            }
+        }
+    });
+    registerTerminalAction({
+        id: "workbench.action.quickOpenTerm" ,
+        title: ( localize2(8973, 'Switch Active Terminal')),
+        precondition: sharedWhenClause.terminalAvailable,
+        run: (c, accessor) => accessor.get(IQuickInputService).quickAccess.show(TerminalQuickAccessProvider.PREFIX)
+    });
+    registerActiveInstanceAction({
+        id: "workbench.action.terminal.scrollToPreviousCommand" ,
+        title: terminalStrings.scrollToPreviousCommand,
+        keybinding: {
+            primary: 2048  | 16 ,
+            when: ( (ContextKeyExpr.and(
+                TerminalContextKeys.focus,
+                 (CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate())
+            ))),
+            weight: 200
+        },
+        precondition: sharedWhenClause.terminalAvailable,
+        icon: Codicon.arrowUp,
+        menu: [
+            {
+                id: MenuId.ViewTitle,
+                group: 'navigation',
+                order: 4,
+                when: ( (ContextKeyExpr.equals('view', TERMINAL_VIEW_ID))),
+                isHiddenByDefault: true
+            }
+        ],
+        run: (activeInstance) => activeInstance.xterm?.markTracker.scrollToPreviousMark(undefined, undefined, ( (activeInstance.capabilities.has(2 ))))
+    });
+    registerActiveInstanceAction({
+        id: "workbench.action.terminal.scrollToNextCommand" ,
+        title: terminalStrings.scrollToNextCommand,
+        keybinding: {
+            primary: 2048  | 18 ,
+            when: ( (ContextKeyExpr.and(
+                TerminalContextKeys.focus,
+                 (CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate())
+            ))),
+            weight: 200
+        },
+        precondition: sharedWhenClause.terminalAvailable,
+        icon: Codicon.arrowDown,
+        menu: [
+            {
+                id: MenuId.ViewTitle,
+                group: 'navigation',
+                order: 4,
+                when: ( (ContextKeyExpr.equals('view', TERMINAL_VIEW_ID))),
+                isHiddenByDefault: true
+            }
+        ],
+        run: (activeInstance) => {
+            activeInstance.xterm?.markTracker.scrollToNextMark();
+            activeInstance.focus();
+        }
+    });
+    registerActiveInstanceAction({
+        id: "workbench.action.terminal.selectToPreviousCommand" ,
+        title: ( localize2(8974, 'Select To Previous Command')),
+        keybinding: {
+            primary: 2048  | 1024  | 16 ,
+            when: TerminalContextKeys.focus,
+            weight: 200
+        },
+        precondition: sharedWhenClause.terminalAvailable,
+        run: (activeInstance) => {
+            activeInstance.xterm?.markTracker.selectToPreviousMark();
+            activeInstance.focus();
+        }
+    });
+    registerActiveInstanceAction({
+        id: "workbench.action.terminal.selectToNextCommand" ,
+        title: ( localize2(8975, 'Select To Next Command')),
+        keybinding: {
+            primary: 2048  | 1024  | 18 ,
+            when: TerminalContextKeys.focus,
+            weight: 200
+        },
+        precondition: sharedWhenClause.terminalAvailable,
+        run: (activeInstance) => {
+            activeInstance.xterm?.markTracker.selectToNextMark();
+            activeInstance.focus();
+        }
+    });
+    registerActiveXtermAction({
+        id: "workbench.action.terminal.selectToPreviousLine" ,
+        title: ( localize2(8976, 'Select To Previous Line')),
+        precondition: sharedWhenClause.terminalAvailable,
+        run: async (xterm, _, instance) => {
+            xterm.markTracker.selectToPreviousLine();
+            (instance || xterm).focus();
+        }
+    });
+    registerActiveXtermAction({
+        id: "workbench.action.terminal.selectToNextLine" ,
+        title: ( localize2(8977, 'Select To Next Line')),
+        precondition: sharedWhenClause.terminalAvailable,
+        run: async (xterm, _, instance) => {
+            xterm.markTracker.selectToNextLine();
+            (instance || xterm).focus();
+        }
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.sendSequence" ,
+        title: terminalStrings.sendSequence,
+        f1: false,
+        metadata: {
+            description: terminalStrings.sendSequence.value,
+            args: [{
+                    name: 'args',
+                    schema: {
+                        type: 'object',
+                        required: ['text'],
+                        properties: {
+                            text: {
+                                description: ( localize(8978, "The sequence of text to send to the terminal")),
+                                type: 'string'
+                            }
+                        },
+                    }
+                }]
+        },
+        run: (c, accessor, args) => terminalSendSequenceCommand(accessor, args)
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.newWithCwd" ,
+        title: terminalStrings.newWithCwd,
+        metadata: {
+            description: terminalStrings.newWithCwd.value,
+            args: [{
+                    name: 'args',
+                    schema: {
+                        type: 'object',
+                        required: ['cwd'],
+                        properties: {
+                            cwd: {
+                                description: ( localize(8979, "The directory to start the terminal at")),
+                                type: 'string'
+                            }
+                        },
+                    }
+                }]
+        },
+        run: async (c, _, args) => {
+            const cwd = isObject(args) && 'cwd' in 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: "workbench.action.terminal.renameWithArg" ,
+        title: terminalStrings.renameWithArgs,
+        metadata: {
+            description: terminalStrings.renameWithArgs.value,
+            args: [{
+                    name: 'args',
+                    schema: {
+                        type: 'object',
+                        required: ['name'],
+                        properties: {
+                            name: {
+                                description: ( localize(8980, "The new name for the terminal")),
+                                type: 'string',
+                                minLength: 1
+                            }
+                        }
+                    }
+                }]
+        },
+        precondition: sharedWhenClause.terminalAvailable,
+        run: async (activeInstance, c, accessor, args) => {
+            const notificationService = accessor.get(INotificationService);
+            const name = isObject(args) && 'name' in args ? toOptionalString(args.name) : undefined;
+            if (!name) {
+                notificationService.warn(( localize(8981, "No name argument provided")));
+                return;
+            }
+            activeInstance.rename(name);
+        }
+    });
+    registerActiveInstanceAction({
+        id: "workbench.action.terminal.relaunch" ,
+        title: ( localize2(8982, 'Relaunch Active Terminal')),
+        run: (activeInstance) => activeInstance.relaunch()
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.split" ,
+        title: terminalStrings.split,
+        precondition: ( (ContextKeyExpr.or(
+            TerminalContextKeys.processSupported,
+            TerminalContextKeys.webExtensionContributedProfile
+        ))),
+        keybinding: {
+            primary: 2048  | 1024  | 26 ,
+            weight: 200 ,
+            mac: {
+                primary: 2048  | 93 ,
+                secondary: [256  | 1024  | 26 ]
+            },
+            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: "workbench.action.terminal.splitActiveTab" ,
+        title: terminalStrings.split,
+        f1: false,
+        keybinding: {
+            primary: 2048  | 1024  | 26 ,
+            mac: {
+                primary: 2048  | 93 ,
+                secondary: [256  | 1024  | 26 ]
+            },
+            weight: 200 ,
+            when: TerminalContextKeys.tabsFocus
+        },
+        run: async (c, accessor) => {
+            const instances = getSelectedInstances(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: "workbench.action.terminal.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: "workbench.action.terminal.joinActiveTab" ,
+        title: ( localize2(8983, 'Join Terminals')),
+        precondition: ( (ContextKeyExpr.and(
+            sharedWhenClause.terminalAvailable,
+             (TerminalContextKeys.tabsSingularSelection.toNegated())
+        ))),
+        run: async (c, accessor) => {
+            const instances = getSelectedInstances(accessor);
+            if (instances && instances.length > 1) {
+                c.groupService.joinInstances(instances);
+            }
+        }
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.join" ,
+        title: ( localize2(8984, '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(8985, '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(8986, 'All terminals are joined already')));
+                return;
+            }
+            const result = await quickInputService.pick(picks, {});
+            if (result) {
+                c.groupService.joinInstances([result.terminal, c.groupService.activeInstance]);
+            }
+        }
+    });
+    registerActiveInstanceAction({
+        id: "workbench.action.terminal.splitInActiveWorkspace" ,
+        title: ( localize2(8987, '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: "workbench.action.terminal.selectAll" ,
+        title: ( localize2(8988, 'Select All')),
+        precondition: sharedWhenClause.terminalAvailable,
+        keybinding: [{
+                primary: 0,
+                mac: { primary: 2048  | 31  },
+                weight: 200 ,
+                when: TerminalContextKeys.focusInAny
+            }],
+        run: (xterm) => xterm.selectAll()
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.new" ,
+        title: ( localize2(8989, 'Create New Terminal')),
+        precondition: ( (ContextKeyExpr.or(
+            TerminalContextKeys.processSupported,
+            TerminalContextKeys.webExtensionContributedProfile
+        ))),
+        icon: newTerminalIcon,
+        keybinding: {
+            primary: 2048  | 1024  | 91 ,
+            mac: { primary: 256  | 1024  | 91  },
+            weight: 200
+        },
+        run: async (c, accessor, args) => {
+            let eventOrOptions = isObject(args) ? args : undefined;
+            const workspaceContextService = accessor.get(IWorkspaceContextService);
+            const commandService = accessor.get(ICommandService);
+            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;
+                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("workbench.action.terminal.newWithProfile" );
+                }
+                else {
+                    commandService.executeCommand("workbench.action.terminal.toggleTerminal" );
+                }
+            }
+        }
+    });
+    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: "workbench.action.terminal.kill" ,
+        title: ( localize2(8990, 'Kill the Active Terminal Instance')),
+        precondition: ( (ContextKeyExpr.or(sharedWhenClause.terminalAvailable, TerminalContextKeys.isOpen))),
+        icon: killTerminalIcon,
+        run: async (c) => killInstance(c, c.groupService.activeInstance)
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.killViewOrEditor" ,
+        title: terminalStrings.kill,
+        f1: false,
+        precondition: ( (ContextKeyExpr.or(sharedWhenClause.terminalAvailable, TerminalContextKeys.isOpen))),
+        run: async (c) => killInstance(c, c.service.activeInstance)
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.killAll" ,
+        title: ( localize2(8991, '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: "workbench.action.terminal.killEditor" ,
+        title: ( localize2(8992, 'Kill the Active Terminal in Editor Area')),
+        precondition: sharedWhenClause.terminalAvailable,
+        keybinding: {
+            primary: 2048  | 53 ,
+            win: { primary: 2048  | 62 , secondary: [2048  | 53 ] },
+            weight: 200 ,
+            when: ( (ContextKeyExpr.and(TerminalContextKeys.focus, TerminalContextKeys.editorFocus)))
+        },
+        run: (c, accessor) => accessor.get(ICommandService).executeCommand(CLOSE_EDITOR_COMMAND_ID)
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.killActiveTab" ,
+        title: terminalStrings.kill,
+        f1: false,
+        precondition: ( (ContextKeyExpr.or(sharedWhenClause.terminalAvailable, TerminalContextKeys.isOpen))),
+        keybinding: {
+            primary: 20 ,
+            mac: {
+                primary: 2048  | 1 ,
+                secondary: [20 ]
+            },
+            weight: 200 ,
+            when: TerminalContextKeys.tabsFocus
+        },
+        run: async (c, accessor) => {
+            const disposePromises = [];
+            for (const terminal of getSelectedInstances(accessor) ?? []) {
+                disposePromises.push(c.service.safeDisposeTerminal(terminal));
+            }
+            await Promise.all(disposePromises);
+            c.groupService.focusTabs();
+        }
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.focusHover" ,
+        title: terminalStrings.focusHover,
+        precondition: ( (ContextKeyExpr.or(sharedWhenClause.terminalAvailable, TerminalContextKeys.isOpen))),
+        keybinding: {
+            primary: KeyChord(2048  | 41 , 2048  | 39 ),
+            weight: 200 ,
+            when: ( (ContextKeyExpr.or(TerminalContextKeys.tabsFocus, TerminalContextKeys.focus)))
+        },
+        run: (c) => c.groupService.focusHover()
+    });
+    registerActiveInstanceAction({
+        id: "workbench.action.terminal.clear" ,
+        title: ( localize2(8993, 'Clear')),
+        precondition: sharedWhenClause.terminalAvailable,
+        keybinding: [{
+                primary: 0,
+                mac: { primary: 2048  | 41  },
+                weight: 200  + 1,
+                when: ( (ContextKeyExpr.or( (ContextKeyExpr.and(
+                    TerminalContextKeys.focus,
+                     (CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate())
+                )),  (ContextKeyExpr.and(
+                    CONTEXT_ACCESSIBILITY_MODE_ENABLED,
+                    accessibleViewIsShown,
+                     (accessibleViewCurrentProviderId.isEqualTo("terminal" ))
+                ))))),
+            }],
+        run: (activeInstance) => activeInstance.clearBuffer()
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.selectDefaultShell" ,
+        title: ( localize2(8994, 'Select Default Profile')),
+        run: (c) => c.service.showProfileQuickPick('setDefault')
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.openSettings" ,
+        title: ( localize2(8995, 'Configure Terminal Settings')),
+        precondition: sharedWhenClause.terminalAvailable,
+        run: (c, accessor) => accessor.get(IPreferencesService).openSettings({ jsonEditor: false, query: '@feature:terminal' })
+    });
+    registerActiveInstanceAction({
+        id: "workbench.action.terminal.setDimensions" ,
+        title: ( localize2(8996, 'Set Fixed Dimensions')),
+        precondition: sharedWhenClause.terminalAvailable_and_opened,
+        run: (activeInstance) => activeInstance.setFixedDimensions()
+    });
+    registerContextualInstanceAction({
+        id: "workbench.action.terminal.sizeToContentWidth" ,
+        title: terminalStrings.toggleSizeToContentWidth,
+        precondition: sharedWhenClause.terminalAvailable_and_opened,
+        keybinding: {
+            primary: 512  | 56 ,
+            weight: 200 ,
+            when: TerminalContextKeys.focus
+        },
+        run: (instance) => instance.toggleSizeToContentWidth()
+    });
+    registerTerminalAction({
+        id: "workbench.action.terminal.clearPreviousSessionHistory" ,
+        title: ( localize2(8997, 'Clear Previous Session History')),
+        precondition: sharedWhenClause.terminalAvailable,
+        run: async (c, accessor) => {
+            getCommandHistory(accessor).clear();
+            clearShellFileHistory();
+        }
+    });
+    if (BrowserFeatures.clipboard.writeText) {
+        registerActiveXtermAction({
+            id: "workbench.action.terminal.copySelection" ,
+            title: ( localize2(8998, 'Copy Selection')),
+            precondition: ( (ContextKeyExpr.or(
+                TerminalContextKeys.textSelectedInFocused,
+                 (ContextKeyExpr.and(sharedWhenClause.terminalAvailable, TerminalContextKeys.textSelected))
+            ))),
+            keybinding: [{
+                    primary: 2048  | 1024  | 33 ,
+                    mac: { primary: 2048  | 33  },
+                    weight: 200 ,
+                    when: ( (ContextKeyExpr.or(
+                         (ContextKeyExpr.and(TerminalContextKeys.textSelected, TerminalContextKeys.focus)),
+                        TerminalContextKeys.textSelectedInFocused
+                    )))
+                }],
+            run: (activeInstance) => activeInstance.copySelection()
+        });
+        registerActiveXtermAction({
+            id: "workbench.action.terminal.copyAndClearSelection" ,
+            title: ( localize2(8999, 'Copy and Clear Selection')),
+            precondition: ( (ContextKeyExpr.or(
+                TerminalContextKeys.textSelectedInFocused,
+                 (ContextKeyExpr.and(sharedWhenClause.terminalAvailable, TerminalContextKeys.textSelected))
+            ))),
+            keybinding: [{
+                    win: { primary: 2048  | 33  },
+                    weight: 200 ,
+                    when: ( (ContextKeyExpr.or(
+                         (ContextKeyExpr.and(TerminalContextKeys.textSelected, TerminalContextKeys.focus)),
+                        TerminalContextKeys.textSelectedInFocused
+                    )))
+                }],
+            run: async (xterm) => {
+                await xterm.copySelection();
+                xterm.clearSelection();
+            }
+        });
+        registerActiveXtermAction({
+            id: "workbench.action.terminal.copySelectionAsHtml" ,
+            title: ( localize2(9000, 'Copy Selection as HTML')),
+            f1: true,
+            category,
+            precondition: ( (ContextKeyExpr.or(
+                TerminalContextKeys.textSelectedInFocused,
+                 (ContextKeyExpr.and(sharedWhenClause.terminalAvailable, TerminalContextKeys.textSelected))
+            ))),
+            run: (xterm) => xterm.copySelection(true)
+        });
+    }
+    if (BrowserFeatures.clipboard.readText) {
+        registerActiveInstanceAction({
+            id: "workbench.action.terminal.paste" ,
+            title: ( localize2(9001, 'Paste into Active Terminal')),
+            precondition: sharedWhenClause.terminalAvailable,
+            keybinding: [{
+                    primary: 2048  | 52 ,
+                    win: { primary: 2048  | 52 , secondary: [2048  | 1024  | 52 ] },
+                    linux: { primary: 2048  | 1024  | 52  },
+                    weight: 200 ,
+                    when: TerminalContextKeys.focus
+                }],
+            run: (activeInstance) => activeInstance.paste()
+        });
+    }
+    if (BrowserFeatures.clipboard.readText && isLinux) {
+        registerActiveInstanceAction({
+            id: "workbench.action.terminal.pasteSelection" ,
+            title: ( localize2(9002, 'Paste Selection into Active Terminal')),
+            precondition: sharedWhenClause.terminalAvailable,
+            keybinding: [{
+                    linux: { primary: 1024  | 19  },
+                    weight: 200 ,
+                    when: TerminalContextKeys.focus
+                }],
+            run: (activeInstance) => activeInstance.pasteSelection()
+        });
+    }
+    registerTerminalAction({
+        id: "workbench.action.terminal.switchTerminal" ,
+        title: ( localize2(9003, 'Switch Terminal')),
+        precondition: sharedWhenClause.terminalAvailable,
+        run: async (c, accessor, args) => {
+            const item = toOptionalString(args);
+            if (!item) {
+                return;
+            }
+            if (item === switchTerminalActionViewItemSeparator) {
+                c.service.refreshActiveGroup();
+                return;
+            }
+            if (item === switchTerminalShowTabsTitle) {
+                accessor.get(IConfigurationService).updateValue("terminal.integrated.tabs.enabled" , 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 getSelectedInstances2(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 getSelectedInstances(accessor, args, args2) {
+    const listService = accessor.get(IListService);
+    const terminalService = accessor.get(ITerminalService);
+    const terminalGroupService = accessor.get(ITerminalGroupService);
+    const result = [];
+    const list = listService.lastFocusedList;
+    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();
+    if (focused.length === 1 && !selections.includes(focused[0])) {
+        result.push(terminalService.getInstanceFromIndex(focused[0]));
+        return result;
+    }
+    for (const selection of selections) {
+        result.push(terminalService.getInstanceFromIndex(selection));
+    }
+    return result.filter(r => !!r);
+}
+function validateTerminalName(name) {
+    if (!name || name.trim().length === 0) {
+        return {
+            content: ( localize(9004, "Providing no name will reset it to the default value")),
+            severity: Severity$1.Info
+        };
+    }
+    return null;
+}
+function convertOptionsOrProfileToOptions(optionsOrProfile) {
+    if (isObject(optionsOrProfile) && 'profileName' in 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: "workbench.action.terminal.newWithProfile" ,
+                title: ( localize2(9005, 'Create New Terminal (With Profile)')),
+                f1: true,
+                category,
+                precondition: ( (ContextKeyExpr.or(
+                    TerminalContextKeys.processSupported,
+                    TerminalContextKeys.webExtensionContributedProfile
+                ))),
+                metadata: {
+                    description: "workbench.action.terminal.newWithProfile" ,
+                    args: [{
+                            name: 'args',
+                            schema: {
+                                type: 'object',
+                                required: ['profileName'],
+                                properties: {
+                                    profileName: {
+                                        description: ( localize(9006, "The name of the profile to create")),
+                                        type: 'string',
+                                        enum: profileEnum.values,
+                                        markdownEnumDescriptions: profileEnum.markdownDescriptions
+                                    },
+                                    location: {
+                                        description: ( localize(9007, "Where to create the terminal")),
+                                        type: 'string',
+                                        enum: ['view', 'editor'],
+                                        enumDescriptions: [
+                                            ( localize(9008, 'Create the terminal in the terminal view')),
+                                            ( localize(9009, '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 && 'profileName' in eventOrOptionsOrProfile) {
+                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 };
+                if ('location' in 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(8940, "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(
+            9010,
+            "(Overriden) {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(8940, "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("terminal.integrated.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(AbstractVariableResolverService.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) {
+    if (instance.target === TerminalLocation.Editor) {
+        await c.editorService.revealActiveEditor();
+        await instance.focusWhenReady(true);
+    }
+    else {
+        await c.groupService.showPanel(true);
+    }
+}
+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(9011, "Enter terminal name")),
+        });
+        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, shrinkWorkspaceFolderCwdPairs, switchTerminalActionViewItemSeparator, switchTerminalShowTabsTitle, terminalSendSequenceCommand, validateTerminalName };