@codingame/monaco-vscode-api 37.0.0 → 37.2.0

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/coreActions.js

@@ -1,340 +0,0 @@
-
-import { URI } from '../../../../../base/common/uri.js';
-import { localize2, localize } from '../../../../../nls.js';
-import { Action2, MenuId, MenuRegistry } from '../../../../../platform/actions/common/actions.js';
-import { ContextKeyExpr } from '../../../../../platform/contextkey/common/contextkey.js';
-import { KeybindingWeight } from '../../../../../platform/keybinding/common/keybindingsRegistry.js';
-import { getNotebookEditorFromEditorPane, cellRangeToViewCells } from '../notebookBrowser.js';
-import { NOTEBOOK_IS_ACTIVE_EDITOR, INTERACTIVE_WINDOW_IS_ACTIVE_EDITOR, REPL_NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_KERNEL_COUNT, NOTEBOOK_KERNEL_SOURCE_COUNT, NOTEBOOK_EDITOR_EDITABLE, NOTEBOOK_EDITOR_FOCUSED } from '../../common/notebookContextKeys.js';
-import { isICellRange } from '../../common/notebookRange.js';
-import { IEditorService } from '../../../../services/editor/common/editorService.service.js';
-import { isEditorCommandsContext } from '../../../../common/editor.js';
-import { INotebookEditorService } from '../services/notebookEditorService.service.js';
-import { ITelemetryService } from '../../../../../platform/telemetry/common/telemetry.service.js';
-import { MarshalledId } from '../../../../../base/common/marshallingIds.js';
-import { isEqual } from '../../../../../base/common/resources.js';
-
-const SELECT_KERNEL_ID = "_notebook.selectKernel";
-const NOTEBOOK_ACTIONS_CATEGORY = ( localize2(14269, "Notebook"));
-const CELL_TITLE_CELL_GROUP_ID = "inline/cell";
-const CELL_TITLE_OUTPUT_GROUP_ID = "inline/output";
-const NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT = KeybindingWeight.EditorContrib;
-const NOTEBOOK_OUTPUT_WEBVIEW_ACTION_WEIGHT = KeybindingWeight.WorkbenchContrib + 1;
-var CellToolbarOrder;
-(function(CellToolbarOrder) {
-    CellToolbarOrder[CellToolbarOrder["RunSection"] = 0] = "RunSection";
-    CellToolbarOrder[CellToolbarOrder["EditCell"] = 1] = "EditCell";
-    CellToolbarOrder[CellToolbarOrder["ExecuteAboveCells"] = 2] = "ExecuteAboveCells";
-    CellToolbarOrder[CellToolbarOrder["ExecuteCellAndBelow"] = 3] = "ExecuteCellAndBelow";
-    CellToolbarOrder[CellToolbarOrder["SaveCell"] = 4] = "SaveCell";
-    CellToolbarOrder[CellToolbarOrder["SplitCell"] = 5] = "SplitCell";
-    CellToolbarOrder[CellToolbarOrder["ClearCellOutput"] = 6] = "ClearCellOutput";
-})(CellToolbarOrder || (CellToolbarOrder = {}));
-var CellOverflowToolbarGroups;
-(function(CellOverflowToolbarGroups) {
-    CellOverflowToolbarGroups["Copy"] = "1_copy";
-    CellOverflowToolbarGroups["Insert"] = "2_insert";
-    CellOverflowToolbarGroups["Edit"] = "3_edit";
-    CellOverflowToolbarGroups["Share"] = "4_share";
-})(CellOverflowToolbarGroups || (CellOverflowToolbarGroups = {}));
-function getContextFromActiveEditor(editorService) {
-    const editor = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
-    if (!editor || !editor.hasModel()) {
-        return;
-    }
-    const activeCell = editor.getActiveCell();
-    const selectedCells = editor.getSelectionViewModels();
-    return {
-        cell: activeCell,
-        selectedCells,
-        notebookEditor: editor
-    };
-}
-function getWidgetFromUri(accessor, uri) {
-    const notebookEditorService = accessor.get(INotebookEditorService);
-    const widget = notebookEditorService.listNotebookEditors().find(widget => widget.hasModel() && ( widget.textModel.uri.toString()) === ( uri.toString()));
-    if (widget && widget.hasModel()) {
-        return widget;
-    }
-    return undefined;
-}
-function getContextFromUri(accessor, context) {
-    const uri = URI.revive(context);
-    if (uri) {
-        const widget = getWidgetFromUri(accessor, uri);
-        if (widget) {
-            return {
-                notebookEditor: widget
-            };
-        }
-    }
-    return undefined;
-}
-function findTargetCellEditor(context, targetCell) {
-    let foundEditor = undefined;
-    for (const [, codeEditor] of context.notebookEditor.codeEditors) {
-        if (isEqual(codeEditor.getModel()?.uri, targetCell.uri)) {
-            foundEditor = codeEditor;
-            break;
-        }
-    }
-    return foundEditor;
-}
-class NotebookAction extends Action2 {
-    constructor(desc) {
-        if (desc.f1 !== false) {
-            desc.f1 = false;
-            const f1Menu = {
-                id: MenuId.CommandPalette,
-                when: ( ContextKeyExpr.or(
-                    NOTEBOOK_IS_ACTIVE_EDITOR,
-                    INTERACTIVE_WINDOW_IS_ACTIVE_EDITOR,
-                    REPL_NOTEBOOK_IS_ACTIVE_EDITOR
-                ))
-            };
-            if (!desc.menu) {
-                desc.menu = [];
-            } else if (!Array.isArray(desc.menu)) {
-                desc.menu = [desc.menu];
-            }
-            desc.menu = [...desc.menu, f1Menu];
-        }
-        desc.category = NOTEBOOK_ACTIONS_CATEGORY;
-        super(desc);
-    }
-    async run(accessor, context, ...additionalArgs) {
-        sendEntryTelemetry(accessor, this.desc.id, context);
-        if (!this.isNotebookActionContext(context)) {
-            context = this.getEditorContextFromArgsOrActive(accessor, context, ...additionalArgs);
-            if (!context) {
-                return;
-            }
-        }
-        return this.runWithContext(accessor, context);
-    }
-    isNotebookActionContext(context) {
-        return !!context && !!context.notebookEditor;
-    }
-    getEditorContextFromArgsOrActive(accessor, context, ...additionalArgs) {
-        return getContextFromActiveEditor(accessor.get(IEditorService));
-    }
-}
-class NotebookMultiCellAction extends Action2 {
-    constructor(desc) {
-        if (desc.f1 !== false) {
-            desc.f1 = false;
-            const f1Menu = {
-                id: MenuId.CommandPalette,
-                when: NOTEBOOK_IS_ACTIVE_EDITOR
-            };
-            if (!desc.menu) {
-                desc.menu = [];
-            } else if (!Array.isArray(desc.menu)) {
-                desc.menu = [desc.menu];
-            }
-            desc.menu = [...desc.menu, f1Menu];
-        }
-        desc.category = NOTEBOOK_ACTIONS_CATEGORY;
-        super(desc);
-    }
-    parseArgs(accessor, ...args) {
-        return undefined;
-    }
-    async run(accessor, ...additionalArgs) {
-        const context = additionalArgs[0];
-        sendEntryTelemetry(accessor, this.desc.id, context);
-        const isFromCellToolbar = isCellToolbarContext(context);
-        if (isFromCellToolbar) {
-            return this.runWithContext(accessor, context);
-        }
-        const parsedArgs = this.parseArgs(accessor, ...additionalArgs);
-        if (parsedArgs) {
-            return this.runWithContext(accessor, parsedArgs);
-        }
-        const editor = getEditorFromArgsOrActivePane(accessor);
-        if (editor) {
-            const selectedCellRange = editor.getSelections().length === 0 ? [editor.getFocus()] : editor.getSelections();
-            return this.runWithContext(accessor, {
-                ui: false,
-                notebookEditor: editor,
-                selectedCells: cellRangeToViewCells(editor, selectedCellRange)
-            });
-        }
-    }
-}
-class NotebookCellAction extends NotebookAction {
-    isCellActionContext(context) {
-        return !!context && !!context.notebookEditor && !!context.cell;
-    }
-    getCellContextFromArgs(accessor, context, ...additionalArgs) {
-        return undefined;
-    }
-    async run(accessor, context, ...additionalArgs) {
-        sendEntryTelemetry(accessor, this.desc.id, context);
-        if (this.isCellActionContext(context)) {
-            return this.runWithContext(accessor, context);
-        }
-        const contextFromArgs = this.getCellContextFromArgs(accessor, context, ...additionalArgs);
-        if (contextFromArgs) {
-            return this.runWithContext(accessor, contextFromArgs);
-        }
-        const activeEditorContext = this.getEditorContextFromArgsOrActive(accessor);
-        if (this.isCellActionContext(activeEditorContext)) {
-            return this.runWithContext(accessor, activeEditorContext);
-        }
-    }
-}
-const executeNotebookCondition = ( ContextKeyExpr.or(
-    ContextKeyExpr.greater(NOTEBOOK_KERNEL_COUNT.key, 0),
-    ContextKeyExpr.greater(NOTEBOOK_KERNEL_SOURCE_COUNT.key, 0)
-));
-function sendEntryTelemetry(accessor, id, context) {
-    if (context) {
-        const telemetryService = accessor.get(ITelemetryService);
-        if (context.source) {
-            telemetryService.publicLog2("workbenchActionExecuted", {
-                id: id,
-                from: context.source
-            });
-        } else if (URI.isUri(context)) {
-            telemetryService.publicLog2("workbenchActionExecuted", {
-                id: id,
-                from: "cellEditorContextMenu"
-            });
-        } else if (context && "from" in context && context.from === "cellContainer") {
-            telemetryService.publicLog2("workbenchActionExecuted", {
-                id: id,
-                from: "cellContainer"
-            });
-        } else {
-            const from = isCellToolbarContext(context) ? "cellToolbar" : (isEditorCommandsContext(context) ? "editorToolbar" : "other");
-            telemetryService.publicLog2("workbenchActionExecuted", {
-                id: id,
-                from: from
-            });
-        }
-    }
-}
-function isCellToolbarContext(context) {
-    return !!context && !!context.notebookEditor && context.$mid === MarshalledId.NotebookCellActionContext;
-}
-function isMultiCellArgs(arg) {
-    if (arg === undefined) {
-        return false;
-    }
-    const ranges = arg.ranges;
-    if (!ranges) {
-        return false;
-    }
-    if (!Array.isArray(ranges) || ( ranges.some(range => !isICellRange(range)))) {
-        return false;
-    }
-    if (arg.document) {
-        const uri = URI.revive(arg.document);
-        if (!uri) {
-            return false;
-        }
-    }
-    return true;
-}
-function getEditorFromArgsOrActivePane(accessor, context) {
-    const editorFromUri = getContextFromUri(accessor, context)?.notebookEditor;
-    if (editorFromUri) {
-        return editorFromUri;
-    }
-    const editor = getNotebookEditorFromEditorPane(accessor.get(IEditorService).activeEditorPane);
-    if (!editor || !editor.hasModel()) {
-        return;
-    }
-    return editor;
-}
-function parseMultiCellExecutionArgs(accessor, ...args) {
-    const firstArg = args[0];
-    if (isMultiCellArgs(firstArg)) {
-        const editor = getEditorFromArgsOrActivePane(accessor, firstArg.document);
-        if (!editor) {
-            return;
-        }
-        const ranges = firstArg.ranges;
-        const selectedCells = ( ranges.map(range => editor.getCellsInRange(range).slice(0))).flat();
-        const autoReveal = firstArg.autoReveal;
-        return {
-            ui: false,
-            notebookEditor: editor,
-            selectedCells,
-            autoReveal
-        };
-    }
-    if (isICellRange(firstArg)) {
-        const secondArg = args[1];
-        const editor = getEditorFromArgsOrActivePane(accessor, secondArg);
-        if (!editor) {
-            return;
-        }
-        return {
-            ui: false,
-            notebookEditor: editor,
-            selectedCells: editor.getCellsInRange(firstArg)
-        };
-    }
-    const context = getContextFromActiveEditor(accessor.get(IEditorService));
-    return context ? {
-        ui: false,
-        notebookEditor: context.notebookEditor,
-        selectedCells: context.selectedCells ?? [],
-        cell: context.cell
-    } : undefined;
-}
-const cellExecutionArgs = [{
-    isOptional: true,
-    name: "options",
-    description: "The cell range options",
-    schema: {
-        "type": "object",
-        "required": ["ranges"],
-        "properties": {
-            "ranges": {
-                "type": "array",
-                items: [{
-                    "type": "object",
-                    "required": ["start", "end"],
-                    "properties": {
-                        "start": {
-                            "type": "number"
-                        },
-                        "end": {
-                            "type": "number"
-                        }
-                    }
-                }]
-            },
-            "document": {
-                "type": "object",
-                "description": "The document uri"
-            },
-            "autoReveal": {
-                "type": "boolean",
-                "description": "Whether the cell should be revealed into view automatically"
-            }
-        }
-    }
-}];
-MenuRegistry.appendMenuItem(MenuId.NotebookCellTitle, {
-    submenu: MenuId.NotebookCellInsert,
-    title: ( localize(14270, "Insert Cell")),
-    group: CellOverflowToolbarGroups.Insert,
-    when: ( NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true))
-});
-MenuRegistry.appendMenuItem(MenuId.EditorContext, {
-    submenu: MenuId.NotebookCellTitle,
-    title: ( localize(14271, "Notebook Cell")),
-    group: CellOverflowToolbarGroups.Insert,
-    when: NOTEBOOK_EDITOR_FOCUSED
-});
-MenuRegistry.appendMenuItem(MenuId.NotebookCellTitle, {
-    title: ( localize(14272, "Share")),
-    submenu: MenuId.EditorContextShare,
-    group: CellOverflowToolbarGroups.Share
-});
-
-export { CELL_TITLE_CELL_GROUP_ID, CELL_TITLE_OUTPUT_GROUP_ID, CellOverflowToolbarGroups, CellToolbarOrder, NOTEBOOK_ACTIONS_CATEGORY, NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT, NOTEBOOK_OUTPUT_WEBVIEW_ACTION_WEIGHT, NotebookAction, NotebookCellAction, NotebookMultiCellAction, SELECT_KERNEL_ID, cellExecutionArgs, executeNotebookCondition, findTargetCellEditor, getContextFromActiveEditor, getContextFromUri, getEditorFromArgsOrActivePane, parseMultiCellExecutionArgs };

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/foldingController.d.ts

