@codingame/monaco-vscode-api 1.78.4 → 1.78.5

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

@@ -0,0 +1,1946 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+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_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';
+import { IDialogService, IFileDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import { IQuickInputService, ItemActivation } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { ActiveGroupEditorsByMostRecentlyUsedQuickAccess, AllEditorsByAppearanceQuickAccess, AllEditorsByMostRecentlyUsedQuickAccess } from './editorQuickAccess.js';
+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);
+        this.commandId = commandId;
+        this.commandArgs = commandArgs;
+    }
+    run(accessor) {
+        const commandService = accessor.get(ICommandService);
+        return commandService.executeCommand(this.commandId, this.commandArgs);
+    }
+}
+class AbstractSplitEditorAction extends Action2 {
+    getDirection(configurationService) {
+        return preferredSideBySideGroupDirection(configurationService);
+    }
+    async run(accessor, context) {
+        const editorGroupService = accessor.get(IEditorGroupsService);
+        const configurationService = accessor.get(IConfigurationService);
+        splitEditor(editorGroupService, this.getDirection(configurationService), context);
+    }
+}
+class SplitEditorAction extends AbstractSplitEditorAction {
+    constructor() {
+        super({
+            id: SplitEditorAction.ID,
+            title: { value: ( localize('splitEditor', "Split Editor")), original: 'Split Editor' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: 2048  | 88
+            },
+            category: Categories.View
+        });
+    }
+}
+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  | 88 )
+            },
+            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  | 88 )
+            },
+            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  | 88 )
+            },
+            category: Categories.View
+        }, SPLIT_EDITOR_RIGHT);
+    }
+}
+class SplitEditorUpAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            id: SPLIT_EDITOR_UP,
+            title: { value: ( localize('splitEditorGroupUp', "Split Editor Up")), original: 'Split Editor Up' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 41 , 2048  | 88 )
+            },
+            category: Categories.View
+        }, SPLIT_EDITOR_UP);
+    }
+}
+SplitEditorUpAction.LABEL = ( localize('splitEditorGroupUp', "Split Editor Up"));
+class SplitEditorDownAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            id: SPLIT_EDITOR_DOWN,
+            title: { value: ( localize('splitEditorGroupDown', "Split Editor Down")), original: 'Split Editor Down' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 41 , 2048  | 88 )
+            },
+            category: Categories.View
+        }, SPLIT_EDITOR_DOWN);
+    }
+}
+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));
+        this.commandService = commandService;
+    }
+    run(context) {
+        return this.commandService.executeCommand(CLOSE_EDITOR_COMMAND_ID, undefined, context);
+    }
+};
+CloseEditorAction.ID = 'workbench.action.closeActiveEditor';
+CloseEditorAction.LABEL = ( localize('closeEditor', "Close Editor"));
+CloseEditorAction = ( __decorate([
+    ( __param(2, ICommandService))
+], CloseEditorAction));
+let UnpinEditorAction = class UnpinEditorAction extends Action {
+    constructor(id, label, commandService) {
+        super(id, label, ThemeIcon.asClassName(Codicon.pinned));
+        this.commandService = commandService;
+    }
+    run(context) {
+        return this.commandService.executeCommand(UNPIN_EDITOR_COMMAND_ID, undefined, context);
+    }
+};
+UnpinEditorAction.ID = 'workbench.action.unpinActiveEditor';
+UnpinEditorAction.LABEL = ( localize('unpinEditor', "Unpin Editor"));
+UnpinEditorAction = ( __decorate([
+    ( __param(2, ICommandService))
+], UnpinEditorAction));
+let CloseOneEditorAction = class CloseOneEditorAction extends Action {
+    constructor(id, label, editorGroupService) {
+        super(id, label, ThemeIcon.asClassName(Codicon.close));
+        this.editorGroupService = editorGroupService;
+    }
+    async run(context) {
+        let group;
+        let editorIndex;
+        if (context) {
+            group = this.editorGroupService.getGroup(context.groupId);
+            if (group) {
+                editorIndex = context.editorIndex;
+            }
+        }
+        if (!group) {
+            group = this.editorGroupService.activeGroup;
+        }
+        if (typeof editorIndex === 'number') {
+            const editorAtIndex = group.getEditorByIndex(editorIndex);
+            if (editorAtIndex) {
+                await group.closeEditor(editorAtIndex, { preserveFocus: context?.preserveFocus });
+                return;
+            }
+        }
+        if (group.activeEditor) {
+            await group.closeEditor(group.activeEditor, { preserveFocus: context?.preserveFocus });
+            return;
+        }
+    }
+};
+CloseOneEditorAction.ID = 'workbench.action.closeActiveEditor';
+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 = [];
+        const groups = editorGroupService.getGroups(2 );
+        for (let i = groups.length - 1; i >= 0; i--) {
+            groupsToClose.push(groups[i]);
+        }
+        return groupsToClose;
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const editorGroupService = accessor.get(IEditorGroupsService);
+        const filesConfigurationService = accessor.get(IFilesConfigurationService);
+        const fileDialogService = accessor.get(IFileDialogService);
+        const dirtyEditorsWithDefaultConfirm = ( new Set());
+        const dirtyAutoSaveOnFocusChangeEditors = ( new Set());
+        const dirtyAutoSaveOnWindowChangeEditors = ( new Set());
+        const editorsWithCustomConfirm = ( new Map());
+        for (const { editor, groupId } of editorService.getEditors(1 , { excludeSticky: this.excludeSticky })) {
+            let confirmClose = false;
+            if (editor.closeHandler) {
+                confirmClose = editor.closeHandler.showConfirm();
+            }
+            else {
+                confirmClose = editor.isDirty() && !editor.isSaving();
+            }
+            if (!confirmClose) {
+                continue;
+            }
+            if (typeof editor.closeHandler?.confirm === 'function') {
+                let customEditorsToConfirm = editorsWithCustomConfirm.get(editor.typeId);
+                if (!customEditorsToConfirm) {
+                    customEditorsToConfirm = ( new Set());
+                    editorsWithCustomConfirm.set(editor.typeId, customEditorsToConfirm);
+                }
+                customEditorsToConfirm.add({ editor, groupId });
+            }
+            else if (filesConfigurationService.getAutoSaveMode() === 3  && !editor.hasCapability(4 )) {
+                dirtyAutoSaveOnFocusChangeEditors.add({ editor, groupId });
+            }
+            else if ((isNative && (isWindows || isLinux)) && filesConfigurationService.getAutoSaveMode() === 4  && !editor.hasCapability(4 )) {
+                dirtyAutoSaveOnWindowChangeEditors.add({ editor, groupId });
+            }
+            else {
+                dirtyEditorsWithDefaultConfirm.add({ editor, groupId });
+            }
+        }
+        if (dirtyEditorsWithDefaultConfirm.size > 0) {
+            const editors = Array.from(( dirtyEditorsWithDefaultConfirm.values()));
+            await this.revealEditorsToConfirm(editors, editorGroupService);
+            const confirmation = await fileDialogService.showSaveConfirm(( editors.map(({ editor }) => {
+                if (editor instanceof SideBySideEditorInput) {
+                    return editor.primary.getName();
+                }
+                return editor.getName();
+            })));
+            switch (confirmation) {
+                case 2 :
+                    return;
+                case 1 :
+                    await editorService.revert(editors, { soft: true });
+                    break;
+                case 0 :
+                    await editorService.save(editors, { reason: 1  });
+                    break;
+            }
+        }
+        for (const [, editorIdentifiers] of editorsWithCustomConfirm) {
+            const editors = Array.from(( editorIdentifiers.values()));
+            await this.revealEditorsToConfirm(editors, editorGroupService);
+            const confirmation = await firstOrDefault(editors)?.editor.closeHandler?.confirm?.(editors);
+            if (typeof confirmation === 'number') {
+                switch (confirmation) {
+                    case 2 :
+                        return;
+                    case 1 :
+                        await editorService.revert(editors, { soft: true });
+                        break;
+                    case 0 :
+                        await editorService.save(editors, { reason: 1  });
+                        break;
+                }
+            }
+        }
+        if (dirtyAutoSaveOnFocusChangeEditors.size > 0) {
+            const editors = Array.from(( dirtyAutoSaveOnFocusChangeEditors.values()));
+            await editorService.save(editors, { reason: 3  });
+        }
+        if (dirtyAutoSaveOnWindowChangeEditors.size > 0) {
+            const editors = Array.from(( dirtyAutoSaveOnWindowChangeEditors.values()));
+            await editorService.save(editors, { reason: 4  });
+        }
+        return this.doCloseAll(editorGroupService);
+    }
+    async revealEditorsToConfirm(editors, editorGroupService) {
+        try {
+            const handledGroups = ( new Set());
+            for (const { editor, groupId } of editors) {
+                if (handledGroups.has(groupId)) {
+                    continue;
+                }
+                handledGroups.add(groupId);
+                const group = editorGroupService.getGroup(groupId);
+                await group?.openEditor(editor);
+            }
+        }
+        catch (error) {
+        }
+    }
+    async doCloseAll(editorGroupService) {
+        await Promise.all(( this.groupsToClose(editorGroupService).map(group => group.closeAllEditors({ excludeSticky: this.excludeSticky }))));
+    }
+}
+class CloseAllEditorsAction extends AbstractCloseAllAction {
+    constructor() {
+        super({
+            id: CloseAllEditorsAction.ID,
+            title: CloseAllEditorsAction.LABEL,
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 41 , 2048  | 53 )
+            },
+            icon: Codicon.closeAll,
+            category: Categories.View
+        });
+    }
+    get excludeSticky() {
+        return true;
+    }
+}
+CloseAllEditorsAction.ID = 'workbench.action.closeAllEditors';
+CloseAllEditorsAction.LABEL = { value: ( localize('closeAllEditors', "Close All Editors")), original: 'Close All Editors' };
+class CloseAllEditorGroupsAction extends AbstractCloseAllAction {
+    constructor() {
+        super({
+            id: 'workbench.action.closeAllGroups',
+            title: { value: ( localize('closeAllGroups', "Close All Editor Groups")), original: 'Close All Editor Groups' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 41 , 2048  | 1024  | 53 )
+            },
+            category: Categories.View
+        });
+    }
+    get excludeSticky() {
+        return false;
+    }
+    async doCloseAll(editorGroupService) {
+        await super.doCloseAll(editorGroupService);
+        for (const groupToClose of this.groupsToClose(editorGroupService)) {
+            editorGroupService.removeGroup(groupToClose);
+        }
+    }
+}
+class CloseEditorsInOtherGroupsAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.closeEditorsInOtherGroups',
+            title: { value: ( localize('closeEditorsInOtherGroups', "Close Editors in Other Groups")), original: 'Close Editors in Other Groups' },
+            f1: true,
+            category: Categories.View
+        });
+    }
+    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 });
+        })));
+    }
+}
+class CloseEditorInAllGroupsAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.closeEditorInAllGroups',
+            title: { value: ( localize('closeEditorInAllGroups', "Close Editor in All Groups")), original: 'Close Editor in All Groups' },
+            f1: true,
+            category: Categories.View
+        });
+    }
+    async run(accessor) {
+        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))));
+        }
+    }
+}
+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  | 89 ]
+                }
+            },
+            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  | 87 ]
+                }
+            },
+            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  | 83  },
+                linux: { primary: 2048  | 1024  | 83  }
+            },
+            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  | 83  },
+                linux: { primary: 2048  | 512  | 83  }
+            },
+            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
+        });
+    }
+    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 historyService = accessor.get(IHistoryService);
+        const { confirmed } = await dialogService.confirm({
+            type: 'warning',
+            message: ( localize(
+                '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"))
+        });
+        if (!confirmed) {
+            return;
+        }
+        historyService.clear();
+    }
+}
+class MoveEditorLeftInGroupAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            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' });
+    }
+}
+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' });
+    }
+}
+class MoveEditorToPreviousGroupAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            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: 2048  | 512  | 17 ,
+                mac: {
+                    primary: 2048  | 256  | 17
+                }
+            },
+            category: Categories.View
+        }, MOVE_ACTIVE_EDITOR_COMMAND_ID, { to: 'next', by: 'group' });
+    }
+}
+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' });
+    }
+}
+class MoveEditorToBelowGroupAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            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' });
+    }
+}
+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' });
+    }
+}
+class MoveEditorToRightGroupAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            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' });
+    }
+}
+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' });
+    }
+}
+class SplitEditorToLeftGroupAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            id: 'workbench.action.splitEditorToLeftGroup',
+            title: { value: ( localize('splitEditorToLeftGroup', "Split Editor into Left Group")), original: 'Split Editor into Left Group' },
+            f1: true,
+            category: Categories.View
+        }, COPY_ACTIVE_EDITOR_COMMAND_ID, { to: 'left', by: 'group' });
+    }
+}
+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({
+            id: EditorLayoutSingleAction.ID,
+            title: { value: ( localize('editorLayoutSingle', "Single Column Editor Layout")), original: 'Single Column Editor Layout' },
+            f1: true,
+            category: Categories.View
+        }, LAYOUT_EDITOR_GROUPS_COMMAND_ID, { groups: [{}] });
+    }
+}
+EditorLayoutSingleAction.ID = 'workbench.action.editorLayoutSingle';
+class EditorLayoutTwoColumnsAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            id: EditorLayoutTwoColumnsAction.ID,
+            title: { value: ( localize('editorLayoutTwoColumns', "Two Columns Editor Layout")), original: 'Two Columns Editor Layout' },
+            f1: true,
+            category: Categories.View
+        }, LAYOUT_EDITOR_GROUPS_COMMAND_ID, { groups: [{}, {}], orientation: 0  });
+    }
+}
+EditorLayoutTwoColumnsAction.ID = 'workbench.action.editorLayoutTwoColumns';
+class EditorLayoutThreeColumnsAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            id: EditorLayoutThreeColumnsAction.ID,
+            title: { value: ( localize('editorLayoutThreeColumns', "Three Columns Editor Layout")), original: 'Three Columns Editor Layout' },
+            f1: true,
+            category: Categories.View
+        }, LAYOUT_EDITOR_GROUPS_COMMAND_ID, { groups: [{}, {}, {}], orientation: 0  });
+    }
+}
+EditorLayoutThreeColumnsAction.ID = 'workbench.action.editorLayoutThreeColumns';
+class EditorLayoutTwoRowsAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            id: EditorLayoutTwoRowsAction.ID,
+            title: { value: ( localize('editorLayoutTwoRows', "Two Rows Editor Layout")), original: 'Two Rows Editor Layout' },
+            f1: true,
+            category: Categories.View
+        }, LAYOUT_EDITOR_GROUPS_COMMAND_ID, { groups: [{}, {}], orientation: 1  });
+    }
+}
+EditorLayoutTwoRowsAction.ID = 'workbench.action.editorLayoutTwoRows';
+class EditorLayoutThreeRowsAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            id: EditorLayoutThreeRowsAction.ID,
+            title: { value: ( localize('editorLayoutThreeRows', "Three Rows Editor Layout")), original: 'Three Rows Editor Layout' },
+            f1: true,
+            category: Categories.View
+        }, LAYOUT_EDITOR_GROUPS_COMMAND_ID, { groups: [{}, {}, {}], orientation: 1  });
+    }
+}
+EditorLayoutThreeRowsAction.ID = 'workbench.action.editorLayoutThreeRows';
+class EditorLayoutTwoByTwoGridAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            id: EditorLayoutTwoByTwoGridAction.ID,
+            title: { value: ( localize('editorLayoutTwoByTwoGrid', "Grid Editor Layout (2x2)")), original: 'Grid Editor Layout (2x2)' },
+            f1: true,
+            category: Categories.View
+        }, LAYOUT_EDITOR_GROUPS_COMMAND_ID, { groups: [{ groups: [{}, {}] }, { groups: [{}, {}] }] });
+    }
+}
+EditorLayoutTwoByTwoGridAction.ID = 'workbench.action.editorLayoutTwoByTwoGrid';
+class EditorLayoutTwoColumnsBottomAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            id: EditorLayoutTwoColumnsBottomAction.ID,
+            title: { value: ( localize('editorLayoutTwoColumnsBottom', "Two Columns Bottom Editor Layout")), original: 'Two Columns Bottom Editor Layout' },
+            f1: true,
+            category: Categories.View
+        }, LAYOUT_EDITOR_GROUPS_COMMAND_ID, { groups: [{}, { groups: [{}, {}] }], orientation: 1  });
+    }
+}
+EditorLayoutTwoColumnsBottomAction.ID = 'workbench.action.editorLayoutTwoColumnsBottom';
+class EditorLayoutTwoRowsRightAction extends ExecuteCommandAction {
+    constructor() {
+        super({
+            id: EditorLayoutTwoRowsRightAction.ID,
+            title: { value: ( localize('editorLayoutTwoRowsRight', "Two Rows Right Editor Layout")), original: 'Two Rows Right Editor Layout' },
+            f1: true,
+            category: Categories.View
+        }, LAYOUT_EDITOR_GROUPS_COMMAND_ID, { groups: [{}, { groups: [{}, {}] }], orientation: 0  });
+    }
+}
+EditorLayoutTwoRowsRightAction.ID = 'workbench.action.editorLayoutTwoRowsRight';
+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 };