@codingame/monaco-vscode-api 7.1.0 → 8.0.0

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

@@ -1,14 +1,11 @@
-import { getActiveElement } from '../../../../base/browser/dom.js';
-import { List } from '../../../../base/browser/ui/list/listWidget.js';
-import { distinct, coalesce } from '../../../../base/common/arrays.js';
 import { KeyMod as KeyMod$1, KeyCode, KeyChord } from '../../../../base/common/keyCodes.js';
 import { matchesScheme, Schemas } from '../../../../base/common/network.js';
-import { extname, isEqual } from '../../../../base/common/resources.js';
+import { extname } from '../../../../base/common/resources.js';
 import { isObject, isString, isUndefined, isNumber } from '../../../../base/common/types.js';
 import { URI } from '../../../../base/common/uri.js';
 import { isDiffEditor } from '../../../../editor/browser/editorBrowser.js';
 import { EditorContextKeys } from '../../../../editor/common/editorContextKeys.js';
-import { localizeWithPath, localize2WithPath } from '../../../../nls.js';
+import { localize, localize2 } from '../../../../nls.js';
 import { Categories } from '../../../../platform/action/common/actionCommonCategories.js';
 import { registerAction2, Action2 } from '../../../../platform/actions/common/actions.js';
 import { CommandsRegistry } from '../../../../platform/commands/common/commands.js';
@@ -26,11 +23,11 @@ import { ActiveGroupEditorsByMostRecentlyUsedQuickAccess } from './editorQuickAc
 import { SideBySideEditor } from './sideBySideEditor.js';
 import { TextDiffEditor } from './textDiffEditor.js';
 import { ActiveEditorGroupEmptyContext, MultipleEditorGroupsContext, ActiveEditorCanSplitInGroupContext, SideBySideEditorActiveContext, TextCompareEditorActiveContext, ActiveEditorGroupLockedContext, ActiveEditorStickyContext } from '../../../common/contextkeys.js';
-import { EditorInputCapabilities, EditorsOrder, CloseDirection, isEditorInputWithOptionsAndGroup, isEditorCommandsContext, isEditorIdentifier } from '../../../common/editor.js';
+import { EditorInputCapabilities, EditorsOrder, CloseDirection, isEditorInputWithOptionsAndGroup } from '../../../common/editor.js';
 import { DiffEditorInput } from '../../../common/editor/diffEditorInput.js';
 import { SideBySideEditorInput } from '../../../common/editor/sideBySideEditorInput.js';
 import { columnToEditorGroup } from '../../../services/editor/common/editorGroupColumn.js';
-import { GroupsOrder, GroupLocation, preferredSideBySideGroupDirection, GroupDirection, isEditorGroup } from '../../../services/editor/common/editorGroupsService.js';
+import { GroupsOrder, GroupLocation, preferredSideBySideGroupDirection, GroupDirection } from '../../../services/editor/common/editorGroupsService.js';
 import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.service.js';
 import { IEditorResolverService } from '../../../services/editor/common/editorResolverService.service.js';
 import { SIDE_GROUP } from '../../../services/editor/common/editorService.js';
@@ -38,7 +35,7 @@ import { IEditorService } from '../../../services/editor/common/editorService.se
 import { IPathService } from '../../../services/path/common/pathService.service.js';
 import { IUntitledTextEditorService } from '../../../services/untitled/common/untitledTextEditorService.service.js';
 import { registerDiffEditorCommands, DIFF_FOCUS_SECONDARY_SIDE, DIFF_FOCUS_PRIMARY_SIDE, DIFF_FOCUS_OTHER_SIDE, DIFF_OPEN_SIDE } from './diffEditorCommands.js';
