@codingame/monaco-vscode-api 1.79.0-next.0 → 1.79.1

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

@@ -2,12 +2,14 @@ import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
 import { firstOrDefault } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { EditorResourceAccessor, DEFAULT_EDITOR_ASSOCIATION } from '../../../common/editor.js';
 import { SideBySideEditorInput } from '../../../common/editor/sideBySideEditorInput.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
 import { IHistoryService } from '../../../services/history/common/history.js';
 import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
 import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { SPLIT_EDITOR_UP, SPLIT_EDITOR_DOWN, CLOSE_EDITOR_COMMAND_ID, UNPIN_EDITOR_COMMAND_ID, COPY_ACTIVE_EDITOR_COMMAND_ID, LAYOUT_EDITOR_GROUPS_COMMAND_ID, splitEditor } from './editorCommands.js';
-import { IEditorGroupsService, preferredSideBySideGroupDirection } from '../../../services/editor/common/editorGroupsService.js';
+import { SPLIT_EDITOR_LEFT, SPLIT_EDITOR_RIGHT, SPLIT_EDITOR_UP, SPLIT_EDITOR_DOWN, CLOSE_EDITOR_COMMAND_ID, UNPIN_EDITOR_COMMAND_ID, MOVE_ACTIVE_EDITOR_COMMAND_ID, COPY_ACTIVE_EDITOR_COMMAND_ID, LAYOUT_EDITOR_GROUPS_COMMAND_ID, splitEditor } from './editorCommands.js';
+import { preferredSideBySideGroupDirection, IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
 import { IEditorService } from '../../../services/editor/common/editorService.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { IWorkspacesService } from '../../../../platform/workspaces/common/workspaces.js';
@@ -17,11 +19,14 @@ import { ActiveGroupEditorsByMostRecentlyUsedQuickAccess, AllEditorsByAppearance
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
 import { IFilesConfigurationService } from '../../../services/filesConfiguration/common/filesConfigurationService.js';
+import { IEditorResolverService } from '../../../services/editor/common/editorResolverService.js';
 import { isNative, isWindows, isLinux } from 'monaco-editor/esm/vs/base/common/platform.js';
 import { Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { KeyChord } from 'monaco-editor/esm/vs/base/common/keyCodes.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
+import { ActiveEditorGroupEmptyContext, ActiveEditorAvailableEditorIdsContext } from '../../../common/contextkeys.js';
 class ExecuteCommandAction extends Action2 {
     constructor(desc, commandId, commandArgs) {
         super(desc);
@@ -58,6 +63,52 @@ class SplitEditorAction extends AbstractSplitEditorAction {
     }
 }
 SplitEditorAction.ID = 'workbench.action.splitEditor';
+class SplitEditorOrthogonalAction extends AbstractSplitEditorAction {
+    constructor() {
+        super({
+            id: 'workbench.action.splitEditorOrthogonal',
+            title: { value: ( localize('splitEditorOrthogonal', "Split Editor Orthogonal")), original: 'Split Editor Orthogonal' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 41 , 2048  | 93 )
+            },
+            category: Categories.View
+        });
+    }
+    getDirection(configurationService) {
+        const direction = preferredSideBySideGroupDirection(configurationService);
+        return direction === 3  ? 1  : 3 ;
+    }
+}
+class SplitEditorLeftAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            id: SPLIT_EDITOR_LEFT,
+            title: { value: ( localize('splitEditorGroupLeft', "Split Editor Left")), original: 'Split Editor Left' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 41 , 2048  | 93 )
+            },
+            category: Categories.View
+        }, SPLIT_EDITOR_LEFT);
+    }
+}
+class SplitEditorRightAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            id: SPLIT_EDITOR_RIGHT,
+            title: { value: ( localize('splitEditorGroupRight', "Split Editor Right")), original: 'Split Editor Right' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 41 , 2048  | 93 )
+            },
+            category: Categories.View
+        }, SPLIT_EDITOR_RIGHT);
+    }
+}
 class SplitEditorUpAction extends ExecuteCommandAction {
     constructor() {
         super({
@@ -88,6 +139,190 @@ class SplitEditorDownAction extends ExecuteCommandAction {
     }
 }
 SplitEditorDownAction.LABEL = ( localize('splitEditorGroupDown', "Split Editor Down"));
+class JoinTwoGroupsAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.joinTwoGroups',
+            title: { value: ( localize('joinTwoGroups', "Join Editor Group with Next Group")), original: 'Join Editor Group with Next Group' },
+            f1: true,
+            category: Categories.View
+        });
+    }
+    async run(accessor, context) {
+        const editorGroupService = accessor.get(IEditorGroupsService);
+        let sourceGroup;
+        if (context && typeof context.groupId === 'number') {
+            sourceGroup = editorGroupService.getGroup(context.groupId);
+        }
+        else {
+            sourceGroup = editorGroupService.activeGroup;
+        }
+        if (sourceGroup) {
+            const targetGroupDirections = [3 , 1 , 2 , 0 ];
+            for (const targetGroupDirection of targetGroupDirections) {
+                const targetGroup = editorGroupService.findGroup({ direction: targetGroupDirection }, sourceGroup);
+                if (targetGroup && sourceGroup !== targetGroup) {
+                    editorGroupService.mergeGroup(sourceGroup, targetGroup);
+                    break;
+                }
+            }
+        }
+    }
+}
+class JoinAllGroupsAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.joinAllGroups',
+            title: { value: ( localize('joinAllGroups', "Join All Editor Groups")), original: 'Join All Editor Groups' },
+            f1: true,
+            category: Categories.View
+        });
+    }
+    async run(accessor) {
+        const editorGroupService = accessor.get(IEditorGroupsService);
+        editorGroupService.mergeAllGroups();
+    }
+}
+class NavigateBetweenGroupsAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.navigateEditorGroups',
+            title: { value: ( localize('navigateEditorGroups', "Navigate Between Editor Groups")), original: 'Navigate Between Editor Groups' },
+            f1: true,
+            category: Categories.View
+        });
+    }
+    async run(accessor) {
+        const editorGroupService = accessor.get(IEditorGroupsService);
+        const nextGroup = editorGroupService.findGroup({ location: 2  }, editorGroupService.activeGroup, true);
+        nextGroup?.focus();
+    }
+}
+class FocusActiveGroupAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.focusActiveEditorGroup',
+            title: { value: ( localize('focusActiveEditorGroup', "Focus Active Editor Group")), original: 'Focus Active Editor Group' },
+            f1: true,
+            category: Categories.View
+        });
+    }
+    async run(accessor) {
+        const editorGroupService = accessor.get(IEditorGroupsService);
+        editorGroupService.activeGroup.focus();
+    }
+}
+class AbstractFocusGroupAction extends Action2 {
+    constructor(desc, scope) {
+        super(desc);
+        this.scope = scope;
+    }
+    async run(accessor) {
+        const editorGroupService = accessor.get(IEditorGroupsService);
+        const group = editorGroupService.findGroup(this.scope, editorGroupService.activeGroup, true);
+        group?.focus();
+    }
+}
+class FocusFirstGroupAction extends AbstractFocusGroupAction {
+    constructor() {
+        super({
+            id: 'workbench.action.focusFirstEditorGroup',
+            title: { value: ( localize('focusFirstEditorGroup', "Focus First Editor Group")), original: 'Focus First Editor Group' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: 2048  | 22
+            },
+            category: Categories.View
+        }, { location: 0  });
+    }
+}
+class FocusLastGroupAction extends AbstractFocusGroupAction {
+    constructor() {
+        super({
+            id: 'workbench.action.focusLastEditorGroup',
+            title: { value: ( localize('focusLastEditorGroup', "Focus Last Editor Group")), original: 'Focus Last Editor Group' },
+            f1: true,
+            category: Categories.View
+        }, { location: 1  });
+    }
+}
+class FocusNextGroup extends AbstractFocusGroupAction {
+    constructor() {
+        super({
+            id: 'workbench.action.focusNextGroup',
+            title: { value: ( localize('focusNextGroup', "Focus Next Editor Group")), original: 'Focus Next Editor Group' },
+            f1: true,
+            category: Categories.View
+        }, { location: 2  });
+    }
+}
+class FocusPreviousGroup extends AbstractFocusGroupAction {
+    constructor() {
+        super({
+            id: 'workbench.action.focusPreviousGroup',
+            title: { value: ( localize('focusPreviousGroup', "Focus Previous Editor Group")), original: 'Focus Previous Editor Group' },
+            f1: true,
+            category: Categories.View
+        }, { location: 3  });
+    }
+}
+class FocusLeftGroup extends AbstractFocusGroupAction {
+    constructor() {
+        super({
+            id: 'workbench.action.focusLeftGroup',
+            title: { value: ( localize('focusLeftGroup', "Focus Left Editor Group")), original: 'Focus Left Editor Group' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 41 , 2048  | 15 )
+            },
+            category: Categories.View
+        }, { direction: 2  });
+    }
+}
+class FocusRightGroup extends AbstractFocusGroupAction {
+    constructor() {
+        super({
+            id: 'workbench.action.focusRightGroup',
+            title: { value: ( localize('focusRightGroup', "Focus Right Editor Group")), original: 'Focus Right Editor Group' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 41 , 2048  | 17 )
+            },
+            category: Categories.View
+        }, { direction: 3  });
+    }
+}
+class FocusAboveGroup extends AbstractFocusGroupAction {
+    constructor() {
+        super({
+            id: 'workbench.action.focusAboveGroup',
+            title: { value: ( localize('focusAboveGroup', "Focus Editor Group Above")), original: 'Focus Editor Group Above' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 41 , 2048  | 16 )
+            },
+            category: Categories.View
+        }, { direction: 0  });
+    }
+}
+class FocusBelowGroup extends AbstractFocusGroupAction {
+    constructor() {
+        super({
+            id: 'workbench.action.focusBelowGroup',
+            title: { value: ( localize('focusBelowGroup', "Focus Editor Group Below")), original: 'Focus Editor Group Below' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 41 , 2048  | 18 )
+            },
+            category: Categories.View
+        }, { direction: 1  });
+    }
+}
 let CloseEditorAction = class CloseEditorAction extends Action {
     constructor(id, label, commandService) {
         super(id, label, ThemeIcon.asClassName(Codicon.close));
@@ -151,6 +386,56 @@ CloseOneEditorAction.LABEL = ( localize('closeOneEditor', "Close"));
 CloseOneEditorAction = ( __decorate([
     ( __param(2, IEditorGroupsService))
 ], CloseOneEditorAction));
+class RevertAndCloseEditorAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.revertAndCloseActiveEditor',
+            title: { value: ( localize('revertAndCloseActiveEditor', "Revert and Close Editor")), original: 'Revert and Close Editor' },
+            f1: true,
+            category: Categories.View
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const logService = accessor.get(ILogService);
+        const activeEditorPane = editorService.activeEditorPane;
+        if (activeEditorPane) {
+            const editor = activeEditorPane.input;
+            const group = activeEditorPane.group;
+            try {
+                await editorService.revert({ editor, groupId: group.id });
+            }
+            catch (error) {
+                logService.error(error);
+                await editorService.revert({ editor, groupId: group.id }, { soft: true });
+            }
+            await group.closeEditor(editor);
+        }
+    }
+}
+class CloseLeftEditorsInGroupAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.closeEditorsToTheLeft',
+            title: { value: ( localize('closeEditorsToTheLeft', "Close Editors to the Left in Group")), original: 'Close Editors to the Left in Group' },
+            f1: true,
+            category: Categories.View
+        });
+    }
+    async run(accessor, context) {
+        const editorGroupService = accessor.get(IEditorGroupsService);
+        const { group, editor } = this.getTarget(editorGroupService, context);
+        if (group && editor) {
+            await group.closeEditors({ direction: 0 , except: editor, excludeSticky: true });
+        }
+    }
+    getTarget(editorGroupService, context) {
+        if (context) {
+            return { editor: context.editor, group: editorGroupService.getGroup(context.groupId) };
+        }
+        return { group: editorGroupService.activeGroup, editor: editorGroupService.activeGroup.activeEditor };
+    }
+}
 class AbstractCloseAllAction extends Action2 {
     groupsToClose(editorGroupService) {
         const groupsToClose = [];
@@ -284,97 +569,937 @@ class CloseAllEditorsAction extends AbstractCloseAllAction {
 }
 CloseAllEditorsAction.ID = 'workbench.action.closeAllEditors';
 CloseAllEditorsAction.LABEL = { value: ( localize('closeAllEditors', "Close All Editors")), original: 'Close All Editors' };
-class NavigateForwardAction extends Action2 {
+class CloseAllEditorGroupsAction extends AbstractCloseAllAction {
     constructor() {
         super({
-            id: NavigateForwardAction.ID,
-            title: { value: ( localize('navigateForward', "Go Forward")), original: 'Go Forward', mnemonicTitle: ( localize({ key: 'miForward', comment: ['&& denotes a mnemonic'] }, "&&Forward")) },
+            id: 'workbench.action.closeAllGroups',
+            title: { value: ( localize('closeAllGroups', "Close All Editor Groups")), original: 'Close All Editor Groups' },
             f1: true,
-            icon: Codicon.arrowRight,
-            precondition: ( ContextKeyExpr.has('canNavigateForward')),
             keybinding: {
                 weight: 200 ,
-                win: { primary: 512  | 17  },
-                mac: { primary: 256  | 1024  | 88  },
-                linux: { primary: 2048  | 1024  | 88  }
+                primary: KeyChord(2048  | 41 , 2048  | 1024  | 53 )
             },
-            menu: [
-                { id: MenuId.MenubarGoMenu, group: '1_history_nav', order: 2 },
-                { id: MenuId.CommandCenter, order: 2 }
-            ]
+            category: Categories.View
         });
     }
-    async run(accessor) {
-        const historyService = accessor.get(IHistoryService);
-        await historyService.goForward(0 );
+    get excludeSticky() {
+        return false;
+    }
+    async doCloseAll(editorGroupService) {
+        await super.doCloseAll(editorGroupService);
+        for (const groupToClose of this.groupsToClose(editorGroupService)) {
+            editorGroupService.removeGroup(groupToClose);
+        }
     }
 }
-NavigateForwardAction.ID = 'workbench.action.navigateForward';
-NavigateForwardAction.LABEL = ( localize('navigateForward', "Go Forward"));
-class NavigateBackwardsAction extends Action2 {
+class CloseEditorsInOtherGroupsAction extends Action2 {
     constructor() {
         super({
-            id: NavigateBackwardsAction.ID,
-            title: { value: ( localize('navigateBack', "Go Back")), original: 'Go Back', mnemonicTitle: ( localize({ key: 'miBack', comment: ['&& denotes a mnemonic'] }, "&&Back")) },
+            id: 'workbench.action.closeEditorsInOtherGroups',
+            title: { value: ( localize('closeEditorsInOtherGroups', "Close Editors in Other Groups")), original: 'Close Editors in Other Groups' },
             f1: true,
-            precondition: ( ContextKeyExpr.has('canNavigateBack')),
-            icon: Codicon.arrowLeft,
-            keybinding: {
-                weight: 200 ,
-                win: { primary: 512  | 15  },
-                mac: { primary: 256  | 88  },
-                linux: { primary: 2048  | 512  | 88  }
-            },
-            menu: [
-                { id: MenuId.MenubarGoMenu, group: '1_history_nav', order: 1 },
-                { id: MenuId.CommandCenter, order: 1 }
-            ]
+            category: Categories.View
         });
     }
-    async run(accessor) {
-        const historyService = accessor.get(IHistoryService);
-        await historyService.goBack(0 );
+    async run(accessor, context) {
+        const editorGroupService = accessor.get(IEditorGroupsService);
+        const groupToSkip = context ? editorGroupService.getGroup(context.groupId) : editorGroupService.activeGroup;
+        await Promise.all(( editorGroupService.getGroups(1 ).map(async (group) => {
+            if (groupToSkip && group.id === groupToSkip.id) {
+                return;
+            }
+            return group.closeAllEditors({ excludeSticky: true });
+        })));
     }
 }
-NavigateBackwardsAction.ID = 'workbench.action.navigateBack';
-NavigateBackwardsAction.LABEL = ( localize('navigateBack', "Go Back"));
-class ReopenClosedEditorAction extends Action2 {
+class CloseEditorInAllGroupsAction extends Action2 {
     constructor() {
         super({
-            id: ReopenClosedEditorAction.ID,
-            title: { value: ( localize('reopenClosedEditor', "Reopen Closed Editor")), original: 'Reopen Closed Editor' },
+            id: 'workbench.action.closeEditorInAllGroups',
+            title: { value: ( localize('closeEditorInAllGroups', "Close Editor in All Groups")), original: 'Close Editor in All Groups' },
             f1: true,
-            keybinding: {
-                weight: 200 ,
-                primary: 2048  | 1024  | 50
-            },
             category: Categories.View
         });
     }
     async run(accessor) {
-        const historyService = accessor.get(IHistoryService);
-        await historyService.reopenLastClosedEditor();
+        const editorService = accessor.get(IEditorService);
+        const editorGroupService = accessor.get(IEditorGroupsService);
+        const activeEditor = editorService.activeEditor;
+        if (activeEditor) {
+            await Promise.all(( editorGroupService.getGroups(1 ).map(group => group.closeEditor(activeEditor))));
+        }
     }
 }
-ReopenClosedEditorAction.ID = 'workbench.action.reopenClosedEditor';
-class ClearRecentFilesAction extends Action2 {
+class AbstractMoveCopyGroupAction extends Action2 {
+    constructor(desc, direction, isMove) {
+        super(desc);
+        this.direction = direction;
+        this.isMove = isMove;
+    }
+    async run(accessor, context) {
+        const editorGroupService = accessor.get(IEditorGroupsService);
+        let sourceGroup;
+        if (context && typeof context.groupId === 'number') {
+            sourceGroup = editorGroupService.getGroup(context.groupId);
+        }
+        else {
+            sourceGroup = editorGroupService.activeGroup;
+        }
+        if (sourceGroup) {
+            let resultGroup = undefined;
+            if (this.isMove) {
+                const targetGroup = this.findTargetGroup(editorGroupService, sourceGroup);
+                if (targetGroup) {
+                    resultGroup = editorGroupService.moveGroup(sourceGroup, targetGroup, this.direction);
+                }
+            }
+            else {
+                resultGroup = editorGroupService.copyGroup(sourceGroup, sourceGroup, this.direction);
+            }
+            if (resultGroup) {
+                editorGroupService.activateGroup(resultGroup);
+            }
+        }
+    }
+    findTargetGroup(editorGroupService, sourceGroup) {
+        const targetNeighbours = [this.direction];
+        switch (this.direction) {
+            case 2 :
+            case 3 :
+                targetNeighbours.push(0 , 1 );
+                break;
+            case 0 :
+            case 1 :
+                targetNeighbours.push(2 , 3 );
+                break;
+        }
+        for (const targetNeighbour of targetNeighbours) {
+            const targetNeighbourGroup = editorGroupService.findGroup({ direction: targetNeighbour }, sourceGroup);
+            if (targetNeighbourGroup) {
+                return targetNeighbourGroup;
+            }
+        }
+        return undefined;
+    }
+}
+class AbstractMoveGroupAction extends AbstractMoveCopyGroupAction {
+    constructor(desc, direction) {
+        super(desc, direction, true);
+    }
+}
+class MoveGroupLeftAction extends AbstractMoveGroupAction {
+    constructor() {
+        super({
+            id: 'workbench.action.moveActiveEditorGroupLeft',
+            title: { value: ( localize('moveActiveGroupLeft', "Move Editor Group Left")), original: 'Move Editor Group Left' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 41 , 15 )
+            },
+            category: Categories.View
+        }, 2 );
+    }
+}
+class MoveGroupRightAction extends AbstractMoveGroupAction {
+    constructor() {
+        super({
+            id: 'workbench.action.moveActiveEditorGroupRight',
+            title: { value: ( localize('moveActiveGroupRight', "Move Editor Group Right")), original: 'Move Editor Group Right' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 41 , 17 )
+            },
+            category: Categories.View
+        }, 3 );
+    }
+}
+class MoveGroupUpAction extends AbstractMoveGroupAction {
+    constructor() {
+        super({
+            id: 'workbench.action.moveActiveEditorGroupUp',
+            title: { value: ( localize('moveActiveGroupUp', "Move Editor Group Up")), original: 'Move Editor Group Up' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 41 , 16 )
+            },
+            category: Categories.View
+        }, 0 );
+    }
+}
+class MoveGroupDownAction extends AbstractMoveGroupAction {
+    constructor() {
+        super({
+            id: 'workbench.action.moveActiveEditorGroupDown',
+            title: { value: ( localize('moveActiveGroupDown', "Move Editor Group Down")), original: 'Move Editor Group Down' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 41 , 18 )
+            },
+            category: Categories.View
+        }, 1 );
+    }
+}
+class AbstractDuplicateGroupAction extends AbstractMoveCopyGroupAction {
+    constructor(desc, direction) {
+        super(desc, direction, false);
+    }
+}
+class DuplicateGroupLeftAction extends AbstractDuplicateGroupAction {
+    constructor() {
+        super({
+            id: 'workbench.action.duplicateActiveEditorGroupLeft',
+            title: { value: ( localize('duplicateActiveGroupLeft', "Duplicate Editor Group Left")), original: 'Duplicate Editor Group Left' },
+            f1: true,
+            category: Categories.View
+        }, 2 );
+    }
+}
+class DuplicateGroupRightAction extends AbstractDuplicateGroupAction {
+    constructor() {
+        super({
+            id: 'workbench.action.duplicateActiveEditorGroupRight',
+            title: { value: ( localize('duplicateActiveGroupRight', "Duplicate Editor Group Right")), original: 'Duplicate Editor Group Right' },
+            f1: true,
+            category: Categories.View
+        }, 3 );
+    }
+}
+class DuplicateGroupUpAction extends AbstractDuplicateGroupAction {
+    constructor() {
+        super({
+            id: 'workbench.action.duplicateActiveEditorGroupUp',
+            title: { value: ( localize('duplicateActiveGroupUp', "Duplicate Editor Group Up")), original: 'Duplicate Editor Group Up' },
+            f1: true,
+            category: Categories.View
+        }, 0 );
+    }
+}
+class DuplicateGroupDownAction extends AbstractDuplicateGroupAction {
+    constructor() {
+        super({
+            id: 'workbench.action.duplicateActiveEditorGroupDown',
+            title: { value: ( localize('duplicateActiveGroupDown', "Duplicate Editor Group Down")), original: 'Duplicate Editor Group Down' },
+            f1: true,
+            category: Categories.View
+        }, 1 );
+    }
+}
+class MinimizeOtherGroupsAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.minimizeOtherEditors',
+            title: { value: ( localize('minimizeOtherEditorGroups', "Maximize Editor Group")), original: 'Maximize Editor Group' },
+            f1: true,
+            category: Categories.View
+        });
+    }
+    async run(accessor) {
+        const editorGroupService = accessor.get(IEditorGroupsService);
+        editorGroupService.arrangeGroups(0 );
+    }
+}
+class ResetGroupSizesAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.evenEditorWidths',
+            title: { value: ( localize('evenEditorGroups', "Reset Editor Group Sizes")), original: 'Reset Editor Group Sizes' },
+            f1: true,
+            category: Categories.View
+        });
+    }
+    async run(accessor) {
+        const editorGroupService = accessor.get(IEditorGroupsService);
+        editorGroupService.arrangeGroups(1 );
+    }
+}
+class ToggleGroupSizesAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.toggleEditorWidths',
+            title: { value: ( localize('toggleEditorWidths', "Toggle Editor Group Sizes")), original: 'Toggle Editor Group Sizes' },
+            f1: true,
+            category: Categories.View
+        });
+    }
+    async run(accessor) {
+        const editorGroupService = accessor.get(IEditorGroupsService);
+        editorGroupService.arrangeGroups(2 );
+    }
+}
+class MaximizeGroupAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.maximizeEditor',
+            title: { value: ( localize('maximizeEditor', "Maximize Editor Group and Hide Side Bars")), original: 'Maximize Editor Group and Hide Side Bars' },
+            f1: true,
+            category: Categories.View
+        });
+    }
+    async run(accessor) {
+        const layoutService = accessor.get(IWorkbenchLayoutService);
+        const editorGroupService = accessor.get(IEditorGroupsService);
+        const editorService = accessor.get(IEditorService);
+        if (editorService.activeEditor) {
+            layoutService.setPartHidden(true, "workbench.parts.sidebar" );
+            layoutService.setPartHidden(true, "workbench.parts.auxiliarybar" );
+            editorGroupService.arrangeGroups(0 );
+        }
+    }
+}
+class AbstractNavigateEditorAction extends Action2 {
+    async run(accessor) {
+        const editorGroupService = accessor.get(IEditorGroupsService);
+        const result = this.navigate(editorGroupService);
+        if (!result) {
+            return;
+        }
+        const { groupId, editor } = result;
+        if (!editor) {
+            return;
+        }
+        const group = editorGroupService.getGroup(groupId);
+        if (group) {
+            await group.openEditor(editor);
+        }
+    }
+}
+class OpenNextEditor extends AbstractNavigateEditorAction {
+    constructor() {
+        super({
+            id: 'workbench.action.nextEditor',
+            title: { value: ( localize('openNextEditor', "Open Next Editor")), original: 'Open Next Editor' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: 2048  | 12 ,
+                mac: {
+                    primary: 2048  | 512  | 17 ,
+                    secondary: [2048  | 1024  | 94 ]
+                }
+            },
+            category: Categories.View
+        });
+    }
+    navigate(editorGroupService) {
+        const activeGroup = editorGroupService.activeGroup;
+        const activeGroupEditors = activeGroup.getEditors(1 );
+        const activeEditorIndex = activeGroup.activeEditor ? activeGroupEditors.indexOf(activeGroup.activeEditor) : -1;
+        if (activeEditorIndex + 1 < activeGroupEditors.length) {
+            return { editor: activeGroupEditors[activeEditorIndex + 1], groupId: activeGroup.id };
+        }
+        const handledGroups = ( new Set());
+        let currentGroup = editorGroupService.activeGroup;
+        while (currentGroup && !( handledGroups.has(currentGroup.id))) {
+            currentGroup = editorGroupService.findGroup({ location: 2  }, currentGroup, true);
+            if (currentGroup) {
+                handledGroups.add(currentGroup.id);
+                const groupEditors = currentGroup.getEditors(1 );
+                if (groupEditors.length > 0) {
+                    return { editor: groupEditors[0], groupId: currentGroup.id };
+                }
+            }
+        }
+        return undefined;
+    }
+}
+class OpenPreviousEditor extends AbstractNavigateEditorAction {
+    constructor() {
+        super({
+            id: 'workbench.action.previousEditor',
+            title: { value: ( localize('openPreviousEditor', "Open Previous Editor")), original: 'Open Previous Editor' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: 2048  | 11 ,
+                mac: {
+                    primary: 2048  | 512  | 15 ,
+                    secondary: [2048  | 1024  | 92 ]
+                }
+            },
+            category: Categories.View
+        });
+    }
+    navigate(editorGroupService) {
+        const activeGroup = editorGroupService.activeGroup;
+        const activeGroupEditors = activeGroup.getEditors(1 );
+        const activeEditorIndex = activeGroup.activeEditor ? activeGroupEditors.indexOf(activeGroup.activeEditor) : -1;
+        if (activeEditorIndex > 0) {
+            return { editor: activeGroupEditors[activeEditorIndex - 1], groupId: activeGroup.id };
+        }
+        const handledGroups = ( new Set());
+        let currentGroup = editorGroupService.activeGroup;
+        while (currentGroup && !( handledGroups.has(currentGroup.id))) {
+            currentGroup = editorGroupService.findGroup({ location: 3  }, currentGroup, true);
+            if (currentGroup) {
+                handledGroups.add(currentGroup.id);
+                const groupEditors = currentGroup.getEditors(1 );
+                if (groupEditors.length > 0) {
+                    return { editor: groupEditors[groupEditors.length - 1], groupId: currentGroup.id };
+                }
+            }
+        }
+        return undefined;
+    }
+}
+class OpenNextEditorInGroup extends AbstractNavigateEditorAction {
+    constructor() {
+        super({
+            id: 'workbench.action.nextEditorInGroup',
+            title: { value: ( localize('nextEditorInGroup', "Open Next Editor in Group")), original: 'Open Next Editor in Group' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 41 , 2048  | 12 ),
+                mac: {
+                    primary: KeyChord(2048  | 41 , 2048  | 512  | 17 )
+                }
+            },
+            category: Categories.View
+        });
+    }
+    navigate(editorGroupService) {
+        const group = editorGroupService.activeGroup;
+        const editors = group.getEditors(1 );
+        const index = group.activeEditor ? editors.indexOf(group.activeEditor) : -1;
+        return { editor: index + 1 < editors.length ? editors[index + 1] : editors[0], groupId: group.id };
+    }
+}
+class OpenPreviousEditorInGroup extends AbstractNavigateEditorAction {
+    constructor() {
+        super({
+            id: 'workbench.action.previousEditorInGroup',
+            title: { value: ( localize('openPreviousEditorInGroup', "Open Previous Editor in Group")), original: 'Open Previous Editor in Group' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 41 , 2048  | 11 ),
+                mac: {
+                    primary: KeyChord(2048  | 41 , 2048  | 512  | 15 )
+                }
+            },
+            category: Categories.View
+        });
+    }
+    navigate(editorGroupService) {
+        const group = editorGroupService.activeGroup;
+        const editors = group.getEditors(1 );
+        const index = group.activeEditor ? editors.indexOf(group.activeEditor) : -1;
+        return { editor: index > 0 ? editors[index - 1] : editors[editors.length - 1], groupId: group.id };
+    }
+}
+class OpenFirstEditorInGroup extends AbstractNavigateEditorAction {
+    constructor() {
+        super({
+            id: 'workbench.action.firstEditorInGroup',
+            title: { value: ( localize('firstEditorInGroup', "Open First Editor in Group")), original: 'Open First Editor in Group' },
+            f1: true,
+            category: Categories.View
+        });
+    }
+    navigate(editorGroupService) {
+        const group = editorGroupService.activeGroup;
+        const editors = group.getEditors(1 );
+        return { editor: editors[0], groupId: group.id };
+    }
+}
+class OpenLastEditorInGroup extends AbstractNavigateEditorAction {
+    constructor() {
+        super({
+            id: 'workbench.action.lastEditorInGroup',
+            title: { value: ( localize('lastEditorInGroup', "Open Last Editor in Group")), original: 'Open Last Editor in Group' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: 512  | 21 ,
+                secondary: [2048  | 30 ],
+                mac: {
+                    primary: 256  | 21 ,
+                    secondary: [2048  | 30 ]
+                }
+            },
+            category: Categories.View
+        });
+    }
+    navigate(editorGroupService) {
+        const group = editorGroupService.activeGroup;
+        const editors = group.getEditors(1 );
+        return { editor: editors[editors.length - 1], groupId: group.id };
+    }
+}
+class NavigateForwardAction extends Action2 {
+    constructor() {
+        super({
+            id: NavigateForwardAction.ID,
+            title: { value: ( localize('navigateForward', "Go Forward")), original: 'Go Forward', mnemonicTitle: ( localize({ key: 'miForward', comment: ['&& denotes a mnemonic'] }, "&&Forward")) },
+            f1: true,
+            icon: Codicon.arrowRight,
+            precondition: ( ContextKeyExpr.has('canNavigateForward')),
+            keybinding: {
+                weight: 200 ,
+                win: { primary: 512  | 17  },
+                mac: { primary: 256  | 1024  | 88  },
+                linux: { primary: 2048  | 1024  | 88  }
+            },
+            menu: [
+                { id: MenuId.MenubarGoMenu, group: '1_history_nav', order: 2 },
+                { id: MenuId.CommandCenter, order: 2 }
+            ]
+        });
+    }
+    async run(accessor) {
+        const historyService = accessor.get(IHistoryService);
+        await historyService.goForward(0 );
+    }
+}
+NavigateForwardAction.ID = 'workbench.action.navigateForward';
+NavigateForwardAction.LABEL = ( localize('navigateForward', "Go Forward"));
+class NavigateBackwardsAction extends Action2 {
+    constructor() {
+        super({
+            id: NavigateBackwardsAction.ID,
+            title: { value: ( localize('navigateBack', "Go Back")), original: 'Go Back', mnemonicTitle: ( localize({ key: 'miBack', comment: ['&& denotes a mnemonic'] }, "&&Back")) },
+            f1: true,
+            precondition: ( ContextKeyExpr.has('canNavigateBack')),
+            icon: Codicon.arrowLeft,
+            keybinding: {
+                weight: 200 ,
+                win: { primary: 512  | 15  },
+                mac: { primary: 256  | 88  },
+                linux: { primary: 2048  | 512  | 88  }
+            },
+            menu: [
+                { id: MenuId.MenubarGoMenu, group: '1_history_nav', order: 1 },
+                { id: MenuId.CommandCenter, order: 1 }
+            ]
+        });
+    }
+    async run(accessor) {
+        const historyService = accessor.get(IHistoryService);
+        await historyService.goBack(0 );
+    }
+}
+NavigateBackwardsAction.ID = 'workbench.action.navigateBack';
+NavigateBackwardsAction.LABEL = ( localize('navigateBack', "Go Back"));
+class NavigatePreviousAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.navigateLast',
+            title: { value: ( localize('navigatePrevious', "Go Previous")), original: 'Go Previous' },
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const historyService = accessor.get(IHistoryService);
+        await historyService.goPrevious(0 );
+    }
+}
+class NavigateForwardInEditsAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.navigateForwardInEditLocations',
+            title: { value: ( localize('navigateForwardInEdits', "Go Forward in Edit Locations")), original: 'Go Forward in Edit Locations' },
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const historyService = accessor.get(IHistoryService);
+        await historyService.goForward(1 );
+    }
+}
+class NavigateBackwardsInEditsAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.navigateBackInEditLocations',
+            title: { value: ( localize('navigateBackInEdits', "Go Back in Edit Locations")), original: 'Go Back in Edit Locations' },
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const historyService = accessor.get(IHistoryService);
+        await historyService.goBack(1 );
+    }
+}
+class NavigatePreviousInEditsAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.navigatePreviousInEditLocations',
+            title: { value: ( localize('navigatePreviousInEdits', "Go Previous in Edit Locations")), original: 'Go Previous in Edit Locations' },
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const historyService = accessor.get(IHistoryService);
+        await historyService.goPrevious(1 );
+    }
+}
+class NavigateToLastEditLocationAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.navigateToLastEditLocation',
+            title: { value: ( localize('navigateToLastEditLocation', "Go to Last Edit Location")), original: 'Go to Last Edit Location' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 41 , 2048  | 47 )
+            }
+        });
+    }
+    async run(accessor) {
+        const historyService = accessor.get(IHistoryService);
+        await historyService.goLast(1 );
+    }
+}
+class NavigateForwardInNavigationsAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.navigateForwardInNavigationLocations',
+            title: { value: ( localize('navigateForwardInNavigations', "Go Forward in Navigation Locations")), original: 'Go Forward in Navigation Locations' },
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const historyService = accessor.get(IHistoryService);
+        await historyService.goForward(2 );
+    }
+}
+class NavigateBackwardsInNavigationsAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.navigateBackInNavigationLocations',
+            title: { value: ( localize('navigateBackInNavigations', "Go Back in Navigation Locations")), original: 'Go Back in Navigation Locations' },
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const historyService = accessor.get(IHistoryService);
+        await historyService.goBack(2 );
+    }
+}
+class NavigatePreviousInNavigationsAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.navigatePreviousInNavigationLocations',
+            title: { value: ( localize(
+                'navigatePreviousInNavigationLocations',
+                "Go Previous in Navigation Locations"
+            )), original: 'Go Previous in Navigation Locations' },
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const historyService = accessor.get(IHistoryService);
+        await historyService.goPrevious(2 );
+    }
+}
+class NavigateToLastNavigationLocationAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.navigateToLastNavigationLocation',
+            title: { value: ( localize('navigateToLastNavigationLocation', "Go to Last Navigation Location")), original: 'Go to Last Navigation Location' },
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const historyService = accessor.get(IHistoryService);
+        await historyService.goLast(2 );
+    }
+}
+class ReopenClosedEditorAction extends Action2 {
+    constructor() {
+        super({
+            id: ReopenClosedEditorAction.ID,
+            title: { value: ( localize('reopenClosedEditor', "Reopen Closed Editor")), original: 'Reopen Closed Editor' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: 2048  | 1024  | 50
+            },
+            category: Categories.View
+        });
+    }
+    async run(accessor) {
+        const historyService = accessor.get(IHistoryService);
+        await historyService.reopenLastClosedEditor();
+    }
+}
+ReopenClosedEditorAction.ID = 'workbench.action.reopenClosedEditor';
+class ClearRecentFilesAction extends Action2 {
     constructor() {
         super({
             id: ClearRecentFilesAction.ID,
             title: { value: ( localize('clearRecentFiles', "Clear Recently Opened")), original: 'Clear Recently Opened' },
             f1: true,
-            category: Categories.File
+            category: Categories.File
+        });
+    }
+    async run(accessor) {
+        const dialogService = accessor.get(IDialogService);
+        const workspacesService = accessor.get(IWorkspacesService);
+        const historyService = accessor.get(IHistoryService);
+        const { confirmed } = await dialogService.confirm({
+            type: 'warning',
+            message: ( localize(
+                'confirmClearRecentsMessage',
+                "Do you want to clear all recently opened files and workspaces?"
+            )),
+            detail: ( localize('confirmClearDetail', "This action is irreversible!")),
+            primaryButton: ( localize({ key: 'clearButtonLabel', comment: ['&& denotes a mnemonic'] }, "&&Clear"))
+        });
+        if (!confirmed) {
+            return;
+        }
+        workspacesService.clearRecentlyOpened();
+        historyService.clearRecentlyOpened();
+    }
+}
+ClearRecentFilesAction.ID = 'workbench.action.clearRecentFiles';
+class ShowEditorsInActiveGroupByMostRecentlyUsedAction extends Action2 {
+    constructor() {
+        super({
+            id: ShowEditorsInActiveGroupByMostRecentlyUsedAction.ID,
+            title: { value: ( localize(
+                'showEditorsInActiveGroup',
+                "Show Editors in Active Group By Most Recently Used"
+            )), original: 'Show Editors in Active Group By Most Recently Used' },
+            f1: true,
+            category: Categories.View
+        });
+    }
+    async run(accessor) {
+        const quickInputService = accessor.get(IQuickInputService);
+        quickInputService.quickAccess.show(ActiveGroupEditorsByMostRecentlyUsedQuickAccess.PREFIX);
+    }
+}
+ShowEditorsInActiveGroupByMostRecentlyUsedAction.ID = 'workbench.action.showEditorsInActiveGroup';
+class ShowAllEditorsByAppearanceAction extends Action2 {
+    constructor() {
+        super({
+            id: ShowAllEditorsByAppearanceAction.ID,
+            title: { value: ( localize('showAllEditors', "Show All Editors By Appearance")), original: 'Show All Editors By Appearance' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 41 , 2048  | 46 ),
+                mac: {
+                    primary: 2048  | 512  | 2
+                }
+            },
+            category: Categories.File
+        });
+    }
+    async run(accessor) {
+        const quickInputService = accessor.get(IQuickInputService);
+        quickInputService.quickAccess.show(AllEditorsByAppearanceQuickAccess.PREFIX);
+    }
+}
+ShowAllEditorsByAppearanceAction.ID = 'workbench.action.showAllEditors';
+class ShowAllEditorsByMostRecentlyUsedAction extends Action2 {
+    constructor() {
+        super({
+            id: ShowAllEditorsByMostRecentlyUsedAction.ID,
+            title: { value: ( localize(
+                'showAllEditorsByMostRecentlyUsed',
+                "Show All Editors By Most Recently Used"
+            )), original: 'Show All Editors By Most Recently Used' },
+            f1: true,
+            category: Categories.View
+        });
+    }
+    async run(accessor) {
+        const quickInputService = accessor.get(IQuickInputService);
+        quickInputService.quickAccess.show(AllEditorsByMostRecentlyUsedQuickAccess.PREFIX);
+    }
+}
+ShowAllEditorsByMostRecentlyUsedAction.ID = 'workbench.action.showAllEditorsByMostRecentlyUsed';
+class AbstractQuickAccessEditorAction extends Action2 {
+    constructor(desc, prefix, itemActivation) {
+        super(desc);
+        this.prefix = prefix;
+        this.itemActivation = itemActivation;
+    }
+    async run(accessor) {
+        const keybindingService = accessor.get(IKeybindingService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const keybindings = keybindingService.lookupKeybindings(this.desc.id);
+        quickInputService.quickAccess.show(this.prefix, {
+            quickNavigateConfiguration: { keybindings },
+            itemActivation: this.itemActivation
+        });
+    }
+}
+class QuickAccessPreviousRecentlyUsedEditorAction extends AbstractQuickAccessEditorAction {
+    constructor() {
+        super({
+            id: 'workbench.action.quickOpenPreviousRecentlyUsedEditor',
+            title: { value: ( localize(
+                'quickOpenPreviousRecentlyUsedEditor',
+                "Quick Open Previous Recently Used Editor"
+            )), original: 'Quick Open Previous Recently Used Editor' },
+            f1: true,
+            category: Categories.View
+        }, AllEditorsByMostRecentlyUsedQuickAccess.PREFIX, undefined);
+    }
+}
+class QuickAccessLeastRecentlyUsedEditorAction extends AbstractQuickAccessEditorAction {
+    constructor() {
+        super({
+            id: 'workbench.action.quickOpenLeastRecentlyUsedEditor',
+            title: { value: ( localize(
+                'quickOpenLeastRecentlyUsedEditor',
+                "Quick Open Least Recently Used Editor"
+            )), original: 'Quick Open Least Recently Used Editor' },
+            f1: true,
+            category: Categories.View
+        }, AllEditorsByMostRecentlyUsedQuickAccess.PREFIX, undefined);
+    }
+}
+class QuickAccessPreviousRecentlyUsedEditorInGroupAction extends AbstractQuickAccessEditorAction {
+    constructor() {
+        super({
+            id: 'workbench.action.quickOpenPreviousRecentlyUsedEditorInGroup',
+            title: { value: ( localize(
+                'quickOpenPreviousRecentlyUsedEditorInGroup',
+                "Quick Open Previous Recently Used Editor in Group"
+            )), original: 'Quick Open Previous Recently Used Editor in Group' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: 2048  | 2 ,
+                mac: {
+                    primary: 256  | 2
+                }
+            },
+            precondition: ( ActiveEditorGroupEmptyContext.toNegated()),
+            category: Categories.View
+        }, ActiveGroupEditorsByMostRecentlyUsedQuickAccess.PREFIX, undefined);
+    }
+}
+class QuickAccessLeastRecentlyUsedEditorInGroupAction extends AbstractQuickAccessEditorAction {
+    constructor() {
+        super({
+            id: 'workbench.action.quickOpenLeastRecentlyUsedEditorInGroup',
+            title: { value: ( localize(
+                'quickOpenLeastRecentlyUsedEditorInGroup',
+                "Quick Open Least Recently Used Editor in Group"
+            )), original: 'Quick Open Least Recently Used Editor in Group' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: 2048  | 1024  | 2 ,
+                mac: {
+                    primary: 256  | 1024  | 2
+                }
+            },
+            precondition: ( ActiveEditorGroupEmptyContext.toNegated()),
+            category: Categories.View
+        }, ActiveGroupEditorsByMostRecentlyUsedQuickAccess.PREFIX, ItemActivation.LAST);
+    }
+}
+class QuickAccessPreviousEditorFromHistoryAction extends Action2 {
+    constructor() {
+        super({
+            id: QuickAccessPreviousEditorFromHistoryAction.ID,
+            title: { value: ( localize('navigateEditorHistoryByInput', "Quick Open Previous Editor from History")), original: 'Quick Open Previous Editor from History' },
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const keybindingService = accessor.get(IKeybindingService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const editorGroupService = accessor.get(IEditorGroupsService);
+        const keybindings = keybindingService.lookupKeybindings(QuickAccessPreviousEditorFromHistoryAction.ID);
+        let itemActivation = undefined;
+        if (editorGroupService.activeGroup.count === 0) {
+            itemActivation = ItemActivation.FIRST;
+        }
+        quickInputService.quickAccess.show('', { quickNavigateConfiguration: { keybindings }, itemActivation });
+    }
+}
+QuickAccessPreviousEditorFromHistoryAction.ID = 'workbench.action.openPreviousEditorFromHistory';
+class OpenNextRecentlyUsedEditorAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.openNextRecentlyUsedEditor',
+            title: { value: ( localize('openNextRecentlyUsedEditor', "Open Next Recently Used Editor")), original: 'Open Next Recently Used Editor' },
+            f1: true,
+            category: Categories.View
+        });
+    }
+    async run(accessor) {
+        const historyService = accessor.get(IHistoryService);
+        historyService.openNextRecentlyUsedEditor();
+    }
+}
+class OpenPreviousRecentlyUsedEditorAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.openPreviousRecentlyUsedEditor',
+            title: { value: ( localize('openPreviousRecentlyUsedEditor', "Open Previous Recently Used Editor")), original: 'Open Previous Recently Used Editor' },
+            f1: true,
+            category: Categories.View
+        });
+    }
+    async run(accessor) {
+        const historyService = accessor.get(IHistoryService);
+        historyService.openPreviouslyUsedEditor();
+    }
+}
+class OpenNextRecentlyUsedEditorInGroupAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.openNextRecentlyUsedEditorInGroup',
+            title: { value: ( localize(
+                'openNextRecentlyUsedEditorInGroup',
+                "Open Next Recently Used Editor In Group"
+            )), original: 'Open Next Recently Used Editor In Group' },
+            f1: true,
+            category: Categories.View
+        });
+    }
+    async run(accessor) {
+        const historyService = accessor.get(IHistoryService);
+        const editorGroupsService = accessor.get(IEditorGroupsService);
+        historyService.openNextRecentlyUsedEditor(editorGroupsService.activeGroup.id);
+    }
+}
+class OpenPreviousRecentlyUsedEditorInGroupAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.openPreviousRecentlyUsedEditorInGroup',
+            title: { value: ( localize(
+                'openPreviousRecentlyUsedEditorInGroup',
+                "Open Previous Recently Used Editor In Group"
+            )), original: 'Open Previous Recently Used Editor In Group' },
+            f1: true,
+            category: Categories.View
+        });
+    }
+    async run(accessor) {
+        const historyService = accessor.get(IHistoryService);
+        const editorGroupsService = accessor.get(IEditorGroupsService);
+        historyService.openPreviouslyUsedEditor(editorGroupsService.activeGroup.id);
+    }
+}
+class ClearEditorHistoryAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.clearEditorHistory',
+            title: { value: ( localize('clearEditorHistory', "Clear Editor History")), original: 'Clear Editor History' },
+            f1: true
         });
     }
     async run(accessor) {
         const dialogService = accessor.get(IDialogService);
-        const workspacesService = accessor.get(IWorkspacesService);
         const historyService = accessor.get(IHistoryService);
         const { confirmed } = await dialogService.confirm({
             type: 'warning',
             message: ( localize(
-                'confirmClearRecentsMessage',
-                "Do you want to clear all recently opened files and workspaces?"
+                'confirmClearEditorHistoryMessage',
+                "Do you want to clear the history of recently opened editors?"
             )),
             detail: ( localize('confirmClearDetail', "This action is irreversible!")),
             primaryButton: ( localize({ key: 'clearButtonLabel', comment: ['&& denotes a mnemonic'] }, "&&Clear"))
@@ -382,90 +1507,191 @@ class ClearRecentFilesAction extends Action2 {
         if (!confirmed) {
             return;
         }
-        workspacesService.clearRecentlyOpened();
-        historyService.clearRecentlyOpened();
+        historyService.clear();
     }
 }
-ClearRecentFilesAction.ID = 'workbench.action.clearRecentFiles';
-class ShowEditorsInActiveGroupByMostRecentlyUsedAction extends Action2 {
+class MoveEditorLeftInGroupAction extends ExecuteCommandAction {
     constructor() {
         super({
-            id: ShowEditorsInActiveGroupByMostRecentlyUsedAction.ID,
-            title: { value: ( localize(
-                'showEditorsInActiveGroup',
-                "Show Editors in Active Group By Most Recently Used"
-            )), original: 'Show Editors in Active Group By Most Recently Used' },
+            id: 'workbench.action.moveEditorLeftInGroup',
+            title: { value: ( localize('moveEditorLeft', "Move Editor Left")), original: 'Move Editor Left' },
+            keybinding: {
+                weight: 200 ,
+                primary: 2048  | 1024  | 11 ,
+                mac: {
+                    primary: KeyChord(2048  | 41 , 2048  | 1024  | 15 )
+                }
+            },
             f1: true,
             category: Categories.View
-        });
+        }, MOVE_ACTIVE_EDITOR_COMMAND_ID, { to: 'left' });
     }
-    async run(accessor) {
-        const quickInputService = accessor.get(IQuickInputService);
-        quickInputService.quickAccess.show(ActiveGroupEditorsByMostRecentlyUsedQuickAccess.PREFIX);
+}
+class MoveEditorRightInGroupAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            id: 'workbench.action.moveEditorRightInGroup',
+            title: { value: ( localize('moveEditorRight', "Move Editor Right")), original: 'Move Editor Right' },
+            keybinding: {
+                weight: 200 ,
+                primary: 2048  | 1024  | 12 ,
+                mac: {
+                    primary: KeyChord(2048  | 41 , 2048  | 1024  | 17 )
+                }
+            },
+            f1: true,
+            category: Categories.View
+        }, MOVE_ACTIVE_EDITOR_COMMAND_ID, { to: 'right' });
     }
 }
