@codingame/monaco-vscode-xterm-common 25.1.2 → 26.0.1

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

@@ -63,7 +63,7 @@ import { ResourceContextKey } from '@codingame/monaco-vscode-api/vscode/vs/workb
 import { SeparatorSelectOption } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/selectBox/selectBox';
 import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
 
-const switchTerminalShowTabsTitle = ( localize(11501, "Show Tabs"));
+const switchTerminalShowTabsTitle = ( localize(11827, "Show Tabs"));
 const category = terminalStrings.actionCategory;
 const sharedWhenClause = (() => {
     const terminalAvailable = ( ContextKeyExpr.or(
@@ -80,48 +80,45 @@ const sharedWhenClause = (() => {
 })();
 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(11502, "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);
+    case "workspaceRoot":
+        if (folders !== undefined && commandService !== undefined) {
+            if (folders.length === 1) {
+                return folders[0].uri;
+            } else if (folders.length > 1) {
+                const options = {
+                    placeHolder: ( localize(11828, "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();
+        }
+        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(11503, "Open Help")));
+        super("workbench.action.terminal.launchHelp", ( localize(11829, "Open Help")));
         this._openerService = _openerService;
     }
     async run() {
-        this._openerService.open('https://aka.ms/vscode-troubleshoot-terminal-launch');
+        this._openerService.open("https://aka.ms/vscode-troubleshoot-terminal-launch");
     }
 };
-TerminalLaunchHelpAction = ( __decorate([
-    ( __param(0, IOpenerService))
-], TerminalLaunchHelpAction));
+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'];
+    delete strictOptions["run"];
     return registerAction2(class extends Action2 {
         constructor() {
             super(strictOptions);
@@ -136,8 +133,7 @@ function parseActionArgs(args) {
         if (args.every(e => e instanceof InstanceContext)) {
             return args;
         }
-    }
-    else if (args instanceof InstanceContext) {
+    } else if (args instanceof InstanceContext) {
         return [args];
     }
     return undefined;
@@ -149,11 +145,7 @@ function registerContextualInstanceAction(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;
+                const activeInstance = (options.activeInstanceType === "view" ? c.groupService : options.activeInstanceType === "editor" ? c.editorService : c.service).activeInstance;
                 if (!activeInstance) {
                     return;
                 }
@@ -213,10 +205,12 @@ function getTerminalServices(accessor) {
 function registerTerminalActions() {
     registerTerminalAction({
         id: TerminalCommandId.NewInActiveWorkspace,
-        title: ( localize2(11504, 'Create New Terminal (In Active Workspace)')),
-        run: async (c) => {
+        title: ( localize2(11830, "Create New Terminal (In Active Workspace)")),
+        run: async c => {
             if (c.service.isProcessSupportRegistered) {
-                const instance = await c.service.createTerminal({ location: c.configService.defaultLocation });
+                const instance = await c.service.createTerminal({
+                    location: c.configService.defaultLocation
+                });
                 if (!instance) {
                     return;
                 }
@@ -228,25 +222,29 @@ function registerTerminalActions() {
     refreshTerminalActions([]);
     registerTerminalAction({
         id: TerminalCommandId.CreateTerminalEditor,
-        title: ( localize2(11505, 'Create New Terminal in Editor Area')),
+        title: ( localize2(11831, "Create New Terminal in Editor Area")),
         run: async (c, _, args) => {
             function isCreateTerminalOptions(obj) {
-                return isObject(obj) && 'location' in obj;
+                return isObject(obj) && "location" in obj;
             }
-            const options = isCreateTerminalOptions(args) ? args : { location: { viewColumn: ACTIVE_GROUP } };
+            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(11505, 'Create New Terminal in Editor Area')),
+        title: ( localize2(11831, "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),
+                    viewColumn: editorGroupToColumn(editorGroupsService, editorGroupsService.activeGroup)
                 }
             });
             await instance.focusWhenReady();
@@ -254,10 +252,12 @@ function registerTerminalActions() {
     });
     registerTerminalAction({
         id: TerminalCommandId.CreateTerminalEditorSide,
-        title: ( localize2(11506, 'Create New Terminal in Editor Area to the Side')),
-        run: async (c) => {
+        title: ( localize2(11832, "Create New Terminal in Editor Area to the Side")),
+        run: async c => {
             const instance = await c.service.createTerminal({
-                location: { viewColumn: SIDE_GROUP }
+                location: {
+                    viewColumn: SIDE_GROUP
+                }
             });
             await instance.focusWhenReady();
         }
@@ -268,15 +268,19 @@ function registerTerminalActions() {
         precondition: sharedWhenClause.terminalAvailable,
         keybinding: {
             primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyMod.Alt | KeyCode.Backquote,
-            mac: { primary: KeyMod.WinCtrl | KeyMod.Shift | KeyMod.Alt | KeyCode.Backquote },
+            mac: {
+                primary: KeyMod.WinCtrl | KeyMod.Shift | KeyMod.Alt | KeyCode.Backquote
+            },
             weight: KeybindingWeight.WorkbenchContrib
         },
-        run: async (c) => {
+        run: async c => {
             const instance = await c.service.createTerminal({
                 location: {
                     viewColumn: AUX_WINDOW_GROUP,
-                    auxiliary: { compact: true },
-                },
+                    auxiliary: {
+                        compact: true
+                    }
+                }
             });
             await instance.focusWhenReady();
         }
@@ -285,16 +289,16 @@ function registerTerminalActions() {
         id: TerminalCommandId.MoveToEditor,
         title: terminalStrings.moveToEditor,
         precondition: sharedWhenClause.terminalAvailable_and_opened,
-        activeInstanceType: 'view',
+        activeInstanceType: "view",
         run: (instance, c) => c.service.moveToEditor(instance),
-        runAfter: (instances) => instances.at(-1)?.focus()
+        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()
+        runAfter: instances => instances.at(-1)?.focus()
     });
     registerTerminalAction({
         id: TerminalCommandId.MoveToTerminalPanel,
@@ -309,7 +313,7 @@ function registerTerminalActions() {
     });
     registerTerminalAction({
         id: TerminalCommandId.FocusPreviousPane,
-        title: ( localize2(11507, 'Focus Previous Terminal in Terminal Group')),
+        title: ( localize2(11833, "Focus Previous Terminal in Terminal Group")),
         keybinding: {
             primary: KeyMod.Alt | KeyCode.LeftArrow,
             secondary: [KeyMod.Alt | KeyCode.UpArrow],
@@ -321,14 +325,14 @@ function registerTerminalActions() {
             weight: KeybindingWeight.WorkbenchContrib + 1
         },
         precondition: sharedWhenClause.terminalAvailable,
-        run: async (c) => {
+        run: async c => {
             c.groupService.activeGroup?.focusPreviousPane();
             await c.groupService.showPanel(true);
         }
     });
     registerTerminalAction({
         id: TerminalCommandId.FocusNextPane,
-        title: ( localize2(11508, 'Focus Next Terminal in Terminal Group')),
+        title: ( localize2(11834, "Focus Next Terminal in Terminal Group")),
         keybinding: {
             primary: KeyMod.Alt | KeyCode.RightArrow,
             secondary: [KeyMod.Alt | KeyCode.DownArrow],
@@ -340,56 +344,68 @@ function registerTerminalActions() {
             weight: KeybindingWeight.WorkbenchContrib + 1
         },
         precondition: sharedWhenClause.terminalAvailable,
-        run: async (c) => {
+        run: async c => {
             c.groupService.activeGroup?.focusNextPane();
             await c.groupService.showPanel(true);
         }
     });
     registerTerminalAction({
         id: TerminalCommandId.ResizePaneLeft,
-        title: ( localize2(11509, 'Resize Terminal Left')),
+        title: ( localize2(11835, "Resize Terminal Left")),
         keybinding: {
-            linux: { primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.LeftArrow },
-            mac: { primary: KeyMod.CtrlCmd | KeyMod.WinCtrl | KeyCode.LeftArrow },
+            linux: {
+                primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.LeftArrow
+            },
+            mac: {
+                primary: KeyMod.CtrlCmd | KeyMod.WinCtrl | KeyCode.LeftArrow
+            },
             when: TerminalContextKeys.focus,
             weight: KeybindingWeight.WorkbenchContrib
         },
         precondition: sharedWhenClause.terminalAvailable,
-        run: (c) => c.groupService.activeGroup?.resizePane(Direction.Left)
+        run: c => c.groupService.activeGroup?.resizePane(Direction.Left)
     });
     registerTerminalAction({
         id: TerminalCommandId.ResizePaneRight,
-        title: ( localize2(11510, 'Resize Terminal Right')),
+        title: ( localize2(11836, "Resize Terminal Right")),
         keybinding: {
-            linux: { primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.RightArrow },
-            mac: { primary: KeyMod.CtrlCmd | KeyMod.WinCtrl | KeyCode.RightArrow },
+            linux: {
+                primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.RightArrow
+            },
+            mac: {
+                primary: KeyMod.CtrlCmd | KeyMod.WinCtrl | KeyCode.RightArrow
+            },
             when: TerminalContextKeys.focus,
             weight: KeybindingWeight.WorkbenchContrib
         },
         precondition: sharedWhenClause.terminalAvailable,
-        run: (c) => c.groupService.activeGroup?.resizePane(Direction.Right)
+        run: c => c.groupService.activeGroup?.resizePane(Direction.Right)
     });
     registerTerminalAction({
         id: TerminalCommandId.ResizePaneUp,
-        title: ( localize2(11511, 'Resize Terminal Up')),
+        title: ( localize2(11837, "Resize Terminal Up")),
         keybinding: {
-            mac: { primary: KeyMod.CtrlCmd | KeyMod.WinCtrl | KeyCode.UpArrow },
+            mac: {
+                primary: KeyMod.CtrlCmd | KeyMod.WinCtrl | KeyCode.UpArrow
+            },
             when: TerminalContextKeys.focus,
             weight: KeybindingWeight.WorkbenchContrib
         },
         precondition: sharedWhenClause.terminalAvailable,
-        run: (c) => c.groupService.activeGroup?.resizePane(Direction.Up)
+        run: c => c.groupService.activeGroup?.resizePane(Direction.Up)
     });
     registerTerminalAction({
         id: TerminalCommandId.ResizePaneDown,
-        title: ( localize2(11512, 'Resize Terminal Down')),
+        title: ( localize2(11838, "Resize Terminal Down")),
         keybinding: {
-            mac: { primary: KeyMod.CtrlCmd | KeyMod.WinCtrl | KeyCode.DownArrow },
+            mac: {
+                primary: KeyMod.CtrlCmd | KeyMod.WinCtrl | KeyCode.DownArrow
+            },
             when: TerminalContextKeys.focus,
             weight: KeybindingWeight.WorkbenchContrib
         },
         precondition: sharedWhenClause.terminalAvailable,
-        run: (c) => c.groupService.activeGroup?.resizePane(Direction.Down)
+        run: c => c.groupService.activeGroup?.resizePane(Direction.Down)
     });
     registerTerminalAction({
         id: TerminalCommandId.Focus,
@@ -404,8 +420,10 @@ function registerTerminalActions() {
             weight: KeybindingWeight.WorkbenchContrib
         },
         precondition: sharedWhenClause.terminalAvailable,
-        run: async (c) => {
-            const instance = c.service.activeInstance || (await c.service.createTerminal({ location: TerminalLocation.Panel }));
+        run: async c => {
+            const instance = c.service.activeInstance || (await c.service.createTerminal({
+                location: TerminalLocation.Panel
+            }));
             if (!instance) {
                 return;
             }
@@ -415,18 +433,18 @@ function registerTerminalActions() {
     });
     registerTerminalAction({
         id: TerminalCommandId.FocusTabs,
-        title: ( localize2(11513, 'Focus Terminal Tabs View')),
+        title: ( localize2(11839, "Focus Terminal Tabs View")),
         keybinding: {
             primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.Backslash,
             weight: KeybindingWeight.WorkbenchContrib,
-            when: ( ContextKeyExpr.or(TerminalContextKeys.tabsFocus, TerminalContextKeys.focus)),
+            when: ( ContextKeyExpr.or(TerminalContextKeys.tabsFocus, TerminalContextKeys.focus))
         },
         precondition: sharedWhenClause.terminalAvailable,
-        run: (c) => c.groupService.focusTabs()
+        run: c => c.groupService.focusTabs()
     });
     registerTerminalAction({
         id: TerminalCommandId.FocusNext,
-        title: ( localize2(11514, 'Focus Next Terminal Group')),
+        title: ( localize2(11840, "Focus Next Terminal Group")),
         precondition: sharedWhenClause.terminalAvailable,
         keybinding: {
             primary: KeyMod.CtrlCmd | KeyCode.PageDown,
@@ -436,14 +454,14 @@ function registerTerminalActions() {
             when: ( ContextKeyExpr.and(TerminalContextKeys.focus, ( TerminalContextKeys.editorFocus.negate()))),
             weight: KeybindingWeight.WorkbenchContrib
         },
-        run: async (c) => {
+        run: async c => {
             c.groupService.setActiveGroupToNext();
             await c.groupService.showPanel(true);
         }
     });
     registerTerminalAction({
         id: TerminalCommandId.FocusPrevious,
-        title: ( localize2(11515, 'Focus Previous Terminal Group')),
+        title: ( localize2(11841, "Focus Previous Terminal Group")),
         precondition: sharedWhenClause.terminalAvailable,
         keybinding: {
             primary: KeyMod.CtrlCmd | KeyCode.PageUp,
@@ -453,27 +471,28 @@ function registerTerminalActions() {
             when: ( ContextKeyExpr.and(TerminalContextKeys.focus, ( TerminalContextKeys.editorFocus.negate()))),
             weight: KeybindingWeight.WorkbenchContrib
         },
-        run: async (c) => {
+        run: async c => {
             c.groupService.setActiveGroupToPrevious();
             await c.groupService.showPanel(true);
         }
     });
     registerTerminalAction({
         id: TerminalCommandId.RunSelectedText,
-        title: ( localize2(11516, 'Run Selected Text In Active Terminal')),
+        title: ( localize2(11842, "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 instance = await c.service.getActiveOrCreateInstance({
+                acceptsInput: true
+            });
             const selection = editor.getSelection();
             let text;
             if (selection.isEmpty()) {
                 text = editor.getModel().getLineContent(selection.selectionStartLineNumber).trim();
-            }
-            else {
+            } else {
                 const endOfLinePreference = isWindows ? EndOfLinePreference.LF : EndOfLinePreference.CRLF;
                 text = editor.getModel().getValueInRange(selection, endOfLinePreference);
             }
@@ -483,7 +502,7 @@ function registerTerminalActions() {
     });
     registerTerminalAction({
         id: TerminalCommandId.RunActiveFile,
-        title: ( localize2(11517, 'Run Active File In Active Terminal')),
+        title: ( localize2(11843, "Run Active File In Active Terminal")),
         precondition: sharedWhenClause.terminalAvailable,
         run: async (c, accessor) => {
             const codeEditorService = accessor.get(ICodeEditorService);
@@ -493,11 +512,13 @@ function registerTerminalActions() {
             if (!editor || !editor.hasModel()) {
                 return;
             }
-            const instance = await c.service.getActiveOrCreateInstance({ acceptsInput: true });
+            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(11518, 'Only files on disk can be run in the terminal')));
+                notificationService.warn(( localize(11844, "Only files on disk can be run in the terminal")));
                 return;
             }
             await instance.sendPath(uri, true);
@@ -506,80 +527,92 @@ function registerTerminalActions() {
     });
     registerActiveXtermAction({
         id: TerminalCommandId.ScrollDownLine,
-        title: ( localize2(11519, 'Scroll Down (Line)')),
+        title: ( localize2(11845, "Scroll Down (Line)")),
         keybinding: {
             primary: KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.PageDown,
-            linux: { primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.DownArrow },
+            linux: {
+                primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.DownArrow
+            },
             when: sharedWhenClause.focusInAny_and_normalBuffer,
             weight: KeybindingWeight.WorkbenchContrib
         },
         precondition: sharedWhenClause.terminalAvailable,
-        run: (xterm) => xterm.scrollDownLine()
+        run: xterm => xterm.scrollDownLine()
     });
     registerActiveXtermAction({
         id: TerminalCommandId.ScrollDownPage,
-        title: ( localize2(11520, 'Scroll Down (Page)')),
+        title: ( localize2(11846, "Scroll Down (Page)")),
         keybinding: {
             primary: KeyMod.Shift | KeyCode.PageDown,
-            mac: { primary: KeyCode.PageDown },
+            mac: {
+                primary: KeyCode.PageDown
+            },
             when: sharedWhenClause.focusInAny_and_normalBuffer,
             weight: KeybindingWeight.WorkbenchContrib
         },
         precondition: sharedWhenClause.terminalAvailable,
-        run: (xterm) => xterm.scrollDownPage()
+        run: xterm => xterm.scrollDownPage()
     });
     registerActiveXtermAction({
         id: TerminalCommandId.ScrollToBottom,
-        title: ( localize2(11521, 'Scroll to Bottom')),
+        title: ( localize2(11847, "Scroll to Bottom")),
         keybinding: {
             primary: KeyMod.CtrlCmd | KeyCode.End,
-            linux: { primary: KeyMod.Shift | KeyCode.End },
+            linux: {
+                primary: KeyMod.Shift | KeyCode.End
+            },
             when: sharedWhenClause.focusInAny_and_normalBuffer,
             weight: KeybindingWeight.WorkbenchContrib
         },
         precondition: sharedWhenClause.terminalAvailable,
-        run: (xterm) => xterm.scrollToBottom()
+        run: xterm => xterm.scrollToBottom()
     });
     registerActiveXtermAction({
         id: TerminalCommandId.ScrollUpLine,
-        title: ( localize2(11522, 'Scroll Up (Line)')),
+        title: ( localize2(11848, "Scroll Up (Line)")),
         keybinding: {
             primary: KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.PageUp,
-            linux: { primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.UpArrow },
+            linux: {
+                primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.UpArrow
+            },
             when: sharedWhenClause.focusInAny_and_normalBuffer,
             weight: KeybindingWeight.WorkbenchContrib
         },
         precondition: sharedWhenClause.terminalAvailable,
-        run: (xterm) => xterm.scrollUpLine()
+        run: xterm => xterm.scrollUpLine()
     });
     registerActiveXtermAction({
         id: TerminalCommandId.ScrollUpPage,
-        title: ( localize2(11523, 'Scroll Up (Page)')),
+        title: ( localize2(11849, "Scroll Up (Page)")),
         f1: true,
         keybinding: {
             primary: KeyMod.Shift | KeyCode.PageUp,
-            mac: { primary: KeyCode.PageUp },
+            mac: {
+                primary: KeyCode.PageUp
+            },
             when: sharedWhenClause.focusInAny_and_normalBuffer,
             weight: KeybindingWeight.WorkbenchContrib
         },
         precondition: sharedWhenClause.terminalAvailable,
-        run: (xterm) => xterm.scrollUpPage()
+        run: xterm => xterm.scrollUpPage()
     });
     registerActiveXtermAction({
         id: TerminalCommandId.ScrollToTop,
-        title: ( localize2(11524, 'Scroll to Top')),
+        title: ( localize2(11850, "Scroll to Top")),
         keybinding: {
             primary: KeyMod.CtrlCmd | KeyCode.Home,
-            linux: { primary: KeyMod.Shift | KeyCode.Home },
+            linux: {
+                primary: KeyMod.Shift | KeyCode.Home
+            },
             when: sharedWhenClause.focusInAny_and_normalBuffer,
             weight: KeybindingWeight.WorkbenchContrib
         },
         precondition: sharedWhenClause.terminalAvailable,
-        run: (xterm) => xterm.scrollToTop()
+        run: xterm => xterm.scrollToTop()
     });
     registerActiveXtermAction({
         id: TerminalCommandId.ClearSelection,
-        title: ( localize2(11525, 'Clear Selection')),
+        title: ( localize2(11851, "Clear Selection")),
         keybinding: {
             primary: KeyCode.Escape,
             when: ( ContextKeyExpr.and(
@@ -590,7 +623,7 @@ function registerTerminalActions() {
             weight: KeybindingWeight.WorkbenchContrib
         },
         precondition: sharedWhenClause.terminalAvailable,
-        run: (xterm) => {
+        run: xterm => {
             if (xterm.hasSelection()) {
                 xterm.clearSelection();
             }
@@ -609,7 +642,7 @@ function registerTerminalActions() {
         precondition: sharedWhenClause.terminalAvailable_and_singularSelection,
         run: async (c, accessor, args) => {
             let icon;
-            if (c.groupService.lastAccessedMenu === 'inline-tab') {
+            if (c.groupService.lastAccessedMenu === "inline-tab") {
                 getResourceOrActiveInstance(c, args)?.changeIcon();
                 return;
             }
@@ -632,7 +665,7 @@ function registerTerminalActions() {
         run: async (c, accessor, args) => {
             let color;
             let i = 0;
-            if (c.groupService.lastAccessedMenu === 'inline-tab') {
+            if (c.groupService.lastAccessedMenu === "inline-tab") {
                 getResourceOrActiveInstance(c, args)?.changeColor();
                 return;
             }
@@ -670,7 +703,7 @@ function registerTerminalActions() {
             if (!firstInstance) {
                 return;
             }
-            if (terminalGroupService.lastAccessedMenu === 'inline-tab') {
+            if (terminalGroupService.lastAccessedMenu === "inline-tab") {
                 return renameWithQuickPick(c, accessor, firstInstance);
             }
             c.editingService.setEditingTerminal(firstInstance);
@@ -688,8 +721,7 @@ function registerTerminalActions() {
                         }
                         try {
                             await Promise.all(promises);
-                        }
-                        catch (e) {
+                        } catch (e) {
                             notificationService.error(e);
                         }
                     }
@@ -699,12 +731,12 @@ function registerTerminalActions() {
     });
     registerActiveInstanceAction({
         id: TerminalCommandId.DetachSession,
-        title: ( localize2(11526, 'Detach Session')),
-        run: (activeInstance) => activeInstance.detachProcessAndDispose(TerminalExitReason.User)
+        title: ( localize2(11852, "Detach Session")),
+        run: activeInstance => activeInstance.detachProcessAndDispose(TerminalExitReason.User)
     });
     registerTerminalAction({
         id: TerminalCommandId.AttachToSession,
-        title: ( localize2(11527, 'Attach to Session')),
+        title: ( localize2(11853, "Attach to Session")),
         run: async (c, accessor) => {
             const quickInputService = accessor.get(IQuickInputService);
             const labelService = accessor.get(ILabelService);
@@ -723,18 +755,22 @@ function registerTerminalActions() {
                 return {
                     label: term.title,
                     detail: term.workspaceName ? `${term.workspaceName} \u2E31 ${cwdLabel}` : cwdLabel,
-                    description: term.pid ? String(term.pid) : '',
+                    description: term.pid ? String(term.pid) : "",
                     term
                 };
             }));
             if (items.length === 0) {
-                notificationService.info(( localize(11528, 'There are no unattached terminals to attach to')));
+                notificationService.info(( localize(11854, "There are no unattached terminals to attach to")));
                 return;
             }
-            const selected = await quickInputService.pick(items, { canPickMany: false });
+            const selected = await quickInputService.pick(items, {
+                canPickMany: false
+            });
             if (selected) {
                 const instance = await c.service.createTerminal({
-                    config: { attachPersistentProcess: selected.term }
+                    config: {
+                        attachPersistentProcess: selected.term
+                    }
                 });
                 c.service.setActiveInstance(instance);
                 await focusActiveTerminal(instance, c);
@@ -751,23 +787,20 @@ function registerTerminalActions() {
         },
         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)))
+        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,
@@ -779,58 +812,55 @@ function registerTerminalActions() {
         },
         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) => {
+        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(11529, 'Select to Previous Command')),
+        title: ( localize2(11855, "Select to Previous Command")),
         keybinding: {
             primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.UpArrow,
             when: TerminalContextKeys.focus,
             weight: KeybindingWeight.WorkbenchContrib
         },
         precondition: sharedWhenClause.terminalAvailable,
-        run: (activeInstance) => {
+        run: activeInstance => {
             activeInstance.xterm?.markTracker.selectToPreviousMark();
             activeInstance.focus();
         }
     });
     registerActiveInstanceAction({
         id: TerminalCommandId.SelectToNextCommand,
-        title: ( localize2(11530, 'Select to Next Command')),
+        title: ( localize2(11856, "Select to Next Command")),
         keybinding: {
             primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.DownArrow,
             when: TerminalContextKeys.focus,
             weight: KeybindingWeight.WorkbenchContrib
         },
         precondition: sharedWhenClause.terminalAvailable,
-        run: (activeInstance) => {
+        run: activeInstance => {
             activeInstance.xterm?.markTracker.selectToNextMark();
             activeInstance.focus();
         }
     });
     registerActiveXtermAction({
         id: TerminalCommandId.SelectToPreviousLine,
-        title: ( localize2(11531, 'Select to Previous Line')),
+        title: ( localize2(11857, "Select to Previous Line")),
         precondition: sharedWhenClause.terminalAvailable,
         run: async (xterm, _, instance) => {
             xterm.markTracker.selectToPreviousLine();
@@ -839,7 +869,7 @@ function registerTerminalActions() {
     });
     registerActiveXtermAction({
         id: TerminalCommandId.SelectToNextLine,
-        title: ( localize2(11532, 'Select to Next Line')),
+        title: ( localize2(11858, "Select to Next Line")),
         precondition: sharedWhenClause.terminalAvailable,
         run: async (xterm, _, instance) => {
             xterm.markTracker.selectToNextLine();
@@ -852,22 +882,24 @@ function registerTerminalActions() {
         metadata: {
             description: terminalStrings.newWithCwd.value,
             args: [{
-                    name: 'args',
-                    schema: {
-                        type: 'object',
-                        required: ['cwd'],
-                        properties: {
-                            cwd: {
-                                description: ( localize(11533, "The directory to start the terminal at")),
-                                type: 'string'
-                            }
-                        },
+                name: "args",
+                schema: {
+                    type: "object",
+                    required: ["cwd"],
+                    properties: {
+                        cwd: {
+                            description: ( localize(11859, "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 });
+            const instance = await c.service.createTerminal({
+                cwd
+            });
             if (!instance) {
                 return;
             }
@@ -881,19 +913,19 @@ function registerTerminalActions() {
         metadata: {
             description: terminalStrings.renameWithArgs.value,
             args: [{
-                    name: 'args',
-                    schema: {
-                        type: 'object',
-                        required: ['name'],
-                        properties: {
-                            name: {
-                                description: ( localize(11534, "The new name for the terminal")),
-                                type: 'string',
-                                minLength: 1
-                            }
+                name: "args",
+                schema: {
+                    type: "object",
+                    required: ["name"],
+                    properties: {
+                        name: {
+                            description: ( localize(11860, "The new name for the terminal")),
+                            type: "string",
+                            minLength: 1
                         }
                     }
-                }]
+                }
+            }]
         },
         precondition: sharedWhenClause.terminalAvailable,
         f1: false,
@@ -901,7 +933,7 @@ function registerTerminalActions() {
             const notificationService = accessor.get(INotificationService);
             const name = args ? toOptionalString(args.name) : undefined;
             if (!name) {
-                notificationService.warn(( localize(11535, "No name argument provided")));
+                notificationService.warn(( localize(11861, "No name argument provided")));
                 return;
             }
             activeInstance.rename(name);
@@ -909,8 +941,8 @@ function registerTerminalActions() {
     });
     registerActiveInstanceAction({
         id: TerminalCommandId.Relaunch,
-        title: ( localize2(11536, 'Relaunch Active Terminal')),
-        run: (activeInstance) => activeInstance.relaunch()
+        title: ( localize2(11862, "Relaunch Active Terminal")),
+        run: activeInstance => activeInstance.relaunch()
     });
     registerTerminalAction({
         id: TerminalCommandId.Split,
@@ -938,11 +970,22 @@ function registerTerminalActions() {
             if (!activeInstance) {
                 return;
             }
-            const cwd = await getCwdForSplit(activeInstance, workspaceContextService.getWorkspace().folders, commandService, c.configService);
+            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 });
+            const instance = await c.service.createTerminal({
+                location: {
+                    parentTerminal: activeInstance
+                },
+                config: options?.config,
+                cwd
+            });
             await focusActiveTerminal(instance, c);
         }
     });
@@ -965,7 +1008,11 @@ function registerTerminalActions() {
                 const promises = [];
                 for (const t of instances) {
                     promises.push((async () => {
-                        await c.service.createTerminal({ location: { parentTerminal: t } });
+                        await c.service.createTerminal({
+                            location: {
+                                parentTerminal: t
+                            }
+                        });
                         await c.groupService.showPanel(true);
                     })());
                 }
@@ -986,7 +1033,7 @@ function registerTerminalActions() {
     });
     registerTerminalAction({
         id: TerminalCommandId.JoinActiveTab,
-        title: ( localize2(11537, 'Join Terminals')),
+        title: ( localize2(11863, "Join Terminals")),
         precondition: ( ContextKeyExpr.and(sharedWhenClause.terminalAvailable, ( TerminalContextKeys.tabsSingularSelection.toNegated()))),
         run: async (c, accessor) => {
             const instances = getSelectedViewInstances(accessor);
@@ -997,7 +1044,7 @@ function registerTerminalActions() {
     });
     registerTerminalAction({
         id: TerminalCommandId.Join,
-        title: ( localize2(11538, 'Join Terminals...')),
+        title: ( localize2(11864, "Join Terminals...")),
         precondition: sharedWhenClause.terminalAvailable,
         run: async (c, accessor) => {
             const themeService = accessor.get(IThemeService);
@@ -1005,7 +1052,7 @@ function registerTerminalActions() {
             const quickInputService = accessor.get(IQuickInputService);
             const picks = [];
             if (c.groupService.instances.length <= 1) {
-                notificationService.warn(( localize(11539, 'Insufficient terminals for the join action')));
+                notificationService.warn(( localize(11865, "Insufficient terminals for the join action")));
                 return;
             }
             const otherInstances = c.groupService.instances.filter(i => i.instanceId !== c.groupService.activeInstance?.instanceId);
@@ -1031,7 +1078,7 @@ function registerTerminalActions() {
                 }
             }
             if (picks.length === 0) {
-                notificationService.warn(( localize(11540, 'All terminals are joined already')));
+                notificationService.warn(( localize(11866, "All terminals are joined already")));
                 return;
             }
             const result = await quickInputService.pick(picks, {});
@@ -1042,9 +1089,13 @@ function registerTerminalActions() {
     });
     registerActiveInstanceAction({
         id: TerminalCommandId.SplitInActiveWorkspace,
-        title: ( localize2(11541, 'Split Terminal (In Active Workspace)')),
+        title: ( localize2(11867, "Split Terminal (In Active Workspace)")),
         run: async (instance, c) => {
-            const newInstance = await c.service.createTerminal({ location: { parentTerminal: instance } });
+            const newInstance = await c.service.createTerminal({
+                location: {
+                    parentTerminal: instance
+                }
+            });
             if (newInstance?.target !== TerminalLocation.Editor) {
                 await c.groupService.showPanel(true);
             }
@@ -1052,19 +1103,21 @@ function registerTerminalActions() {
     });
     registerActiveXtermAction({
         id: TerminalCommandId.SelectAll,
-        title: ( localize2(11542, 'Select All')),
+        title: ( localize2(11868, "Select All")),
         precondition: sharedWhenClause.terminalAvailable,
         keybinding: [{
-                primary: 0,
-                mac: { primary: KeyMod.CtrlCmd | KeyCode.KeyA },
-                weight: KeybindingWeight.WorkbenchContrib,
-                when: TerminalContextKeys.focusInAny
-            }],
-        run: (xterm) => xterm.selectAll()
+            primary: 0,
+            mac: {
+                primary: KeyMod.CtrlCmd | KeyCode.KeyA
+            },
+            weight: KeybindingWeight.WorkbenchContrib,
+            when: TerminalContextKeys.focusInAny
+        }],
+        run: xterm => xterm.selectAll()
     });
     registerTerminalAction({
         id: TerminalCommandId.New,
-        title: ( localize2(11543, 'Create New Terminal')),
+        title: ( localize2(11869, "Create New Terminal")),
         precondition: ( ContextKeyExpr.or(
             TerminalContextKeys.processSupported,
             TerminalContextKeys.webExtensionContributedProfile
@@ -1072,7 +1125,9 @@ function registerTerminalActions() {
         icon: newTerminalIcon,
         keybinding: {
             primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.Backquote,
-            mac: { primary: KeyMod.WinCtrl | KeyMod.Shift | KeyCode.Backquote },
+            mac: {
+                primary: KeyMod.WinCtrl | KeyMod.Shift | KeyCode.Backquote
+            },
             weight: KeybindingWeight.WorkbenchContrib
         },
         run: async (c, accessor, args) => {
@@ -1082,19 +1137,24 @@ function registerTerminalActions() {
             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 } });
+                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) };
+                    eventOrOptions.location = {
+                        viewColumn: editorGroupToColumn(editorGroupsService, editorGroupsService.activeGroup)
+                    };
                 }
                 let instance;
                 if (folders.length <= 1) {
                     instance = await c.service.createTerminal(eventOrOptions);
-                }
-                else {
+                } else {
                     const cwd = (await pickTerminalCwd(accessor))?.cwd;
                     if (!cwd) {
                         return;
@@ -1104,12 +1164,10 @@ function registerTerminalActions() {
                 }
                 c.service.setActiveInstance(instance);
                 await focusActiveTerminal(instance, c);
-            }
-            else {
+            } else {
                 if (c.profileService.contributedProfiles.length > 0) {
                     commandService.executeCommand(TerminalCommandId.NewWithProfile);
-                }
-                else {
+                } else {
                     commandService.executeCommand(TerminalCommandId.Toggle);
                 }
             }
@@ -1126,24 +1184,24 @@ function registerTerminalActions() {
     }
     registerTerminalAction({
         id: TerminalCommandId.Kill,
-        title: ( localize2(11544, 'Kill the Active Terminal Instance')),
+        title: ( localize2(11870, "Kill the Active Terminal Instance")),
         precondition: ( ContextKeyExpr.or(sharedWhenClause.terminalAvailable, TerminalContextKeys.isOpen)),
         icon: killTerminalIcon,
-        run: async (c) => killInstance(c, c.groupService.activeInstance)
+        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)
+        run: async c => killInstance(c, c.service.activeInstance)
     });
     registerTerminalAction({
         id: TerminalCommandId.KillAll,
-        title: ( localize2(11545, 'Kill All Terminals')),
+        title: ( localize2(11871, "Kill All Terminals")),
         precondition: ( ContextKeyExpr.or(sharedWhenClause.terminalAvailable, TerminalContextKeys.isOpen)),
         icon: Codicon.trash,
-        run: async (c) => {
+        run: async c => {
             const disposePromises = [];
             for (const instance of c.service.instances) {
                 disposePromises.push(c.service.safeDisposeTerminal(instance));
@@ -1153,11 +1211,14 @@ function registerTerminalActions() {
     });
     registerTerminalAction({
         id: TerminalCommandId.KillEditor,
-        title: ( localize2(11546, 'Kill the Active Terminal in Editor Area')),
+        title: ( localize2(11872, "Kill the Active Terminal in Editor Area")),
         precondition: sharedWhenClause.terminalAvailable,
         keybinding: {
             primary: KeyMod.CtrlCmd | KeyCode.KeyW,
-            win: { primary: KeyMod.CtrlCmd | KeyCode.F4, secondary: [KeyMod.CtrlCmd | KeyCode.KeyW] },
+            win: {
+                primary: KeyMod.CtrlCmd | KeyCode.F4,
+                secondary: [KeyMod.CtrlCmd | KeyCode.KeyW]
+            },
             weight: KeybindingWeight.WorkbenchContrib,
             when: ( ContextKeyExpr.and(TerminalContextKeys.focus, TerminalContextKeys.editorFocus))
         },
@@ -1195,36 +1256,41 @@ function registerTerminalActions() {
             weight: KeybindingWeight.WorkbenchContrib,
             when: ( ContextKeyExpr.or(TerminalContextKeys.tabsFocus, TerminalContextKeys.focus))
         },
-        run: (c) => c.groupService.focusHover()
+        run: c => c.groupService.focusHover()
     });
     registerActiveInstanceAction({
         id: TerminalCommandId.Clear,
-        title: ( localize2(11547, 'Clear')),
+        title: ( localize2(11873, "Clear")),
         precondition: sharedWhenClause.terminalAvailable,
         keybinding: [{
-                primary: 0,
-                mac: { primary: KeyMod.CtrlCmd | KeyCode.KeyK },
-                weight: KeybindingWeight.WorkbenchContrib + 1,
-                when: ( ContextKeyExpr.or(( ContextKeyExpr.and(TerminalContextKeys.focus, ( CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate()))), ( ContextKeyExpr.and(CONTEXT_ACCESSIBILITY_MODE_ENABLED, accessibleViewIsShown, ( accessibleViewCurrentProviderId.isEqualTo(AccessibleViewProviderId.Terminal)))))),
-            }],
-        run: (activeInstance) => activeInstance.clearBuffer()
+            primary: 0,
+            mac: {
+                primary: KeyMod.CtrlCmd | KeyCode.KeyK
+            },
+            weight: KeybindingWeight.WorkbenchContrib + 1,
+            when: ( ContextKeyExpr.or(( ContextKeyExpr.and(TerminalContextKeys.focus, ( CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate()))), ( ContextKeyExpr.and(CONTEXT_ACCESSIBILITY_MODE_ENABLED, accessibleViewIsShown, ( accessibleViewCurrentProviderId.isEqualTo(AccessibleViewProviderId.Terminal))))))
+        }],
+        run: activeInstance => activeInstance.clearBuffer()
     });
     registerTerminalAction({
         id: TerminalCommandId.SelectDefaultProfile,
-        title: ( localize2(11548, 'Select Default Profile')),
-        run: (c) => c.service.showProfileQuickPick('setDefault')
+        title: ( localize2(11874, "Select Default Profile")),
+        run: c => c.service.showProfileQuickPick("setDefault")
     });
     registerTerminalAction({
         id: TerminalCommandId.ConfigureTerminalSettings,
-        title: ( localize2(11549, 'Configure Terminal Settings')),
+        title: ( localize2(11875, "Configure Terminal Settings")),
         precondition: sharedWhenClause.terminalAvailable,
-        run: (c, accessor) => accessor.get(IPreferencesService).openSettings({ jsonEditor: false, query: '@feature:terminal' })
+        run: (c, accessor) => accessor.get(IPreferencesService).openSettings({
+            jsonEditor: false,
+            query: "@feature:terminal"
+        })
     });
     registerActiveInstanceAction({
         id: TerminalCommandId.SetDimensions,
-        title: ( localize2(11550, 'Set Fixed Dimensions')),
+        title: ( localize2(11876, "Set Fixed Dimensions")),
         precondition: sharedWhenClause.terminalAvailable_and_opened,
-        run: (activeInstance) => activeInstance.setFixedDimensions()
+        run: activeInstance => activeInstance.setFixedDimensions()
     });
     registerContextualInstanceAction({
         id: TerminalCommandId.SizeToContentWidth,
@@ -1235,11 +1301,11 @@ function registerTerminalActions() {
             weight: KeybindingWeight.WorkbenchContrib,
             when: TerminalContextKeys.focus
         },
-        run: (instance) => instance.toggleSizeToContentWidth()
+        run: instance => instance.toggleSizeToContentWidth()
     });
     registerTerminalAction({
         id: TerminalCommandId.SwitchTerminal,
-        title: ( localize2(11551, 'Switch Terminal')),
+        title: ( localize2(11877, "Switch Terminal")),
         precondition: sharedWhenClause.terminalAvailable,
         run: async (c, accessor, args) => {
             const item = toOptionalString(args);
@@ -1269,12 +1335,10 @@ function registerTerminalActions() {
                         config: profile
                     });
                     c.service.setActiveInstance(instance);
-                }
-                else {
+                } else {
                     console.warn(`No profile with name "${profileSelection}"`);
                 }
-            }
-            else {
+            } else {
                 console.warn(`Unmatched terminal item: "${item}"`);
             }
         }
@@ -1303,7 +1367,7 @@ function getSelectedViewInstances(accessor, args, args2) {
     const result = [];
     const list = listService.lastFocusedList instanceof TerminalTabList ? listService.lastFocusedList : undefined;
     const selections = list?.getSelection();
-    if (terminalGroupService.lastAccessedMenu === 'inline-tab' && !selections?.length) {
+    if (terminalGroupService.lastAccessedMenu === "inline-tab" && !selections?.length) {
         const instance = terminalGroupService.activeInstance;
         return instance ? [terminalGroupService.activeInstance] : undefined;
     }
@@ -1324,18 +1388,21 @@ function getSelectedViewInstances(accessor, args, args2) {
 function validateTerminalName(name) {
     if (!name || name.trim().length === 0) {
         return {
-            content: ( localize(11552, "Providing no name will reset it to the default value")),
+            content: ( localize(11878, "Providing no name will reset it to the default value")),
             severity: Severity.Info
         };
     }
     return null;
 }
 function isTerminalProfile(obj) {
-    return isObject(obj) && 'profileName' in obj;
+    return isObject(obj) && "profileName" in obj;
 }
 function convertOptionsOrProfileToOptions(optionsOrProfile) {
     if (isTerminalProfile(optionsOrProfile)) {
-        return { config: optionsOrProfile, location: optionsOrProfile.location };
+        return {
+            config: optionsOrProfile,
+            location: optionsOrProfile.location
+        };
     }
     return optionsOrProfile;
 }
@@ -1347,7 +1414,7 @@ function refreshTerminalActions(detectedProfiles) {
         constructor() {
             super({
                 id: TerminalCommandId.NewWithProfile,
-                title: ( localize2(11553, 'Create New Terminal (With Profile)')),
+                title: ( localize2(11879, "Create New Terminal (With Profile)")),
                 f1: true,
                 precondition: ( ContextKeyExpr.or(
                     TerminalContextKeys.processSupported,
@@ -1356,30 +1423,27 @@ function refreshTerminalActions(detectedProfiles) {
                 metadata: {
                     description: TerminalCommandId.NewWithProfile,
                     args: [{
-                            name: 'args',
-                            schema: {
-                                type: 'object',
-                                required: ['profileName'],
-                                properties: {
-                                    profileName: {
-                                        description: ( localize(11554, "The name of the profile to create")),
-                                        type: 'string',
-                                        enum: profileEnum.values,
-                                        markdownEnumDescriptions: profileEnum.markdownDescriptions
-                                    },
-                                    location: {
-                                        description: ( localize(11555, "Where to create the terminal")),
-                                        type: 'string',
-                                        enum: ['view', 'editor'],
-                                        enumDescriptions: [
-                                            ( localize(11556, 'Create the terminal in the terminal view')),
-                                            ( localize(11557, 'Create the terminal in the editor')),
-                                        ]
-                                    }
+                        name: "args",
+                        schema: {
+                            type: "object",
+                            required: ["profileName"],
+                            properties: {
+                                profileName: {
+                                    description: ( localize(11880, "The name of the profile to create")),
+                                    type: "string",
+                                    enum: profileEnum.values,
+                                    markdownEnumDescriptions: profileEnum.markdownDescriptions
+                                },
+                                location: {
+                                    description: ( localize(11881, "Where to create the terminal")),
+                                    type: "string",
+                                    enum: ["view", "editor"],
+                                    enumDescriptions: [( localize(11882, "Create the terminal in the terminal view")), ( localize(11883, "Create the terminal in the editor"))]
                                 }
                             }
-                        }]
-                },
+                        }
+                    }]
+                }
             });
         }
         async run(accessor, eventOrOptionsOrProfile, profile) {
@@ -1390,44 +1454,53 @@ function refreshTerminalActions(detectedProfiles) {
             let options;
             let instance;
             let cwd;
-            if (isObject(eventOrOptionsOrProfile) && eventOrOptionsOrProfile && hasKey(eventOrOptionsOrProfile, { profileName: true })) {
+            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 };
+                options = {
+                    config
+                };
                 function isSimpleArgs(obj) {
-                    return isObject(obj) && 'location' in 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;
+                    case "editor":
+                        options.location = TerminalLocation.Editor;
+                        break;
+                    case "view":
+                        options.location = TerminalLocation.Panel;
+                        break;
                     }
                 }
-            }
-            else if (isMouseEvent(eventOrOptionsOrProfile) || isPointerEvent(eventOrOptionsOrProfile) || isKeyboardEvent(eventOrOptionsOrProfile)) {
+            } else if (isMouseEvent(eventOrOptionsOrProfile) || isPointerEvent(eventOrOptionsOrProfile) || isKeyboardEvent(eventOrOptionsOrProfile)) {
                 event = eventOrOptionsOrProfile;
-                options = profile ? { config: profile } : undefined;
-            }
-            else {
+                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 });
+                    await c.service.createTerminal({
+                        location: {
+                            parentTerminal
+                        },
+                        config: options?.config
+                    });
                     return;
                 }
             }
             const folders = workspaceContextService.getWorkspace().folders;
             if (folders.length > 1) {
                 const options = {
-                    placeHolder: ( localize(11502, "Select current working directory for new terminal"))
+                    placeHolder: ( localize(11828, "Select current working directory for new terminal"))
                 };
                 const workspace = await commandService.executeCommand(PICK_WORKSPACE_FOLDER_COMMAND_ID, [options]);
                 if (!workspace) {
@@ -1438,9 +1511,8 @@ function refreshTerminalActions(detectedProfiles) {
             if (options) {
                 options.cwd = cwd;
                 instance = await c.service.createTerminal(options);
-            }
-            else {
-                instance = await c.service.showProfileQuickPick('createInstance', cwd);
+            } else {
+                instance = await c.service.showProfileQuickPick("createInstance", cwd);
             }
             if (instance) {
                 c.service.setActiveInstance(instance);
@@ -1474,13 +1546,11 @@ async function pickTerminalCwd(accessor, cancel) {
     }
     const folderPicks = ( shrinkedPairs.map(pair => {
         const label = pair.folder.name;
-        const description = pair.isOverridden
-            ? ( localize(
-            11558,
-            "(Overriden) {0}",
-            labelService.getUriLabel(pair.cwd, { relative: !pair.isAbsolute })
-        ))
-            : labelService.getUriLabel(dirname(pair.cwd), { relative: true });
+        const description = pair.isOverridden ? ( localize(11884, "(Overriden) {0}", labelService.getUriLabel(pair.cwd, {
+            relative: !pair.isAbsolute
+        }))) : labelService.getUriLabel(dirname(pair.cwd), {
+            relative: true
+        });
         return {
             label,
             description: description !== label ? description : undefined,
@@ -1489,23 +1559,41 @@ async function pickTerminalCwd(accessor, cancel) {
         };
     }));
     const options = {
-        placeHolder: ( localize(11502, "Select current working directory for new terminal")),
+        placeHolder: ( localize(11828, "Select current working directory for new terminal")),
         matchOnDescription: true,
-        canPickMany: false,
+        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 });
+    const cwdConfig = configurationService.getValue(TerminalSettingId.Cwd, {
+        resource: folder.uri
+    });
     if (!isString(cwdConfig) || cwdConfig.length === 0) {
-        return { folder, cwd: folder.uri, isAbsolute: false, isOverridden: false };
+        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) };
+    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());
@@ -1521,10 +1609,7 @@ function shrinkWorkspaceFolderCwdPairs(pairs) {
     return selectedPairsInOrder;
 }
 async function focusActiveTerminal(instance, c) {
-    const target = instance
-        ?? c.service.activeInstance
-        ?? c.editorService.activeInstance
-        ?? c.groupService.activeInstance;
+    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);
@@ -1541,7 +1626,7 @@ async function renameWithQuickPick(c, accessor, resource) {
     if (instance) {
         const title = await accessor.get(IQuickInputService).input({
             value: instance.title,
-            prompt: ( localize(11559, "Enter terminal name")),
+            prompt: ( localize(11885, "Enter terminal name"))
         });
         if (title) {
             instance.rename(title);