@@ -1,17 +0,0 @@
-import { Disposable } from "../../../../../base/common/lifecycle.js";
-import { INotebookEditor, INotebookEditorMouseEvent, INotebookEditorContribution, CellFoldingState } from "../notebookBrowser.js";
-import { ICellRange } from "../../common/notebookRange.js";
-export declare class FoldingController extends Disposable implements INotebookEditorContribution {
-    private readonly _notebookEditor;
-    static id: string;
-    private _foldingModel;
-    private readonly _localStore;
-    constructor(_notebookEditor: INotebookEditor);
-    saveViewState(): ICellRange[];
-    restoreViewState(state: ICellRange[] | undefined): void;
-    setFoldingStateDown(index: number, state: CellFoldingState, levels: number): void;
-    setFoldingStateUp(index: number, state: CellFoldingState, levels: number): void;
-    private _updateEditorFoldingRanges;
-    onMouseUp(e: INotebookEditorMouseEvent): void;
-    recompute(): void;
-}

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/foldingController.js

@@ -1,272 +0,0 @@
-
-import { Disposable, DisposableStore } from '../../../../../base/common/lifecycle.js';
-import { NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_EDITOR_FOCUSED } from '../../common/notebookContextKeys.js';
-import { CellFoldingState, getNotebookEditorFromEditorPane } from '../notebookBrowser.js';
-import { FoldingModel } from '../viewModel/foldingModel.js';
-import { CellKind } from '../../common/notebookCommon.js';
-import { registerNotebookContribution } from '../notebookEditorExtensions.js';
-import { registerAction2, Action2 } from '../../../../../platform/actions/common/actions.js';
-import { ContextKeyExpr } from '../../../../../platform/contextkey/common/contextkey.js';
-import { InputFocusedContextKey } from '../../../../../platform/contextkey/common/contextkeys.js';
-import { KeyCode, KeyMod as KeyMod$1 } from '../../../../../base/common/keyCodes.js';
-import { KeybindingWeight } from '../../../../../platform/keybinding/common/keybindingsRegistry.js';
-import { IEditorService } from '../../../../services/editor/common/editorService.service.js';
-import { NOTEBOOK_ACTIONS_CATEGORY } from './coreActions.js';
-import { localize, localize2 } from '../../../../../nls.js';
-
-class FoldingController extends Disposable {
-    static {
-        this.id = "workbench.notebook.foldingController";
-    }
-    constructor(_notebookEditor) {
-        super();
-        this._notebookEditor = _notebookEditor;
-        this._foldingModel = null;
-        this._localStore = this._register(( new DisposableStore()));
-        this._register(this._notebookEditor.onMouseUp(e => {
-            this.onMouseUp(e);
-        }));
-        this._register(this._notebookEditor.onDidChangeModel(() => {
-            this._localStore.clear();
-            if (!this._notebookEditor.hasModel()) {
-                return;
-            }
-            this._localStore.add(this._notebookEditor.onDidChangeCellState(e => {
-                if (e.source.editStateChanged && e.cell.cellKind === CellKind.Markup) {
-                    this._foldingModel?.recompute();
-                }
-            }));
-            this._foldingModel = ( new FoldingModel());
-            this._localStore.add(this._foldingModel);
-            this._foldingModel.attachViewModel(this._notebookEditor.getViewModel());
-            this._localStore.add(this._foldingModel.onDidFoldingRegionChanged(() => {
-                this._updateEditorFoldingRanges();
-            }));
-        }));
-    }
-    saveViewState() {
-        return this._foldingModel?.getMemento() || [];
-    }
-    restoreViewState(state) {
-        this._foldingModel?.applyMemento(state || []);
-        this._updateEditorFoldingRanges();
-    }
-    setFoldingStateDown(index, state, levels) {
-        const doCollapse = state === CellFoldingState.Collapsed;
-        const region = this._foldingModel.getRegionAtLine(index + 1);
-        const regions = [];
-        if (region) {
-            if (region.isCollapsed !== doCollapse) {
-                regions.push(region);
-            }
-            if (levels > 1) {
-                const regionsInside = this._foldingModel.getRegionsInside(region, (r, level) => r.isCollapsed !== doCollapse && level < levels);
-                regions.push(...regionsInside);
-            }
-        }
-        regions.forEach(
-            r => this._foldingModel.setCollapsed(r.regionIndex, state === CellFoldingState.Collapsed)
-        );
-        this._updateEditorFoldingRanges();
-    }
-    setFoldingStateUp(index, state, levels) {
-        if (!this._foldingModel) {
-            return;
-        }
-        const regions = this._foldingModel.getAllRegionsAtLine(
-            index + 1,
-            (region, level) => region.isCollapsed !== (state === CellFoldingState.Collapsed) && level <= levels
-        );
-        regions.forEach(
-            r => this._foldingModel.setCollapsed(r.regionIndex, state === CellFoldingState.Collapsed)
-        );
-        this._updateEditorFoldingRanges();
-    }
-    _updateEditorFoldingRanges() {
-        if (!this._foldingModel) {
-            return;
-        }
-        if (!this._notebookEditor.hasModel()) {
-            return;
-        }
-        const vm = this._notebookEditor.getViewModel();
-        vm.updateFoldingRanges(this._foldingModel.regions);
-        const hiddenRanges = vm.getHiddenRanges();
-        this._notebookEditor.setHiddenAreas(hiddenRanges);
-    }
-    onMouseUp(e) {
-        if (!e.event.target) {
-            return;
-        }
-        if (!this._notebookEditor.hasModel()) {
-            return;
-        }
-        const viewModel = this._notebookEditor.getViewModel();
-        const target = e.event.target;
-        if (target.classList.contains("codicon-notebook-collapsed") || target.classList.contains("codicon-notebook-expanded")) {
-            const parent = target.parentElement;
-            if (!parent.classList.contains("notebook-folding-indicator")) {
-                return;
-            }
-            const cellViewModel = e.target;
-            const modelIndex = viewModel.getCellIndex(cellViewModel);
-            const state = viewModel.getFoldingState(modelIndex);
-            if (state === CellFoldingState.None) {
-                return;
-            }
-            this.setFoldingStateUp(
-                modelIndex,
-                state === CellFoldingState.Collapsed ? CellFoldingState.Expanded : CellFoldingState.Collapsed,
-                1
-            );
-            this._notebookEditor.focusElement(cellViewModel);
-        }
-        return;
-    }
-    recompute() {
-        this._foldingModel?.recompute();
-    }
-}
-registerNotebookContribution(FoldingController.id, FoldingController);
-const NOTEBOOK_FOLD_COMMAND_LABEL = ( localize(14312, "Fold Cell"));
-const NOTEBOOK_UNFOLD_COMMAND_LABEL = ( localize2(14313, "Unfold Cell"));
-const FOLDING_COMMAND_ARGS = {
-    args: [{
-        isOptional: true,
-        name: "index",
-        description: "The cell index",
-        schema: {
-            "type": "object",
-            "required": ["index", "direction"],
-            "properties": {
-                "index": {
-                    "type": "number"
-                },
-                "direction": {
-                    "type": "string",
-                    "enum": ["up", "down"],
-                    "default": "down"
-                },
-                "levels": {
-                    "type": "number",
-                    "default": 1
-                }
-            }
-        }
-    }]
-};
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: "notebook.fold",
-            title: ( localize2(14312, "Fold Cell")),
-            category: NOTEBOOK_ACTIONS_CATEGORY,
-            keybinding: {
-                when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ContextKeyExpr.not(InputFocusedContextKey))),
-                primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.BracketLeft,
-                mac: {
-                    primary: KeyMod$1.CtrlCmd | KeyMod$1.Alt | KeyCode.BracketLeft,
-                    secondary: [KeyCode.LeftArrow]
-                },
-                secondary: [KeyCode.LeftArrow],
-                weight: KeybindingWeight.WorkbenchContrib
-            },
-            metadata: {
-                description: NOTEBOOK_FOLD_COMMAND_LABEL,
-                args: FOLDING_COMMAND_ARGS.args
-            },
-            precondition: NOTEBOOK_IS_ACTIVE_EDITOR,
-            f1: true
-        });
-    }
-    async run(accessor, args) {
-        const editorService = accessor.get(IEditorService);
-        const editor = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
-        if (!editor) {
-            return;
-        }
-        if (!editor.hasModel()) {
-            return;
-        }
-        const levels = args && args.levels || 1;
-        const direction = args && args.direction === "up" ? "up" : "down";
-        let index = undefined;
-        if (args) {
-            index = args.index;
-        } else {
-            const activeCell = editor.getActiveCell();
-            if (!activeCell) {
-                return;
-            }
-            index = editor.getCellIndex(activeCell);
-        }
-        const controller = editor.getContribution(FoldingController.id);
-        if (index !== undefined) {
-            const targetCell = (index < 0 || index >= editor.getLength()) ? undefined : editor.cellAt(index);
-            if (targetCell?.cellKind === CellKind.Code && direction === "down") {
-                return;
-            }
-            if (direction === "up") {
-                controller.setFoldingStateUp(index, CellFoldingState.Collapsed, levels);
-            } else {
-                controller.setFoldingStateDown(index, CellFoldingState.Collapsed, levels);
-            }
-            const viewIndex = editor.getViewModel().getNearestVisibleCellIndexUpwards(index);
-            editor.focusElement(editor.cellAt(viewIndex));
-        }
-    }
-});
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: "notebook.unfold",
-            title: NOTEBOOK_UNFOLD_COMMAND_LABEL,
-            category: NOTEBOOK_ACTIONS_CATEGORY,
-            keybinding: {
-                when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ContextKeyExpr.not(InputFocusedContextKey))),
-                primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.BracketRight,
-                mac: {
-                    primary: KeyMod$1.CtrlCmd | KeyMod$1.Alt | KeyCode.BracketRight,
-                    secondary: [KeyCode.RightArrow]
-                },
-                secondary: [KeyCode.RightArrow],
-                weight: KeybindingWeight.WorkbenchContrib
-            },
-            metadata: {
-                description: NOTEBOOK_UNFOLD_COMMAND_LABEL,
-                args: FOLDING_COMMAND_ARGS.args
-            },
-            precondition: NOTEBOOK_IS_ACTIVE_EDITOR,
-            f1: true
-        });
-    }
-    async run(accessor, args) {
-        const editorService = accessor.get(IEditorService);
-        const editor = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
-        if (!editor) {
-            return;
-        }
-        const levels = args && args.levels || 1;
-        const direction = args && args.direction === "up" ? "up" : "down";
-        let index = undefined;
-        if (args) {
-            index = args.index;
-        } else {
-            const activeCell = editor.getActiveCell();
-            if (!activeCell) {
-                return;
-            }
-            index = editor.getCellIndex(activeCell);
-        }
-        const controller = editor.getContribution(FoldingController.id);
-        if (index !== undefined) {
-            if (direction === "up") {
-                controller.setFoldingStateUp(index, CellFoldingState.Expanded, levels);
-            } else {
-                controller.setFoldingStateDown(index, CellFoldingState.Expanded, levels);
-            }
-        }
-    }
-});
-
-export { FoldingController };