@codingame/monaco-vscode-api 4.1.0 → 4.1.1

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

@@ -1,719 +0,0 @@
-import { Iterable } from '../../../../../base/common/iterator.js';
-import { isEqual } from '../../../../../base/common/resources.js';
-import { ThemeIcon } from '../../../../../base/common/themables.js';
-import { ILanguageService } from '../../../../../editor/common/languages/language.js';
-import { localizeWithPath, localize2WithPath } from '../../../../../nls.js';
-import { registerAction2, MenuRegistry, MenuId } from '../../../../../platform/actions/common/actions.js';
-import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';
-import { ContextKeyExpr } from '../../../../../platform/contextkey/common/contextkey.js';
-import { IDebugService } from '../../../debug/common/debug.js';
-import { InlineChatController } from '../../../inlineChat/browser/inlineChatController.js';
-import { CTX_INLINE_CHAT_FOCUSED } from '../../../inlineChat/common/inlineChat.js';
-import { insertCell } from './cellOperations.js';
-import { CTX_NOTEBOOK_CELL_CHAT_FOCUSED } from './chat/notebookChatContext.js';
-import { NotebookChatController } from './chat/notebookChatController.js';
-import { NotebookAction, executeNotebookCondition, getContextFromUri, getContextFromActiveEditor, NotebookMultiCellAction, NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT, cellExecutionArgs, parseMultiCellExecutionArgs, CELL_TITLE_CELL_GROUP_ID, NotebookCellAction } from './coreActions.js';
-import { EXECUTE_CELL_COMMAND_ID, CellEditState, ScrollToRevealBehavior, CellFocusMode } from '../notebookBrowser.js';
-import { executingStateIcon, executeAllIcon, executeIcon, executeAboveIcon, executeBelowIcon, stopIcon, errorStateIcon } from '../notebookIcons.js';
-import { NotebookSetting, CellKind, CellUri } from '../../common/notebookCommon.js';
-import { NOTEBOOK_CELL_TYPE, NOTEBOOK_KERNEL_COUNT, NOTEBOOK_KERNEL_SOURCE_COUNT, NOTEBOOK_MISSING_KERNEL_EXTENSION, NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_INTERRUPTIBLE_KERNEL, NOTEBOOK_HAS_SOMETHING_RUNNING, NOTEBOOK_CELL_LIST_FOCUSED, NOTEBOOK_HAS_RUNNING_CELL, NOTEBOOK_LAST_CELL_FAILED, NOTEBOOK_CELL_EXECUTING, NOTEBOOK_CELL_EXECUTION_STATE } from '../../common/notebookContextKeys.js';
-import { NotebookEditorInput } from '../../common/notebookEditorInput.js';
-import { INotebookExecutionStateService } from '../../common/notebookExecutionStateService.js';
-import { IEditorGroupsService } from '../../../../services/editor/common/editorGroupsService.js';
-import { IEditorService } from '../../../../services/editor/common/editorService.js';
-const EXECUTE_NOTEBOOK_COMMAND_ID = 'notebook.execute';
-const CANCEL_NOTEBOOK_COMMAND_ID = 'notebook.cancelExecution';
-const INTERRUPT_NOTEBOOK_COMMAND_ID = 'notebook.interruptExecution';
-const CANCEL_CELL_COMMAND_ID = 'notebook.cell.cancelExecution';
-const EXECUTE_CELL_FOCUS_CONTAINER_COMMAND_ID = 'notebook.cell.executeAndFocusContainer';
-const EXECUTE_CELL_SELECT_BELOW = 'notebook.cell.executeAndSelectBelow';
-const EXECUTE_CELL_INSERT_BELOW = 'notebook.cell.executeAndInsertBelow';
-const EXECUTE_CELL_AND_BELOW = 'notebook.cell.executeCellAndBelow';
-const EXECUTE_CELLS_ABOVE = 'notebook.cell.executeCellsAbove';
-const RENDER_ALL_MARKDOWN_CELLS = 'notebook.renderAllMarkdownCells';
-const REVEAL_RUNNING_CELL = 'notebook.revealRunningCell';
-const REVEAL_LAST_FAILED_CELL = 'notebook.revealLastFailedCell';
-const executeCondition = ( ContextKeyExpr.and(( NOTEBOOK_CELL_TYPE.isEqualTo('code')), ( ContextKeyExpr.or(
-    ContextKeyExpr.greater(NOTEBOOK_KERNEL_COUNT.key, 0),
-    ContextKeyExpr.greater(NOTEBOOK_KERNEL_SOURCE_COUNT.key, 0),
-    NOTEBOOK_MISSING_KERNEL_EXTENSION
-))));
-const executeThisCellCondition = ( ContextKeyExpr.and(executeCondition, ( NOTEBOOK_CELL_EXECUTING.toNegated())));
-function renderAllMarkdownCells(context) {
-    for (let i = 0; i < context.notebookEditor.getLength(); i++) {
-        const cell = context.notebookEditor.cellAt(i);
-        if (cell.cellKind === CellKind.Markup) {
-            cell.updateEditState(CellEditState.Preview, 'renderAllMarkdownCells');
-        }
-    }
-}
-async function runCell(editorGroupsService, context) {
-    const group = editorGroupsService.activeGroup;
-    if (group) {
-        if (group.activeEditor) {
-            group.pinEditor(group.activeEditor);
-        }
-    }
-    if (context.ui && context.cell) {
-        await context.notebookEditor.executeNotebookCells(Iterable.single(context.cell));
-        if (context.autoReveal) {
-            const cellIndex = context.notebookEditor.getCellIndex(context.cell);
-            context.notebookEditor.revealCellRangeInView({ start: cellIndex, end: cellIndex + 1 });
-        }
-    }
-    else if (context.selectedCells?.length || context.cell) {
-        const selectedCells = context.selectedCells?.length ? context.selectedCells : [context.cell];
-        await context.notebookEditor.executeNotebookCells(selectedCells);
-        const firstCell = selectedCells[0];
-        if (firstCell && context.autoReveal) {
-            const cellIndex = context.notebookEditor.getCellIndex(firstCell);
-            context.notebookEditor.revealCellRangeInView({ start: cellIndex, end: cellIndex + 1 });
-        }
-    }
-    let foundEditor = undefined;
-    for (const [, codeEditor] of context.notebookEditor.codeEditors) {
-        if (isEqual(codeEditor.getModel()?.uri, (context.cell ?? context.selectedCells?.[0])?.uri)) {
-            foundEditor = codeEditor;
-            break;
-        }
-    }
-    if (!foundEditor) {
-        return;
-    }
-    const controller = InlineChatController.get(foundEditor);
-    if (!controller) {
-        return;
-    }
-    controller.createSnapshot();
-}
-registerAction2(class RenderAllMarkdownCellsAction extends NotebookAction {
-    constructor() {
-        super({
-            id: RENDER_ALL_MARKDOWN_CELLS,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/executeActions',
-                'notebookActions.renderMarkdown',
-                "Render All Markdown Cells"
-            )),
-        });
-    }
-    async runWithContext(accessor, context) {
-        renderAllMarkdownCells(context);
-    }
-});
-registerAction2(class ExecuteNotebookAction extends NotebookAction {
-    constructor() {
-        super({
-            id: EXECUTE_NOTEBOOK_COMMAND_ID,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/executeActions',
-                'notebookActions.executeNotebook',
-                "Run All"
-            )),
-            icon: executeAllIcon,
-            metadata: {
-                description: ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/controller/executeActions',
-                    'notebookActions.executeNotebook',
-                    "Run All"
-                )),
-                args: [
-                    {
-                        name: 'uri',
-                        description: 'The document uri'
-                    }
-                ]
-            },
-            menu: [
-                {
-                    id: MenuId.EditorTitle,
-                    order: -1,
-                    group: 'navigation',
-                    when: ( ContextKeyExpr.and(NOTEBOOK_IS_ACTIVE_EDITOR, executeNotebookCondition, ( ContextKeyExpr.or(( NOTEBOOK_INTERRUPTIBLE_KERNEL.toNegated()), ( NOTEBOOK_HAS_SOMETHING_RUNNING.toNegated()))), ( ContextKeyExpr.notEquals('config.notebook.globalToolbar', true))))
-                },
-                {
-                    id: MenuId.NotebookToolbar,
-                    order: -1,
-                    group: 'navigation/execute',
-                    when: ( ContextKeyExpr.and(executeNotebookCondition, ( ContextKeyExpr.or(( NOTEBOOK_INTERRUPTIBLE_KERNEL.toNegated()), ( NOTEBOOK_HAS_SOMETHING_RUNNING.toNegated()))), ( ContextKeyExpr.and(NOTEBOOK_HAS_SOMETHING_RUNNING, ( NOTEBOOK_INTERRUPTIBLE_KERNEL.toNegated())))?.negate(), ( ContextKeyExpr.equals('config.notebook.globalToolbar', true))))
-                }
-            ]
-        });
-    }
-    getEditorContextFromArgsOrActive(accessor, context) {
-        return getContextFromUri(accessor, context) ?? getContextFromActiveEditor(accessor.get(IEditorService));
-    }
-    async runWithContext(accessor, context) {
-        renderAllMarkdownCells(context);
-        const editorService = accessor.get(IEditorService);
-        const editor = editorService.getEditors(0 ).find(editor => editor.editor instanceof NotebookEditorInput && editor.editor.viewType === context.notebookEditor.textModel.viewType && ( editor.editor.resource.toString()) === ( context.notebookEditor.textModel.uri.toString()));
-        const editorGroupService = accessor.get(IEditorGroupsService);
-        if (editor) {
-            const group = editorGroupService.getGroup(editor.groupId);
-            group?.pinEditor(editor.editor);
-        }
-        return context.notebookEditor.executeNotebookCells();
-    }
-});
-registerAction2(class ExecuteCell extends NotebookMultiCellAction {
-    constructor() {
-        super({
-            id: EXECUTE_CELL_COMMAND_ID,
-            precondition: executeThisCellCondition,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/executeActions',
-                'notebookActions.execute',
-                "Execute Cell"
-            )),
-            keybinding: {
-                when: ( ContextKeyExpr.or(NOTEBOOK_CELL_LIST_FOCUSED, ( ContextKeyExpr.and(CTX_NOTEBOOK_CELL_CHAT_FOCUSED, CTX_INLINE_CHAT_FOCUSED)))),
-                primary: 256  | 3 ,
-                win: {
-                    primary: 2048  | 512  | 3
-                },
-                weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT
-            },
-            menu: {
-                id: MenuId.NotebookCellExecutePrimary,
-                when: executeThisCellCondition,
-                group: 'inline'
-            },
-            metadata: {
-                description: ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/controller/executeActions',
-                    'notebookActions.execute',
-                    "Execute Cell"
-                )),
-                args: cellExecutionArgs
-            },
-            icon: executeIcon
-        });
-    }
-    parseArgs(accessor, ...args) {
-        return parseMultiCellExecutionArgs(accessor, ...args);
-    }
-    async runWithContext(accessor, context) {
-        const editorGroupsService = accessor.get(IEditorGroupsService);
-        if (context.ui) {
-            await context.notebookEditor.focusNotebookCell(context.cell, 'container', { skipReveal: true });
-        }
-        const chatController = NotebookChatController.get(context.notebookEditor);
-        const editingCell = chatController?.getEditingCell();
-        if (chatController?.hasFocus() && editingCell) {
-            const group = editorGroupsService.activeGroup;
-            if (group) {
-                if (group.activeEditor) {
-                    group.pinEditor(group.activeEditor);
-                }
-            }
-            await context.notebookEditor.executeNotebookCells([editingCell]);
-            return;
-        }
-        await runCell(editorGroupsService, context);
-    }
-});
-registerAction2(class ExecuteAboveCells extends NotebookMultiCellAction {
-    constructor() {
-        super({
-            id: EXECUTE_CELLS_ABOVE,
-            precondition: executeCondition,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/executeActions',
-                'notebookActions.executeAbove',
-                "Execute Above Cells"
-            )),
-            menu: [
-                {
-                    id: MenuId.NotebookCellExecute,
-                    when: ( ContextKeyExpr.and(executeCondition, ( ContextKeyExpr.equals(`config.${NotebookSetting.consolidatedRunButton}`, true))))
-                },
-                {
-                    id: MenuId.NotebookCellTitle,
-                    order: 1 ,
-                    group: CELL_TITLE_CELL_GROUP_ID,
-                    when: ( ContextKeyExpr.and(executeCondition, ( ContextKeyExpr.equals(`config.${NotebookSetting.consolidatedRunButton}`, false))))
-                }
-            ],
-            icon: executeAboveIcon
-        });
-    }
-    parseArgs(accessor, ...args) {
-        return parseMultiCellExecutionArgs(accessor, ...args);
-    }
-    async runWithContext(accessor, context) {
-        let endCellIdx = undefined;
-        if (context.ui) {
-            endCellIdx = context.notebookEditor.getCellIndex(context.cell);
-            await context.notebookEditor.focusNotebookCell(context.cell, 'container', { skipReveal: true });
-        }
-        else {
-            endCellIdx = Math.min(...( context.selectedCells.map(cell => context.notebookEditor.getCellIndex(cell))));
-        }
-        if (typeof endCellIdx === 'number') {
-            const range = { start: 0, end: endCellIdx };
-            const cells = context.notebookEditor.getCellsInRange(range);
-            context.notebookEditor.executeNotebookCells(cells);
-        }
-    }
-});
-registerAction2(class ExecuteCellAndBelow extends NotebookMultiCellAction {
-    constructor() {
-        super({
-            id: EXECUTE_CELL_AND_BELOW,
-            precondition: executeCondition,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/executeActions',
-                'notebookActions.executeBelow',
-                "Execute Cell and Below"
-            )),
-            menu: [
-                {
-                    id: MenuId.NotebookCellExecute,
-                    when: ( ContextKeyExpr.and(executeCondition, ( ContextKeyExpr.equals(`config.${NotebookSetting.consolidatedRunButton}`, true))))
-                },
-                {
-                    id: MenuId.NotebookCellTitle,
-                    order: 2 ,
-                    group: CELL_TITLE_CELL_GROUP_ID,
-                    when: ( ContextKeyExpr.and(executeCondition, ( ContextKeyExpr.equals(`config.${NotebookSetting.consolidatedRunButton}`, false))))
-                }
-            ],
-            icon: executeBelowIcon
-        });
-    }
-    parseArgs(accessor, ...args) {
-        return parseMultiCellExecutionArgs(accessor, ...args);
-    }
-    async runWithContext(accessor, context) {
-        let startCellIdx = undefined;
-        if (context.ui) {
-            startCellIdx = context.notebookEditor.getCellIndex(context.cell);
-            await context.notebookEditor.focusNotebookCell(context.cell, 'container', { skipReveal: true });
-        }
-        else {
-            startCellIdx = Math.min(...( context.selectedCells.map(cell => context.notebookEditor.getCellIndex(cell))));
-        }
-        if (typeof startCellIdx === 'number') {
-            const range = { start: startCellIdx, end: context.notebookEditor.getLength() };
-            const cells = context.notebookEditor.getCellsInRange(range);
-            context.notebookEditor.executeNotebookCells(cells);
-        }
-    }
-});
-registerAction2(class ExecuteCellFocusContainer extends NotebookMultiCellAction {
-    constructor() {
-        super({
-            id: EXECUTE_CELL_FOCUS_CONTAINER_COMMAND_ID,
-            precondition: executeThisCellCondition,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/executeActions',
-                'notebookActions.executeAndFocusContainer',
-                "Execute Cell and Focus Container"
-            )),
-            metadata: {
-                description: ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/controller/executeActions',
-                    'notebookActions.executeAndFocusContainer',
-                    "Execute Cell and Focus Container"
-                )),
-                args: cellExecutionArgs
-            },
-            icon: executeIcon
-        });
-    }
-    parseArgs(accessor, ...args) {
-        return parseMultiCellExecutionArgs(accessor, ...args);
-    }
-    async runWithContext(accessor, context) {
-        const editorGroupsService = accessor.get(IEditorGroupsService);
-        if (context.ui) {
-            await context.notebookEditor.focusNotebookCell(context.cell, 'container', { skipReveal: true });
-        }
-        else {
-            const firstCell = context.selectedCells[0];
-            if (firstCell) {
-                await context.notebookEditor.focusNotebookCell(firstCell, 'container', { skipReveal: true });
-            }
-        }
-        await runCell(editorGroupsService, context);
-    }
-});
-const cellCancelCondition = ( ContextKeyExpr.or(( ContextKeyExpr.equals(NOTEBOOK_CELL_EXECUTION_STATE.key, 'executing')), ( ContextKeyExpr.equals(NOTEBOOK_CELL_EXECUTION_STATE.key, 'pending'))));
-registerAction2(class CancelExecuteCell extends NotebookMultiCellAction {
-    constructor() {
-        super({
-            id: CANCEL_CELL_COMMAND_ID,
-            precondition: cellCancelCondition,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/executeActions',
-                'notebookActions.cancel',
-                "Stop Cell Execution"
-            )),
-            icon: stopIcon,
-            menu: {
-                id: MenuId.NotebookCellExecutePrimary,
-                when: cellCancelCondition,
-                group: 'inline'
-            },
-            metadata: {
-                description: ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/controller/executeActions',
-                    'notebookActions.cancel',
-                    "Stop Cell Execution"
-                )),
-                args: [
-                    {
-                        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',
-                                }
-                            }
-                        }
-                    }
-                ]
-            },
-        });
-    }
-    parseArgs(accessor, ...args) {
-        return parseMultiCellExecutionArgs(accessor, ...args);
-    }
-    async runWithContext(accessor, context) {
-        if (context.ui) {
-            await context.notebookEditor.focusNotebookCell(context.cell, 'container', { skipReveal: true });
-            return context.notebookEditor.cancelNotebookCells(Iterable.single(context.cell));
-        }
-        else {
-            return context.notebookEditor.cancelNotebookCells(context.selectedCells);
-        }
-    }
-});
-registerAction2(class ExecuteCellSelectBelow extends NotebookCellAction {
-    constructor() {
-        super({
-            id: EXECUTE_CELL_SELECT_BELOW,
-            precondition: ( ContextKeyExpr.or(executeThisCellCondition, ( NOTEBOOK_CELL_TYPE.isEqualTo('markup')))),
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/executeActions',
-                'notebookActions.executeAndSelectBelow',
-                "Execute Notebook Cell and Select Below"
-            )),
-            keybinding: {
-                when: ( ContextKeyExpr.and(NOTEBOOK_CELL_LIST_FOCUSED, ( CTX_INLINE_CHAT_FOCUSED.negate()))),
-                primary: 1024  | 3 ,
-                weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT
-            },
-        });
-    }
-    async runWithContext(accessor, context) {
-        const editorGroupsService = accessor.get(IEditorGroupsService);
-        const idx = context.notebookEditor.getCellIndex(context.cell);
-        if (typeof idx !== 'number') {
-            return;
-        }
-        const languageService = accessor.get(ILanguageService);
-        const config = accessor.get(IConfigurationService);
-        const scrollBehavior = config.getValue(NotebookSetting.scrollToRevealCell);
-        let focusOptions;
-        if (scrollBehavior === 'none') {
-            focusOptions = { skipReveal: true };
-        }
-        else {
-            focusOptions = {
-                revealBehavior: scrollBehavior === 'fullCell' ? ScrollToRevealBehavior.fullCell : ScrollToRevealBehavior.firstLine
-            };
-        }
-        if (context.cell.cellKind === CellKind.Markup) {
-            const nextCell = context.notebookEditor.cellAt(idx + 1);
-            context.cell.updateEditState(CellEditState.Preview, EXECUTE_CELL_SELECT_BELOW);
-            if (nextCell) {
-                await context.notebookEditor.focusNotebookCell(nextCell, 'container', focusOptions);
-            }
-            else {
-                const newCell = insertCell(languageService, context.notebookEditor, idx, CellKind.Markup, 'below');
-                if (newCell) {
-                    await context.notebookEditor.focusNotebookCell(newCell, 'editor', focusOptions);
-                }
-            }
-            return;
-        }
-        else {
-            const nextCell = context.notebookEditor.cellAt(idx + 1);
-            if (nextCell) {
-                await context.notebookEditor.focusNotebookCell(nextCell, 'container', focusOptions);
-            }
-            else {
-                const newCell = insertCell(languageService, context.notebookEditor, idx, CellKind.Code, 'below');
-                if (newCell) {
-                    await context.notebookEditor.focusNotebookCell(newCell, 'editor', focusOptions);
-                }
-            }
-            return runCell(editorGroupsService, context);
-        }
-    }
-});
-registerAction2(class ExecuteCellInsertBelow extends NotebookCellAction {
-    constructor() {
-        super({
-            id: EXECUTE_CELL_INSERT_BELOW,
-            precondition: ( ContextKeyExpr.or(executeThisCellCondition, ( NOTEBOOK_CELL_TYPE.isEqualTo('markup')))),
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/executeActions',
-                'notebookActions.executeAndInsertBelow',
-                "Execute Notebook Cell and Insert Below"
-            )),
-            keybinding: {
-                when: NOTEBOOK_CELL_LIST_FOCUSED,
-                primary: 512  | 3 ,
-                weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT
-            },
-        });
-    }
-    async runWithContext(accessor, context) {
-        const editorGroupsService = accessor.get(IEditorGroupsService);
-        const idx = context.notebookEditor.getCellIndex(context.cell);
-        const languageService = accessor.get(ILanguageService);
-        const newFocusMode = context.cell.focusMode === CellFocusMode.Editor ? 'editor' : 'container';
-        const newCell = insertCell(languageService, context.notebookEditor, idx, context.cell.cellKind, 'below');
-        if (newCell) {
-            await context.notebookEditor.focusNotebookCell(newCell, newFocusMode);
-        }
-        if (context.cell.cellKind === CellKind.Markup) {
-            context.cell.updateEditState(CellEditState.Preview, EXECUTE_CELL_INSERT_BELOW);
-        }
-        else {
-            runCell(editorGroupsService, context);
-        }
-    }
-});
-class CancelNotebook extends NotebookAction {
-    getEditorContextFromArgsOrActive(accessor, context) {
-        return getContextFromUri(accessor, context) ?? getContextFromActiveEditor(accessor.get(IEditorService));
-    }
-    async runWithContext(accessor, context) {
-        return context.notebookEditor.cancelNotebookCells();
-    }
-}
-registerAction2(class CancelAllNotebook extends CancelNotebook {
-    constructor() {
-        super({
-            id: CANCEL_NOTEBOOK_COMMAND_ID,
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/notebook/browser/controller/executeActions',
-                'notebookActions.cancelNotebook',
-                "Stop Execution"
-            )),
-            icon: stopIcon,
-            menu: [
-                {
-                    id: MenuId.EditorTitle,
-                    order: -1,
-                    group: 'navigation',
-                    when: ( ContextKeyExpr.and(NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_HAS_SOMETHING_RUNNING, ( NOTEBOOK_INTERRUPTIBLE_KERNEL.toNegated()), ( ContextKeyExpr.notEquals('config.notebook.globalToolbar', true))))
-                },
-                {
-                    id: MenuId.NotebookToolbar,
-                    order: -1,
-                    group: 'navigation/execute',
-                    when: ( ContextKeyExpr.and(NOTEBOOK_HAS_SOMETHING_RUNNING, ( NOTEBOOK_INTERRUPTIBLE_KERNEL.toNegated()), ( ContextKeyExpr.equals('config.notebook.globalToolbar', true))))
-                }
-            ]
-        });
-    }
-});
-registerAction2(class InterruptNotebook extends CancelNotebook {
-    constructor() {
-        super({
-            id: INTERRUPT_NOTEBOOK_COMMAND_ID,
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/notebook/browser/controller/executeActions',
-                'notebookActions.interruptNotebook',
-                "Interrupt"
-            )),
-            precondition: ( ContextKeyExpr.and(NOTEBOOK_HAS_SOMETHING_RUNNING, NOTEBOOK_INTERRUPTIBLE_KERNEL)),
-            icon: stopIcon,
-            menu: [
-                {
-                    id: MenuId.EditorTitle,
-                    order: -1,
-                    group: 'navigation',
-                    when: ( ContextKeyExpr.and(
-                        NOTEBOOK_IS_ACTIVE_EDITOR,
-                        NOTEBOOK_HAS_SOMETHING_RUNNING,
-                        NOTEBOOK_INTERRUPTIBLE_KERNEL,
-                        ( ContextKeyExpr.notEquals('config.notebook.globalToolbar', true))
-                    ))
-                },
-                {
-                    id: MenuId.NotebookToolbar,
-                    order: -1,
-                    group: 'navigation/execute',
-                    when: ( ContextKeyExpr.and(
-                        NOTEBOOK_HAS_SOMETHING_RUNNING,
-                        NOTEBOOK_INTERRUPTIBLE_KERNEL,
-                        ( ContextKeyExpr.equals('config.notebook.globalToolbar', true))
-                    ))
-                },
-                {
-                    id: MenuId.InteractiveToolbar,
-                    group: 'navigation/execute'
-                }
-            ]
-        });
-    }
-});
-MenuRegistry.appendMenuItem(MenuId.NotebookToolbar, {
-    title: ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/controller/executeActions',
-        'revealRunningCellShort',
-        "Go To"
-    )),
-    submenu: MenuId.NotebookCellExecuteGoTo,
-    group: 'navigation/execute',
-    order: 20,
-    icon: ThemeIcon.modify(executingStateIcon, 'spin')
-});
-registerAction2(class RevealRunningCellAction extends NotebookAction {
-    constructor() {
-        super({
-            id: REVEAL_RUNNING_CELL,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/executeActions',
-                'revealRunningCell',
-                "Go to Running Cell"
-            )),
-            tooltip: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/executeActions',
-                'revealRunningCell',
-                "Go to Running Cell"
-            )),
-            shortTitle: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/executeActions',
-                'revealRunningCell',
-                "Go to Running Cell"
-            )),
-            precondition: NOTEBOOK_HAS_RUNNING_CELL,
-            menu: [
-                {
-                    id: MenuId.EditorTitle,
-                    when: ( ContextKeyExpr.and(NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_HAS_RUNNING_CELL, ( ContextKeyExpr.notEquals('config.notebook.globalToolbar', true)))),
-                    group: 'navigation',
-                    order: 0
-                },
-                {
-                    id: MenuId.NotebookCellExecuteGoTo,
-                    when: ( ContextKeyExpr.and(NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_HAS_RUNNING_CELL, ( ContextKeyExpr.equals('config.notebook.globalToolbar', true)))),
-                    group: 'navigation/execute',
-                    order: 20
-                },
-                {
-                    id: MenuId.InteractiveToolbar,
-                    when: ( ContextKeyExpr.and(NOTEBOOK_HAS_RUNNING_CELL, ( ContextKeyExpr.equals('activeEditor', 'workbench.editor.interactive')))),
-                    group: 'navigation',
-                    order: 10
-                }
-            ],
-            icon: ThemeIcon.modify(executingStateIcon, 'spin')
-        });
-    }
-    async runWithContext(accessor, context) {
-        const notebookExecutionStateService = accessor.get(INotebookExecutionStateService);
-        const notebook = context.notebookEditor.textModel.uri;
-        const executingCells = notebookExecutionStateService.getCellExecutionsForNotebook(notebook);
-        if (executingCells[0]) {
-            const topStackFrameCell = this.findCellAtTopFrame(accessor, notebook);
-            const focusHandle = topStackFrameCell ?? executingCells[0].cellHandle;
-            const cell = context.notebookEditor.getCellByHandle(focusHandle);
-            if (cell) {
-                context.notebookEditor.focusNotebookCell(cell, 'container');
-            }
-        }
-    }
-    findCellAtTopFrame(accessor, notebook) {
-        const debugService = accessor.get(IDebugService);
-        for (const session of debugService.getModel().getSessions()) {
-            for (const thread of session.getAllThreads()) {
-                const sf = thread.getTopStackFrame();
-                if (sf) {
-                    const parsed = CellUri.parse(sf.source.uri);
-                    if (parsed && ( parsed.notebook.toString()) === ( notebook.toString())) {
-                        return parsed.handle;
-                    }
-                }
-            }
-        }
-        return undefined;
-    }
-});
-registerAction2(class RevealLastFailedCellAction extends NotebookAction {
-    constructor() {
-        super({
-            id: REVEAL_LAST_FAILED_CELL,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/executeActions',
-                'revealLastFailedCell',
-                "Go to Most Recently Failed Cell"
-            )),
-            tooltip: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/executeActions',
-                'revealLastFailedCell',
-                "Go to Most Recently Failed Cell"
-            )),
-            shortTitle: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/executeActions',
-                'revealLastFailedCellShort',
-                "Go to Most Recently Failed Cell"
-            )),
-            precondition: NOTEBOOK_LAST_CELL_FAILED,
-            menu: [
-                {
-                    id: MenuId.EditorTitle,
-                    when: ( ContextKeyExpr.and(NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_LAST_CELL_FAILED, ( NOTEBOOK_HAS_RUNNING_CELL.toNegated()), ( ContextKeyExpr.notEquals('config.notebook.globalToolbar', true)))),
-                    group: 'navigation',
-                    order: 0
-                },
-                {
-                    id: MenuId.NotebookCellExecuteGoTo,
-                    when: ( ContextKeyExpr.and(NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_LAST_CELL_FAILED, ( NOTEBOOK_HAS_RUNNING_CELL.toNegated()), ( ContextKeyExpr.equals('config.notebook.globalToolbar', true)))),
-                    group: 'navigation/execute',
-                    order: 20
-                },
-            ],
-            icon: errorStateIcon,
-        });
-    }
-    async runWithContext(accessor, context) {
-        const notebookExecutionStateService = accessor.get(INotebookExecutionStateService);
-        const notebook = context.notebookEditor.textModel.uri;
-        const lastFailedCellHandle = notebookExecutionStateService.getLastFailedCellForNotebook(notebook);
-        if (lastFailedCellHandle !== undefined) {
-            const lastFailedCell = context.notebookEditor.getCellByHandle(lastFailedCellHandle);
-            if (lastFailedCell) {
-                context.notebookEditor.focusNotebookCell(lastFailedCell, 'container');
-            }
-        }
-    }
-});
-export { executeCondition, executeThisCellCondition };