@codingame/monaco-vscode-api 1.78.8 → 1.79.0

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

@@ -1,436 +1,26 @@
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { withNullAsUndefined, isObject, isString, isUndefined, isNumber } from 'monaco-editor/esm/vs/base/common/types.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { KeybindingsRegistry } from 'monaco-editor/esm/vs/platform/keybinding/common/keybindingsRegistry.js';
-import { isUntitledWithAssociatedResource, isEditorInputWithOptionsAndGroup, isEditorIdentifier } from '../../../common/editor.js';
-import { TextCompareEditorVisibleContext, TextCompareEditorActiveContext, ActiveEditorGroupEmptyContext, MultipleEditorGroupsContext, ActiveEditorCanSplitInGroupContext, SideBySideEditorActiveContext, ActiveEditorGroupLockedContext, ActiveEditorStickyContext } from '../../../common/contextkeys.js';
+import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { isUntitledWithAssociatedResource, isEditorIdentifier } from '../../../common/editor.js';
 import { columnToEditorGroup } from '../../../services/editor/common/editorGroupColumn.js';
 import { IEditorService, SIDE_GROUP } from '../../../services/editor/common/editorService.js';
-import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
-import { TextDiffEditor } from './textDiffEditor.js';
-import { KeyChord } from 'monaco-editor/esm/vs/base/common/keyCodes.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
-import { IListService } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
 import { List } from 'monaco-editor/esm/vs/base/browser/ui/list/listWidget.js';