-ShowEditorsInActiveGroupByMostRecentlyUsedAction.ID = 'workbench.action.showEditorsInActiveGroup';
-class ShowAllEditorsByAppearanceAction extends Action2 {
+class MoveEditorToPreviousGroupAction extends ExecuteCommandAction {
     constructor() {
         super({
-            id: ShowAllEditorsByAppearanceAction.ID,
-            title: { value: ( localize('showAllEditors', "Show All Editors By Appearance")), original: 'Show All Editors By Appearance' },
+            id: 'workbench.action.moveEditorToPreviousGroup',
+            title: { value: ( localize('moveEditorToPreviousGroup', "Move Editor into Previous Group")), original: 'Move Editor into Previous Group' },
+            keybinding: {
+                weight: 200 ,
+                primary: 2048  | 512  | 15 ,
+                mac: {
+                    primary: 2048  | 256  | 15
+                }
+            },
+            f1: true,
+            category: Categories.View,
+        }, MOVE_ACTIVE_EDITOR_COMMAND_ID, { to: 'previous', by: 'group' });
+    }
+}
+class MoveEditorToNextGroupAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            id: 'workbench.action.moveEditorToNextGroup',
+            title: { value: ( localize('moveEditorToNextGroup', "Move Editor into Next Group")), original: 'Move Editor into Next Group' },
             f1: true,
             keybinding: {
                 weight: 200 ,
-                primary: KeyChord(2048  | 41 , 2048  | 46 ),
+                primary: 2048  | 512  | 17 ,
                 mac: {
-                    primary: 2048  | 512  | 2
+                    primary: 2048  | 256  | 17
                 }
             },
-            category: Categories.File
-        });
+            category: Categories.View
+        }, MOVE_ACTIVE_EDITOR_COMMAND_ID, { to: 'next', by: 'group' });
     }
