@codingame/monaco-vscode-api 25.1.1 → 26.0.0

package/vscode/src/vs/workbench/browser/parts/editor/editorCommands.js

@@ -37,57 +37,57 @@ import { DIFF_FOCUS_SECONDARY_SIDE, DIFF_FOCUS_PRIMARY_SIDE, DIFF_FOCUS_OTHER_SI
 import { resolveCommandsContext } from './editorCommandsContext.js';
 import { prepareMoveCopyEditors } from './editor.js';
 
-const CLOSE_SAVED_EDITORS_COMMAND_ID = 'workbench.action.closeUnmodifiedEditors';
-const CLOSE_EDITORS_IN_GROUP_COMMAND_ID = 'workbench.action.closeEditorsInGroup';
-const CLOSE_EDITORS_AND_GROUP_COMMAND_ID = 'workbench.action.closeEditorsAndGroup';
-const CLOSE_EDITORS_TO_THE_RIGHT_COMMAND_ID = 'workbench.action.closeEditorsToTheRight';
-const CLOSE_EDITOR_COMMAND_ID = 'workbench.action.closeActiveEditor';
-const CLOSE_PINNED_EDITOR_COMMAND_ID = 'workbench.action.closeActivePinnedEditor';
-const CLOSE_EDITOR_GROUP_COMMAND_ID = 'workbench.action.closeGroup';
-const CLOSE_OTHER_EDITORS_IN_GROUP_COMMAND_ID = 'workbench.action.closeOtherEditors';
-const MOVE_ACTIVE_EDITOR_COMMAND_ID = 'moveActiveEditor';
-const COPY_ACTIVE_EDITOR_COMMAND_ID = 'copyActiveEditor';
-const LAYOUT_EDITOR_GROUPS_COMMAND_ID = 'layoutEditorGroups';
-const KEEP_EDITOR_COMMAND_ID = 'workbench.action.keepEditor';
-const TOGGLE_KEEP_EDITORS_COMMAND_ID = 'workbench.action.toggleKeepEditors';
-const TOGGLE_LOCK_GROUP_COMMAND_ID = 'workbench.action.toggleEditorGroupLock';
-const LOCK_GROUP_COMMAND_ID = 'workbench.action.lockEditorGroup';
-const UNLOCK_GROUP_COMMAND_ID = 'workbench.action.unlockEditorGroup';
-const SHOW_EDITORS_IN_GROUP = 'workbench.action.showEditorsInGroup';
-const REOPEN_WITH_COMMAND_ID = 'workbench.action.reopenWithEditor';
-const REOPEN_ACTIVE_EDITOR_WITH_COMMAND_ID = 'reopenActiveEditorWith';
-const PIN_EDITOR_COMMAND_ID = 'workbench.action.pinEditor';
-const UNPIN_EDITOR_COMMAND_ID = 'workbench.action.unpinEditor';
-const SPLIT_EDITOR = 'workbench.action.splitEditor';
-const SPLIT_EDITOR_UP = 'workbench.action.splitEditorUp';
-const SPLIT_EDITOR_DOWN = 'workbench.action.splitEditorDown';
-const SPLIT_EDITOR_LEFT = 'workbench.action.splitEditorLeft';
-const SPLIT_EDITOR_RIGHT = 'workbench.action.splitEditorRight';
-const MOVE_EDITOR_INTO_ABOVE_GROUP = 'workbench.action.moveEditorToAboveGroup';
-const MOVE_EDITOR_INTO_BELOW_GROUP = 'workbench.action.moveEditorToBelowGroup';
-const MOVE_EDITOR_INTO_LEFT_GROUP = 'workbench.action.moveEditorToLeftGroup';
-const MOVE_EDITOR_INTO_RIGHT_GROUP = 'workbench.action.moveEditorToRightGroup';
-const TOGGLE_MAXIMIZE_EDITOR_GROUP = 'workbench.action.toggleMaximizeEditorGroup';
-const SPLIT_EDITOR_IN_GROUP = 'workbench.action.splitEditorInGroup';
-const TOGGLE_SPLIT_EDITOR_IN_GROUP = 'workbench.action.toggleSplitEditorInGroup';
-const JOIN_EDITOR_IN_GROUP = 'workbench.action.joinEditorInGroup';
-const TOGGLE_SPLIT_EDITOR_IN_GROUP_LAYOUT = 'workbench.action.toggleSplitEditorInGroupLayout';
-const FOCUS_FIRST_SIDE_EDITOR = 'workbench.action.focusFirstSideEditor';
-const FOCUS_SECOND_SIDE_EDITOR = 'workbench.action.focusSecondSideEditor';
-const FOCUS_OTHER_SIDE_EDITOR = 'workbench.action.focusOtherSideEditor';
-const FOCUS_LEFT_GROUP_WITHOUT_WRAP_COMMAND_ID = 'workbench.action.focusLeftGroupWithoutWrap';
-const FOCUS_RIGHT_GROUP_WITHOUT_WRAP_COMMAND_ID = 'workbench.action.focusRightGroupWithoutWrap';
-const FOCUS_ABOVE_GROUP_WITHOUT_WRAP_COMMAND_ID = 'workbench.action.focusAboveGroupWithoutWrap';
-const FOCUS_BELOW_GROUP_WITHOUT_WRAP_COMMAND_ID = 'workbench.action.focusBelowGroupWithoutWrap';
-const OPEN_EDITOR_AT_INDEX_COMMAND_ID = 'workbench.action.openEditorAtIndex';
-const MOVE_EDITOR_INTO_NEW_WINDOW_COMMAND_ID = 'workbench.action.moveEditorToNewWindow';
-const COPY_EDITOR_INTO_NEW_WINDOW_COMMAND_ID = 'workbench.action.copyEditorToNewWindow';
-const MOVE_EDITOR_GROUP_INTO_NEW_WINDOW_COMMAND_ID = 'workbench.action.moveEditorGroupToNewWindow';
-const COPY_EDITOR_GROUP_INTO_NEW_WINDOW_COMMAND_ID = 'workbench.action.copyEditorGroupToNewWindow';
-const NEW_EMPTY_EDITOR_WINDOW_COMMAND_ID = 'workbench.action.newEmptyEditorWindow';
-const API_OPEN_EDITOR_COMMAND_ID = '_workbench.open';
-const API_OPEN_DIFF_EDITOR_COMMAND_ID = '_workbench.diff';
-const API_OPEN_WITH_EDITOR_COMMAND_ID = '_workbench.openWith';
+const CLOSE_SAVED_EDITORS_COMMAND_ID = "workbench.action.closeUnmodifiedEditors";
+const CLOSE_EDITORS_IN_GROUP_COMMAND_ID = "workbench.action.closeEditorsInGroup";
+const CLOSE_EDITORS_AND_GROUP_COMMAND_ID = "workbench.action.closeEditorsAndGroup";
+const CLOSE_EDITORS_TO_THE_RIGHT_COMMAND_ID = "workbench.action.closeEditorsToTheRight";
+const CLOSE_EDITOR_COMMAND_ID = "workbench.action.closeActiveEditor";
+const CLOSE_PINNED_EDITOR_COMMAND_ID = "workbench.action.closeActivePinnedEditor";
+const CLOSE_EDITOR_GROUP_COMMAND_ID = "workbench.action.closeGroup";
+const CLOSE_OTHER_EDITORS_IN_GROUP_COMMAND_ID = "workbench.action.closeOtherEditors";
+const MOVE_ACTIVE_EDITOR_COMMAND_ID = "moveActiveEditor";
+const COPY_ACTIVE_EDITOR_COMMAND_ID = "copyActiveEditor";
+const LAYOUT_EDITOR_GROUPS_COMMAND_ID = "layoutEditorGroups";
+const KEEP_EDITOR_COMMAND_ID = "workbench.action.keepEditor";
+const TOGGLE_KEEP_EDITORS_COMMAND_ID = "workbench.action.toggleKeepEditors";
+const TOGGLE_LOCK_GROUP_COMMAND_ID = "workbench.action.toggleEditorGroupLock";
+const LOCK_GROUP_COMMAND_ID = "workbench.action.lockEditorGroup";
+const UNLOCK_GROUP_COMMAND_ID = "workbench.action.unlockEditorGroup";
+const SHOW_EDITORS_IN_GROUP = "workbench.action.showEditorsInGroup";
+const REOPEN_WITH_COMMAND_ID = "workbench.action.reopenWithEditor";
+const REOPEN_ACTIVE_EDITOR_WITH_COMMAND_ID = "reopenActiveEditorWith";
+const PIN_EDITOR_COMMAND_ID = "workbench.action.pinEditor";
+const UNPIN_EDITOR_COMMAND_ID = "workbench.action.unpinEditor";
+const SPLIT_EDITOR = "workbench.action.splitEditor";
+const SPLIT_EDITOR_UP = "workbench.action.splitEditorUp";
+const SPLIT_EDITOR_DOWN = "workbench.action.splitEditorDown";
+const SPLIT_EDITOR_LEFT = "workbench.action.splitEditorLeft";
+const SPLIT_EDITOR_RIGHT = "workbench.action.splitEditorRight";
+const MOVE_EDITOR_INTO_ABOVE_GROUP = "workbench.action.moveEditorToAboveGroup";
+const MOVE_EDITOR_INTO_BELOW_GROUP = "workbench.action.moveEditorToBelowGroup";
+const MOVE_EDITOR_INTO_LEFT_GROUP = "workbench.action.moveEditorToLeftGroup";
+const MOVE_EDITOR_INTO_RIGHT_GROUP = "workbench.action.moveEditorToRightGroup";
+const TOGGLE_MAXIMIZE_EDITOR_GROUP = "workbench.action.toggleMaximizeEditorGroup";
+const SPLIT_EDITOR_IN_GROUP = "workbench.action.splitEditorInGroup";
+const TOGGLE_SPLIT_EDITOR_IN_GROUP = "workbench.action.toggleSplitEditorInGroup";
+const JOIN_EDITOR_IN_GROUP = "workbench.action.joinEditorInGroup";
+const TOGGLE_SPLIT_EDITOR_IN_GROUP_LAYOUT = "workbench.action.toggleSplitEditorInGroupLayout";
+const FOCUS_FIRST_SIDE_EDITOR = "workbench.action.focusFirstSideEditor";
+const FOCUS_SECOND_SIDE_EDITOR = "workbench.action.focusSecondSideEditor";
+const FOCUS_OTHER_SIDE_EDITOR = "workbench.action.focusOtherSideEditor";
+const FOCUS_LEFT_GROUP_WITHOUT_WRAP_COMMAND_ID = "workbench.action.focusLeftGroupWithoutWrap";
+const FOCUS_RIGHT_GROUP_WITHOUT_WRAP_COMMAND_ID = "workbench.action.focusRightGroupWithoutWrap";
+const FOCUS_ABOVE_GROUP_WITHOUT_WRAP_COMMAND_ID = "workbench.action.focusAboveGroupWithoutWrap";
+const FOCUS_BELOW_GROUP_WITHOUT_WRAP_COMMAND_ID = "workbench.action.focusBelowGroupWithoutWrap";
+const OPEN_EDITOR_AT_INDEX_COMMAND_ID = "workbench.action.openEditorAtIndex";
+const MOVE_EDITOR_INTO_NEW_WINDOW_COMMAND_ID = "workbench.action.moveEditorToNewWindow";
+const COPY_EDITOR_INTO_NEW_WINDOW_COMMAND_ID = "workbench.action.copyEditorToNewWindow";
+const MOVE_EDITOR_GROUP_INTO_NEW_WINDOW_COMMAND_ID = "workbench.action.moveEditorGroupToNewWindow";
+const COPY_EDITOR_GROUP_INTO_NEW_WINDOW_COMMAND_ID = "workbench.action.copyEditorGroupToNewWindow";
+const NEW_EMPTY_EDITOR_WINDOW_COMMAND_ID = "workbench.action.newEmptyEditorWindow";
+const API_OPEN_EDITOR_COMMAND_ID = "_workbench.open";
+const API_OPEN_DIFF_EDITOR_COMMAND_ID = "_workbench.diff";
+const API_OPEN_WITH_EDITOR_COMMAND_ID = "_workbench.openWith";
 const EDITOR_CORE_NAVIGATION_COMMANDS = [
     SPLIT_EDITOR,
     CLOSE_EDITOR_COMMAND_ID,
@@ -95,7 +95,7 @@ const EDITOR_CORE_NAVIGATION_COMMANDS = [
     UNLOCK_GROUP_COMMAND_ID,
     TOGGLE_MAXIMIZE_EDITOR_GROUP
 ];
-const isSelectedEditorsMoveCopyArg = function (arg) {
+const isSelectedEditorsMoveCopyArg = function(arg) {
     if (!isObject(arg)) {
         return false;
     }
@@ -112,19 +112,19 @@ const isSelectedEditorsMoveCopyArg = function (arg) {
 };
 function registerEditorMoveCopyCommand() {
     const moveCopyJSONSchema = {
-        'type': 'object',
-        'required': ['to'],
-        'properties': {
-            'to': {
-                'type': 'string',
-                'enum': ['left', 'right']
+        "type": "object",
+        "required": ["to"],
+        "properties": {
+            "to": {
+                "type": "string",
+                "enum": ["left", "right"]
             },
-            'by': {
-                'type': 'string',
-                'enum': ['tab', 'group']
+            "by": {
+                "type": "string",
+                "enum": ["tab", "group"]
             },
-            'value': {
-                'type': 'number'
+            "value": {
+                "type": "number"
             }
         }
     };
@@ -135,18 +135,16 @@ function registerEditorMoveCopyCommand() {
         primary: 0,
         handler: (accessor, args) => moveCopySelectedEditors(true, args, accessor),
         metadata: {
-            description: ( localize(3380, "Move the active editor by tabs or groups")),
-            args: [
-                {
-                    name: ( localize(3381, "Active editor move argument")),
-                    description: ( localize(
-                        3382,
-                        "Argument Properties:\n\t* 'to': String value providing where to move.\n\t* 'by': String value providing the unit for move (by tab or by group).\n\t* 'value': Number value providing how many positions or an absolute position to move."
-                    )),
-                    constraint: isSelectedEditorsMoveCopyArg,
-                    schema: moveCopyJSONSchema
-                }
-            ]
+            description: ( localize(3384, "Move the active editor by tabs or groups")),
+            args: [{
+                name: ( localize(3385, "Active editor move argument")),
+                description: ( localize(
+                    3386,
+                    "Argument Properties:\n\t* 'to': String value providing where to move.\n\t* 'by': String value providing the unit for move (by tab or by group).\n\t* 'value': Number value providing how many positions or an absolute position to move."
+                )),
+                constraint: isSelectedEditorsMoveCopyArg,
+                schema: moveCopyJSONSchema
+            }]
         }
     });
     KeybindingsRegistry.registerCommandAndKeybindingRule({
@@ -156,57 +154,72 @@ function registerEditorMoveCopyCommand() {
         primary: 0,
         handler: (accessor, args) => moveCopySelectedEditors(false, args, accessor),
         metadata: {
-            description: ( localize(3383, "Copy the active editor by groups")),
-            args: [
-                {
-                    name: ( localize(3384, "Active editor copy argument")),
-                    description: ( localize(
-                        3385,
-                        "Argument Properties:\n\t* 'to': String value providing where to copy.\n\t* 'value': Number value providing how many positions or an absolute position to copy."
-                    )),
-                    constraint: isSelectedEditorsMoveCopyArg,
-                    schema: moveCopyJSONSchema
-                }
-            ]
+            description: ( localize(3387, "Copy the active editor by groups")),
+            args: [{
+                name: ( localize(3388, "Active editor copy argument")),
+                description: ( localize(
+                    3389,
+                    "Argument Properties:\n\t* 'to': String value providing where to copy.\n\t* 'value': Number value providing how many positions or an absolute position to copy."
+                )),
+                constraint: isSelectedEditorsMoveCopyArg,
+                schema: moveCopyJSONSchema
+            }]
         }
     });
-    [
-        { id: MOVE_EDITOR_INTO_ABOVE_GROUP, to: 'up' },
-        { id: MOVE_EDITOR_INTO_BELOW_GROUP, to: 'down' },
-        { id: MOVE_EDITOR_INTO_LEFT_GROUP, to: 'left' },
-        { id: MOVE_EDITOR_INTO_RIGHT_GROUP, to: 'right' }
-    ].forEach(({ id, to }) => {
-        CommandsRegistry.registerCommand(id, function (accessor, ...args) {
-            const resolvedContext = resolveCommandsContext(args, accessor.get(IEditorService), accessor.get(IEditorGroupsService), accessor.get(IListService));
+    [{
+        id: MOVE_EDITOR_INTO_ABOVE_GROUP,
+        to: "up"
+    }, {
+        id: MOVE_EDITOR_INTO_BELOW_GROUP,
+        to: "down"
+    }, {
+        id: MOVE_EDITOR_INTO_LEFT_GROUP,
+        to: "left"
+    }, {
+        id: MOVE_EDITOR_INTO_RIGHT_GROUP,
+        to: "right"
+    }].forEach((
+        {
+            id,
+            to
+        }
+    ) => {
+        CommandsRegistry.registerCommand(id, function(accessor, ...args) {
+            const resolvedContext = resolveCommandsContext(
+                args,
+                accessor.get(IEditorService),
+                accessor.get(IEditorGroupsService),
+                accessor.get(IListService)
+            );
             if (resolvedContext.groupedEditors.length) {
-                moveCopyEditorsToGroup(true, { to}, resolvedContext.groupedEditors[0].group, resolvedContext.groupedEditors[0].editors, accessor);
+                moveCopyEditorsToGroup(true, {
+                    to}, resolvedContext.groupedEditors[0].group, resolvedContext.groupedEditors[0].editors, accessor);
             }
         });
     });
     function moveCopySelectedEditors(isMove, args = Object.create(null), accessor) {
-        args.to = args.to || 'right';
-        args.by = args.by || 'tab';
-        args.value = typeof args.value === 'number' ? args.value : 1;
+        args.to = args.to || "right";
+        args.by = args.by || "tab";
+        args.value = typeof args.value === "number" ? args.value : 1;
         const activeGroup = accessor.get(IEditorGroupsService).activeGroup;
         const selectedEditors = activeGroup.selectedEditors;
         if (selectedEditors.length > 0) {
             switch (args.by) {
-                case 'tab':
-                    if (isMove) {
-                        return moveTabs(args, activeGroup, selectedEditors);
-                    }
-                    break;
-                case 'group':
-                    return moveCopyEditorsToGroup(isMove, args, activeGroup, selectedEditors, accessor);
+            case "tab":
+                if (isMove) {
+                    return moveTabs(args, activeGroup, selectedEditors);
+                }
+                break;
+            case "group":
+                return moveCopyEditorsToGroup(isMove, args, activeGroup, selectedEditors, accessor);
             }
         }
     }
     function moveTabs(args, group, editors) {
         const to = args.to;
-        if (to === 'first' || to === 'right') {
+        if (to === "first" || to === "right") {
             editors = [...editors].reverse();
-        }
-        else if (to === 'position' && (args.value ?? 1) < group.getIndexOfEditor(editors[0])) {
+        } else if (to === "position" && (args.value ?? 1) < group.getIndexOfEditor(editors[0])) {
             editors = [...editors].reverse();
         }
         for (const editor of editors) {
@@ -216,89 +229,106 @@ function registerEditorMoveCopyCommand() {
     function moveTab(args, group, editor) {
         let index = group.getIndexOfEditor(editor);
         switch (args.to) {
-            case 'first':
-                index = 0;
-                break;
-            case 'last':
-                index = group.count - 1;
-                break;
-            case 'left':
-                index = index - (args.value ?? 1);
-                break;
-            case 'right':
-                index = index + (args.value ?? 1);
-                break;
-            case 'center':
-                index = Math.round(group.count / 2) - 1;
-                break;
-            case 'position':
-                index = (args.value ?? 1) - 1;
-                break;
+        case "first":
+            index = 0;
+            break;
+        case "last":
+            index = group.count - 1;
+            break;
+        case "left":
+            index = index - (args.value ?? 1);
+            break;
+        case "right":
+            index = index + (args.value ?? 1);
+            break;
+        case "center":
+            index = Math.round(group.count / 2) - 1;
+            break;
+        case "position":
+            index = (args.value ?? 1) - 1;
+            break;
         }
         index = index < 0 ? 0 : index >= group.count ? group.count - 1 : index;
-        group.moveEditor(editor, group, { index });
+        group.moveEditor(editor, group, {
+            index
+        });
     }
     function moveCopyEditorsToGroup(isMove, args, sourceGroup, editors, accessor) {
         const editorGroupsService = accessor.get(IEditorGroupsService);
         const configurationService = accessor.get(IConfigurationService);
         let targetGroup;
         switch (args.to) {
-            case 'left':
-                targetGroup = editorGroupsService.findGroup({ direction: GroupDirection.LEFT }, sourceGroup);
-                if (!targetGroup) {
-                    targetGroup = editorGroupsService.addGroup(sourceGroup, GroupDirection.LEFT);
-                }
-                break;
-            case 'right':
-                targetGroup = editorGroupsService.findGroup({ direction: GroupDirection.RIGHT }, sourceGroup);
-                if (!targetGroup) {
-                    targetGroup = editorGroupsService.addGroup(sourceGroup, GroupDirection.RIGHT);
-                }
-                break;
-            case 'up':
-                targetGroup = editorGroupsService.findGroup({ direction: GroupDirection.UP }, sourceGroup);
-                if (!targetGroup) {
-                    targetGroup = editorGroupsService.addGroup(sourceGroup, GroupDirection.UP);
-                }
-                break;
-            case 'down':
-                targetGroup = editorGroupsService.findGroup({ direction: GroupDirection.DOWN }, sourceGroup);
-                if (!targetGroup) {
-                    targetGroup = editorGroupsService.addGroup(sourceGroup, GroupDirection.DOWN);
-                }
-                break;
-            case 'first':
-                targetGroup = editorGroupsService.findGroup({ location: GroupLocation.FIRST }, sourceGroup);
-                break;
-            case 'last':
-                targetGroup = editorGroupsService.findGroup({ location: GroupLocation.LAST }, sourceGroup);
-                break;
-            case 'previous':
-                targetGroup = editorGroupsService.findGroup({ location: GroupLocation.PREVIOUS }, sourceGroup);
-                if (!targetGroup) {
-                    const oppositeDirection = preferredSideBySideGroupDirection(configurationService) === GroupDirection.RIGHT ? GroupDirection.LEFT : GroupDirection.UP;
-                    targetGroup = editorGroupsService.addGroup(sourceGroup, oppositeDirection);
-                }
-                break;
-            case 'next':
-                targetGroup = editorGroupsService.findGroup({ location: GroupLocation.NEXT }, sourceGroup);
-                if (!targetGroup) {
-                    targetGroup = editorGroupsService.addGroup(sourceGroup, preferredSideBySideGroupDirection(configurationService));
-                }
-                break;
-            case 'center':
-                targetGroup = editorGroupsService.getGroups(GroupsOrder.GRID_APPEARANCE)[(editorGroupsService.count / 2) - 1];
-                break;
-            case 'position':
-                targetGroup = editorGroupsService.getGroups(GroupsOrder.GRID_APPEARANCE)[(args.value ?? 1) - 1];
-                break;
+        case "left":
+            targetGroup = editorGroupsService.findGroup({
+                direction: GroupDirection.LEFT
+            }, sourceGroup);
+            if (!targetGroup) {
+                targetGroup = editorGroupsService.addGroup(sourceGroup, GroupDirection.LEFT);
+            }
+            break;
+        case "right":
+            targetGroup = editorGroupsService.findGroup({
+                direction: GroupDirection.RIGHT
+            }, sourceGroup);
+            if (!targetGroup) {
+                targetGroup = editorGroupsService.addGroup(sourceGroup, GroupDirection.RIGHT);
+            }
+            break;
+        case "up":
+            targetGroup = editorGroupsService.findGroup({
+                direction: GroupDirection.UP
+            }, sourceGroup);
+            if (!targetGroup) {
+                targetGroup = editorGroupsService.addGroup(sourceGroup, GroupDirection.UP);
+            }
+            break;
+        case "down":
+            targetGroup = editorGroupsService.findGroup({
+                direction: GroupDirection.DOWN
+            }, sourceGroup);
+            if (!targetGroup) {
+                targetGroup = editorGroupsService.addGroup(sourceGroup, GroupDirection.DOWN);
+            }
+            break;
+        case "first":
+            targetGroup = editorGroupsService.findGroup({
+                location: GroupLocation.FIRST
+            }, sourceGroup);
+            break;
+        case "last":
+            targetGroup = editorGroupsService.findGroup({
+                location: GroupLocation.LAST
+            }, sourceGroup);
+            break;
+        case "previous":
+            targetGroup = editorGroupsService.findGroup({
+                location: GroupLocation.PREVIOUS
+            }, sourceGroup);
+            if (!targetGroup) {
+                const oppositeDirection = preferredSideBySideGroupDirection(configurationService) === GroupDirection.RIGHT ? GroupDirection.LEFT : GroupDirection.UP;
+                targetGroup = editorGroupsService.addGroup(sourceGroup, oppositeDirection);
+            }
+            break;
+        case "next":
+            targetGroup = editorGroupsService.findGroup({
+                location: GroupLocation.NEXT
+            }, sourceGroup);
+            if (!targetGroup) {
+                targetGroup = editorGroupsService.addGroup(sourceGroup, preferredSideBySideGroupDirection(configurationService));
+            }
+            break;
+        case "center":
+            targetGroup = editorGroupsService.getGroups(GroupsOrder.GRID_APPEARANCE)[(editorGroupsService.count / 2) - 1];
+            break;
+        case "position":
+            targetGroup = editorGroupsService.getGroups(GroupsOrder.GRID_APPEARANCE)[(args.value ?? 1) - 1];
+            break;
         }
         if (targetGroup) {
             const editorsWithOptions = prepareMoveCopyEditors(sourceGroup, editors);
             if (isMove) {
                 sourceGroup.moveEditors(editorsWithOptions, targetGroup);
-            }
-            else if (sourceGroup.id !== targetGroup.id) {
+            } else if (sourceGroup.id !== targetGroup.id) {
                 sourceGroup.copyEditors(editorsWithOptions, targetGroup);
             }
             targetGroup.focus();
@@ -307,7 +337,7 @@ function registerEditorMoveCopyCommand() {
 }
 function registerEditorGroupsLayoutCommands() {
     function applyEditorLayout(accessor, layout) {
-        if (!layout || typeof layout !== 'object') {
+        if (!layout || typeof layout !== "object") {
             return;
         }
         const editorGroupsService = accessor.get(IEditorGroupsService);
@@ -317,51 +347,48 @@ function registerEditorGroupsLayoutCommands() {
         applyEditorLayout(accessor, args);
     });
     CommandsRegistry.registerCommand({
-        id: 'vscode.setEditorLayout',
+        id: "vscode.setEditorLayout",
         handler: (accessor, args) => applyEditorLayout(accessor, args),
         metadata: {
-            'description': `Set the editor layout. Editor layout is represented as a tree of groups in which the first group is the root group of the layout.
-					The orientation of the first group is 0 (horizontal) by default unless specified otherwise. The other orientations are 1 (vertical).
-					The orientation of subsequent groups is the opposite of the orientation of the group that contains it.
-					Here are some examples: A layout representing 1 row and 2 columns: { orientation: 0, groups: [{}, {}] }.
-					A layout representing 3 rows and 1 column: { orientation: 1, groups: [{}, {}, {}] }.
-					A layout representing 3 rows and 1 column in which the second row has 2 columns: { orientation: 1, groups: [{}, { groups: [{}, {}] }, {}] }
-					`,
+            "description": `Set the editor layout. Editor layout is represented as a tree of groups in which the first group is the root group of the layout.
+                    The orientation of the first group is 0 (horizontal) by default unless specified otherwise. The other orientations are 1 (vertical).
+                    The orientation of subsequent groups is the opposite of the orientation of the group that contains it.
+                    Here are some examples: A layout representing 1 row and 2 columns: { orientation: 0, groups: [{}, {}] }.
+                    A layout representing 3 rows and 1 column: { orientation: 1, groups: [{}, {}, {}] }.
+                    A layout representing 3 rows and 1 column in which the second row has 2 columns: { orientation: 1, groups: [{}, { groups: [{}, {}] }, {}] }
+                    `,
             args: [{
-                    name: 'args',
-                    schema: {
-                        'type': 'object',
-                        'required': ['groups'],
-                        'properties': {
-                            'orientation': {
-                                'type': 'number',
-                                'default': 0,
-                                'description': `The orientation of the root group in the layout. 0 for horizontal, 1 for vertical.`,
-                                'enum': [0, 1],
-                                'enumDescriptions': [
-                                    ( localize(3386, "Horizontal")),
-                                    ( localize(3387, "Vertical"))
-                                ],
-                            },
-                            'groups': {
-                                '$ref': '#/definitions/editorGroupsSchema',
-                                'default': [{}, {}]
-                            }
+                name: "args",
+                schema: {
+                    "type": "object",
+                    "required": ["groups"],
+                    "properties": {
+                        "orientation": {
+                            "type": "number",
+                            "default": 0,
+                            "description": `The orientation of the root group in the layout. 0 for horizontal, 1 for vertical.`,
+                            "enum": [0, 1],
+                            "enumDescriptions": [( localize(3390, "Horizontal")), ( localize(3391, "Vertical"))]
+                        },
+                        "groups": {
+                            "$ref": "#/definitions/editorGroupsSchema",
+                            "default": [{}, {}]
                         }
                     }
-                }]
+                }
+            }]
         }
     });
     CommandsRegistry.registerCommand({
-        id: 'vscode.getEditorLayout',
-        handler: (accessor) => {
+        id: "vscode.getEditorLayout",
+        handler: accessor => {
             const editorGroupsService = accessor.get(IEditorGroupsService);
             return editorGroupsService.getLayout();
         },
         metadata: {
-            description: 'Get Editor Layout',
+            description: "Get Editor Layout",
             args: [],
-            returns: 'An editor layout object, in the same format as vscode.setEditorLayout'
+            returns: "An editor layout object, in the same format as vscode.setEditorLayout"
         }
     });
 }
@@ -370,64 +397,97 @@ function registerOpenEditorAPICommands() {
         if (!context) {
             return [options, column];
         }
-        return [
-            { ...context.editorOptions, ...(options ?? Object.create(null)) },
-            context.sideBySide ? SIDE_GROUP : column
-        ];
+        return [{
+            ...context.editorOptions,
+            ...(options ?? Object.create(null))
+        }, context.sideBySide ? SIDE_GROUP : column];
     }
     CommandsRegistry.registerCommand({
-        id: 'vscode.open',
+        id: "vscode.open",
         handler: (accessor, arg) => {
             accessor.get(ICommandService).executeCommand(API_OPEN_EDITOR_COMMAND_ID, arg);
         },
         metadata: {
-            description: 'Opens the provided resource in the editor.',
-            args: [{ name: 'Uri' }]
+            description: "Opens the provided resource in the editor.",
+            args: [{
+                name: "Uri"
+            }]
         }
     });
-    CommandsRegistry.registerCommand(API_OPEN_EDITOR_COMMAND_ID, async function (accessor, resourceArg, columnAndOptions, label, context) {
-        const editorService = accessor.get(IEditorService);
-        const editorGroupsService = accessor.get(IEditorGroupsService);
-        const openerService = accessor.get(IOpenerService);
-        const pathService = accessor.get(IPathService);
-        const configurationService = accessor.get(IConfigurationService);
-        const untitledTextEditorService = accessor.get(IUntitledTextEditorService);
-        const resourceOrString = typeof resourceArg === 'string' ? resourceArg : ( URI.from(resourceArg, true));
-        const [columnArg, optionsArg] = columnAndOptions ?? [];
-        if (optionsArg || typeof columnArg === 'number' || matchesScheme(resourceOrString, Schemas.untitled)) {
-            const [options, column] = mixinContext(context, optionsArg, columnArg);
-            const resource = URI.isUri(resourceOrString) ? resourceOrString : ( URI.parse(resourceOrString));
-            let input;
-            if (untitledTextEditorService.isUntitledWithAssociatedResource(resource)) {
-                input = { resource: resource.with({ scheme: pathService.defaultUriScheme }), forceUntitled: true, options, label };
+    CommandsRegistry.registerCommand(
+        API_OPEN_EDITOR_COMMAND_ID,
+        async function(accessor, resourceArg, columnAndOptions, label, context) {
+            const editorService = accessor.get(IEditorService);
+            const editorGroupsService = accessor.get(IEditorGroupsService);
+            const openerService = accessor.get(IOpenerService);
+            const pathService = accessor.get(IPathService);
+            const configurationService = accessor.get(IConfigurationService);
+            const untitledTextEditorService = accessor.get(IUntitledTextEditorService);
+            const resourceOrString = typeof resourceArg === "string" ? resourceArg : ( URI.from(resourceArg, true));
+            const [columnArg, optionsArg] = columnAndOptions ?? [];
+            if (optionsArg || typeof columnArg === "number" || matchesScheme(resourceOrString, Schemas.untitled)) {
+                const [options, column] = mixinContext(context, optionsArg, columnArg);
+                const resource = URI.isUri(resourceOrString) ? resourceOrString : ( URI.parse(resourceOrString));
+                let input;
+                if (untitledTextEditorService.isUntitledWithAssociatedResource(resource)) {
+                    input = {
+                        resource: resource.with({
+                            scheme: pathService.defaultUriScheme
+                        }),
+                        forceUntitled: true,
+                        options,
+                        label
+                    };
+                } else {
+                    input = {
+                        resource,
+                        options,
+                        label
+                    };
+                }
+                await editorService.openEditor(
+                    input,
+                    columnToEditorGroup(editorGroupsService, configurationService, column)
+                );
+            }
+            else if (matchesScheme(resourceOrString, Schemas.command)) {
+                return;
             }
             else {
-                input = { resource, options, label };
+                await openerService.open(resourceOrString, {
+                    openToSide: context?.sideBySide,
+                    editorOptions: context?.editorOptions
+                });
             }
-            await editorService.openEditor(input, columnToEditorGroup(editorGroupsService, configurationService, column));
-        }
-        else if (matchesScheme(resourceOrString, Schemas.command)) {
-            return;
-        }
-        else {
-            await openerService.open(resourceOrString, { openToSide: context?.sideBySide, editorOptions: context?.editorOptions });
         }
-    });
+    );
     CommandsRegistry.registerCommand({
-        id: 'vscode.diff',
+        id: "vscode.diff",
         handler: (accessor, left, right, label) => {
             accessor.get(ICommandService).executeCommand(API_OPEN_DIFF_EDITOR_COMMAND_ID, left, right, label);
         },
         metadata: {
-            description: 'Opens the provided resources in the diff editor to compare their contents.',
-            args: [
-                { name: 'left', description: 'Left-hand side resource of the diff editor' },
-                { name: 'right', description: 'Right-hand side resource of the diff editor' },
-                { name: 'title', description: 'Human readable title for the diff editor' },
-            ]
+            description: "Opens the provided resources in the diff editor to compare their contents.",
+            args: [{
+                name: "left",
+                description: "Left-hand side resource of the diff editor"
+            }, {
+                name: "right",
+                description: "Right-hand side resource of the diff editor"
+            }, {
+                name: "title",
+                description: "Human readable title for the diff editor"
+            }]
         }
     });
-    CommandsRegistry.registerCommand(API_OPEN_DIFF_EDITOR_COMMAND_ID, async function (accessor, originalResource, modifiedResource, labelAndOrDescription, columnAndOptions, context) {
+    CommandsRegistry.registerCommand(API_OPEN_DIFF_EDITOR_COMMAND_ID, async function(
+        accessor,
+        originalResource,
+        modifiedResource,
+        labelAndOrDescription,
+        columnAndOptions,
+        context
+    ) {
         const editorService = accessor.get(IEditorService);
         const editorGroupsService = accessor.get(IEditorGroupsService);
         const configurationService = accessor.get(IConfigurationService);
@@ -435,69 +495,99 @@ function registerOpenEditorAPICommands() {
         const [options, column] = mixinContext(context, optionsArg, columnArg);
         let label = undefined;
         let description = undefined;
-        if (typeof labelAndOrDescription === 'string') {
+        if (typeof labelAndOrDescription === "string") {
             label = labelAndOrDescription;
-        }
-        else if (labelAndOrDescription) {
+        } else if (labelAndOrDescription) {
             label = labelAndOrDescription.label;
             description = labelAndOrDescription.description;
         }
         await editorService.openEditor({
-            original: { resource: ( URI.from(originalResource, true)) },
-            modified: { resource: ( URI.from(modifiedResource, true)) },
+            original: {
+                resource: ( URI.from(originalResource, true))
+            },
+            modified: {
+                resource: ( URI.from(modifiedResource, true))
+            },
             label,
             description,
             options
         }, columnToEditorGroup(editorGroupsService, configurationService, column));
     });
-    CommandsRegistry.registerCommand(API_OPEN_WITH_EDITOR_COMMAND_ID, async (accessor, resource, id, columnAndOptions) => {
-        const editorService = accessor.get(IEditorService);
-        const editorGroupsService = accessor.get(IEditorGroupsService);
-        const configurationService = accessor.get(IConfigurationService);
-        const [columnArg, optionsArg] = columnAndOptions ?? [];
-        await editorService.openEditor({ resource: ( URI.from(resource, true)), options: { pinned: true, ...optionsArg, override: id } }, columnToEditorGroup(editorGroupsService, configurationService, columnArg));
-    });
+    CommandsRegistry.registerCommand(
+        API_OPEN_WITH_EDITOR_COMMAND_ID,
+        async (accessor, resource, id, columnAndOptions) => {
+            const editorService = accessor.get(IEditorService);
+            const editorGroupsService = accessor.get(IEditorGroupsService);
+            const configurationService = accessor.get(IConfigurationService);
+            const [columnArg, optionsArg] = columnAndOptions ?? [];
+            await editorService.openEditor({
+                resource: ( URI.from(resource, true)),
+                options: {
+                    pinned: true,
+                    ...optionsArg,
+                    override: id
+                }
+            }, columnToEditorGroup(editorGroupsService, configurationService, columnArg));
+        }
+    );
     CommandsRegistry.registerCommand({
-        id: 'vscode.changes',
+        id: "vscode.changes",
         handler: (accessor, title, resources) => {
-            accessor.get(ICommandService).executeCommand('_workbench.changes', title, resources);
+            accessor.get(ICommandService).executeCommand("_workbench.changes", title, resources);
         },
         metadata: {
-            description: 'Opens a list of resources in the changes editor to compare their contents.',
-            args: [
-                { name: 'title', description: 'Human readable title for the diff editor' },
-                { name: 'resources', description: 'List of resources to open in the changes editor' }
-            ]
+            description: "Opens a list of resources in the changes editor to compare their contents.",
+            args: [{
+                name: "title",
+                description: "Human readable title for the diff editor"
+            }, {
+                name: "resources",
+                description: "List of resources to open in the changes editor"
+            }]
         }
     });
-    CommandsRegistry.registerCommand('_workbench.changes', async (accessor, title, resources) => {
+    CommandsRegistry.registerCommand("_workbench.changes", async (accessor, title, resources) => {
         const editorService = accessor.get(IEditorService);
         const editor = [];
         for (const [label, original, modified] of resources) {
             editor.push({
                 resource: URI.revive(label),
-                original: { resource: URI.revive(original) },
-                modified: { resource: URI.revive(modified) },
+                original: {
+                    resource: URI.revive(original)
+                },
+                modified: {
+                    resource: URI.revive(modified)
+                }
             });
         }
-        await editorService.openEditor({ resources: editor, label: title });
+        await editorService.openEditor({
+            resources: editor,
+            label: title
+        });
     });
-    CommandsRegistry.registerCommand('_workbench.openMultiDiffEditor', async (accessor, options) => {
+    CommandsRegistry.registerCommand("_workbench.openMultiDiffEditor", async (accessor, options) => {
         const editorService = accessor.get(IEditorService);
-        const resources = options.resources?.map(r => ({ original: { resource: URI.revive(r.originalUri) }, modified: { resource: URI.revive(r.modifiedUri) } }));
+        const resources = options.resources?.map(r => ({
+            original: {
+                resource: URI.revive(r.originalUri)
+            },
+            modified: {
+                resource: URI.revive(r.modifiedUri)
+            }
+        }));
         const revealUri = options.reveal?.modifiedUri ? URI.revive(options.reveal.modifiedUri) : undefined;
         const revealResource = revealUri && resources ? resources.find(r => isEqual(r.modified.resource, revealUri)) : undefined;
         if (options.reveal && !revealResource) {
-            console.error('Reveal resource not found');
+            console.error("Reveal resource not found");
         }
         const multiDiffEditorOptions = {
             viewState: revealResource ? {
                 revealData: {
                     resource: {
                         original: revealResource.original.resource,
-                        modified: revealResource.modified.resource,
+                        modified: revealResource.modified.resource
                     },
-                    range: options.reveal?.range,
+                    range: options.reveal?.range
                 }
             } : undefined
         };
@@ -505,7 +595,7 @@ function registerOpenEditorAPICommands() {
             multiDiffSource: options.multiDiffSourceUri ? URI.revive(options.multiDiffSourceUri) : undefined,
             resources,
             label: options.title,
-            options: multiDiffEditorOptions,
+            options: multiDiffEditorOptions
         });
     });
 }
@@ -513,7 +603,7 @@ function registerOpenEditorAtIndexCommands() {
     const openEditorAtIndex = (accessor, editorIndex) => {
         const editorService = accessor.get(IEditorService);
         const activeEditorPane = editorService.activeEditorPane;
-        if (activeEditorPane && typeof editorIndex === 'number') {
+        if (activeEditorPane && typeof editorIndex === "number") {
             const editor = activeEditorPane.group.getEditorByIndex(editorIndex);
             if (editor) {
                 editorService.openEditor(editor);
@@ -532,24 +622,36 @@ function registerOpenEditorAtIndexCommands() {
             weight: KeybindingWeight.WorkbenchContrib,
             when: undefined,
             primary: KeyMod$1.Alt | toKeyCode(visibleIndex),
-            mac: { primary: KeyMod$1.WinCtrl | toKeyCode(visibleIndex) },
+            mac: {
+                primary: KeyMod$1.WinCtrl | toKeyCode(visibleIndex)
+            },
             handler: accessor => openEditorAtIndex(accessor, editorIndex)
         });
     }
     function toKeyCode(index) {
         switch (index) {
-            case 0: return KeyCode.Digit0;
-            case 1: return KeyCode.Digit1;
-            case 2: return KeyCode.Digit2;
-            case 3: return KeyCode.Digit3;
-            case 4: return KeyCode.Digit4;
-            case 5: return KeyCode.Digit5;
-            case 6: return KeyCode.Digit6;
-            case 7: return KeyCode.Digit7;
-            case 8: return KeyCode.Digit8;
-            case 9: return KeyCode.Digit9;
-        }
-        throw ( new Error('invalid index'));
+        case 0:
+            return KeyCode.Digit0;
+        case 1:
+            return KeyCode.Digit1;
+        case 2:
+            return KeyCode.Digit2;
+        case 3:
+            return KeyCode.Digit3;
+        case 4:
+            return KeyCode.Digit4;
+        case 5:
+            return KeyCode.Digit5;
+        case 6:
+            return KeyCode.Digit6;
+        case 7:
+            return KeyCode.Digit7;
+        case 8:
+            return KeyCode.Digit8;
+        case 9:
+            return KeyCode.Digit9;
+        }
+        throw ( new Error("invalid index"));
     }
 }
 function registerFocusEditorGroupAtIndexCommands() {
@@ -570,7 +672,9 @@ function registerFocusEditorGroupAtIndexCommands() {
                     return groups[groupIndex].focus();
                 }
                 const direction = preferredSideBySideGroupDirection(configurationService);
-                const lastGroup = editorGroupsService.findGroup({ location: GroupLocation.LAST });
+                const lastGroup = editorGroupsService.findGroup({
+                    location: GroupLocation.LAST
+                });
                 if (!lastGroup) {
                     return;
                 }
@@ -581,52 +685,88 @@ function registerFocusEditorGroupAtIndexCommands() {
     }
     function toCommandId(index) {
         switch (index) {
-            case 1: return 'workbench.action.focusSecondEditorGroup';
-            case 2: return 'workbench.action.focusThirdEditorGroup';
-            case 3: return 'workbench.action.focusFourthEditorGroup';
-            case 4: return 'workbench.action.focusFifthEditorGroup';
-            case 5: return 'workbench.action.focusSixthEditorGroup';
-            case 6: return 'workbench.action.focusSeventhEditorGroup';
-            case 7: return 'workbench.action.focusEighthEditorGroup';
-        }
-        throw ( new Error('Invalid index'));
+        case 1:
+            return "workbench.action.focusSecondEditorGroup";
+        case 2:
+            return "workbench.action.focusThirdEditorGroup";
+        case 3:
+            return "workbench.action.focusFourthEditorGroup";
+        case 4:
+            return "workbench.action.focusFifthEditorGroup";
+        case 5:
+            return "workbench.action.focusSixthEditorGroup";
+        case 6:
+            return "workbench.action.focusSeventhEditorGroup";
+        case 7:
+            return "workbench.action.focusEighthEditorGroup";
+        }
+        throw ( new Error("Invalid index"));
     }
     function toKeyCode(index) {
         switch (index) {
-            case 1: return KeyCode.Digit2;
-            case 2: return KeyCode.Digit3;
-            case 3: return KeyCode.Digit4;
-            case 4: return KeyCode.Digit5;
-            case 5: return KeyCode.Digit6;
-            case 6: return KeyCode.Digit7;
-            case 7: return KeyCode.Digit8;
-        }
-        throw ( new Error('Invalid index'));
+        case 1:
+            return KeyCode.Digit2;
+        case 2:
+            return KeyCode.Digit3;
+        case 3:
+            return KeyCode.Digit4;
+        case 4:
+            return KeyCode.Digit5;
+        case 5:
+            return KeyCode.Digit6;
+        case 6:
+            return KeyCode.Digit7;
+        case 7:
+            return KeyCode.Digit8;
+        }
+        throw ( new Error("Invalid index"));
     }
 }
 function splitEditor(editorGroupsService, direction, resolvedContext) {
     if (!resolvedContext.groupedEditors.length) {
         return;
     }
-    const { group, editors } = resolvedContext.groupedEditors[0];
+    const {
+        group,
+        editors
+    } = resolvedContext.groupedEditors[0];
     const preserveFocus = resolvedContext.preserveFocus;
     const newGroup = editorGroupsService.addGroup(group, direction);
     for (const editorToCopy of editors) {
         if (editorToCopy && !editorToCopy.hasCapability(EditorInputCapabilities.Singleton)) {
-            group.copyEditor(editorToCopy, newGroup, { preserveFocus });
+            group.copyEditor(editorToCopy, newGroup, {
+                preserveFocus
+            });
         }
     }
     newGroup.focus();
 }
 function registerSplitEditorCommands() {
-    [
-        { id: SPLIT_EDITOR_UP, direction: GroupDirection.UP },
-        { id: SPLIT_EDITOR_DOWN, direction: GroupDirection.DOWN },
-        { id: SPLIT_EDITOR_LEFT, direction: GroupDirection.LEFT },
-        { id: SPLIT_EDITOR_RIGHT, direction: GroupDirection.RIGHT }
-    ].forEach(({ id, direction }) => {
-        CommandsRegistry.registerCommand(id, function (accessor, ...args) {
-            const resolvedContext = resolveCommandsContext(args, accessor.get(IEditorService), accessor.get(IEditorGroupsService), accessor.get(IListService));
+    [{
+        id: SPLIT_EDITOR_UP,
+        direction: GroupDirection.UP
+    }, {
+        id: SPLIT_EDITOR_DOWN,
+        direction: GroupDirection.DOWN
+    }, {
+        id: SPLIT_EDITOR_LEFT,
+        direction: GroupDirection.LEFT
+    }, {
+        id: SPLIT_EDITOR_RIGHT,
+        direction: GroupDirection.RIGHT
+    }].forEach((
+        {
+            id,
+            direction
+        }
+    ) => {
+        CommandsRegistry.registerCommand(id, function(accessor, ...args) {
+            const resolvedContext = resolveCommandsContext(
+                args,
+                accessor.get(IEditorService),
+                accessor.get(IEditorGroupsService),
+                accessor.get(IListService)
+            );
             splitEditor(accessor.get(IEditorGroupsService), direction, resolvedContext);
         });
     });
@@ -638,32 +778,48 @@ function registerCloseEditorCommands() {
         let keepStickyEditors = undefined;
         if (forceCloseStickyEditors) {
             keepStickyEditors = false;
-        }
-        else if (args.length) {
+        } else if (args.length) {
             keepStickyEditors = false;
-        }
-        else {
-            keepStickyEditors = editorGroupsService.partOptions.preventPinnedEditorClose === 'keyboard' || editorGroupsService.partOptions.preventPinnedEditorClose === 'keyboardAndMouse';
+        } else {
+            keepStickyEditors = editorGroupsService.partOptions.preventPinnedEditorClose === "keyboard" || editorGroupsService.partOptions.preventPinnedEditorClose === "keyboardAndMouse";
         }
         if (keepStickyEditors) {
             const activeGroup = editorGroupsService.activeGroup;
             const activeEditor = activeGroup.activeEditor;
             if (activeEditor && activeGroup.isSticky(activeEditor)) {
-                const nextNonStickyEditorInGroup = activeGroup.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE, { excludeSticky: true })[0];
+                const nextNonStickyEditorInGroup = activeGroup.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE, {
+                    excludeSticky: true
+                })[0];
                 if (nextNonStickyEditorInGroup) {
                     return activeGroup.openEditor(nextNonStickyEditorInGroup);
                 }
-                const nextNonStickyEditorInAllGroups = editorService.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE, { excludeSticky: true })[0];
+                const nextNonStickyEditorInAllGroups = editorService.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE, {
+                    excludeSticky: true
+                })[0];
                 if (nextNonStickyEditorInAllGroups) {
-                    return Promise.resolve(editorGroupsService.getGroup(nextNonStickyEditorInAllGroups.groupId)?.openEditor(nextNonStickyEditorInAllGroups.editor));
+                    return Promise.resolve(
+                        editorGroupsService.getGroup(nextNonStickyEditorInAllGroups.groupId)?.openEditor(nextNonStickyEditorInAllGroups.editor)
+                    );
                 }
             }
         }
-        const resolvedContext = resolveCommandsContext(args, accessor.get(IEditorService), accessor.get(IEditorGroupsService), accessor.get(IListService));
+        const resolvedContext = resolveCommandsContext(
+            args,
+            accessor.get(IEditorService),
+            accessor.get(IEditorGroupsService),
+            accessor.get(IListService)
+        );
         const preserveFocus = resolvedContext.preserveFocus;
-        return Promise.all(( resolvedContext.groupedEditors.map(async ({ group, editors }) => {
+        return Promise.all(( resolvedContext.groupedEditors.map(async (
+            {
+                group,
+                editors
+            }
+        ) => {
             const editorsToClose = editors.filter(editor => !keepStickyEditors || !group.isSticky(editor));
-            await group.closeEditors(editorsToClose, { preserveFocus });
+            await group.closeEditors(editorsToClose, {
+                preserveFocus
+            });
         })));
     }
     KeybindingsRegistry.registerCommandAndKeybindingRule({
@@ -671,13 +827,16 @@ function registerCloseEditorCommands() {
         weight: KeybindingWeight.WorkbenchContrib,
         when: undefined,
         primary: KeyMod$1.CtrlCmd | KeyCode.KeyW,
-        win: { primary: KeyMod$1.CtrlCmd | KeyCode.F4, secondary: [KeyMod$1.CtrlCmd | KeyCode.KeyW] },
+        win: {
+            primary: KeyMod$1.CtrlCmd | KeyCode.F4,
+            secondary: [KeyMod$1.CtrlCmd | KeyCode.KeyW]
+        },
         handler: (accessor, ...args) => {
             return closeEditorHandler(accessor, false, ...args);
         }
     });
     CommandsRegistry.registerCommand(CLOSE_PINNED_EDITOR_COMMAND_ID, (accessor, ...args) => {
-        return closeEditorHandler(accessor, true , ...args);
+        return closeEditorHandler(accessor, true, ...args);
     });
     KeybindingsRegistry.registerCommandAndKeybindingRule({
         id: CLOSE_EDITORS_IN_GROUP_COMMAND_ID,
@@ -685,9 +844,20 @@ function registerCloseEditorCommands() {
         when: undefined,
         primary: KeyChord(KeyMod$1.CtrlCmd | KeyCode.KeyK, KeyCode.KeyW),
         handler: (accessor, ...args) => {
-            const resolvedContext = resolveCommandsContext(args, accessor.get(IEditorService), accessor.get(IEditorGroupsService), accessor.get(IListService));
-            return Promise.all(( resolvedContext.groupedEditors.map(async ({ group }) => {
-                await group.closeAllEditors({ excludeSticky: true });
+            const resolvedContext = resolveCommandsContext(
+                args,
+                accessor.get(IEditorService),
+                accessor.get(IEditorGroupsService),
+                accessor.get(IListService)
+            );
+            return Promise.all(( resolvedContext.groupedEditors.map(async (
+                {
+                    group
+                }
+            ) => {
+                await group.closeAllEditors({
+                    excludeSticky: true
+                });
             })));
         }
     });
@@ -696,10 +866,18 @@ function registerCloseEditorCommands() {
         weight: KeybindingWeight.WorkbenchContrib,
         when: ( ContextKeyExpr.and(ActiveEditorGroupEmptyContext, MultipleEditorGroupsContext)),
         primary: KeyMod$1.CtrlCmd | KeyCode.KeyW,
-        win: { primary: KeyMod$1.CtrlCmd | KeyCode.F4, secondary: [KeyMod$1.CtrlCmd | KeyCode.KeyW] },
+        win: {
+            primary: KeyMod$1.CtrlCmd | KeyCode.F4,
+            secondary: [KeyMod$1.CtrlCmd | KeyCode.KeyW]
+        },
         handler: (accessor, ...args) => {
             const editorGroupsService = accessor.get(IEditorGroupsService);
-            const commandsContext = resolveCommandsContext(args, accessor.get(IEditorService), editorGroupsService, accessor.get(IListService));
+            const commandsContext = resolveCommandsContext(
+                args,
+                accessor.get(IEditorService),
+                editorGroupsService,
+                accessor.get(IListService)
+            );
             if (commandsContext.groupedEditors.length) {
                 editorGroupsService.removeGroup(commandsContext.groupedEditors[0].group);
             }
@@ -711,9 +889,23 @@ function registerCloseEditorCommands() {
         when: undefined,
         primary: KeyChord(KeyMod$1.CtrlCmd | KeyCode.KeyK, KeyCode.KeyU),
         handler: (accessor, ...args) => {
-            const resolvedContext = resolveCommandsContext(args, accessor.get(IEditorService), accessor.get(IEditorGroupsService), accessor.get(IListService));
-            return Promise.all(( resolvedContext.groupedEditors.map(async ({ group }) => {
-                await group.closeEditors({ savedOnly: true, excludeSticky: true }, { preserveFocus: resolvedContext.preserveFocus });
+            const resolvedContext = resolveCommandsContext(
+                args,
+                accessor.get(IEditorService),
+                accessor.get(IEditorGroupsService),
+                accessor.get(IListService)
+            );
+            return Promise.all(( resolvedContext.groupedEditors.map(async (
+                {
+                    group
+                }
+            ) => {
+                await group.closeEditors({
+                    savedOnly: true,
+                    excludeSticky: true
+                }, {
+                    preserveFocus: resolvedContext.preserveFocus
+                });
             })));
         }
     });
@@ -722,17 +914,33 @@ function registerCloseEditorCommands() {
         weight: KeybindingWeight.WorkbenchContrib,
         when: undefined,
         primary: undefined,
-        mac: { primary: KeyMod$1.CtrlCmd | KeyMod$1.Alt | KeyCode.KeyT },
+        mac: {
+            primary: KeyMod$1.CtrlCmd | KeyMod$1.Alt | KeyCode.KeyT
+        },
         handler: (accessor, ...args) => {
-            const resolvedContext = resolveCommandsContext(args, accessor.get(IEditorService), accessor.get(IEditorGroupsService), accessor.get(IListService));
-            return Promise.all(( resolvedContext.groupedEditors.map(async ({ group, editors }) => {
-                const editorsToClose = group.getEditors(EditorsOrder.SEQUENTIAL, { excludeSticky: true }).filter(editor => !editors.includes(editor));
+            const resolvedContext = resolveCommandsContext(
+                args,
+                accessor.get(IEditorService),
+                accessor.get(IEditorGroupsService),
+                accessor.get(IListService)
+            );
+            return Promise.all(( resolvedContext.groupedEditors.map(async (
+                {
+                    group,
+                    editors
+                }
+            ) => {
+                const editorsToClose = group.getEditors(EditorsOrder.SEQUENTIAL, {
+                    excludeSticky: true
+                }).filter(editor => !editors.includes(editor));
                 for (const editorToKeep of editors) {
                     if (editorToKeep) {
                         group.pinEditor(editorToKeep);
                     }
                 }
-                await group.closeEditors(editorsToClose, { preserveFocus: resolvedContext.preserveFocus });
+                await group.closeEditors(editorsToClose, {
+                    preserveFocus: resolvedContext.preserveFocus
+                });
             })));
         }
     });
@@ -742,13 +950,27 @@ function registerCloseEditorCommands() {
         when: undefined,
         primary: undefined,
         handler: async (accessor, ...args) => {
-            const resolvedContext = resolveCommandsContext(args, accessor.get(IEditorService), accessor.get(IEditorGroupsService), accessor.get(IListService));
+            const resolvedContext = resolveCommandsContext(
+                args,
+                accessor.get(IEditorService),
+                accessor.get(IEditorGroupsService),
+                accessor.get(IListService)
+            );
             if (resolvedContext.groupedEditors.length) {
-                const { group, editors } = resolvedContext.groupedEditors[0];
+                const {
+                    group,
+                    editors
+                } = resolvedContext.groupedEditors[0];
                 if (group.activeEditor) {
                     group.pinEditor(group.activeEditor);
                 }
-                await group.closeEditors({ direction: CloseDirection.RIGHT, except: editors[0], excludeSticky: true }, { preserveFocus: resolvedContext.preserveFocus });
+                await group.closeEditors({
+                    direction: CloseDirection.RIGHT,
+                    except: editors[0],
+                    excludeSticky: true
+                }, {
+                    preserveFocus: resolvedContext.preserveFocus
+                });
             }
         }
     });
@@ -774,15 +996,26 @@ function registerCloseEditorCommands() {
         const editorService = accessor.get(IEditorService);
         const editorResolverService = accessor.get(IEditorResolverService);
         const telemetryService = accessor.get(ITelemetryService);
-        const resolvedContext = resolveCommandsContext(args, editorService, accessor.get(IEditorGroupsService), accessor.get(IListService));
+        const resolvedContext = resolveCommandsContext(
+            args,
+            editorService,
+            accessor.get(IEditorGroupsService),
+            accessor.get(IListService)
+        );
         const editorReplacements = ( new Map());
-        for (const { group, editors } of resolvedContext.groupedEditors) {
+        for (const {
+            group,
+            editors
+        } of resolvedContext.groupedEditors) {
             for (const editor of editors) {
                 const untypedEditor = editor.toUntyped();
                 if (!untypedEditor) {
                     return;
                 }
-                untypedEditor.options = { ...editorService.activeEditorPane?.options, override: editorOverride };
+                untypedEditor.options = {
+                    ...editorService.activeEditorPane?.options,
+                    override: editorOverride
+                };
                 const resolvedEditor = await editorResolverService.resolveEditor(untypedEditor, group);
                 if (!isEditorInputWithOptionsAndGroup(resolvedEditor)) {
                     return;
@@ -798,11 +1031,11 @@ function registerCloseEditorCommands() {
                     forceReplaceDirty: editor.resource?.scheme === Schemas.untitled,
                     options: resolvedEditor.options
                 });
-                telemetryService.publicLog2('workbenchEditorReopen', {
-                    scheme: editor.resource?.scheme ?? '',
-                    ext: editor.resource ? extname(editor.resource) : '',
-                    from: editor.editorId ?? '',
-                    to: resolvedEditor.editor.editorId ?? ''
+                telemetryService.publicLog2("workbenchEditorReopen", {
+                    scheme: editor.resource?.scheme ?? "",
+                    ext: editor.resource ? extname(editor.resource) : "",
+                    from: editor.editorId ?? "",
+                    to: resolvedEditor.editor.editorId ?? ""
                 });
             }
         }
@@ -813,9 +1046,16 @@ function registerCloseEditorCommands() {
     }
     CommandsRegistry.registerCommand(CLOSE_EDITORS_AND_GROUP_COMMAND_ID, async (accessor, ...args) => {
         const editorGroupsService = accessor.get(IEditorGroupsService);
-        const resolvedContext = resolveCommandsContext(args, accessor.get(IEditorService), editorGroupsService, accessor.get(IListService));
+        const resolvedContext = resolveCommandsContext(
+            args,
+            accessor.get(IEditorService),
+            editorGroupsService,
+            accessor.get(IListService)
+        );
         if (resolvedContext.groupedEditors.length) {
-            const { group } = resolvedContext.groupedEditors[0];
+            const {
+                group
+            } = resolvedContext.groupedEditors[0];
             await group.closeAllEditors();
             if (group.count === 0 && editorGroupsService.getGroup(group.id) ) {
                 editorGroupsService.removeGroup(group);
@@ -824,28 +1064,25 @@ function registerCloseEditorCommands() {
     });
 }
 function registerFocusEditorGroupWihoutWrapCommands() {
-    const commands = [
-        {
-            id: FOCUS_LEFT_GROUP_WITHOUT_WRAP_COMMAND_ID,
-            direction: GroupDirection.LEFT
-        },
-        {
-            id: FOCUS_RIGHT_GROUP_WITHOUT_WRAP_COMMAND_ID,
-            direction: GroupDirection.RIGHT
-        },
-        {
-            id: FOCUS_ABOVE_GROUP_WITHOUT_WRAP_COMMAND_ID,
-            direction: GroupDirection.UP,
-        },
-        {
-            id: FOCUS_BELOW_GROUP_WITHOUT_WRAP_COMMAND_ID,
-            direction: GroupDirection.DOWN
-        }
-    ];
+    const commands = [{
+        id: FOCUS_LEFT_GROUP_WITHOUT_WRAP_COMMAND_ID,
+        direction: GroupDirection.LEFT
+    }, {
+        id: FOCUS_RIGHT_GROUP_WITHOUT_WRAP_COMMAND_ID,
+        direction: GroupDirection.RIGHT
+    }, {
+        id: FOCUS_ABOVE_GROUP_WITHOUT_WRAP_COMMAND_ID,
+        direction: GroupDirection.UP
+    }, {
+        id: FOCUS_BELOW_GROUP_WITHOUT_WRAP_COMMAND_ID,
+        direction: GroupDirection.DOWN
+    }];
     for (const command of commands) {
-        CommandsRegistry.registerCommand(command.id, async (accessor) => {
+        CommandsRegistry.registerCommand(command.id, async accessor => {
             const editorGroupsService = accessor.get(IEditorGroupsService);
-            const group = editorGroupsService.findGroup({ direction: command.direction }, editorGroupsService.activeGroup, false) ?? editorGroupsService.activeGroup;
+            const group = editorGroupsService.findGroup({
+                direction: command.direction
+            }, editorGroupsService.activeGroup, false) ?? editorGroupsService.activeGroup;
             group.focus();
         });
     }
@@ -856,41 +1093,55 @@ function registerSplitEditorInGroupCommands() {
         if (!resolvedContext.groupedEditors.length) {
             return;
         }
-        const { group, editors } = resolvedContext.groupedEditors[0];
+        const {
+            group,
+            editors
+        } = resolvedContext.groupedEditors[0];
         const editor = editors[0];
         if (!editor) {
             return;
         }
         await group.replaceEditors([{
-                editor,
-                replacement: instantiationService.createInstance(SideBySideEditorInput, undefined, undefined, editor, editor),
-                forceReplaceDirty: true
-            }]);
+            editor,
+            replacement: instantiationService.createInstance(SideBySideEditorInput, undefined, undefined, editor, editor),
+            forceReplaceDirty: true
+        }]);
     }
     registerAction2(class extends Action2 {
         constructor() {
             super({
                 id: SPLIT_EDITOR_IN_GROUP,
-                title: ( localize2(3388, 'Split Editor in Group')),
+                title: ( localize2(3392, "Split Editor in Group")),
                 category: Categories.View,
                 precondition: ActiveEditorCanSplitInGroupContext,
                 f1: true,
                 keybinding: {
                     weight: KeybindingWeight.WorkbenchContrib,
                     when: ActiveEditorCanSplitInGroupContext,
-                    primary: KeyChord(KeyMod$1.CtrlCmd | KeyCode.KeyK, KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.Backslash)
+                    primary: KeyChord(
+                        KeyMod$1.CtrlCmd | KeyCode.KeyK,
+                        KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.Backslash
+                    )
                 }
             });
         }
         run(accessor, ...args) {
-            return splitEditorInGroup(accessor, resolveCommandsContext(args, accessor.get(IEditorService), accessor.get(IEditorGroupsService), accessor.get(IListService)));
+            return splitEditorInGroup(accessor, resolveCommandsContext(
+                args,
+                accessor.get(IEditorService),
+                accessor.get(IEditorGroupsService),
+                accessor.get(IListService)
+            ));
         }
     });
     async function joinEditorInGroup(resolvedContext) {
         if (!resolvedContext.groupedEditors.length) {
             return;
         }
-        const { group, editors } = resolvedContext.groupedEditors[0];
+        const {
+            group,
+            editors
+        } = resolvedContext.groupedEditors[0];
         const editor = editors[0];
         if (!editor) {
             return;
@@ -901,58 +1152,77 @@ function registerSplitEditorInGroupCommands() {
         let options = undefined;
         const activeEditorPane = group.activeEditorPane;
         if (activeEditorPane instanceof SideBySideEditor && group.activeEditor === editor) {
-            for (const pane of [activeEditorPane.getPrimaryEditorPane(), activeEditorPane.getSecondaryEditorPane()]) {
+            for (const pane of [
+                activeEditorPane.getPrimaryEditorPane(),
+                activeEditorPane.getSecondaryEditorPane()
+            ]) {
                 if (pane?.hasFocus()) {
-                    options = { viewState: pane.getViewState() };
+                    options = {
+                        viewState: pane.getViewState()
+                    };
                     break;
                 }
             }
         }
         await group.replaceEditors([{
-                editor,
-                replacement: editor.primary,
-                options
-            }]);
+            editor,
+            replacement: editor.primary,
+            options
+        }]);
     }
     registerAction2(class extends Action2 {
         constructor() {
             super({
                 id: JOIN_EDITOR_IN_GROUP,
-                title: ( localize2(3389, 'Join Editor in Group')),
+                title: ( localize2(3393, "Join Editor in Group")),
                 category: Categories.View,
                 precondition: SideBySideEditorActiveContext,
                 f1: true,
                 keybinding: {
                     weight: KeybindingWeight.WorkbenchContrib,
                     when: SideBySideEditorActiveContext,
-                    primary: KeyChord(KeyMod$1.CtrlCmd | KeyCode.KeyK, KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.Backslash)
+                    primary: KeyChord(
+                        KeyMod$1.CtrlCmd | KeyCode.KeyK,
+                        KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.Backslash
+                    )
                 }
             });
         }
         run(accessor, ...args) {
-            return joinEditorInGroup(resolveCommandsContext(args, accessor.get(IEditorService), accessor.get(IEditorGroupsService), accessor.get(IListService)));
+            return joinEditorInGroup(resolveCommandsContext(
+                args,
+                accessor.get(IEditorService),
+                accessor.get(IEditorGroupsService),
+                accessor.get(IListService)
+            ));
         }
     });
     registerAction2(class extends Action2 {
         constructor() {
             super({
                 id: TOGGLE_SPLIT_EDITOR_IN_GROUP,
-                title: ( localize2(3390, 'Toggle Split Editor in Group')),
+                title: ( localize2(3394, "Toggle Split Editor in Group")),
                 category: Categories.View,
                 precondition: ( ContextKeyExpr.or(ActiveEditorCanSplitInGroupContext, SideBySideEditorActiveContext)),
                 f1: true
             });
         }
         async run(accessor, ...args) {
-            const resolvedContext = resolveCommandsContext(args, accessor.get(IEditorService), accessor.get(IEditorGroupsService), accessor.get(IListService));
+            const resolvedContext = resolveCommandsContext(
+                args,
+                accessor.get(IEditorService),
+                accessor.get(IEditorGroupsService),
+                accessor.get(IListService)
+            );
             if (!resolvedContext.groupedEditors.length) {
                 return;
             }
-            const { editors } = resolvedContext.groupedEditors[0];
+            const {
+                editors
+            } = resolvedContext.groupedEditors[0];
             if (editors[0] instanceof SideBySideEditorInput) {
                 await joinEditorInGroup(resolvedContext);
-            }
-            else if (editors[0]) {
+            } else if (editors[0]) {
                 await splitEditorInGroup(accessor, resolvedContext);
             }
         }
@@ -961,7 +1231,7 @@ function registerSplitEditorInGroupCommands() {
         constructor() {
             super({
                 id: TOGGLE_SPLIT_EDITOR_IN_GROUP_LAYOUT,
-                title: ( localize2(3391, 'Toggle Layout of Split Editor in Group')),
+                title: ( localize2(3395, "Toggle Layout of Split Editor in Group")),
                 category: Categories.View,
                 precondition: SideBySideEditorActiveContext,
                 f1: true
@@ -971,11 +1241,10 @@ function registerSplitEditorInGroupCommands() {
             const configurationService = accessor.get(IConfigurationService);
             const currentSetting = configurationService.getValue(SideBySideEditor.SIDE_BY_SIDE_LAYOUT_SETTING);
             let newSetting;
-            if (currentSetting !== 'horizontal') {
-                newSetting = 'horizontal';
-            }
-            else {
-                newSetting = 'vertical';
+            if (currentSetting !== "horizontal") {
+                newSetting = "horizontal";
+            } else {
+                newSetting = "vertical";
             }
             return configurationService.updateValue(SideBySideEditor.SIDE_BY_SIDE_LAYOUT_SETTING, newSetting);
         }
@@ -986,7 +1255,7 @@ function registerFocusSideEditorsCommands() {
         constructor() {
             super({
                 id: FOCUS_FIRST_SIDE_EDITOR,
-                title: ( localize2(3392, 'Focus First Side in Active Editor')),
+                title: ( localize2(3396, "Focus First Side in Active Editor")),
                 category: Categories.View,
                 precondition: ( ContextKeyExpr.or(SideBySideEditorActiveContext, TextCompareEditorActiveContext)),
                 f1: true
@@ -998,8 +1267,7 @@ function registerFocusSideEditorsCommands() {
             const activeEditorPane = editorService.activeEditorPane;
             if (activeEditorPane instanceof SideBySideEditor) {
                 activeEditorPane.getSecondaryEditorPane()?.focus();
-            }
-            else if (activeEditorPane instanceof TextDiffEditor) {
+            } else if (activeEditorPane instanceof TextDiffEditor) {
                 await commandService.executeCommand(DIFF_FOCUS_SECONDARY_SIDE);
             }
         }
@@ -1008,7 +1276,7 @@ function registerFocusSideEditorsCommands() {
         constructor() {
             super({
                 id: FOCUS_SECOND_SIDE_EDITOR,
-                title: ( localize2(3393, 'Focus Second Side in Active Editor')),
+                title: ( localize2(3397, "Focus Second Side in Active Editor")),
                 category: Categories.View,
                 precondition: ( ContextKeyExpr.or(SideBySideEditorActiveContext, TextCompareEditorActiveContext)),
                 f1: true
@@ -1020,8 +1288,7 @@ function registerFocusSideEditorsCommands() {
             const activeEditorPane = editorService.activeEditorPane;
             if (activeEditorPane instanceof SideBySideEditor) {
                 activeEditorPane.getPrimaryEditorPane()?.focus();
-            }
-            else if (activeEditorPane instanceof TextDiffEditor) {
+            } else if (activeEditorPane instanceof TextDiffEditor) {
                 await commandService.executeCommand(DIFF_FOCUS_PRIMARY_SIDE);
             }
         }
@@ -1030,7 +1297,7 @@ function registerFocusSideEditorsCommands() {
         constructor() {
             super({
                 id: FOCUS_OTHER_SIDE_EDITOR,
-                title: ( localize2(3394, 'Focus Other Side in Active Editor')),
+                title: ( localize2(3398, "Focus Other Side in Active Editor")),
                 category: Categories.View,
                 precondition: ( ContextKeyExpr.or(SideBySideEditorActiveContext, TextCompareEditorActiveContext)),
                 f1: true
@@ -1043,12 +1310,10 @@ function registerFocusSideEditorsCommands() {
             if (activeEditorPane instanceof SideBySideEditor) {
                 if (activeEditorPane.getPrimaryEditorPane()?.hasFocus()) {
                     activeEditorPane.getSecondaryEditorPane()?.focus();
-                }
-                else {
+                } else {
                     activeEditorPane.getPrimaryEditorPane()?.focus();
                 }
-            }
-            else if (activeEditorPane instanceof TextDiffEditor) {
+            } else if (activeEditorPane instanceof TextDiffEditor) {
                 await commandService.executeCommand(DIFF_FOCUS_OTHER_SIDE);
             }
         }
@@ -1061,8 +1326,16 @@ function registerOtherEditorCommands() {
         when: undefined,
         primary: KeyChord(KeyMod$1.CtrlCmd | KeyCode.KeyK, KeyCode.Enter),
         handler: async (accessor, ...args) => {
-            const resolvedContext = resolveCommandsContext(args, accessor.get(IEditorService), accessor.get(IEditorGroupsService), accessor.get(IListService));
-            for (const { group, editors } of resolvedContext.groupedEditors) {
+            const resolvedContext = resolveCommandsContext(
+                args,
+                accessor.get(IEditorService),
+                accessor.get(IEditorGroupsService),
+                accessor.get(IListService)
+            );
+            for (const {
+                group,
+                editors
+            } of resolvedContext.groupedEditors) {
                 for (const editor of editors) {
                     group.pinEditor(editor);
                 }
@@ -1073,13 +1346,18 @@ function registerOtherEditorCommands() {
         id: TOGGLE_KEEP_EDITORS_COMMAND_ID,
         handler: accessor => {
             const configurationService = accessor.get(IConfigurationService);
-            const currentSetting = configurationService.getValue('workbench.editor.enablePreview');
+            const currentSetting = configurationService.getValue("workbench.editor.enablePreview");
             const newSetting = currentSetting !== true;
-            configurationService.updateValue('workbench.editor.enablePreview', newSetting);
+            configurationService.updateValue("workbench.editor.enablePreview", newSetting);
         }
     });
     function setEditorGroupLock(accessor, locked, ...args) {
-        const resolvedContext = resolveCommandsContext(args, accessor.get(IEditorService), accessor.get(IEditorGroupsService), accessor.get(IListService));
+        const resolvedContext = resolveCommandsContext(
+            args,
+            accessor.get(IEditorService),
+            accessor.get(IEditorGroupsService),
+            accessor.get(IListService)
+        );
         const group = resolvedContext.groupedEditors[0]?.group;
         group?.lock(locked ?? !group.isLocked);
     }
@@ -1087,7 +1365,7 @@ function registerOtherEditorCommands() {
         constructor() {
             super({
                 id: TOGGLE_LOCK_GROUP_COMMAND_ID,
-                title: ( localize2(3395, 'Toggle Editor Group Lock')),
+                title: ( localize2(3399, "Toggle Editor Group Lock")),
                 category: Categories.View,
                 f1: true
             });
@@ -1100,7 +1378,7 @@ function registerOtherEditorCommands() {
         constructor() {
             super({
                 id: LOCK_GROUP_COMMAND_ID,
-                title: ( localize2(3396, 'Lock Editor Group')),
+                title: ( localize2(3400, "Lock Editor Group")),
                 category: Categories.View,
                 precondition: ( ActiveEditorGroupLockedContext.toNegated()),
                 f1: true
@@ -1114,7 +1392,7 @@ function registerOtherEditorCommands() {
         constructor() {
             super({
                 id: UNLOCK_GROUP_COMMAND_ID,
-                title: ( localize2(3397, 'Unlock Editor Group')),
+                title: ( localize2(3401, "Unlock Editor Group")),
                 precondition: ActiveEditorGroupLockedContext,
                 category: Categories.View,
                 f1: true
@@ -1130,8 +1408,16 @@ function registerOtherEditorCommands() {
         when: ( ActiveEditorStickyContext.toNegated()),
         primary: KeyChord(KeyMod$1.CtrlCmd | KeyCode.KeyK, KeyMod$1.Shift | KeyCode.Enter),
         handler: async (accessor, ...args) => {
-            const resolvedContext = resolveCommandsContext(args, accessor.get(IEditorService), accessor.get(IEditorGroupsService), accessor.get(IListService));
-            for (const { group, editors } of resolvedContext.groupedEditors) {
+            const resolvedContext = resolveCommandsContext(
+                args,
+                accessor.get(IEditorService),
+                accessor.get(IEditorGroupsService),
+                accessor.get(IListService)
+            );
+            for (const {
+                group,
+                editors
+            } of resolvedContext.groupedEditors) {
                 for (const editor of editors) {
                     group.stickEditor(editor);
                 }
@@ -1144,8 +1430,16 @@ function registerOtherEditorCommands() {
         when: ActiveEditorStickyContext,
         primary: KeyChord(KeyMod$1.CtrlCmd | KeyCode.KeyK, KeyMod$1.Shift | KeyCode.Enter),
         handler: async (accessor, ...args) => {
-            const resolvedContext = resolveCommandsContext(args, accessor.get(IEditorService), accessor.get(IEditorGroupsService), accessor.get(IListService));
-            for (const { group, editors } of resolvedContext.groupedEditors) {
+            const resolvedContext = resolveCommandsContext(
+                args,
+                accessor.get(IEditorService),
+                accessor.get(IEditorGroupsService),
+                accessor.get(IListService)
+            );
+            for (const {
+                group,
+                editors
+            } of resolvedContext.groupedEditors) {
                 for (const editor of editors) {
                     group.unstickEditor(editor);
                 }
@@ -1160,7 +1454,12 @@ function registerOtherEditorCommands() {
         handler: (accessor, ...args) => {
             const editorGroupsService = accessor.get(IEditorGroupsService);
             const quickInputService = accessor.get(IQuickInputService);
-            const commandsContext = resolveCommandsContext(args, accessor.get(IEditorService), editorGroupsService, accessor.get(IListService));
+            const commandsContext = resolveCommandsContext(
+                args,
+                accessor.get(IEditorService),
+                editorGroupsService,
+                accessor.get(IListService)
+            );
             const group = commandsContext.groupedEditors[0]?.group;
             if (group) {
                 editorGroupsService.activateGroup(group);