-const _moduleId = "vs/workbench/browser/parts/editor/editorCommands";
+import { resolveCommandsContext } from './editorCommandsContext.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';
@@ -132,13 +129,12 @@ function registerActiveEditorMoveCopyCommand() {
         primary: 0,
         handler: (accessor, args) => moveCopyActiveEditor(true, args, accessor),
         metadata: {
-            description: ( localizeWithPath(_moduleId, 0, "Move the active editor by tabs or groups")),
+            description: ( localize(5499, "Move the active editor by tabs or groups")),
             args: [
                 {
-                    name: ( localizeWithPath(_moduleId, 1, "Active editor move argument")),
-                    description: ( localizeWithPath(
-                        _moduleId,
-                        2,
+                    name: ( localize(5500, "Active editor move argument")),
+                    description: ( localize(
+                        5501,
                         "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: isActiveEditorMoveCopyArg,
@@ -154,13 +150,12 @@ function registerActiveEditorMoveCopyCommand() {
         primary: 0,
         handler: (accessor, args) => moveCopyActiveEditor(false, args, accessor),
         metadata: {
-            description: ( localizeWithPath(_moduleId, 3, "Copy the active editor by groups")),
+            description: ( localize(5502, "Copy the active editor by groups")),
             args: [
                 {
-                    name: ( localizeWithPath(_moduleId, 4, "Active editor copy argument")),
-                    description: ( localizeWithPath(
-                        _moduleId,
-                        5,
+                    name: ( localize(5503, "Active editor copy argument")),
+                    description: ( localize(
+                        5504,
                         "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: isActiveEditorMoveCopyArg,
@@ -213,55 +208,55 @@ function registerActiveEditorMoveCopyCommand() {
         group.moveEditor(control.input, group, { index });
     }
     function moveCopyActiveEditorToGroup(isMove, args, control, accessor) {
-        const editorGroupService = accessor.get(IEditorGroupsService);
+        const editorGroupsService = accessor.get(IEditorGroupsService);
         const configurationService = accessor.get(IConfigurationService);
         const sourceGroup = control.group;
         let targetGroup;
         switch (args.to) {
             case 'left':
-                targetGroup = editorGroupService.findGroup({ direction: GroupDirection.LEFT }, sourceGroup);
+                targetGroup = editorGroupsService.findGroup({ direction: GroupDirection.LEFT }, sourceGroup);
                 if (!targetGroup) {
-                    targetGroup = editorGroupService.addGroup(sourceGroup, GroupDirection.LEFT);
+                    targetGroup = editorGroupsService.addGroup(sourceGroup, GroupDirection.LEFT);
                 }
                 break;
             case 'right':
-                targetGroup = editorGroupService.findGroup({ direction: GroupDirection.RIGHT }, sourceGroup);
+                targetGroup = editorGroupsService.findGroup({ direction: GroupDirection.RIGHT }, sourceGroup);
                 if (!targetGroup) {
-                    targetGroup = editorGroupService.addGroup(sourceGroup, GroupDirection.RIGHT);
+                    targetGroup = editorGroupsService.addGroup(sourceGroup, GroupDirection.RIGHT);
                 }
                 break;
             case 'up':
-                targetGroup = editorGroupService.findGroup({ direction: GroupDirection.UP }, sourceGroup);
+                targetGroup = editorGroupsService.findGroup({ direction: GroupDirection.UP }, sourceGroup);
                 if (!targetGroup) {
-                    targetGroup = editorGroupService.addGroup(sourceGroup, GroupDirection.UP);
+                    targetGroup = editorGroupsService.addGroup(sourceGroup, GroupDirection.UP);
                 }
                 break;
             case 'down':
-                targetGroup = editorGroupService.findGroup({ direction: GroupDirection.DOWN }, sourceGroup);
+                targetGroup = editorGroupsService.findGroup({ direction: GroupDirection.DOWN }, sourceGroup);
                 if (!targetGroup) {
-                    targetGroup = editorGroupService.addGroup(sourceGroup, GroupDirection.DOWN);
+                    targetGroup = editorGroupsService.addGroup(sourceGroup, GroupDirection.DOWN);
                 }
                 break;
             case 'first':
-                targetGroup = editorGroupService.findGroup({ location: GroupLocation.FIRST }, sourceGroup);
+                targetGroup = editorGroupsService.findGroup({ location: GroupLocation.FIRST }, sourceGroup);
                 break;
             case 'last':
-                targetGroup = editorGroupService.findGroup({ location: GroupLocation.LAST }, sourceGroup);
+                targetGroup = editorGroupsService.findGroup({ location: GroupLocation.LAST }, sourceGroup);
                 break;
             case 'previous':
-                targetGroup = editorGroupService.findGroup({ location: GroupLocation.PREVIOUS }, sourceGroup);
+                targetGroup = editorGroupsService.findGroup({ location: GroupLocation.PREVIOUS }, sourceGroup);
                 break;
             case 'next':
-                targetGroup = editorGroupService.findGroup({ location: GroupLocation.NEXT }, sourceGroup);
+                targetGroup = editorGroupsService.findGroup({ location: GroupLocation.NEXT }, sourceGroup);
                 if (!targetGroup) {
-                    targetGroup = editorGroupService.addGroup(sourceGroup, preferredSideBySideGroupDirection(configurationService));
+                    targetGroup = editorGroupsService.addGroup(sourceGroup, preferredSideBySideGroupDirection(configurationService));
                 }
                 break;
             case 'center':
-                targetGroup = editorGroupService.getGroups(GroupsOrder.GRID_APPEARANCE)[(editorGroupService.count / 2) - 1];
+                targetGroup = editorGroupsService.getGroups(GroupsOrder.GRID_APPEARANCE)[(editorGroupsService.count / 2) - 1];
                 break;
             case 'position':
-                targetGroup = editorGroupService.getGroups(GroupsOrder.GRID_APPEARANCE)[(args.value ?? 1) - 1];
+                targetGroup = editorGroupsService.getGroups(GroupsOrder.GRID_APPEARANCE)[(args.value ?? 1) - 1];
                 break;
         }
         if (targetGroup) {
@@ -280,8 +275,8 @@ function registerEditorGroupsLayoutCommands() {
         if (!layout || typeof layout !== 'object') {
             return;
         }
-        const editorGroupService = accessor.get(IEditorGroupsService);
-        editorGroupService.applyLayout(layout);
+        const editorGroupsService = accessor.get(IEditorGroupsService);
+        editorGroupsService.applyLayout(layout);
     }
     CommandsRegistry.registerCommand(LAYOUT_EDITOR_GROUPS_COMMAND_ID, (accessor, args) => {
         applyEditorLayout(accessor, args);
@@ -314,8 +309,8 @@ function registerEditorGroupsLayoutCommands() {
     CommandsRegistry.registerCommand({
         id: 'vscode.getEditorLayout',
         handler: (accessor) => {
-            const editorGroupService = accessor.get(IEditorGroupsService);
-            return editorGroupService.getLayout();
+            const editorGroupsService = accessor.get(IEditorGroupsService);
+            return editorGroupsService.getLayout();
         },
         metadata: {
             description: 'Get Editor Layout',
@@ -346,7 +341,7 @@ function registerOpenEditorAPICommands() {
     });
     CommandsRegistry.registerCommand(API_OPEN_EDITOR_COMMAND_ID, async function (accessor, resourceArg, columnAndOptions, label, context) {
         const editorService = accessor.get(IEditorService);
-        const editorGroupService = accessor.get(IEditorGroupsService);
+        const editorGroupsService = accessor.get(IEditorGroupsService);
         const openerService = accessor.get(IOpenerService);
         const pathService = accessor.get(IPathService);
         const configurationService = accessor.get(IConfigurationService);
@@ -363,7 +358,7 @@ function registerOpenEditorAPICommands() {
             else {
                 input = { resource, options, label };
             }
-            await editorService.openEditor(input, columnToEditorGroup(editorGroupService, configurationService, column));
+            await editorService.openEditor(input, columnToEditorGroup(editorGroupsService, configurationService, column));
         }
         else if (matchesScheme(resourceOrString, Schemas.command)) {
             return;
@@ -388,7 +383,7 @@ function registerOpenEditorAPICommands() {
     });
     CommandsRegistry.registerCommand(API_OPEN_DIFF_EDITOR_COMMAND_ID, async function (accessor, originalResource, modifiedResource, labelAndOrDescription, columnAndOptions, context) {
         const editorService = accessor.get(IEditorService);
-        const editorGroupService = accessor.get(IEditorGroupsService);
+        const editorGroupsService = accessor.get(IEditorGroupsService);
         const configurationService = accessor.get(IConfigurationService);
         const [columnArg, optionsArg] = columnAndOptions ?? [];
         const [options, column] = mixinContext(context, optionsArg, columnArg);
@@ -407,7 +402,7 @@ function registerOpenEditorAPICommands() {
             label,
             description,
             options
-        }, columnToEditorGroup(editorGroupService, configurationService, column));
+        }, columnToEditorGroup(editorGroupsService, configurationService, column));
     });
     CommandsRegistry.registerCommand(API_OPEN_WITH_EDITOR_COMMAND_ID, async (accessor, resource, id, columnAndOptions) => {
         const editorService = accessor.get(IEditorService);
@@ -501,21 +496,21 @@ function registerFocusEditorGroupAtIndexCommands() {
             when: undefined,
             primary: KeyMod$1.CtrlCmd | toKeyCode(groupIndex),
             handler: accessor => {
-                const editorGroupService = accessor.get(IEditorGroupsService);
+                const editorGroupsService = accessor.get(IEditorGroupsService);
                 const configurationService = accessor.get(IConfigurationService);
-                if (groupIndex > editorGroupService.count) {
+                if (groupIndex > editorGroupsService.count) {
                     return;
                 }
-                const groups = editorGroupService.getGroups(GroupsOrder.GRID_APPEARANCE);
+                const groups = editorGroupsService.getGroups(GroupsOrder.GRID_APPEARANCE);
                 if (groups[groupIndex]) {
                     return groups[groupIndex].focus();
                 }
                 const direction = preferredSideBySideGroupDirection(configurationService);
-                const lastGroup = editorGroupService.findGroup({ location: GroupLocation.LAST });
+                const lastGroup = editorGroupsService.findGroup({ location: GroupLocation.LAST });
                 if (!lastGroup) {
                     return;
                 }
-                const newGroup = editorGroupService.addGroup(lastGroup, direction);
+                const newGroup = editorGroupsService.addGroup(lastGroup, direction);
                 newGroup.focus();
             }
         });
@@ -545,41 +540,19 @@ function registerFocusEditorGroupAtIndexCommands() {
         throw ( (new Error('Invalid index')));
     }
 }
-function splitEditor(editorGroupService, direction, contexts) {
-    let newGroup;
-    let sourceGroup;
-    for (const context of contexts ?? [undefined]) {
-        let currentGroup;
-        if (context) {
-            currentGroup = editorGroupService.getGroup(context.groupId);
-        }
-        else {
-            currentGroup = editorGroupService.activeGroup;
-        }
-        if (!currentGroup) {
-            continue;
-        }
-        if (!sourceGroup) {
-            sourceGroup = currentGroup;
-        }
-        else if (sourceGroup.id !== currentGroup.id) {
-            continue;
-        }
-        if (!newGroup) {
-            newGroup = editorGroupService.addGroup(currentGroup, direction);
-        }
-        let editorToCopy;
-        if (context && typeof context.editorIndex === 'number') {
-            editorToCopy = currentGroup.getEditorByIndex(context.editorIndex);
-        }
-        else {
-            editorToCopy = currentGroup.activeEditor ?? undefined;
-        }
+function splitEditor(editorGroupsService, direction, resolvedContext) {
+    if (!resolvedContext.groupedEditors.length) {
+        return;
+    }
+    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)) {
-            currentGroup.copyEditor(editorToCopy, newGroup, { preserveFocus: context?.preserveFocus });
+            group.copyEditor(editorToCopy, newGroup, { preserveFocus });
         }
     }
-    newGroup?.focus();
+    newGroup.focus();
 }
 function registerSplitEditorCommands() {
     [
@@ -588,21 +561,21 @@ function registerSplitEditorCommands() {
         { id: SPLIT_EDITOR_LEFT, direction: GroupDirection.LEFT },
         { id: SPLIT_EDITOR_RIGHT, direction: GroupDirection.RIGHT }
     ].forEach(({ id, direction }) => {
-        CommandsRegistry.registerCommand(id, function (accessor, resourceOrContext, context) {
-            const { editors } = getEditorsContext(accessor, resourceOrContext, context);
-            splitEditor(accessor.get(IEditorGroupsService), direction, editors);
+        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);
         });
     });
 }
 function registerCloseEditorCommands() {
-    function closeEditorHandler(accessor, forceCloseStickyEditors, resourceOrContext, context) {
+    function closeEditorHandler(accessor, forceCloseStickyEditors, ...args) {
         const editorGroupsService = accessor.get(IEditorGroupsService);
         const editorService = accessor.get(IEditorService);
         let keepStickyEditors = undefined;
         if (forceCloseStickyEditors) {
             keepStickyEditors = false;
         }
-        else if (resourceOrContext || context) {
+        else if (args.length) {
             keepStickyEditors = false;
         }
         else {
@@ -622,17 +595,11 @@ function registerCloseEditorCommands() {
                 }
             }
         }
-        const { editors, groups } = getEditorsContext(accessor, resourceOrContext, context);
-        return Promise.all(( (groups.map(async (group) => {
-            if (group) {
-                const editorsToClose = coalesce(( (editors
-                    .filter(editor => editor.groupId === group.id)
-                    .map(
-                    editor => typeof editor.editorIndex === 'number' ? group.getEditorByIndex(editor.editorIndex) : group.activeEditor
-                ))))
-                    .filter(editor => !keepStickyEditors || !group.isSticky(editor));
-                await group.closeEditors(editorsToClose, { preserveFocus: context?.preserveFocus });
-            }
+        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 }) => {
+            const editorsToClose = editors.filter(editor => !keepStickyEditors || !group.isSticky(editor));
+            await group.closeEditors(editorsToClose, { preserveFocus });
         }))));
     }
     KeybindingsRegistry.registerCommandAndKeybindingRule({
@@ -641,24 +608,22 @@ function registerCloseEditorCommands() {
         when: undefined,
         primary: KeyMod$1.CtrlCmd | KeyCode.KeyW,
         win: { primary: KeyMod$1.CtrlCmd | KeyCode.F4, secondary: [KeyMod$1.CtrlCmd | KeyCode.KeyW] },
-        handler: (accessor, resourceOrContext, context) => {
-            return closeEditorHandler(accessor, false, resourceOrContext, context);
+        handler: (accessor, ...args) => {
+            return closeEditorHandler(accessor, false, ...args);
         }
     });
-    CommandsRegistry.registerCommand(CLOSE_PINNED_EDITOR_COMMAND_ID, (accessor, resourceOrContext, context) => {
-        return closeEditorHandler(accessor, true , resourceOrContext, context);
+    CommandsRegistry.registerCommand(CLOSE_PINNED_EDITOR_COMMAND_ID, (accessor, ...args) => {
+        return closeEditorHandler(accessor, true , ...args);
     });
     KeybindingsRegistry.registerCommandAndKeybindingRule({
         id: CLOSE_EDITORS_IN_GROUP_COMMAND_ID,
         weight: KeybindingWeight.WorkbenchContrib,
         when: undefined,
         primary: KeyChord(KeyMod$1.CtrlCmd | KeyCode.KeyK, KeyCode.KeyW),
-        handler: (accessor, resourceOrContext, context) => {
-            return Promise.all(( (getEditorsContext(accessor, resourceOrContext, context).groups.map(async (group) => {
-                if (group) {
-                    await group.closeAllEditors({ excludeSticky: true });
-                    return;
-                }
+        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 });
             }))));
         }
     });
@@ -668,18 +633,11 @@ function registerCloseEditorCommands() {
         when: ( (ContextKeyExpr.and(ActiveEditorGroupEmptyContext, MultipleEditorGroupsContext))),
         primary: KeyMod$1.CtrlCmd | KeyCode.KeyW,
         win: { primary: KeyMod$1.CtrlCmd | KeyCode.F4, secondary: [KeyMod$1.CtrlCmd | KeyCode.KeyW] },
-        handler: (accessor, resourceOrContext, context) => {
-            const editorGroupService = accessor.get(IEditorGroupsService);
-            const commandsContext = getCommandsContext(accessor, resourceOrContext, context);
-            let group;
-            if (commandsContext && typeof commandsContext.groupId === 'number') {
-                group = editorGroupService.getGroup(commandsContext.groupId);
-            }
-            else {
-                group = editorGroupService.activeGroup;
-            }
-            if (group) {
-                editorGroupService.removeGroup(group);
+        handler: (accessor, ...args) => {
+            const editorGroupsService = accessor.get(IEditorGroupsService);
+            const commandsContext = resolveCommandsContext(args, accessor.get(IEditorService), editorGroupsService, accessor.get(IListService));
+            if (commandsContext.groupedEditors.length) {
+                editorGroupsService.removeGroup(commandsContext.groupedEditors[0].group);
             }
         }
     });
@@ -688,11 +646,10 @@ function registerCloseEditorCommands() {
         weight: KeybindingWeight.WorkbenchContrib,
         when: undefined,
         primary: KeyChord(KeyMod$1.CtrlCmd | KeyCode.KeyK, KeyCode.KeyU),
-        handler: (accessor, resourceOrContext, context) => {
-            return Promise.all(( (getEditorsContext(accessor, resourceOrContext, context).groups.map(async (group) => {
-                if (group) {
-                    await group.closeEditors({ savedOnly: true, excludeSticky: true }, { preserveFocus: context?.preserveFocus });
-                }
+        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 });
             }))));
         }
     });
@@ -702,23 +659,16 @@ function registerCloseEditorCommands() {
         when: undefined,
         primary: undefined,
         mac: { primary: KeyMod$1.CtrlCmd | KeyMod$1.Alt | KeyCode.KeyT },
-        handler: (accessor, resourceOrContext, context) => {
-            const { editors, groups } = getEditorsContext(accessor, resourceOrContext, context);
-            return Promise.all(( (groups.map(async (group) => {
-                if (group) {
-                    const editorsToKeep = ( (editors
-                        .filter(editor => editor.groupId === group.id)
-                        .map(
-                        editor => typeof editor.editorIndex === 'number' ? group.getEditorByIndex(editor.editorIndex) : group.activeEditor
-                    )));
-                    const editorsToClose = group.getEditors(EditorsOrder.SEQUENTIAL, { excludeSticky: true }).filter(editor => !editorsToKeep.includes(editor));
-                    for (const editorToKeep of editorsToKeep) {
-                        if (editorToKeep) {
-                            group.pinEditor(editorToKeep);
-                        }
+        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));
+                for (const editorToKeep of editors) {
+                    if (editorToKeep) {
+                        group.pinEditor(editorToKeep);
                     }
-                    await group.closeEditors(editorsToClose, { preserveFocus: context?.preserveFocus });
                 }
+                await group.closeEditors(editorsToClose, { preserveFocus: resolvedContext.preserveFocus });
             }))));
         }
     });
@@ -727,14 +677,14 @@ function registerCloseEditorCommands() {
         weight: KeybindingWeight.WorkbenchContrib,
         when: undefined,
         primary: undefined,
-        handler: async (accessor, resourceOrContext, context) => {
-            const editorGroupService = accessor.get(IEditorGroupsService);
-            const { group, editor } = resolveCommandsContext(editorGroupService, getCommandsContext(accessor, resourceOrContext, context));
-            if (group && editor) {
+        handler: async (accessor, ...args) => {
+            const resolvedContext = resolveCommandsContext(args, accessor.get(IEditorService), accessor.get(IEditorGroupsService), accessor.get(IListService));
+            if (resolvedContext.groupedEditors.length) {
+                const { group, editors } = resolvedContext.groupedEditors[0];
                 if (group.activeEditor) {
                     group.pinEditor(group.activeEditor);
                 }
-                await group.closeEditors({ direction: CloseDirection.RIGHT, except: editor, excludeSticky: true }, { preserveFocus: context?.preserveFocus });
+                await group.closeEditors({ direction: CloseDirection.RIGHT, except: editors[0], excludeSticky: true }, { preserveFocus: resolvedContext.preserveFocus });
             }
         }
     });
@@ -743,39 +693,41 @@ function registerCloseEditorCommands() {
         weight: KeybindingWeight.WorkbenchContrib,
         when: undefined,
         primary: undefined,
-        handler: async (accessor, resourceOrContext, context) => {
+        handler: async (accessor, ...args) => {
             const editorService = accessor.get(IEditorService);
             const editorResolverService = accessor.get(IEditorResolverService);
             const telemetryService = accessor.get(ITelemetryService);
-            const editorsAndGroup = resolveEditorsContext(getEditorsContext(accessor, resourceOrContext, context));
+            const resolvedContext = resolveCommandsContext(args, editorService, accessor.get(IEditorGroupsService), accessor.get(IListService));
             const editorReplacements = ( (new Map()));
-            for (const { editor, group } of editorsAndGroup) {
-                const untypedEditor = editor.toUntyped();
-                if (!untypedEditor) {
-                    return;
-                }
-                untypedEditor.options = { ...editorService.activeEditorPane?.options, override: EditorResolution.PICK };
-                const resolvedEditor = await editorResolverService.resolveEditor(untypedEditor, group);
-                if (!isEditorInputWithOptionsAndGroup(resolvedEditor)) {
-                    return;
-                }
-                let editorReplacementsInGroup = editorReplacements.get(group);
-                if (!editorReplacementsInGroup) {
-                    editorReplacementsInGroup = [];
-                    editorReplacements.set(group, editorReplacementsInGroup);
+            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: EditorResolution.PICK };
+                    const resolvedEditor = await editorResolverService.resolveEditor(untypedEditor, group);
+                    if (!isEditorInputWithOptionsAndGroup(resolvedEditor)) {
+                        return;
+                    }
+                    let editorReplacementsInGroup = editorReplacements.get(group);
+                    if (!editorReplacementsInGroup) {
+                        editorReplacementsInGroup = [];
+                        editorReplacements.set(group, editorReplacementsInGroup);
+                    }
+                    editorReplacementsInGroup.push({
+                        editor: editor,
+                        replacement: resolvedEditor.editor,
+                        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 ?? ''
+                    });
                 }
-                editorReplacementsInGroup.push({
-                    editor: editor,
-                    replacement: resolvedEditor.editor,
-                    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 ?? ''
-                });
             }
             for (const [group, replacements] of editorReplacements) {
                 await group.replaceEditors(replacements);
@@ -783,13 +735,14 @@ function registerCloseEditorCommands() {
             }
         }
     });
-    CommandsRegistry.registerCommand(CLOSE_EDITORS_AND_GROUP_COMMAND_ID, async (accessor, resourceOrContext, context) => {
-        const editorGroupService = accessor.get(IEditorGroupsService);
-        const { group } = resolveCommandsContext(editorGroupService, getCommandsContext(accessor, resourceOrContext, context));
-        if (group) {
+    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));
+        if (resolvedContext.groupedEditors.length) {
+            const { group } = resolvedContext.groupedEditors[0];
             await group.closeAllEditors();
-            if (group.count === 0 && editorGroupService.getGroup(group.id) ) {
-                editorGroupService.removeGroup(group);
+            if (group.count === 0 && editorGroupsService.getGroup(group.id) ) {
+                editorGroupsService.removeGroup(group);
             }
         }
     });
@@ -815,17 +768,20 @@ function registerFocusEditorGroupWihoutWrapCommands() {
     ];
     for (const command of commands) {
         CommandsRegistry.registerCommand(command.id, async (accessor) => {
-            const editorGroupService = accessor.get(IEditorGroupsService);
-            const group = editorGroupService.findGroup({ direction: command.direction }, editorGroupService.activeGroup, false);
+            const editorGroupsService = accessor.get(IEditorGroupsService);
+            const group = editorGroupsService.findGroup({ direction: command.direction }, editorGroupsService.activeGroup, false);
             group?.focus();
         });
     }
 }
 function registerSplitEditorInGroupCommands() {
-    async function splitEditorInGroup(accessor, resourceOrContext, context) {
-        const editorGroupService = accessor.get(IEditorGroupsService);
+    async function splitEditorInGroup(accessor, resolvedContext) {
         const instantiationService = accessor.get(IInstantiationService);
-        const { group, editor } = resolveCommandsContext(editorGroupService, getCommandsContext(accessor, resourceOrContext, context));
+        if (!resolvedContext.groupedEditors.length) {
+            return;
+        }
+        const { group, editors } = resolvedContext.groupedEditors[0];
+        const editor = editors[0];
         if (!editor) {
             return;
         }
@@ -839,7 +795,7 @@ function registerSplitEditorInGroupCommands() {
         constructor() {
             super({
                 id: SPLIT_EDITOR_IN_GROUP,
-                title: ( localize2WithPath(_moduleId, 6, 'Split Editor in Group')),
+                title: ( localize2(5505, 'Split Editor in Group')),
                 category: Categories.View,
                 precondition: ActiveEditorCanSplitInGroupContext,
                 f1: true,
@@ -850,13 +806,19 @@ function registerSplitEditorInGroupCommands() {
                 }
             });
         }
-        run(accessor, resourceOrContext, context) {
-            return splitEditorInGroup(accessor, resourceOrContext, context);
+        run(accessor, ...args) {
+            return splitEditorInGroup(accessor, resolveCommandsContext(args, accessor.get(IEditorService), accessor.get(IEditorGroupsService), accessor.get(IListService)));
         }
     });
-    async function joinEditorInGroup(accessor, resourceOrContext, context) {
-        const editorGroupService = accessor.get(IEditorGroupsService);
-        const { group, editor } = resolveCommandsContext(editorGroupService, getCommandsContext(accessor, resourceOrContext, context));
+    async function joinEditorInGroup(resolvedContext) {
+        if (!resolvedContext.groupedEditors.length) {
+            return;
+        }
+        const { group, editors } = resolvedContext.groupedEditors[0];
+        const editor = editors[0];
+        if (!editor) {
+            return;
+        }
         if (!(editor instanceof SideBySideEditorInput)) {
             return;
         }
@@ -880,7 +842,7 @@ function registerSplitEditorInGroupCommands() {
         constructor() {
             super({
                 id: JOIN_EDITOR_IN_GROUP,
-                title: ( localize2WithPath(_moduleId, 7, 'Join Editor in Group')),
+                title: ( localize2(5506, 'Join Editor in Group')),
                 category: Categories.View,
                 precondition: SideBySideEditorActiveContext,
                 f1: true,
@@ -891,28 +853,31 @@ function registerSplitEditorInGroupCommands() {
                 }
             });
         }
-        run(accessor, resourceOrContext, context) {
-            return joinEditorInGroup(accessor, resourceOrContext, context);
+        run(accessor, ...args) {
+            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: ( localize2WithPath(_moduleId, 8, 'Toggle Split Editor in Group')),
+                title: ( localize2(5507, 'Toggle Split Editor in Group')),
                 category: Categories.View,
                 precondition: ( (ContextKeyExpr.or(ActiveEditorCanSplitInGroupContext, SideBySideEditorActiveContext))),
                 f1: true
             });
         }
-        async run(accessor, resourceOrContext, context) {
-            const editorGroupService = accessor.get(IEditorGroupsService);
-            const { editor } = resolveCommandsContext(editorGroupService, getCommandsContext(accessor, resourceOrContext, context));
-            if (editor instanceof SideBySideEditorInput) {
-                await joinEditorInGroup(accessor, resourceOrContext, context);
+        async run(accessor, ...args) {
+            const resolvedContext = resolveCommandsContext(args, accessor.get(IEditorService), accessor.get(IEditorGroupsService), accessor.get(IListService));
+            if (!resolvedContext.groupedEditors.length) {
+                return;
             }
-            else if (editor) {
-                await splitEditorInGroup(accessor, resourceOrContext, context);
+            const { editors } = resolvedContext.groupedEditors[0];
+            if (editors[0] instanceof SideBySideEditorInput) {
+                await joinEditorInGroup(resolvedContext);
+            }
+            else if (editors[0]) {
+                await splitEditorInGroup(accessor, resolvedContext);
             }
         }
     });
@@ -920,7 +885,7 @@ function registerSplitEditorInGroupCommands() {
         constructor() {
             super({
                 id: TOGGLE_SPLIT_EDITOR_IN_GROUP_LAYOUT,
-                title: ( localize2WithPath(_moduleId, 9, 'Toggle Layout of Split Editor in Group')),
+                title: ( localize2(5508, 'Toggle Layout of Split Editor in Group')),
                 category: Categories.View,
                 precondition: SideBySideEditorActiveContext,
                 f1: true
@@ -945,7 +910,7 @@ function registerFocusSideEditorsCommands() {
         constructor() {
             super({
                 id: FOCUS_FIRST_SIDE_EDITOR,
-                title: ( localize2WithPath(_moduleId, 10, 'Focus First Side in Active Editor')),
+                title: ( localize2(5509, 'Focus First Side in Active Editor')),
                 category: Categories.View,
                 precondition: ( (ContextKeyExpr.or(SideBySideEditorActiveContext, TextCompareEditorActiveContext))),
                 f1: true
@@ -967,7 +932,7 @@ function registerFocusSideEditorsCommands() {
         constructor() {
             super({
                 id: FOCUS_SECOND_SIDE_EDITOR,
-                title: ( localize2WithPath(_moduleId, 11, 'Focus Second Side in Active Editor')),
+                title: ( localize2(5510, 'Focus Second Side in Active Editor')),
                 category: Categories.View,
                 precondition: ( (ContextKeyExpr.or(SideBySideEditorActiveContext, TextCompareEditorActiveContext))),
                 f1: true
@@ -989,7 +954,7 @@ function registerFocusSideEditorsCommands() {
         constructor() {
             super({
                 id: FOCUS_OTHER_SIDE_EDITOR,
-                title: ( localize2WithPath(_moduleId, 12, 'Focus Other Side in Active Editor')),
+                title: ( localize2(5511, 'Focus Other Side in Active Editor')),
                 category: Categories.View,
                 precondition: ( (ContextKeyExpr.or(SideBySideEditorActiveContext, TextCompareEditorActiveContext))),
                 f1: true
@@ -1019,11 +984,12 @@ function registerOtherEditorCommands() {
         weight: KeybindingWeight.WorkbenchContrib,
         when: undefined,
         primary: KeyChord(KeyMod$1.CtrlCmd | KeyCode.KeyK, KeyCode.Enter),
-        handler: async (accessor, resourceOrContext, context) => {
-            const editorGroupService = accessor.get(IEditorGroupsService);
-            const { group, editor } = resolveCommandsContext(editorGroupService, getCommandsContext(accessor, resourceOrContext, context));
-            if (group && editor) {
-                return group.pinEditor(editor);
+        handler: async (accessor, ...args) => {
+            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);
+                }
             }
         }
     });
@@ -1036,50 +1002,50 @@ function registerOtherEditorCommands() {
             configurationService.updateValue('workbench.editor.enablePreview', newSetting);
         }
     });
-    function setEditorGroupLock(accessor, resourceOrContext, context, locked) {
-        const editorGroupService = accessor.get(IEditorGroupsService);
-        const { group } = resolveCommandsContext(editorGroupService, getCommandsContext(accessor, resourceOrContext, context));
+    function setEditorGroupLock(accessor, locked, ...args) {
+        const resolvedContext = resolveCommandsContext(args, accessor.get(IEditorService), accessor.get(IEditorGroupsService), accessor.get(IListService));
+        const group = resolvedContext.groupedEditors[0]?.group;
         group?.lock(locked ?? !group.isLocked);
     }
     registerAction2(class extends Action2 {
         constructor() {
             super({
                 id: TOGGLE_LOCK_GROUP_COMMAND_ID,
-                title: ( localize2WithPath(_moduleId, 13, 'Toggle Editor Group Lock')),
+                title: ( localize2(5512, 'Toggle Editor Group Lock')),
                 category: Categories.View,
                 f1: true
             });
         }
-        async run(accessor, resourceOrContext, context) {
-            setEditorGroupLock(accessor, resourceOrContext, context);
+        async run(accessor, ...args) {
+            setEditorGroupLock(accessor, undefined, ...args);
         }
     });
     registerAction2(class extends Action2 {
         constructor() {
             super({
                 id: LOCK_GROUP_COMMAND_ID,
-                title: ( localize2WithPath(_moduleId, 14, 'Lock Editor Group')),
+                title: ( localize2(5513, 'Lock Editor Group')),
                 category: Categories.View,
                 precondition: ( (ActiveEditorGroupLockedContext.toNegated())),
                 f1: true
             });
         }
-        async run(accessor, resourceOrContext, context) {
-            setEditorGroupLock(accessor, resourceOrContext, context, true);
+        async run(accessor, ...args) {
+            setEditorGroupLock(accessor, true, ...args);
         }
     });
     registerAction2(class extends Action2 {
         constructor() {
             super({
                 id: UNLOCK_GROUP_COMMAND_ID,
-                title: ( localize2WithPath(_moduleId, 15, 'Unlock Editor Group')),
+                title: ( localize2(5514, 'Unlock Editor Group')),
                 precondition: ActiveEditorGroupLockedContext,
                 category: Categories.View,
                 f1: true
             });
         }
-        async run(accessor, resourceOrContext, context) {
-            setEditorGroupLock(accessor, resourceOrContext, context, false);
+        async run(accessor, ...args) {
+            setEditorGroupLock(accessor, false, ...args);
         }
     });
     KeybindingsRegistry.registerCommandAndKeybindingRule({
@@ -1087,9 +1053,12 @@ function registerOtherEditorCommands() {
         weight: KeybindingWeight.WorkbenchContrib,
         when: ( (ActiveEditorStickyContext.toNegated())),
         primary: KeyChord(KeyMod$1.CtrlCmd | KeyCode.KeyK, KeyMod$1.Shift | KeyCode.Enter),
-        handler: async (accessor, resourceOrContext, context) => {
-            for (const { editor, group } of resolveEditorsContext(getEditorsContext(accessor, resourceOrContext, context))) {
-                group.stickEditor(editor);
+        handler: async (accessor, ...args) => {
+            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);
+                }
             }
         }
     });
@@ -1100,7 +1069,7 @@ function registerOtherEditorCommands() {
         primary: KeyChord(KeyMod$1.CtrlCmd | KeyCode.KeyK, KeyMod$1.Shift | KeyCode.KeyO),
         handler: async (accessor) => {
             const editorService = accessor.get(IEditorService);
-            const editorGroupService = accessor.get(IEditorGroupsService);
+            const editorGroupsService = accessor.get(IEditorGroupsService);
             const activeEditor = editorService.activeEditor;
             const activeTextEditorControl = editorService.activeTextEditorControl;
             if (!isDiffEditor(activeTextEditorControl) || !(activeEditor instanceof DiffEditorInput)) {
@@ -1114,7 +1083,7 @@ function registerOtherEditorCommands() {
             else {
                 editor = activeEditor.modified;
             }
-            return editorGroupService.activeGroup.openEditor(editor);
+            return editorGroupsService.activeGroup.openEditor(editor);
         }
     });
     KeybindingsRegistry.registerCommandAndKeybindingRule({
@@ -1122,9 +1091,12 @@ function registerOtherEditorCommands() {
         weight: KeybindingWeight.WorkbenchContrib,
         when: ActiveEditorStickyContext,
         primary: KeyChord(KeyMod$1.CtrlCmd | KeyCode.KeyK, KeyMod$1.Shift | KeyCode.Enter),
-        handler: async (accessor, resourceOrContext, context) => {
-            for (const { editor, group } of resolveEditorsContext(getEditorsContext(accessor, resourceOrContext, context))) {
-                group.unstickEditor(editor);
+        handler: async (accessor, ...args) => {
+            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);
+                }
             }
         }
     });
@@ -1133,113 +1105,18 @@ function registerOtherEditorCommands() {
         weight: KeybindingWeight.WorkbenchContrib,
         when: undefined,
         primary: undefined,
-        handler: (accessor, resourceOrContext, context) => {
-            const editorGroupService = accessor.get(IEditorGroupsService);
+        handler: (accessor, ...args) => {
+            const editorGroupsService = accessor.get(IEditorGroupsService);
             const quickInputService = accessor.get(IQuickInputService);
-            const commandsContext = getCommandsContext(accessor, resourceOrContext, context);
-            if (commandsContext && typeof commandsContext.groupId === 'number') {
-                const group = editorGroupService.getGroup(commandsContext.groupId);
-                if (group) {
-                    editorGroupService.activateGroup(group);
-                }
+            const commandsContext = resolveCommandsContext(args, accessor.get(IEditorService), editorGroupsService, accessor.get(IListService));
+            const group = commandsContext.groupedEditors[0]?.group;
+            if (group) {
+                editorGroupsService.activateGroup(group);
             }
             return quickInputService.quickAccess.show(ActiveGroupEditorsByMostRecentlyUsedQuickAccess.PREFIX);
         }
     });
 }
-function getEditorsContext(accessor, resourceOrContext, context) {
-    const editorGroupService = accessor.get(IEditorGroupsService);
-    const listService = accessor.get(IListService);
-    const editorContext = getMultiSelectedEditorContexts(getCommandsContext(accessor, resourceOrContext, context), listService, editorGroupService);
-    const activeGroup = editorGroupService.activeGroup;
-    if (editorContext.length === 0 && activeGroup.activeEditor) {
-        editorContext.push({
-            groupId: activeGroup.id,
-            editorIndex: activeGroup.getIndexOfEditor(activeGroup.activeEditor)
-        });
-    }
-    return {
-        editors: editorContext,
-        groups: ( (distinct(( (editorContext.map(context => context.groupId)))).map(groupId => editorGroupService.getGroup(groupId))))
-    };
-}
-function resolveEditorsContext(context) {
-    const { editors, groups } = context;
-    const editorsAndGroup = ( (editors.map(e => {
-        if (e.editorIndex === undefined) {
-            return undefined;
-        }
-        const group = groups.find(group => group && group.id === e.groupId);
-        const editor = group?.getEditorByIndex(e.editorIndex);
-        if (!editor || !group) {
-            return undefined;
-        }
-        return { editor, group };
-    })));
-    return coalesce(editorsAndGroup);
-}
-function getCommandsContext(accessor, resourceOrContext, context) {
-    const isUri = URI.isUri(resourceOrContext);
-    const editorCommandsContext = isUri ? context : resourceOrContext ? resourceOrContext : context;
-    if (editorCommandsContext && isEditorCommandsContext(editorCommandsContext)) {
-        return editorCommandsContext;
-    }
-    if (isUri) {
-        const editorGroupService = accessor.get(IEditorGroupsService);
-        const editorGroup = editorGroupService.getGroups(GroupsOrder.MOST_RECENTLY_ACTIVE).find(group => isEqual(group.activeEditor?.resource, resourceOrContext));
-        if (editorGroup) {
-            return { groupId: editorGroup.index, editorIndex: editorGroup.getIndexOfEditor(editorGroup.activeEditor) };
-        }
-    }
-    return undefined;
-}
-function resolveCommandsContext(editorGroupService, context) {
-    let group = context && typeof context.groupId === 'number' ? editorGroupService.getGroup(context.groupId) : undefined;
-    let editor = group && context && typeof context.editorIndex === 'number' ? group.getEditorByIndex(context.editorIndex) ?? undefined : undefined;
-    if (!group) {
-        group = editorGroupService.activeGroup;
-    }
-    if (!editor) {
-        editor = group.activeEditor ?? undefined;
-    }
-    return { group, editor };
-}
-function getMultiSelectedEditorContexts(editorContext, listService, editorGroupService) {
-    const list = listService.lastFocusedList;
-    if (list instanceof List && list.getHTMLElement() === getActiveElement()) {
-        const elementToContext = (element) => {
-            if (isEditorGroup(element)) {
-                return { groupId: element.id, editorIndex: undefined };
-            }
-            const group = editorGroupService.getGroup(element.groupId);
-            return { groupId: element.groupId, editorIndex: group ? group.getIndexOfEditor(element.editor) : -1 };
-        };
-        const onlyEditorGroupAndEditor = (e) => isEditorGroup(e) || isEditorIdentifier(e);
-        const focusedElements = list.getFocusedElements().filter(onlyEditorGroupAndEditor);
-        const focus = editorContext ? editorContext : focusedElements.length ? ( (focusedElements.map(elementToContext)))[0] : undefined;
-        if (focus) {
-            const selection = list.getSelectedElements().filter(onlyEditorGroupAndEditor);
-            if (selection.length > 1) {
-                return (
-                     (selection.map(elementToContext))
-                );
-            }
-            return [focus];
-        }
-    }
-    else {
-        const group = editorContext ? editorGroupService.getGroup(editorContext.groupId) : editorGroupService.activeGroup;
-        const editor = editorContext && editorContext.editorIndex !== undefined ? group?.getEditorByIndex(editorContext.editorIndex) : group?.activeEditor;
-        if (group && editor) {
-            if (group.isSelected(editor)) {
-                return (
-                     (group.selectedEditors.map(se => ({ groupId: group.id, editorIndex: group.getIndexOfEditor(se) })))
-                );
-            }
-        }
-    }
-    return !!editorContext ? [editorContext] : [];
-}
 function setup() {
     registerActiveEditorMoveCopyCommand();
     registerEditorGroupsLayoutCommands();
@@ -1254,4 +1131,4 @@ function setup() {
     registerSplitEditorCommands();
     registerFocusEditorGroupWihoutWrapCommands();
 }
-export { API_OPEN_DIFF_EDITOR_COMMAND_ID, API_OPEN_EDITOR_COMMAND_ID, API_OPEN_WITH_EDITOR_COMMAND_ID, CLOSE_EDITORS_AND_GROUP_COMMAND_ID, CLOSE_EDITORS_IN_GROUP_COMMAND_ID, CLOSE_EDITORS_TO_THE_RIGHT_COMMAND_ID, CLOSE_EDITOR_COMMAND_ID, CLOSE_EDITOR_GROUP_COMMAND_ID, CLOSE_OTHER_EDITORS_IN_GROUP_COMMAND_ID, CLOSE_PINNED_EDITOR_COMMAND_ID, CLOSE_SAVED_EDITORS_COMMAND_ID, COPY_ACTIVE_EDITOR_COMMAND_ID, COPY_EDITOR_GROUP_INTO_NEW_WINDOW_COMMAND_ID, COPY_EDITOR_INTO_NEW_WINDOW_COMMAND_ID, EDITOR_CORE_NAVIGATION_COMMANDS, FOCUS_ABOVE_GROUP_WITHOUT_WRAP_COMMAND_ID, FOCUS_BELOW_GROUP_WITHOUT_WRAP_COMMAND_ID, FOCUS_FIRST_SIDE_EDITOR, FOCUS_LEFT_GROUP_WITHOUT_WRAP_COMMAND_ID, FOCUS_OTHER_SIDE_EDITOR, FOCUS_RIGHT_GROUP_WITHOUT_WRAP_COMMAND_ID, FOCUS_SECOND_SIDE_EDITOR, JOIN_EDITOR_IN_GROUP, KEEP_EDITOR_COMMAND_ID, LAYOUT_EDITOR_GROUPS_COMMAND_ID, LOCK_GROUP_COMMAND_ID, MOVE_ACTIVE_EDITOR_COMMAND_ID, MOVE_EDITOR_GROUP_INTO_NEW_WINDOW_COMMAND_ID, MOVE_EDITOR_INTO_NEW_WINDOW_COMMAND_ID, NEW_EMPTY_EDITOR_WINDOW_COMMAND_ID, OPEN_EDITOR_AT_INDEX_COMMAND_ID, PIN_EDITOR_COMMAND_ID, REOPEN_WITH_COMMAND_ID, SHOW_EDITORS_IN_GROUP, SPLIT_EDITOR, SPLIT_EDITOR_DOWN, SPLIT_EDITOR_IN_GROUP, SPLIT_EDITOR_LEFT, SPLIT_EDITOR_RIGHT, SPLIT_EDITOR_UP, TOGGLE_KEEP_EDITORS_COMMAND_ID, TOGGLE_LOCK_GROUP_COMMAND_ID, TOGGLE_MAXIMIZE_EDITOR_GROUP, TOGGLE_SPLIT_EDITOR_IN_GROUP, TOGGLE_SPLIT_EDITOR_IN_GROUP_LAYOUT, UNLOCK_GROUP_COMMAND_ID, UNPIN_EDITOR_COMMAND_ID, getCommandsContext, getEditorsContext, getMultiSelectedEditorContexts, resolveCommandsContext, resolveEditorsContext, setup, splitEditor };
+export { API_OPEN_DIFF_EDITOR_COMMAND_ID, API_OPEN_EDITOR_COMMAND_ID, API_OPEN_WITH_EDITOR_COMMAND_ID, CLOSE_EDITORS_AND_GROUP_COMMAND_ID, CLOSE_EDITORS_IN_GROUP_COMMAND_ID, CLOSE_EDITORS_TO_THE_RIGHT_COMMAND_ID, CLOSE_EDITOR_COMMAND_ID, CLOSE_EDITOR_GROUP_COMMAND_ID, CLOSE_OTHER_EDITORS_IN_GROUP_COMMAND_ID, CLOSE_PINNED_EDITOR_COMMAND_ID, CLOSE_SAVED_EDITORS_COMMAND_ID, COPY_ACTIVE_EDITOR_COMMAND_ID, COPY_EDITOR_GROUP_INTO_NEW_WINDOW_COMMAND_ID, COPY_EDITOR_INTO_NEW_WINDOW_COMMAND_ID, EDITOR_CORE_NAVIGATION_COMMANDS, FOCUS_ABOVE_GROUP_WITHOUT_WRAP_COMMAND_ID, FOCUS_BELOW_GROUP_WITHOUT_WRAP_COMMAND_ID, FOCUS_FIRST_SIDE_EDITOR, FOCUS_LEFT_GROUP_WITHOUT_WRAP_COMMAND_ID, FOCUS_OTHER_SIDE_EDITOR, FOCUS_RIGHT_GROUP_WITHOUT_WRAP_COMMAND_ID, FOCUS_SECOND_SIDE_EDITOR, JOIN_EDITOR_IN_GROUP, KEEP_EDITOR_COMMAND_ID, LAYOUT_EDITOR_GROUPS_COMMAND_ID, LOCK_GROUP_COMMAND_ID, MOVE_ACTIVE_EDITOR_COMMAND_ID, MOVE_EDITOR_GROUP_INTO_NEW_WINDOW_COMMAND_ID, MOVE_EDITOR_INTO_NEW_WINDOW_COMMAND_ID, NEW_EMPTY_EDITOR_WINDOW_COMMAND_ID, OPEN_EDITOR_AT_INDEX_COMMAND_ID, PIN_EDITOR_COMMAND_ID, REOPEN_WITH_COMMAND_ID, SHOW_EDITORS_IN_GROUP, SPLIT_EDITOR, SPLIT_EDITOR_DOWN, SPLIT_EDITOR_IN_GROUP, SPLIT_EDITOR_LEFT, SPLIT_EDITOR_RIGHT, SPLIT_EDITOR_UP, TOGGLE_KEEP_EDITORS_COMMAND_ID, TOGGLE_LOCK_GROUP_COMMAND_ID, TOGGLE_MAXIMIZE_EDITOR_GROUP, TOGGLE_SPLIT_EDITOR_IN_GROUP, TOGGLE_SPLIT_EDITOR_IN_GROUP_LAYOUT, UNLOCK_GROUP_COMMAND_ID, UNPIN_EDITOR_COMMAND_ID, setup, splitEditor };