-    async run(accessor) {
-        const quickInputService = accessor.get(IQuickInputService);
-        quickInputService.quickAccess.show(AllEditorsByAppearanceQuickAccess.PREFIX);
+}
+class MoveEditorToAboveGroupAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            id: 'workbench.action.moveEditorToAboveGroup',
+            title: { value: ( localize('moveEditorToAboveGroup', "Move Editor into Group Above")), original: 'Move Editor into Group Above' },
+            f1: true,
+            category: Categories.View
+        }, MOVE_ACTIVE_EDITOR_COMMAND_ID, { to: 'up', by: 'group' });
     }
 }
-ShowAllEditorsByAppearanceAction.ID = 'workbench.action.showAllEditors';
-class ShowAllEditorsByMostRecentlyUsedAction extends Action2 {
+class MoveEditorToBelowGroupAction extends ExecuteCommandAction {
     constructor() {
         super({
-            id: ShowAllEditorsByMostRecentlyUsedAction.ID,
-            title: { value: ( localize(
-                'showAllEditorsByMostRecentlyUsed',
-                "Show All Editors By Most Recently Used"
-            )), original: 'Show All Editors By Most Recently Used' },
+            id: 'workbench.action.moveEditorToBelowGroup',
+            title: { value: ( localize('moveEditorToBelowGroup', "Move Editor into Group Below")), original: 'Move Editor into Group Below' },
             f1: true,
             category: Categories.View
-        });
+        }, MOVE_ACTIVE_EDITOR_COMMAND_ID, { to: 'down', by: 'group' });
     }