-import { distinct, coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { IEditorGroupsService, preferredSideBySideGroupDirection, isEditorGroup } from '../../../services/editor/common/editorGroupsService.js';
-import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { isEditorGroup, IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { CommandsRegistry, ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { MenuRegistry, MenuId, registerAction2, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
-import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
-import { ActiveGroupEditorsByMostRecentlyUsedQuickAccess } from './editorQuickAccess.js';
 import { IOpenerService, matchesScheme } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
-import { EditorResolution } from 'monaco-editor/esm/vs/platform/editor/common/editor.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { SideBySideEditorInput } from '../../../common/editor/sideBySideEditorInput.js';
-import { SideBySideEditor } from './sideBySideEditor.js';
-import { IEditorResolverService } from '../../../services/editor/common/editorResolverService.js';
 import { IPathService } from '../../../services/path/common/pathService.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { extname } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { DiffEditorInput } from '../../../common/editor/diffEditorInput.js';
-import { isDiffEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.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 PIN_EDITOR_COMMAND_ID = 'workbench.action.pinEditor';
 const UNPIN_EDITOR_COMMAND_ID = 'workbench.action.unpinEditor';
-const TOGGLE_DIFF_SIDE_BY_SIDE = 'toggle.diff.renderSideBySide';
-const GOTO_NEXT_CHANGE = 'workbench.action.compareEditor.nextChange';
-const GOTO_PREVIOUS_CHANGE = 'workbench.action.compareEditor.previousChange';
-const DIFF_FOCUS_PRIMARY_SIDE = 'workbench.action.compareEditor.focusPrimarySide';
-const DIFF_FOCUS_SECONDARY_SIDE = 'workbench.action.compareEditor.focusSecondarySide';
-const DIFF_FOCUS_OTHER_SIDE = 'workbench.action.compareEditor.focusOtherSide';
-const DIFF_OPEN_SIDE = 'workbench.action.compareEditor.openSide';
 const TOGGLE_DIFF_IGNORE_TRIM_WHITESPACE = 'toggle.diff.ignoreTrimWhitespace';
 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 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 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 isActiveEditorMoveCopyArg = function (arg) {
-    if (!isObject(arg)) {
-        return false;
-    }
-    if (!isString(arg.to)) {
-        return false;
-    }
-    if (!isUndefined(arg.by) && !isString(arg.by)) {
-        return false;
-    }
-    if (!isUndefined(arg.value) && !isNumber(arg.value)) {
-        return false;
-    }
-    return true;
-};
-function registerActiveEditorMoveCopyCommand() {
-    const moveCopyJSONSchema = {
-        'type': 'object',
-        'required': ['to'],
-        'properties': {
-            'to': {
-                'type': 'string',
-                'enum': ['left', 'right']
-            },
-            'by': {
-                'type': 'string',
-                'enum': ['tab', 'group']
-            },
-            'value': {
-                'type': 'number'
-            }
-        }
-    };
-    KeybindingsRegistry.registerCommandAndKeybindingRule({
-        id: MOVE_ACTIVE_EDITOR_COMMAND_ID,
-        weight: 200 ,
-        when: EditorContextKeys.editorTextFocus,
-        primary: 0,
-        handler: (accessor, args) => moveCopyActiveEditor(true, args, accessor),
-        description: {
-            description: ( localize(
-                'editorCommand.activeEditorMove.description',
-                "Move the active editor by tabs or groups"
-            )),
-            args: [
-                {
-                    name: ( localize('editorCommand.activeEditorMove.arg.name', "Active editor move argument")),
-                    description: ( localize(
-                        'editorCommand.activeEditorMove.arg.description',
-                        "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,
-                    schema: moveCopyJSONSchema
-                }
-            ]
-        }
-    });
-    KeybindingsRegistry.registerCommandAndKeybindingRule({
-        id: COPY_ACTIVE_EDITOR_COMMAND_ID,
-        weight: 200 ,
-        when: EditorContextKeys.editorTextFocus,
-        primary: 0,
-        handler: (accessor, args) => moveCopyActiveEditor(false, args, accessor),
-        description: {
-            description: ( localize(
-                'editorCommand.activeEditorCopy.description',
-                "Copy the active editor by groups"
-            )),
-            args: [
-                {
-                    name: ( localize('editorCommand.activeEditorCopy.arg.name', "Active editor copy argument")),
-                    description: ( localize(
-                        'editorCommand.activeEditorCopy.arg.description',
-                        "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,
-                    schema: moveCopyJSONSchema
-                }
-            ]
-        }
-    });
-    function moveCopyActiveEditor(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;
-        const activeEditorPane = accessor.get(IEditorService).activeEditorPane;
-        if (activeEditorPane) {
-            switch (args.by) {
-                case 'tab':
-                    if (isMove) {
-                        return moveActiveTab(args, activeEditorPane);
-                    }
-                    break;
-                case 'group':
-                    return moveCopyActiveEditorToGroup(isMove, args, activeEditorPane, accessor);
-            }
-        }
-    }
-    function moveActiveTab(args, control) {
-        const group = control.group;
-        let index = group.getIndexOfEditor(control.input);
-        switch (args.to) {
-            case 'first':
-                index = 0;
-                break;
-            case 'last':
-                index = group.count - 1;
-                break;
-            case 'left':
-                index = index - args.value;
-                break;
-            case 'right':
-                index = index + args.value;
-                break;
-            case 'center':
-                index = Math.round(group.count / 2) - 1;
-                break;
-            case 'position':
-                index = args.value - 1;
-                break;
-        }
-        index = index < 0 ? 0 : index >= group.count ? group.count - 1 : index;
-        group.moveEditor(control.input, group, { index });
-    }
-    function moveCopyActiveEditorToGroup(isMove, args, control, accessor) {
-        const editorGroupService = accessor.get(IEditorGroupsService);
-        const configurationService = accessor.get(IConfigurationService);
-        const sourceGroup = control.group;
-        let targetGroup;
-        switch (args.to) {
-            case 'left':
-                targetGroup = editorGroupService.findGroup({ direction: 2  }, sourceGroup);
-                if (!targetGroup) {
-                    targetGroup = editorGroupService.addGroup(sourceGroup, 2 );
-                }
-                break;
-            case 'right':
-                targetGroup = editorGroupService.findGroup({ direction: 3  }, sourceGroup);
-                if (!targetGroup) {
-                    targetGroup = editorGroupService.addGroup(sourceGroup, 3 );
-                }
-                break;
-            case 'up':
-                targetGroup = editorGroupService.findGroup({ direction: 0  }, sourceGroup);
-                if (!targetGroup) {
-                    targetGroup = editorGroupService.addGroup(sourceGroup, 0 );
-                }
-                break;
-            case 'down':
-                targetGroup = editorGroupService.findGroup({ direction: 1  }, sourceGroup);
-                if (!targetGroup) {
-                    targetGroup = editorGroupService.addGroup(sourceGroup, 1 );
-                }
-                break;
-            case 'first':
-                targetGroup = editorGroupService.findGroup({ location: 0  }, sourceGroup);
-                break;
-            case 'last':
-                targetGroup = editorGroupService.findGroup({ location: 1  }, sourceGroup);
-                break;
-            case 'previous':
-                targetGroup = editorGroupService.findGroup({ location: 3  }, sourceGroup);
-                break;
-            case 'next':
-                targetGroup = editorGroupService.findGroup({ location: 2  }, sourceGroup);
-                if (!targetGroup) {
-                    targetGroup = editorGroupService.addGroup(sourceGroup, preferredSideBySideGroupDirection(configurationService));
-                }
-                break;
-            case 'center':
-                targetGroup = editorGroupService.getGroups(2 )[(editorGroupService.count / 2) - 1];
-                break;
-            case 'position':
-                targetGroup = editorGroupService.getGroups(2 )[args.value - 1];
-                break;
-        }
-        if (targetGroup) {
-            if (isMove) {
-                sourceGroup.moveEditor(control.input, targetGroup);
-            }
-            else if (sourceGroup.id !== targetGroup.id) {
-                sourceGroup.copyEditor(control.input, targetGroup);
-            }
-            targetGroup.focus();
-        }
-    }
-}
-function registerEditorGroupsLayoutCommands() {
-    function applyEditorLayout(accessor, layout) {
-        if (!layout || typeof layout !== 'object') {
-            return;
-        }
-        const editorGroupService = accessor.get(IEditorGroupsService);
-        editorGroupService.applyLayout(layout);
-    }
-    CommandsRegistry.registerCommand(LAYOUT_EDITOR_GROUPS_COMMAND_ID, (accessor, args) => {
-        applyEditorLayout(accessor, args);
-    });
-    CommandsRegistry.registerCommand({
-        id: 'vscode.setEditorLayout',
-        handler: (accessor, args) => applyEditorLayout(accessor, args),
-        description: {
-            description: 'Set Editor Layout',
-            args: [{
-                    name: 'args',
-                    schema: {
-                        'type': 'object',
-                        'required': ['groups'],
-                        'properties': {
-                            'orientation': {
-                                'type': 'number',
-                                'default': 0,
-                                'enum': [0, 1]
-                            },
-                            'groups': {
-                                '$ref': '#/definitions/editorGroupsSchema',
-                                'default': [{}, {}]
-                            }
-                        }
-                    }
-                }]
-        }
-    });
-    CommandsRegistry.registerCommand({
-        id: 'vscode.getEditorLayout',
-        handler: (accessor) => {
-            const editorGroupService = accessor.get(IEditorGroupsService);
-            return editorGroupService.getLayout();
-        },
-        description: {
-            description: 'Get Editor Layout',
-            args: [],
-            returns: 'An editor layout object, in the same format as vscode.setEditorLayout'
-        }
-    });
-}
-function registerDiffEditorCommands() {
-    KeybindingsRegistry.registerCommandAndKeybindingRule({
-        id: GOTO_NEXT_CHANGE,
-        weight: 200 ,
-        when: TextCompareEditorVisibleContext,
-        primary: 512  | 63 ,
-        handler: accessor => navigateInDiffEditor(accessor, true)
-    });
-    KeybindingsRegistry.registerCommandAndKeybindingRule({
-        id: GOTO_PREVIOUS_CHANGE,
-        weight: 200 ,
-        when: TextCompareEditorVisibleContext,
-        primary: 512  | 1024  | 63 ,
-        handler: accessor => navigateInDiffEditor(accessor, false)
-    });
-    function getActiveTextDiffEditor(accessor) {
-        const editorService = accessor.get(IEditorService);
-        for (const editor of [editorService.activeEditorPane, ...editorService.visibleEditorPanes]) {
-            if (editor instanceof TextDiffEditor) {
-                return editor;
-            }
-        }
-        return undefined;
-    }
-    function navigateInDiffEditor(accessor, next) {
-        const activeTextDiffEditor = getActiveTextDiffEditor(accessor);
-        if (activeTextDiffEditor) {
-            const navigator = activeTextDiffEditor.getDiffNavigator();
-            if (navigator) {
-                next ? navigator.next() : navigator.previous();
-            }
-        }
-    }
-    let FocusTextDiffEditorMode;
-    ( (function(FocusTextDiffEditorMode) {
-        FocusTextDiffEditorMode[FocusTextDiffEditorMode["Original"] = 0] = "Original";
-        FocusTextDiffEditorMode[FocusTextDiffEditorMode["Modified"] = 1] = "Modified";
-        FocusTextDiffEditorMode[FocusTextDiffEditorMode["Toggle"] = 2] = "Toggle";
-    })(FocusTextDiffEditorMode || (FocusTextDiffEditorMode = {})));
-    function focusInDiffEditor(accessor, mode) {
-        const activeTextDiffEditor = getActiveTextDiffEditor(accessor);
-        if (activeTextDiffEditor) {
-            switch (mode) {
-                case FocusTextDiffEditorMode.Original:
-                    activeTextDiffEditor.getControl()?.getOriginalEditor().focus();
-                    break;
-                case FocusTextDiffEditorMode.Modified:
-                    activeTextDiffEditor.getControl()?.getModifiedEditor().focus();
-                    break;
-                case FocusTextDiffEditorMode.Toggle:
-                    if (activeTextDiffEditor.getControl()?.getModifiedEditor().hasWidgetFocus()) {
-                        return focusInDiffEditor(accessor, FocusTextDiffEditorMode.Original);
-                    }
-                    else {
-                        return focusInDiffEditor(accessor, FocusTextDiffEditorMode.Modified);
-                    }
-            }
-        }
-    }
-    function toggleDiffSideBySide(accessor) {
-        const configurationService = accessor.get(IConfigurationService);
-        const newValue = !configurationService.getValue('diffEditor.renderSideBySide');
-        configurationService.updateValue('diffEditor.renderSideBySide', newValue);
-    }
-    function toggleDiffIgnoreTrimWhitespace(accessor) {
-        const configurationService = accessor.get(IConfigurationService);
-        const newValue = !configurationService.getValue('diffEditor.ignoreTrimWhitespace');
-        configurationService.updateValue('diffEditor.ignoreTrimWhitespace', newValue);
-    }
-    KeybindingsRegistry.registerCommandAndKeybindingRule({
-        id: TOGGLE_DIFF_SIDE_BY_SIDE,
-        weight: 200 ,
-        when: undefined,
-        primary: undefined,
-        handler: accessor => toggleDiffSideBySide(accessor)
-    });
-    KeybindingsRegistry.registerCommandAndKeybindingRule({
-        id: DIFF_FOCUS_PRIMARY_SIDE,
-        weight: 200 ,
-        when: undefined,
-        primary: undefined,
-        handler: accessor => focusInDiffEditor(accessor, FocusTextDiffEditorMode.Modified)
-    });
-    KeybindingsRegistry.registerCommandAndKeybindingRule({
-        id: DIFF_FOCUS_SECONDARY_SIDE,
-        weight: 200 ,
-        when: undefined,
-        primary: undefined,
-        handler: accessor => focusInDiffEditor(accessor, FocusTextDiffEditorMode.Original)
-    });
-    KeybindingsRegistry.registerCommandAndKeybindingRule({
-        id: DIFF_FOCUS_OTHER_SIDE,
-        weight: 200 ,
-        when: undefined,
-        primary: undefined,
-        handler: accessor => focusInDiffEditor(accessor, FocusTextDiffEditorMode.Toggle)
-    });
-    MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
-        command: {
-            id: TOGGLE_DIFF_SIDE_BY_SIDE,
-            title: {
-                value: ( localize('toggleInlineView', "Toggle Inline View")),
-                original: 'Compare: Toggle Inline View'
-            },
-            category: ( localize('compare', "Compare"))
-        },
-        when: TextCompareEditorActiveContext
-    });
-    KeybindingsRegistry.registerCommandAndKeybindingRule({
-        id: TOGGLE_DIFF_IGNORE_TRIM_WHITESPACE,
-        weight: 200 ,
-        when: undefined,
-        primary: undefined,
-        handler: accessor => toggleDiffIgnoreTrimWhitespace(accessor)
-    });
-}
 function registerOpenEditorAPICommands() {
     function mixinContext(context, options, column) {
         if (!context) {
@@ -523,101 +113,6 @@ function registerOpenEditorAPICommands() {
         return editorService.openEditor({ resource: URI.revive(resource), options: { ...optionsArg, pinned: true, override: id } }, columnToEditorGroup(editorGroupsService, configurationService, columnArg));
     });
 }
-function registerOpenEditorAtIndexCommands() {
-    const openEditorAtIndex = (accessor, editorIndex) => {
-        const editorService = accessor.get(IEditorService);
-        const activeEditorPane = editorService.activeEditorPane;
-        if (activeEditorPane) {
-            const editor = activeEditorPane.group.getEditorByIndex(editorIndex);
-            if (editor) {
-                editorService.openEditor(editor);
-            }
-        }
-    };
-    CommandsRegistry.registerCommand({
-        id: OPEN_EDITOR_AT_INDEX_COMMAND_ID,
-        handler: openEditorAtIndex
-    });
-    for (let i = 0; i < 9; i++) {
-        const editorIndex = i;
-        const visibleIndex = i + 1;
-        KeybindingsRegistry.registerCommandAndKeybindingRule({
-            id: OPEN_EDITOR_AT_INDEX_COMMAND_ID + visibleIndex,
-            weight: 200 ,
-            when: undefined,
-            primary: 512  | toKeyCode(visibleIndex),
-            mac: { primary: 256  | toKeyCode(visibleIndex) },
-            handler: accessor => openEditorAtIndex(accessor, editorIndex)
-        });
-    }
-    function toKeyCode(index) {
-        switch (index) {
-            case 0: return 21 ;
-            case 1: return 22 ;
-            case 2: return 23 ;
-            case 3: return 24 ;
-            case 4: return 25 ;
-            case 5: return 26 ;
-            case 6: return 27 ;
-            case 7: return 28 ;
-            case 8: return 29 ;
-            case 9: return 30 ;
-        }
-        throw new Error('invalid index');
-    }
-}
-function registerFocusEditorGroupAtIndexCommands() {
-    for (let groupIndex = 1; groupIndex < 8; groupIndex++) {
-        KeybindingsRegistry.registerCommandAndKeybindingRule({
-            id: toCommandId(groupIndex),
-            weight: 200 ,
-            when: undefined,
-            primary: 2048  | toKeyCode(groupIndex),
-            handler: accessor => {
-                const editorGroupService = accessor.get(IEditorGroupsService);
-                const configurationService = accessor.get(IConfigurationService);
-                if (groupIndex > editorGroupService.count) {
-                    return;
-                }
-                const groups = editorGroupService.getGroups(2 );
-                if (groups[groupIndex]) {
-                    return groups[groupIndex].focus();
-                }
-                const direction = preferredSideBySideGroupDirection(configurationService);
-                const lastGroup = editorGroupService.findGroup({ location: 1  });
-                if (!lastGroup) {
-                    return;
-                }
-                const newGroup = editorGroupService.addGroup(lastGroup, direction);
-                newGroup.focus();
-            }
-        });
-    }
-    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');
-    }
-    function toKeyCode(index) {
-        switch (index) {
-            case 1: return 23 ;
-            case 2: return 24 ;
-            case 3: return 25 ;
-            case 4: return 26 ;
-            case 5: return 27 ;
-            case 6: return 28 ;
-            case 7: return 29 ;
-        }
-        throw new Error('Invalid index');
-    }
-}
 function splitEditor(editorGroupService, direction, context) {
     let sourceGroup;
     if (context && typeof context.groupId === 'number') {
@@ -642,607 +137,6 @@ function splitEditor(editorGroupService, direction, context) {
     }
     newGroup.focus();
 }
-function registerSplitEditorCommands() {
-    [
-        { id: SPLIT_EDITOR_UP, direction: 0  },
-        { id: SPLIT_EDITOR_DOWN, direction: 1  },
-        { id: SPLIT_EDITOR_LEFT, direction: 2  },
-        { id: SPLIT_EDITOR_RIGHT, direction: 3  }
-    ].forEach(({ id, direction }) => {
-        CommandsRegistry.registerCommand(id, function (accessor, resourceOrContext, context) {
-            splitEditor(accessor.get(IEditorGroupsService), direction, getCommandsContext(resourceOrContext, context));
-        });
-    });
-}
-function registerCloseEditorCommands() {
-    function closeEditorHandler(accessor, forceCloseStickyEditors, resourceOrContext, context) {
-        const editorGroupsService = accessor.get(IEditorGroupsService);
-        const editorService = accessor.get(IEditorService);
-        let keepStickyEditors = true;
-        if (forceCloseStickyEditors) {
-            keepStickyEditors = false;
-        }
-        else if (resourceOrContext || context) {
-            keepStickyEditors = false;
-        }
-        if (keepStickyEditors && !resourceOrContext && !context) {
-            const activeGroup = editorGroupsService.activeGroup;
-            const activeEditor = activeGroup.activeEditor;
-            if (activeEditor && activeGroup.isSticky(activeEditor)) {
-                const nextNonStickyEditorInGroup = activeGroup.getEditors(0 , { excludeSticky: true })[0];
-                if (nextNonStickyEditorInGroup) {
-                    return activeGroup.openEditor(nextNonStickyEditorInGroup);
-                }
-                const nextNonStickyEditorInAllGroups = editorService.getEditors(0 , { excludeSticky: true })[0];
-                if (nextNonStickyEditorInAllGroups) {
-                    return Promise.resolve(editorGroupsService.getGroup(nextNonStickyEditorInAllGroups.groupId)?.openEditor(nextNonStickyEditorInAllGroups.editor));
-                }
-            }
-        }
-        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 });
-            }
-        })));
-    }
-    KeybindingsRegistry.registerCommandAndKeybindingRule({
-        id: CLOSE_EDITOR_COMMAND_ID,
-        weight: 200 ,
-        when: undefined,
-        primary: 2048  | 53 ,
-        win: { primary: 2048  | 62 , secondary: [2048  | 53 ] },
-        handler: (accessor, resourceOrContext, context) => {
-            return closeEditorHandler(accessor, false, resourceOrContext, context);
-        }
-    });
-    CommandsRegistry.registerCommand(CLOSE_PINNED_EDITOR_COMMAND_ID, (accessor, resourceOrContext, context) => {
-        return closeEditorHandler(accessor, true , resourceOrContext, context);
-    });
-    KeybindingsRegistry.registerCommandAndKeybindingRule({
-        id: CLOSE_EDITORS_IN_GROUP_COMMAND_ID,
-        weight: 200 ,
-        when: undefined,
-        primary: KeyChord(2048  | 41 , 53 ),
-        handler: (accessor, resourceOrContext, context) => {
-            return Promise.all(( getEditorsContext(accessor, resourceOrContext, context).groups.map(async (group) => {
-                if (group) {
-                    await group.closeAllEditors({ excludeSticky: true });
-                    return;
-                }
-            })));
-        }
-    });
-    KeybindingsRegistry.registerCommandAndKeybindingRule({
-        id: CLOSE_EDITOR_GROUP_COMMAND_ID,
-        weight: 200 ,
-        when: ( ContextKeyExpr.and(ActiveEditorGroupEmptyContext, MultipleEditorGroupsContext)),
-        primary: 2048  | 53 ,
-        win: { primary: 2048  | 62 , secondary: [2048  | 53 ] },
-        handler: (accessor, resourceOrContext, context) => {
-            const editorGroupService = accessor.get(IEditorGroupsService);
-            const commandsContext = getCommandsContext(resourceOrContext, context);
-            let group;
-            if (commandsContext && typeof commandsContext.groupId === 'number') {
-                group = editorGroupService.getGroup(commandsContext.groupId);
-            }
-            else {
-                group = editorGroupService.activeGroup;
-            }
-            if (group) {
-                editorGroupService.removeGroup(group);
-            }
-        }
-    });
-    KeybindingsRegistry.registerCommandAndKeybindingRule({
-        id: CLOSE_SAVED_EDITORS_COMMAND_ID,
-        weight: 200 ,
-        when: undefined,
-        primary: KeyChord(2048  | 41 , 51 ),
-        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 });
-                }
-            })));
-        }
-    });
-    KeybindingsRegistry.registerCommandAndKeybindingRule({
-        id: CLOSE_OTHER_EDITORS_IN_GROUP_COMMAND_ID,
-        weight: 200 ,
-        when: undefined,
-        primary: undefined,
-        mac: { primary: 2048  | 512  | 50  },
-        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(1 , { excludeSticky: true }).filter(editor => !editorsToKeep.includes(editor));
-                    for (const editorToKeep of editorsToKeep) {
-                        if (editorToKeep) {
-                            group.pinEditor(editorToKeep);
-                        }
-                    }
-                    await group.closeEditors(editorsToClose, { preserveFocus: context?.preserveFocus });
-                }
-            })));
-        }
-    });
-    KeybindingsRegistry.registerCommandAndKeybindingRule({
-        id: CLOSE_EDITORS_TO_THE_RIGHT_COMMAND_ID,
-        weight: 200 ,
-        when: undefined,
-        primary: undefined,
-        handler: async (accessor, resourceOrContext, context) => {
-            const editorGroupService = accessor.get(IEditorGroupsService);
-            const { group, editor } = resolveCommandsContext(editorGroupService, getCommandsContext(resourceOrContext, context));
-            if (group && editor) {
-                if (group.activeEditor) {
-                    group.pinEditor(group.activeEditor);
-                }
-                await group.closeEditors({ direction: 1 , except: editor, excludeSticky: true }, { preserveFocus: context?.preserveFocus });
-            }
-        }
-    });
-    KeybindingsRegistry.registerCommandAndKeybindingRule({
-        id: REOPEN_WITH_COMMAND_ID,
-        weight: 200 ,
-        when: undefined,
-        primary: undefined,
-        handler: async (accessor, resourceOrContext, context) => {
-            const editorGroupService = accessor.get(IEditorGroupsService);
-            const editorService = accessor.get(IEditorService);
-            const editorResolverService = accessor.get(IEditorResolverService);
-            const telemetryService = accessor.get(ITelemetryService);
-            const { group, editor } = resolveCommandsContext(editorGroupService, getCommandsContext(resourceOrContext, context));
-            if (!editor) {
-                return;
-            }
-            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;
-            }
-            await resolvedEditor.group.replaceEditors([
-                {
-                    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 ?? ''
-            });
-            await resolvedEditor.group.openEditor(resolvedEditor.editor);
-        }
-    });
-    CommandsRegistry.registerCommand(CLOSE_EDITORS_AND_GROUP_COMMAND_ID, async (accessor, resourceOrContext, context) => {
-        const editorGroupService = accessor.get(IEditorGroupsService);
-        const { group } = resolveCommandsContext(editorGroupService, getCommandsContext(resourceOrContext, context));
-        if (group) {
-            await group.closeAllEditors();
-            if (group.count === 0 && editorGroupService.getGroup(group.id) ) {
-                editorGroupService.removeGroup(group);
-            }
-        }
-    });
-}
-function registerFocusEditorGroupWihoutWrapCommands() {
-    const commands = [
-        {
-            id: FOCUS_LEFT_GROUP_WITHOUT_WRAP_COMMAND_ID,
-            direction: 2
-        },
-        {
-            id: FOCUS_RIGHT_GROUP_WITHOUT_WRAP_COMMAND_ID,
-            direction: 3
-        },
-        {
-            id: FOCUS_ABOVE_GROUP_WITHOUT_WRAP_COMMAND_ID,
-            direction: 0 ,
-        },
-        {
-            id: FOCUS_BELOW_GROUP_WITHOUT_WRAP_COMMAND_ID,
-            direction: 1
-        }
-    ];
-    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);
-            group?.focus();
-        });
-    }
-}
-function registerSplitEditorInGroupCommands() {
-    async function splitEditorInGroup(accessor, resourceOrContext, context) {
-        const editorGroupService = accessor.get(IEditorGroupsService);
-        const instantiationService = accessor.get(IInstantiationService);
-        const { group, editor } = resolveCommandsContext(editorGroupService, getCommandsContext(resourceOrContext, context));
-        if (!editor) {
-            return;
-        }
-        await group.replaceEditors([{
-                editor,
-                replacement: instantiationService.createInstance(SideBySideEditorInput, undefined, undefined, editor, editor),
-                forceReplaceDirty: true
-            }]);
-    }
-    registerAction2(class extends Action2 {
-        constructor() {
-            super({
-                id: SPLIT_EDITOR_IN_GROUP,
-                title: { value: ( localize('splitEditorInGroup', "Split Editor in Group")), original: 'Split Editor in Group' },
-                category: Categories.View,
-                precondition: ActiveEditorCanSplitInGroupContext,
-                f1: true,
-                keybinding: {
-                    weight: 200 ,
-                    when: ActiveEditorCanSplitInGroupContext,
-                    primary: KeyChord(2048  | 41 , 2048  | 1024  | 88 )
-                }
-            });
-        }
-        run(accessor, resourceOrContext, context) {
-            return splitEditorInGroup(accessor, resourceOrContext, context);
-        }
-    });
-    async function joinEditorInGroup(accessor, resourceOrContext, context) {
-        const editorGroupService = accessor.get(IEditorGroupsService);
-        const { group, editor } = resolveCommandsContext(editorGroupService, getCommandsContext(resourceOrContext, context));
-        if (!(editor instanceof SideBySideEditorInput)) {
-            return;
-        }
-        let options = undefined;
-        const activeEditorPane = group.activeEditorPane;
-        if (activeEditorPane instanceof SideBySideEditor && group.activeEditor === editor) {
-            for (const pane of [activeEditorPane.getPrimaryEditorPane(), activeEditorPane.getSecondaryEditorPane()]) {
-                if (pane?.hasFocus()) {
-                    options = { viewState: pane.getViewState() };
-                    break;
-                }
-            }
-        }
-        await group.replaceEditors([{
-                editor,
-                replacement: editor.primary,
-                options
-            }]);
-    }
-    registerAction2(class extends Action2 {
-        constructor() {
-            super({
-                id: JOIN_EDITOR_IN_GROUP,
-                title: { value: ( localize('joinEditorInGroup', "Join Editor in Group")), original: 'Join Editor in Group' },
-                category: Categories.View,
-                precondition: SideBySideEditorActiveContext,
-                f1: true,
-                keybinding: {
-                    weight: 200 ,
-                    when: SideBySideEditorActiveContext,
-                    primary: KeyChord(2048  | 41 , 2048  | 1024  | 88 )
-                }
-            });
-        }
-        run(accessor, resourceOrContext, context) {
-            return joinEditorInGroup(accessor, resourceOrContext, context);
-        }
-    });
-    registerAction2(class extends Action2 {
-        constructor() {
-            super({
-                id: TOGGLE_SPLIT_EDITOR_IN_GROUP,
-                title: { value: ( localize('toggleJoinEditorInGroup', "Toggle Split Editor in Group")), original: '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(resourceOrContext, context));
-            if (editor instanceof SideBySideEditorInput) {
-                await joinEditorInGroup(accessor, resourceOrContext, context);
-            }
-            else if (editor) {
-                await splitEditorInGroup(accessor, resourceOrContext, context);
-            }
-        }
-    });
-    registerAction2(class extends Action2 {
-        constructor() {
-            super({
-                id: TOGGLE_SPLIT_EDITOR_IN_GROUP_LAYOUT,
-                title: { value: ( localize('toggleSplitEditorInGroupLayout', "Toggle Layout of Split Editor in Group")), original: 'Toggle Layout of Split Editor in Group' },
-                category: Categories.View,
-                precondition: SideBySideEditorActiveContext,
-                f1: true
-            });
-        }
-        async run(accessor) {
-            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';
-            }
-            return configurationService.updateValue(SideBySideEditor.SIDE_BY_SIDE_LAYOUT_SETTING, newSetting);
-        }
-    });
-}
-function registerFocusSideEditorsCommands() {
-    registerAction2(class extends Action2 {
-        constructor() {
-            super({
-                id: FOCUS_FIRST_SIDE_EDITOR,
-                title: { value: ( localize('focusLeftSideEditor', "Focus First Side in Active Editor")), original: 'Focus First Side in Active Editor' },
-                category: Categories.View,
-                precondition: ( ContextKeyExpr.or(SideBySideEditorActiveContext, TextCompareEditorActiveContext)),
-                f1: true
-            });
-        }
-        async run(accessor) {
-            const editorService = accessor.get(IEditorService);
-            const commandService = accessor.get(ICommandService);
-            const activeEditorPane = editorService.activeEditorPane;
-            if (activeEditorPane instanceof SideBySideEditor) {
-                activeEditorPane.getSecondaryEditorPane()?.focus();
-            }
-            else if (activeEditorPane instanceof TextDiffEditor) {
-                await commandService.executeCommand(DIFF_FOCUS_SECONDARY_SIDE);
-            }
-        }
-    });
-    registerAction2(class extends Action2 {
-        constructor() {
-            super({
-                id: FOCUS_SECOND_SIDE_EDITOR,
-                title: { value: ( localize('focusRightSideEditor', "Focus Second Side in Active Editor")), original: 'Focus Second Side in Active Editor' },
-                category: Categories.View,
-                precondition: ( ContextKeyExpr.or(SideBySideEditorActiveContext, TextCompareEditorActiveContext)),
-                f1: true
-            });
-        }
-        async run(accessor) {
-            const editorService = accessor.get(IEditorService);
-            const commandService = accessor.get(ICommandService);
-            const activeEditorPane = editorService.activeEditorPane;
-            if (activeEditorPane instanceof SideBySideEditor) {
-                activeEditorPane.getPrimaryEditorPane()?.focus();
-            }
-            else if (activeEditorPane instanceof TextDiffEditor) {
-                await commandService.executeCommand(DIFF_FOCUS_PRIMARY_SIDE);
-            }
-        }
-    });
-    registerAction2(class extends Action2 {
-        constructor() {
-            super({
-                id: FOCUS_OTHER_SIDE_EDITOR,
-                title: { value: ( localize('focusOtherSideEditor', "Focus Other Side in Active Editor")), original: 'Focus Other Side in Active Editor' },
-                category: Categories.View,
-                precondition: ( ContextKeyExpr.or(SideBySideEditorActiveContext, TextCompareEditorActiveContext)),
-                f1: true
-            });
-        }
-        async run(accessor) {
-            const editorService = accessor.get(IEditorService);
-            const commandService = accessor.get(ICommandService);
-            const activeEditorPane = editorService.activeEditorPane;
-            if (activeEditorPane instanceof SideBySideEditor) {
-                if (activeEditorPane.getPrimaryEditorPane()?.hasFocus()) {
-                    activeEditorPane.getSecondaryEditorPane()?.focus();
-                }
-                else {
-                    activeEditorPane.getPrimaryEditorPane()?.focus();
-                }
-            }
-            else if (activeEditorPane instanceof TextDiffEditor) {
-                await commandService.executeCommand(DIFF_FOCUS_OTHER_SIDE);
-            }
-        }
-    });
-}
-function registerOtherEditorCommands() {
-    KeybindingsRegistry.registerCommandAndKeybindingRule({
-        id: KEEP_EDITOR_COMMAND_ID,
-        weight: 200 ,
-        when: undefined,
-        primary: KeyChord(2048  | 41 , 3 ),
-        handler: async (accessor, resourceOrContext, context) => {
-            const editorGroupService = accessor.get(IEditorGroupsService);
-            const { group, editor } = resolveCommandsContext(editorGroupService, getCommandsContext(resourceOrContext, context));
-            if (group && editor) {
-                return group.pinEditor(editor);
-            }
-        }
-    });
-    CommandsRegistry.registerCommand({
-        id: TOGGLE_KEEP_EDITORS_COMMAND_ID,
-        handler: accessor => {
-            const configurationService = accessor.get(IConfigurationService);
-            const currentSetting = configurationService.getValue('workbench.editor.enablePreview');
-            const newSetting = currentSetting === true ? false : true;
-            configurationService.updateValue('workbench.editor.enablePreview', newSetting);
-        }
-    });
-    function setEditorGroupLock(accessor, resourceOrContext, context, locked) {
-        const editorGroupService = accessor.get(IEditorGroupsService);
-        const { group } = resolveCommandsContext(editorGroupService, getCommandsContext(resourceOrContext, context));
-        group?.lock(locked ?? !group.isLocked);
-    }
-    registerAction2(class extends Action2 {
-        constructor() {
-            super({
-                id: TOGGLE_LOCK_GROUP_COMMAND_ID,
-                title: { value: ( localize('toggleEditorGroupLock', "Toggle Editor Group Lock")), original: 'Toggle Editor Group Lock' },
-                category: Categories.View,
-                precondition: MultipleEditorGroupsContext,
-                f1: true
-            });
-        }
-        async run(accessor, resourceOrContext, context) {
-            setEditorGroupLock(accessor, resourceOrContext, context);
-        }
-    });
-    registerAction2(class extends Action2 {
-        constructor() {
-            super({
-                id: LOCK_GROUP_COMMAND_ID,
-                title: { value: ( localize('lockEditorGroup', "Lock Editor Group")), original: 'Lock Editor Group' },
-                category: Categories.View,
-                precondition: ( ContextKeyExpr.and(MultipleEditorGroupsContext, ( ActiveEditorGroupLockedContext.toNegated()))),
-                f1: true
-            });
-        }
-        async run(accessor, resourceOrContext, context) {
-            setEditorGroupLock(accessor, resourceOrContext, context, true);
-        }
-    });
-    registerAction2(class extends Action2 {
-        constructor() {
-            super({
-                id: UNLOCK_GROUP_COMMAND_ID,
-                title: { value: ( localize('unlockEditorGroup', "Unlock Editor Group")), original: 'Unlock Editor Group' },
-                precondition: ( ContextKeyExpr.and(MultipleEditorGroupsContext, ActiveEditorGroupLockedContext)),
-                category: Categories.View,
-                f1: true
-            });
-        }
-        async run(accessor, resourceOrContext, context) {
-            setEditorGroupLock(accessor, resourceOrContext, context, false);
-        }
-    });
-    KeybindingsRegistry.registerCommandAndKeybindingRule({
-        id: PIN_EDITOR_COMMAND_ID,
-        weight: 200 ,
-        when: ( ActiveEditorStickyContext.toNegated()),
-        primary: KeyChord(2048  | 41 , 1024  | 3 ),
-        handler: async (accessor, resourceOrContext, context) => {
-            const editorGroupService = accessor.get(IEditorGroupsService);
-            const { group, editor } = resolveCommandsContext(editorGroupService, getCommandsContext(resourceOrContext, context));
-            if (group && editor) {
-                return group.stickEditor(editor);
-            }
-        }
-    });
-    KeybindingsRegistry.registerCommandAndKeybindingRule({
-        id: DIFF_OPEN_SIDE,
-        weight: 200 ,
-        when: EditorContextKeys.inDiffEditor,
-        primary: KeyChord(2048  | 41 , 1024  | 45 ),
-        handler: async (accessor) => {
-            const editorService = accessor.get(IEditorService);
-            const editorGroupService = accessor.get(IEditorGroupsService);
-            const activeEditor = editorService.activeEditor;
-            const activeTextEditorControl = editorService.activeTextEditorControl;
-            if (!isDiffEditor(activeTextEditorControl) || !(activeEditor instanceof DiffEditorInput)) {
-                return;
-            }
-            let editor;
-            const originalEditor = activeTextEditorControl.getOriginalEditor();
-            if (originalEditor.hasTextFocus()) {
-                editor = activeEditor.original;
-            }
-            else {
-                editor = activeEditor.modified;
-            }
-            return editorGroupService.activeGroup.openEditor(editor);
-        }
-    });
-    KeybindingsRegistry.registerCommandAndKeybindingRule({
-        id: UNPIN_EDITOR_COMMAND_ID,
-        weight: 200 ,
-        when: ActiveEditorStickyContext,
-        primary: KeyChord(2048  | 41 , 1024  | 3 ),
-        handler: async (accessor, resourceOrContext, context) => {
-            const editorGroupService = accessor.get(IEditorGroupsService);
-            const { group, editor } = resolveCommandsContext(editorGroupService, getCommandsContext(resourceOrContext, context));
-            if (group && editor) {
-                return group.unstickEditor(editor);
-            }
-        }
-    });
-    KeybindingsRegistry.registerCommandAndKeybindingRule({
-        id: SHOW_EDITORS_IN_GROUP,
-        weight: 200 ,
-        when: undefined,
-        primary: undefined,
-        handler: (accessor, resourceOrContext, context) => {
-            const editorGroupService = accessor.get(IEditorGroupsService);
-            const quickInputService = accessor.get(IQuickInputService);
-            const commandsContext = getCommandsContext(resourceOrContext, context);
-            if (commandsContext && typeof commandsContext.groupId === 'number') {
-                const group = editorGroupService.getGroup(commandsContext.groupId);
-                if (group) {
-                    editorGroupService.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(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 getCommandsContext(resourceOrContext, context) {
-    if (URI.isUri(resourceOrContext)) {
-        return context;
-    }
-    if (resourceOrContext && typeof resourceOrContext.groupId === 'number') {
-        return resourceOrContext;
-    }
-    if (context && typeof context.groupId === 'number') {
-        return context;
-    }
-    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' ? withNullAsUndefined(group.getEditorByIndex(context.editorIndex)) : undefined;
-    if (!group) {
-        group = editorGroupService.activeGroup;
-    }
-    if (!editor) {
-        editor = withNullAsUndefined(group.activeEditor);
-    }
-    return { group, editor };
-}
 function getMultiSelectedEditorContexts(editorContext, listService, editorGroupService) {
     const list = listService.lastFocusedList;
     if (list instanceof List && list.getHTMLElement() === document.activeElement) {
@@ -1273,17 +167,6 @@ function getMultiSelectedEditorContexts(editorContext, listService, editorGroupS
     return !!editorContext ? [editorContext] : [];
 }
 function setup() {
-    registerActiveEditorMoveCopyCommand();
-    registerEditorGroupsLayoutCommands();
-    registerDiffEditorCommands();
     registerOpenEditorAPICommands();
-    registerOpenEditorAtIndexCommands();
-    registerCloseEditorCommands();
-    registerOtherEditorCommands();
-    registerSplitEditorInGroupCommands();
-    registerFocusSideEditorsCommands();
-    registerFocusEditorGroupAtIndexCommands();
-    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, DIFF_FOCUS_OTHER_SIDE, DIFF_FOCUS_PRIMARY_SIDE, DIFF_FOCUS_SECONDARY_SIDE, DIFF_OPEN_SIDE, 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, GOTO_NEXT_CHANGE, GOTO_PREVIOUS_CHANGE, JOIN_EDITOR_IN_GROUP, KEEP_EDITOR_COMMAND_ID, LAYOUT_EDITOR_GROUPS_COMMAND_ID, LOCK_GROUP_COMMAND_ID, MOVE_ACTIVE_EDITOR_COMMAND_ID, OPEN_EDITOR_AT_INDEX_COMMAND_ID, PIN_EDITOR_COMMAND_ID, REOPEN_WITH_COMMAND_ID, SHOW_EDITORS_IN_GROUP, SPLIT_EDITOR_DOWN, SPLIT_EDITOR_IN_GROUP, SPLIT_EDITOR_LEFT, SPLIT_EDITOR_RIGHT, SPLIT_EDITOR_UP, TOGGLE_DIFF_IGNORE_TRIM_WHITESPACE, TOGGLE_DIFF_SIDE_BY_SIDE, TOGGLE_KEEP_EDITORS_COMMAND_ID, TOGGLE_LOCK_GROUP_COMMAND_ID, TOGGLE_SPLIT_EDITOR_IN_GROUP, TOGGLE_SPLIT_EDITOR_IN_GROUP_LAYOUT, UNLOCK_GROUP_COMMAND_ID, UNPIN_EDITOR_COMMAND_ID, getMultiSelectedEditorContexts, 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_EDITOR_COMMAND_ID, COPY_ACTIVE_EDITOR_COMMAND_ID, LAYOUT_EDITOR_GROUPS_COMMAND_ID, SPLIT_EDITOR_DOWN, SPLIT_EDITOR_UP, TOGGLE_DIFF_IGNORE_TRIM_WHITESPACE, UNPIN_EDITOR_COMMAND_ID, getMultiSelectedEditorContexts, setup, splitEditor };