-    async run(accessor) {
-        const quickInputService = accessor.get(IQuickInputService);
-        quickInputService.quickAccess.show(AllEditorsByMostRecentlyUsedQuickAccess.PREFIX);
+}
+class MoveEditorToLeftGroupAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            id: 'workbench.action.moveEditorToLeftGroup',
+            title: { value: ( localize('moveEditorToLeftGroup', "Move Editor into Left Group")), original: 'Move Editor into Left Group' },
+            f1: true,
+            category: Categories.View
+        }, MOVE_ACTIVE_EDITOR_COMMAND_ID, { to: 'left', by: 'group' });
     }
 }
-ShowAllEditorsByMostRecentlyUsedAction.ID = 'workbench.action.showAllEditorsByMostRecentlyUsed';
-class QuickAccessPreviousEditorFromHistoryAction extends Action2 {
+class MoveEditorToRightGroupAction extends ExecuteCommandAction {
     constructor() {
         super({
-            id: QuickAccessPreviousEditorFromHistoryAction.ID,
-            title: { value: ( localize('navigateEditorHistoryByInput', "Quick Open Previous Editor from History")), original: 'Quick Open Previous Editor from History' },
-            f1: true
-        });
+            id: 'workbench.action.moveEditorToRightGroup',
+            title: { value: ( localize('moveEditorToRightGroup', "Move Editor into Right Group")), original: 'Move Editor into Right Group' },
+            f1: true,
+            category: Categories.View
+        }, MOVE_ACTIVE_EDITOR_COMMAND_ID, { to: 'right', by: 'group' });
     }
-    async run(accessor) {
-        const keybindingService = accessor.get(IKeybindingService);
-        const quickInputService = accessor.get(IQuickInputService);
-        const editorGroupService = accessor.get(IEditorGroupsService);
-        const keybindings = keybindingService.lookupKeybindings(QuickAccessPreviousEditorFromHistoryAction.ID);
-        let itemActivation = undefined;
-        if (editorGroupService.activeGroup.count === 0) {
-            itemActivation = ItemActivation.FIRST;
-        }
-        quickInputService.quickAccess.show('', { quickNavigateConfiguration: { keybindings }, itemActivation });
+}
+class MoveEditorToFirstGroupAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            id: 'workbench.action.moveEditorToFirstGroup',
+            title: { value: ( localize('moveEditorToFirstGroup', "Move Editor into First Group")), original: 'Move Editor into First Group' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: 1024  | 512  | 22 ,
+                mac: {
+                    primary: 2048  | 256  | 22
+                }
+            },
+            category: Categories.View
+        }, MOVE_ACTIVE_EDITOR_COMMAND_ID, { to: 'first', by: 'group' });
+    }
+}
+class MoveEditorToLastGroupAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            id: 'workbench.action.moveEditorToLastGroup',
+            title: { value: ( localize('moveEditorToLastGroup', "Move Editor into Last Group")), original: 'Move Editor into Last Group' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: 1024  | 512  | 30 ,
+                mac: {
+                    primary: 2048  | 256  | 30
+                }
+            },
+            category: Categories.View
+        }, MOVE_ACTIVE_EDITOR_COMMAND_ID, { to: 'last', by: 'group' });
+    }
+}
+class SplitEditorToPreviousGroupAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            id: 'workbench.action.splitEditorToPreviousGroup',
+            title: { value: ( localize('splitEditorToPreviousGroup', "Split Editor into Previous Group")), original: 'Split Editor into Previous Group' },
+            f1: true,
+            category: Categories.View
+        }, COPY_ACTIVE_EDITOR_COMMAND_ID, { to: 'previous', by: 'group' });
+    }
+}
+class SplitEditorToNextGroupAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            id: 'workbench.action.splitEditorToNextGroup',
+            title: { value: ( localize('splitEditorToNextGroup', "Split Editor into Next Group")), original: 'Split Editor into Next Group' },
+            f1: true,
+            category: Categories.View
+        }, COPY_ACTIVE_EDITOR_COMMAND_ID, { to: 'next', by: 'group' });
+    }
+}
+class SplitEditorToAboveGroupAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            id: 'workbench.action.splitEditorToAboveGroup',
+            title: { value: ( localize('splitEditorToAboveGroup', "Split Editor into Group Above")), original: 'Split Editor into Group Above' },
+            f1: true,
+            category: Categories.View
+        }, COPY_ACTIVE_EDITOR_COMMAND_ID, { to: 'up', by: 'group' });
+    }
+}
+class SplitEditorToBelowGroupAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            id: 'workbench.action.splitEditorToBelowGroup',
+            title: { value: ( localize('splitEditorToBelowGroup', "Split Editor into Group Below")), original: 'Split Editor into Group Below' },
+            f1: true,
+            category: Categories.View
+        }, COPY_ACTIVE_EDITOR_COMMAND_ID, { to: 'down', by: 'group' });
     }
 }
-QuickAccessPreviousEditorFromHistoryAction.ID = 'workbench.action.openPreviousEditorFromHistory';
 class SplitEditorToLeftGroupAction extends ExecuteCommandAction {
     constructor() {
         super({
@@ -478,6 +1704,36 @@ class SplitEditorToLeftGroupAction extends ExecuteCommandAction {
 }
 SplitEditorToLeftGroupAction.ID = 'workbench.action.splitEditorToLeftGroup';
 SplitEditorToLeftGroupAction.LABEL = ( localize('splitEditorToLeftGroup', "Split Editor into Left Group"));
+class SplitEditorToRightGroupAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            id: 'workbench.action.splitEditorToRightGroup',
+            title: { value: ( localize('splitEditorToRightGroup', "Split Editor into Right Group")), original: 'Split Editor into Right Group' },
+            f1: true,
+            category: Categories.View
+        }, COPY_ACTIVE_EDITOR_COMMAND_ID, { to: 'right', by: 'group' });
+    }
+}
+class SplitEditorToFirstGroupAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            id: 'workbench.action.splitEditorToFirstGroup',
+            title: { value: ( localize('splitEditorToFirstGroup', "Split Editor into First Group")), original: 'Split Editor into First Group' },
+            f1: true,
+            category: Categories.View
+        }, COPY_ACTIVE_EDITOR_COMMAND_ID, { to: 'first', by: 'group' });
+    }
+}
+class SplitEditorToLastGroupAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            id: 'workbench.action.splitEditorToLastGroup',
+            title: { value: ( localize('splitEditorToLastGroup', "Split Editor into Last Group")), original: 'Split Editor into Last Group' },
+            f1: true,
+            category: Categories.View
+        }, COPY_ACTIVE_EDITOR_COMMAND_ID, { to: 'last', by: 'group' });
+    }
+}
 class EditorLayoutSingleAction extends ExecuteCommandAction {
     constructor() {
         super({
@@ -566,4 +1822,125 @@ class EditorLayoutTwoRowsRightAction extends ExecuteCommandAction {
     }
 }
 EditorLayoutTwoRowsRightAction.ID = 'workbench.action.editorLayoutTwoRowsRight';
-export { ClearRecentFilesAction, CloseAllEditorsAction, CloseEditorAction, CloseOneEditorAction, EditorLayoutSingleAction, EditorLayoutThreeColumnsAction, EditorLayoutThreeRowsAction, EditorLayoutTwoByTwoGridAction, EditorLayoutTwoColumnsAction, EditorLayoutTwoColumnsBottomAction, EditorLayoutTwoRowsAction, EditorLayoutTwoRowsRightAction, NavigateBackwardsAction, NavigateForwardAction, QuickAccessPreviousEditorFromHistoryAction, ReopenClosedEditorAction, ShowAllEditorsByAppearanceAction, ShowAllEditorsByMostRecentlyUsedAction, ShowEditorsInActiveGroupByMostRecentlyUsedAction, SplitEditorAction, SplitEditorDownAction, SplitEditorToLeftGroupAction, SplitEditorUpAction, UnpinEditorAction };
+class AbstractCreateEditorGroupAction extends Action2 {
+    constructor(desc, direction) {
+        super(desc);
+        this.direction = direction;
+    }
+    async run(accessor) {
+        const editorGroupService = accessor.get(IEditorGroupsService);
+        editorGroupService.addGroup(editorGroupService.activeGroup, this.direction, { activate: true });
+    }
+}
+class NewEditorGroupLeftAction extends AbstractCreateEditorGroupAction {
+    constructor() {
+        super({
+            id: 'workbench.action.newGroupLeft',
+            title: { value: ( localize('newGroupLeft', "New Editor Group to the Left")), original: 'New Editor Group to the Left' },
+            f1: true,
+            category: Categories.View
+        }, 2 );
+    }
+}
+class NewEditorGroupRightAction extends AbstractCreateEditorGroupAction {
+    constructor() {
+        super({
+            id: 'workbench.action.newGroupRight',
+            title: { value: ( localize('newGroupRight', "New Editor Group to the Right")), original: 'New Editor Group to the Right' },
+            f1: true,
+            category: Categories.View
+        }, 3 );
+    }
+}
+class NewEditorGroupAboveAction extends AbstractCreateEditorGroupAction {
+    constructor() {
+        super({
+            id: 'workbench.action.newGroupAbove',
+            title: { value: ( localize('newGroupAbove', "New Editor Group Above")), original: 'New Editor Group Above' },
+            f1: true,
+            category: Categories.View
+        }, 0 );
+    }
+}
+class NewEditorGroupBelowAction extends AbstractCreateEditorGroupAction {
+    constructor() {
+        super({
+            id: 'workbench.action.newGroupBelow',
+            title: { value: ( localize('newGroupBelow', "New Editor Group Below")), original: 'New Editor Group Below' },
+            f1: true,
+            category: Categories.View
+        }, 1 );
+    }
+}
+class ToggleEditorTypeAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.toggleEditorType',
+            title: { value: ( localize('toggleEditorType', "Toggle Editor Type")), original: 'Toggle Editor Type' },
+            f1: true,
+            category: Categories.View,
+            precondition: ActiveEditorAvailableEditorIdsContext
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const editorResolverService = accessor.get(IEditorResolverService);
+        const activeEditorPane = editorService.activeEditorPane;
+        if (!activeEditorPane) {
+            return;
+        }
+        const activeEditorResource = EditorResourceAccessor.getCanonicalUri(activeEditorPane.input);
+        if (!activeEditorResource) {
+            return;
+        }
+        const editorIds = ( editorResolverService.getEditors(activeEditorResource).map(editor => editor.id)).filter(id => id !== activeEditorPane.input.editorId);
+        if (editorIds.length === 0) {
+            return;
+        }
+        await editorService.replaceEditors([
+            {
+                editor: activeEditorPane.input,
+                replacement: {
+                    resource: activeEditorResource,
+                    options: {
+                        override: editorIds[0]
+                    }
+                }
+            }
+        ], activeEditorPane.group);
+    }
+}
+class ReOpenInTextEditorAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.reopenTextEditor',
+            title: { value: ( localize('reopenTextEditor', "Reopen Editor With Text Editor")), original: 'Reopen Editor With Text Editor' },
+            f1: true,
+            category: Categories.View,
+            precondition: ActiveEditorAvailableEditorIdsContext
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const activeEditorPane = editorService.activeEditorPane;
+        if (!activeEditorPane) {
+            return;
+        }
+        const activeEditorResource = EditorResourceAccessor.getCanonicalUri(activeEditorPane.input);
+        if (!activeEditorResource) {
+            return;
+        }
+        await editorService.replaceEditors([
+            {
+                editor: activeEditorPane.input,
+                replacement: {
+                    resource: activeEditorResource,
+                    options: {
+                        override: DEFAULT_EDITOR_ASSOCIATION.id
+                    }
+                }
+            }
+        ], activeEditorPane.group);
+    }
+}
+export { ClearEditorHistoryAction, ClearRecentFilesAction, CloseAllEditorGroupsAction, CloseAllEditorsAction, CloseEditorAction, CloseEditorInAllGroupsAction, CloseEditorsInOtherGroupsAction, CloseLeftEditorsInGroupAction, CloseOneEditorAction, DuplicateGroupDownAction, DuplicateGroupLeftAction, DuplicateGroupRightAction, DuplicateGroupUpAction, EditorLayoutSingleAction, EditorLayoutThreeColumnsAction, EditorLayoutThreeRowsAction, EditorLayoutTwoByTwoGridAction, EditorLayoutTwoColumnsAction, EditorLayoutTwoColumnsBottomAction, EditorLayoutTwoRowsAction, EditorLayoutTwoRowsRightAction, FocusAboveGroup, FocusActiveGroupAction, FocusBelowGroup, FocusFirstGroupAction, FocusLastGroupAction, FocusLeftGroup, FocusNextGroup, FocusPreviousGroup, FocusRightGroup, JoinAllGroupsAction, JoinTwoGroupsAction, MaximizeGroupAction, MinimizeOtherGroupsAction, MoveEditorLeftInGroupAction, MoveEditorRightInGroupAction, MoveEditorToAboveGroupAction, MoveEditorToBelowGroupAction, MoveEditorToFirstGroupAction, MoveEditorToLastGroupAction, MoveEditorToLeftGroupAction, MoveEditorToNextGroupAction, MoveEditorToPreviousGroupAction, MoveEditorToRightGroupAction, MoveGroupDownAction, MoveGroupLeftAction, MoveGroupRightAction, MoveGroupUpAction, NavigateBackwardsAction, NavigateBackwardsInEditsAction, NavigateBackwardsInNavigationsAction, NavigateBetweenGroupsAction, NavigateForwardAction, NavigateForwardInEditsAction, NavigateForwardInNavigationsAction, NavigatePreviousAction, NavigatePreviousInEditsAction, NavigatePreviousInNavigationsAction, NavigateToLastEditLocationAction, NavigateToLastNavigationLocationAction, NewEditorGroupAboveAction, NewEditorGroupBelowAction, NewEditorGroupLeftAction, NewEditorGroupRightAction, OpenFirstEditorInGroup, OpenLastEditorInGroup, OpenNextEditor, OpenNextEditorInGroup, OpenNextRecentlyUsedEditorAction, OpenNextRecentlyUsedEditorInGroupAction, OpenPreviousEditor, OpenPreviousEditorInGroup, OpenPreviousRecentlyUsedEditorAction, OpenPreviousRecentlyUsedEditorInGroupAction, QuickAccessLeastRecentlyUsedEditorAction, QuickAccessLeastRecentlyUsedEditorInGroupAction, QuickAccessPreviousEditorFromHistoryAction, QuickAccessPreviousRecentlyUsedEditorAction, QuickAccessPreviousRecentlyUsedEditorInGroupAction, ReOpenInTextEditorAction, ReopenClosedEditorAction, ResetGroupSizesAction, RevertAndCloseEditorAction, ShowAllEditorsByAppearanceAction, ShowAllEditorsByMostRecentlyUsedAction, ShowEditorsInActiveGroupByMostRecentlyUsedAction, SplitEditorAction, SplitEditorDownAction, SplitEditorLeftAction, SplitEditorOrthogonalAction, SplitEditorRightAction, SplitEditorToAboveGroupAction, SplitEditorToBelowGroupAction, SplitEditorToFirstGroupAction, SplitEditorToLastGroupAction, SplitEditorToLeftGroupAction, SplitEditorToNextGroupAction, SplitEditorToPreviousGroupAction, SplitEditorToRightGroupAction, SplitEditorUpAction, ToggleEditorTypeAction, ToggleGroupSizesAction, UnpinEditorAction };