@codingame/monaco-vscode-notebook-service-override 1.85.1

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/clipboard/notebookClipboard.js

@@ -0,0 +1,485 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_EDITOR_EDITABLE, NOTEBOOK_CELL_EDITABLE } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
+import { expandCellRangesWithHiddenCells, cellRangeToViewCells, getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { CopyAction, PasteAction, CutAction } from 'monaco-editor/esm/vs/editor/contrib/clipboard/browser/clipboard.js';
+import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+import { cloneNotebookCellTextModel } from 'vscode/vscode/vs/workbench/contrib/notebook/common/model/notebookCellTextModel';
+import { SelectionStateType } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
+import * as platform from 'monaco-editor/esm/vs/base/common/platform.js';
+import { registerAction2, MenuId, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { NotebookCellAction, NotebookAction, NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/coreActions';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { InputFocusedContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkeys.js';
+import { UndoCommand, RedoCommand } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { showWindowLogActionId } from 'vscode/vscode/vs/workbench/services/log/common/logConstants';
+import { getWindow, getActiveElement } from 'monaco-editor/esm/vs/base/browser/dom.js';
+
+let _logging = false;
+function toggleLogging() {
+    _logging = !_logging;
+}
+function _log(loggerService, str) {
+    if (_logging) {
+        loggerService.info(`[NotebookClipboard]: ${str}`);
+    }
+}
+function getFocusedWebviewDelegate(accessor) {
+    const loggerService = accessor.get(ILogService);
+    const editorService = accessor.get(IEditorService);
+    const editor = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
+    if (!editor) {
+        _log(loggerService, '[Revive Webview] No notebook editor found for active editor pane, bypass');
+        return;
+    }
+    if (!editor.hasEditorFocus()) {
+        _log(loggerService, '[Revive Webview] Notebook editor is not focused, bypass');
+        return;
+    }
+    if (!editor.hasWebviewFocus()) {
+        _log(loggerService, '[Revive Webview] Notebook editor backlayer webview is not focused, bypass');
+        return;
+    }
+    const webview = editor.getInnerWebview();
+    _log(loggerService, '[Revive Webview] Notebook editor backlayer webview is focused');
+    return webview;
+}
+function withWebview(accessor, f) {
+    const webview = getFocusedWebviewDelegate(accessor);
+    if (webview) {
+        f(webview);
+        return true;
+    }
+    return false;
+}
+const PRIORITY = 105;
+UndoCommand.addImplementation(PRIORITY, 'notebook-webview', accessor => {
+    return withWebview(accessor, webview => webview.undo());
+});
+RedoCommand.addImplementation(PRIORITY, 'notebook-webview', accessor => {
+    return withWebview(accessor, webview => webview.redo());
+});
+CopyAction?.addImplementation(PRIORITY, 'notebook-webview', accessor => {
+    return withWebview(accessor, webview => webview.copy());
+});
+PasteAction?.addImplementation(PRIORITY, 'notebook-webview', accessor => {
+    return withWebview(accessor, webview => webview.paste());
+});
+CutAction?.addImplementation(PRIORITY, 'notebook-webview', accessor => {
+    return withWebview(accessor, webview => webview.cut());
+});
+function runPasteCells(editor, activeCell, pasteCells) {
+    if (!editor.hasModel()) {
+        return false;
+    }
+    const textModel = editor.textModel;
+    if (editor.isReadOnly) {
+        return false;
+    }
+    const originalState = {
+        kind: SelectionStateType.Index,
+        focus: editor.getFocus(),
+        selections: editor.getSelections()
+    };
+    if (activeCell) {
+        const currCellIndex = editor.getCellIndex(activeCell);
+        const newFocusIndex = typeof currCellIndex === 'number' ? currCellIndex + 1 : 0;
+        textModel.applyEdits([
+            {
+                editType: 1 ,
+                index: newFocusIndex,
+                count: 0,
+                cells: ( pasteCells.items.map(cell => cloneNotebookCellTextModel(cell)))
+            }
+        ], true, originalState, () => ({
+            kind: SelectionStateType.Index,
+            focus: { start: newFocusIndex, end: newFocusIndex + 1 },
+            selections: [{ start: newFocusIndex, end: newFocusIndex + pasteCells.items.length }]
+        }), undefined, true);
+    }
+    else {
+        if (editor.getLength() !== 0) {
+            return false;
+        }
+        textModel.applyEdits([
+            {
+                editType: 1 ,
+                index: 0,
+                count: 0,
+                cells: ( pasteCells.items.map(cell => cloneNotebookCellTextModel(cell)))
+            }
+        ], true, originalState, () => ({
+            kind: SelectionStateType.Index,
+            focus: { start: 0, end: 1 },
+            selections: [{ start: 1, end: pasteCells.items.length + 1 }]
+        }), undefined, true);
+    }
+    return true;
+}
+function runCopyCells(accessor, editor, targetCell) {
+    if (!editor.hasModel()) {
+        return false;
+    }
+    if (editor.hasOutputTextSelection()) {
+        getWindow(editor.getDomNode()).document.execCommand('copy');
+        return true;
+    }
+    const clipboardService = accessor.get(IClipboardService);
+    const notebookService = accessor.get(INotebookService);
+    const selections = editor.getSelections();
+    if (targetCell) {
+        const targetCellIndex = editor.getCellIndex(targetCell);
+        const containingSelection = selections.find(selection => selection.start <= targetCellIndex && targetCellIndex < selection.end);
+        if (!containingSelection) {
+            clipboardService.writeText(targetCell.getText());
+            notebookService.setToCopy([targetCell.model], true);
+            return true;
+        }
+    }
+    const selectionRanges = expandCellRangesWithHiddenCells(editor, editor.getSelections());
+    const selectedCells = cellRangeToViewCells(editor, selectionRanges);
+    if (!selectedCells.length) {
+        return false;
+    }
+    clipboardService.writeText(( selectedCells.map(cell => cell.getText())).join('\n'));
+    notebookService.setToCopy(( selectedCells.map(cell => cell.model)), true);
+    return true;
+}
+function runCutCells(accessor, editor, targetCell) {
+    if (!editor.hasModel() || editor.isReadOnly) {
+        return false;
+    }
+    const textModel = editor.textModel;
+    const clipboardService = accessor.get(IClipboardService);
+    const notebookService = accessor.get(INotebookService);
+    const selections = editor.getSelections();
+    if (targetCell) {
+        const targetCellIndex = editor.getCellIndex(targetCell);
+        const containingSelection = selections.find(selection => selection.start <= targetCellIndex && targetCellIndex < selection.end);
+        if (!containingSelection) {
+            clipboardService.writeText(targetCell.getText());
+            const focus = editor.getFocus();
+            const newFocus = focus.end <= targetCellIndex ? focus : { start: focus.start - 1, end: focus.end - 1 };
+            const newSelections = ( selections.map(
+                selection => (selection.end <= targetCellIndex ? selection : { start: selection.start - 1, end: selection.end - 1 })
+            ));
+            textModel.applyEdits([
+                { editType: 1 , index: targetCellIndex, count: 1, cells: [] }
+            ], true, { kind: SelectionStateType.Index, focus: editor.getFocus(), selections: selections }, () => ({ kind: SelectionStateType.Index, focus: newFocus, selections: newSelections }), undefined, true);
+            notebookService.setToCopy([targetCell.model], false);
+            return true;
+        }
+    }
+    const focus = editor.getFocus();
+    const containingSelection = selections.find(selection => selection.start <= focus.start && focus.end <= selection.end);
+    if (!containingSelection) {
+        const targetCell = editor.cellAt(focus.start);
+        clipboardService.writeText(targetCell.getText());
+        const newFocus = focus.end === editor.getLength() ? { start: focus.start - 1, end: focus.end - 1 } : focus;
+        const newSelections = ( selections.map(
+            selection => (selection.end <= focus.start ? selection : { start: selection.start - 1, end: selection.end - 1 })
+        ));
+        textModel.applyEdits([
+            { editType: 1 , index: focus.start, count: 1, cells: [] }
+        ], true, { kind: SelectionStateType.Index, focus: editor.getFocus(), selections: selections }, () => ({ kind: SelectionStateType.Index, focus: newFocus, selections: newSelections }), undefined, true);
+        notebookService.setToCopy([targetCell.model], false);
+        return true;
+    }
+    const selectionRanges = expandCellRangesWithHiddenCells(editor, editor.getSelections());
+    const selectedCells = cellRangeToViewCells(editor, selectionRanges);
+    if (!selectedCells.length) {
+        return false;
+    }
+    clipboardService.writeText(( selectedCells.map(cell => cell.getText())).join('\n'));
+    const edits = ( selectionRanges.map(
+        range => ({ editType: 1 , index: range.start, count: range.end - range.start, cells: [] })
+    ));
+    const firstSelectIndex = selectionRanges[0].start;
+    const newFocusedCellIndex = firstSelectIndex < textModel.cells.length - 1
+        ? firstSelectIndex
+        : Math.max(textModel.cells.length - 2, 0);
+    textModel.applyEdits(edits, true, { kind: SelectionStateType.Index, focus: editor.getFocus(), selections: selectionRanges }, () => {
+        return {
+            kind: SelectionStateType.Index,
+            focus: { start: newFocusedCellIndex, end: newFocusedCellIndex + 1 },
+            selections: [{ start: newFocusedCellIndex, end: newFocusedCellIndex + 1 }]
+        };
+    }, undefined, true);
+    notebookService.setToCopy(( selectedCells.map(cell => cell.model)), false);
+    return true;
+}
+let NotebookClipboardContribution = class NotebookClipboardContribution extends Disposable {
+    constructor(_editorService) {
+        super();
+        this._editorService = _editorService;
+        const PRIORITY = 105;
+        if (CopyAction) {
+            this._register(CopyAction.addImplementation(PRIORITY, 'notebook-clipboard', accessor => {
+                return this.runCopyAction(accessor);
+            }));
+        }
+        if (PasteAction) {
+            this._register(PasteAction.addImplementation(PRIORITY, 'notebook-clipboard', accessor => {
+                return this.runPasteAction(accessor);
+            }));
+        }
+        if (CutAction) {
+            this._register(CutAction.addImplementation(PRIORITY, 'notebook-clipboard', accessor => {
+                return this.runCutAction(accessor);
+            }));
+        }
+    }
+    _getContext() {
+        const editor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
+        const activeCell = editor?.getActiveCell();
+        return {
+            editor,
+            activeCell
+        };
+    }
+    _focusInsideEmebedMonaco(editor) {
+        const windowSelection = getWindow(editor.getDomNode()).getSelection();
+        if (windowSelection?.rangeCount !== 1) {
+            return false;
+        }
+        const activeSelection = windowSelection.getRangeAt(0);
+        if (activeSelection.startContainer === activeSelection.endContainer && activeSelection.endOffset - activeSelection.startOffset === 0) {
+            return false;
+        }
+        let container = activeSelection.commonAncestorContainer;
+        const body = editor.getDomNode();
+        if (!body.contains(container)) {
+            return false;
+        }
+        while (container
+            &&
+                container !== body) {
+            if (container.classList && container.classList.contains('monaco-editor')) {
+                return true;
+            }
+            container = container.parentNode;
+        }
+        return false;
+    }
+    runCopyAction(accessor) {
+        const loggerService = accessor.get(ILogService);
+        const activeElement = getActiveElement();
+        if (activeElement && ['input', 'textarea'].indexOf(activeElement.tagName.toLowerCase()) >= 0) {
+            _log(loggerService, '[NotebookEditor] focus is on input or textarea element, bypass');
+            return false;
+        }
+        const { editor } = this._getContext();
+        if (!editor) {
+            _log(loggerService, '[NotebookEditor] no active notebook editor, bypass');
+            return false;
+        }
+        if (this._focusInsideEmebedMonaco(editor)) {
+            _log(loggerService, '[NotebookEditor] focus is on embed monaco editor, bypass');
+            return false;
+        }
+        _log(loggerService, '[NotebookEditor] run copy actions on notebook model');
+        return runCopyCells(accessor, editor, undefined);
+    }
+    runPasteAction(accessor) {
+        const activeElement = getActiveElement();
+        if (activeElement && ['input', 'textarea'].indexOf(activeElement.tagName.toLowerCase()) >= 0) {
+            return false;
+        }
+        const notebookService = accessor.get(INotebookService);
+        const pasteCells = notebookService.getToCopy();
+        if (!pasteCells) {
+            return false;
+        }
+        const { editor, activeCell } = this._getContext();
+        if (!editor) {
+            return false;
+        }
+        return runPasteCells(editor, activeCell, pasteCells);
+    }
+    runCutAction(accessor) {
+        const activeElement = getActiveElement();
+        if (activeElement && ['input', 'textarea'].indexOf(activeElement.tagName.toLowerCase()) >= 0) {
+            return false;
+        }
+        const { editor } = this._getContext();
+        if (!editor) {
+            return false;
+        }
+        return runCutCells(accessor, editor, undefined);
+    }
+};
+NotebookClipboardContribution = ( __decorate([
+    ( __param(0, IEditorService))
+], NotebookClipboardContribution));
+const workbenchContributionsRegistry = ( Registry.as(Extensions.Workbench));
+workbenchContributionsRegistry.registerWorkbenchContribution(NotebookClipboardContribution, 2 );
+const COPY_CELL_COMMAND_ID = 'notebook.cell.copy';
+const CUT_CELL_COMMAND_ID = 'notebook.cell.cut';
+const PASTE_CELL_COMMAND_ID = 'notebook.cell.paste';
+const PASTE_CELL_ABOVE_COMMAND_ID = 'notebook.cell.pasteAbove';
+registerAction2(class extends NotebookCellAction {
+    constructor() {
+        super({
+            id: COPY_CELL_COMMAND_ID,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/clipboard/notebookClipboard',
+                'notebookActions.copy',
+                "Copy Cell"
+            )),
+            menu: {
+                id: MenuId.NotebookCellTitle,
+                when: NOTEBOOK_EDITOR_FOCUSED,
+                group: "1_copy" ,
+            },
+            keybinding: platform.isNative ? undefined : {
+                primary: 2048  | 33 ,
+                win: { primary: 2048  | 33 , secondary: [2048  | 19 ] },
+                when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ContextKeyExpr.not(InputFocusedContextKey))),
+                weight: 200
+            }
+        });
+    }
+    async runWithContext(accessor, context) {
+        runCopyCells(accessor, context.notebookEditor, context.cell);
+    }
+});
+registerAction2(class extends NotebookCellAction {
+    constructor() {
+        super({
+            id: CUT_CELL_COMMAND_ID,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/clipboard/notebookClipboard',
+                'notebookActions.cut',
+                "Cut Cell"
+            )),
+            menu: {
+                id: MenuId.NotebookCellTitle,
+                when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_EDITOR_EDITABLE, NOTEBOOK_CELL_EDITABLE)),
+                group: "1_copy" ,
+            },
+            keybinding: platform.isNative ? undefined : {
+                when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ContextKeyExpr.not(InputFocusedContextKey))),
+                primary: 2048  | 54 ,
+                win: { primary: 2048  | 54 , secondary: [1024  | 20 ] },
+                weight: 200
+            }
+        });
+    }
+    async runWithContext(accessor, context) {
+        runCutCells(accessor, context.notebookEditor, context.cell);
+    }
+});
+registerAction2(class extends NotebookAction {
+    constructor() {
+        super({
+            id: PASTE_CELL_COMMAND_ID,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/clipboard/notebookClipboard',
+                'notebookActions.paste',
+                "Paste Cell"
+            )),
+            menu: {
+                id: MenuId.NotebookCellTitle,
+                when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_EDITOR_EDITABLE)),
+                group: "1_copy" ,
+            },
+            keybinding: platform.isNative ? undefined : {
+                when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ContextKeyExpr.not(InputFocusedContextKey))),
+                primary: 2048  | 52 ,
+                win: { primary: 2048  | 52 , secondary: [1024  | 19 ] },
+                linux: { primary: 2048  | 52 , secondary: [1024  | 19 ] },
+                weight: 100
+            }
+        });
+    }
+    async runWithContext(accessor, context) {
+        const notebookService = accessor.get(INotebookService);
+        const pasteCells = notebookService.getToCopy();
+        if (!context.notebookEditor.hasModel() || context.notebookEditor.isReadOnly) {
+            return;
+        }
+        if (!pasteCells) {
+            return;
+        }
+        runPasteCells(context.notebookEditor, context.cell, pasteCells);
+    }
+});
+registerAction2(class extends NotebookCellAction {
+    constructor() {
+        super({
+            id: PASTE_CELL_ABOVE_COMMAND_ID,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/clipboard/notebookClipboard',
+                'notebookActions.pasteAbove',
+                "Paste Cell Above"
+            )),
+            keybinding: {
+                when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ContextKeyExpr.not(InputFocusedContextKey))),
+                primary: 2048  | 1024  | 52 ,
+                weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT
+            },
+        });
+    }
+    async runWithContext(accessor, context) {
+        const notebookService = accessor.get(INotebookService);
+        const pasteCells = notebookService.getToCopy();
+        const editor = context.notebookEditor;
+        const textModel = editor.textModel;
+        if (editor.isReadOnly) {
+            return;
+        }
+        if (!pasteCells) {
+            return;
+        }
+        const originalState = {
+            kind: SelectionStateType.Index,
+            focus: editor.getFocus(),
+            selections: editor.getSelections()
+        };
+        const currCellIndex = context.notebookEditor.getCellIndex(context.cell);
+        const newFocusIndex = currCellIndex;
+        textModel.applyEdits([
+            {
+                editType: 1 ,
+                index: currCellIndex,
+                count: 0,
+                cells: ( pasteCells.items.map(cell => cloneNotebookCellTextModel(cell)))
+            }
+        ], true, originalState, () => ({
+            kind: SelectionStateType.Index,
+            focus: { start: newFocusIndex, end: newFocusIndex + 1 },
+            selections: [{ start: newFocusIndex, end: newFocusIndex + pasteCells.items.length }]
+        }), undefined, true);
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.toggleNotebookClipboardLog',
+            title: { value: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/clipboard/notebookClipboard',
+                'toggleNotebookClipboardLog',
+                "Toggle Notebook Clipboard Troubleshooting"
+            )), original: 'Toggle Notebook Clipboard Troubleshooting' },
+            category: Categories.Developer,
+            f1: true
+        });
+    }
+    run(accessor) {
+        toggleLogging();
+        if (_logging) {
+            const commandService = accessor.get(ICommandService);
+            commandService.executeCommand(showWindowLogActionId);
+        }
+    }
+});
+
+export { NotebookClipboardContribution, runCopyCells, runCutCells, runPasteCells };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/debug/notebookBreakpoints.js

@@ -0,0 +1,106 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { NotebookCellsChangeType, CellUri } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+
+let NotebookBreakpoints = class NotebookBreakpoints extends Disposable {
+    constructor(_debugService, _notebookService, _editorService) {
+        super();
+        this._debugService = _debugService;
+        this._editorService = _editorService;
+        const listeners = ( new ResourceMap());
+        this._register(_notebookService.onWillAddNotebookDocument(model => {
+            listeners.set(model.uri, model.onWillAddRemoveCells(e => {
+                const debugModel = this._debugService.getModel();
+                if (!debugModel.getBreakpoints().length) {
+                    return;
+                }
+                if (e.rawEvent.kind !== NotebookCellsChangeType.ModelChange) {
+                    return;
+                }
+                for (const change of e.rawEvent.changes) {
+                    const [start, deleteCount] = change;
+                    if (deleteCount > 0) {
+                        const deleted = model.cells.slice(start, start + deleteCount);
+                        for (const deletedCell of deleted) {
+                            const cellBps = debugModel.getBreakpoints({ uri: deletedCell.uri });
+                            cellBps.forEach(cellBp => this._debugService.removeBreakpoints(cellBp.getId()));
+                        }
+                    }
+                }
+            }));
+        }));
+        this._register(_notebookService.onWillRemoveNotebookDocument(model => {
+            this.updateBreakpoints(model);
+            listeners.get(model.uri)?.dispose();
+            listeners.delete(model.uri);
+        }));
+        this._register(this._debugService.getModel().onDidChangeBreakpoints(e => {
+            const newCellBp = e?.added?.find(bp => 'uri' in bp && bp.uri.scheme === Schemas.vscodeNotebookCell);
+            if (newCellBp) {
+                const parsed = CellUri.parse(newCellBp.uri);
+                if (!parsed) {
+                    return;
+                }
+                const editor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
+                if (!editor || !editor.hasModel() || ( editor.textModel.uri.toString()) !== ( parsed.notebook.toString())) {
+                    return;
+                }
+                const cell = editor.getCellByHandle(parsed.handle);
+                if (!cell) {
+                    return;
+                }
+                editor.focusElement(cell);
+            }
+        }));
+    }
+    updateBreakpoints(model) {
+        const bps = this._debugService.getModel().getBreakpoints();
+        if (!bps.length || !model.cells.length) {
+            return;
+        }
+        const idxMap = ( new ResourceMap());
+        model.cells.forEach((cell, i) => {
+            idxMap.set(cell.uri, i);
+        });
+        bps.forEach(bp => {
+            const idx = idxMap.get(bp.uri);
+            if (typeof idx !== 'number') {
+                return;
+            }
+            const notebook = CellUri.parse(bp.uri)?.notebook;
+            if (!notebook) {
+                return;
+            }
+            const newUri = CellUri.generate(notebook, idx);
+            if (isEqual(newUri, bp.uri)) {
+                return;
+            }
+            this._debugService.removeBreakpoints(bp.getId());
+            this._debugService.addBreakpoints(newUri, [
+                {
+                    column: bp.column,
+                    condition: bp.condition,
+                    enabled: bp.enabled,
+                    hitCondition: bp.hitCondition,
+                    logMessage: bp.logMessage,
+                    lineNumber: bp.lineNumber
+                }
+            ]);
+        });
+    }
+};
+NotebookBreakpoints = ( __decorate([
+    ( __param(0, IDebugService)),
+    ( __param(1, INotebookService)),
+    ( __param(2, IEditorService))
+], NotebookBreakpoints));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(NotebookBreakpoints, 3 );

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/debug/notebookCellPausing.js

@@ -0,0 +1,67 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { CellUri } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { CellExecutionUpdateType } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionService';
+import { INotebookExecutionStateService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService';
+
+let NotebookCellPausing = class NotebookCellPausing extends Disposable {
+    constructor(_debugService, _notebookExecutionStateService) {
+        super();
+        this._debugService = _debugService;
+        this._notebookExecutionStateService = _notebookExecutionStateService;
+        this._pausedCells = ( new Set());
+        this._register(_debugService.getModel().onDidChangeCallStack(() => {
+            this.onDidChangeCallStack(true);
+            this._scheduler.schedule();
+        }));
+        this._scheduler = this._register(( new RunOnceScheduler(() => this.onDidChangeCallStack(false), 2000)));
+    }
+    async onDidChangeCallStack(fallBackOnStaleCallstack) {
+        const newPausedCells = ( new Set());
+        for (const session of this._debugService.getModel().getSessions()) {
+            for (const thread of session.getAllThreads()) {
+                let callStack = thread.getCallStack();
+                if (fallBackOnStaleCallstack && !callStack.length) {
+                    callStack = thread.getStaleCallStack();
+                }
+                callStack.forEach(sf => {
+                    const parsed = CellUri.parse(sf.source.uri);
+                    if (parsed) {
+                        newPausedCells.add(( sf.source.uri.toString()));
+                        this.editIsPaused(sf.source.uri, true);
+                    }
+                });
+            }
+        }
+        for (const uri of this._pausedCells) {
+            if (!( newPausedCells.has(uri))) {
+                this.editIsPaused(( URI.parse(uri)), false);
+                this._pausedCells.delete(uri);
+            }
+        }
+        newPausedCells.forEach(cell => this._pausedCells.add(cell));
+    }
+    editIsPaused(cellUri, isPaused) {
+        const parsed = CellUri.parse(cellUri);
+        if (parsed) {
+            const exeState = this._notebookExecutionStateService.getCellExecution(cellUri);
+            if (exeState && (exeState.isPaused !== isPaused || !exeState.didPause)) {
+                exeState.update([{
+                        editType: CellExecutionUpdateType.ExecutionState,
+                        didPause: true,
+                        isPaused
+                    }]);
+            }
+        }
+    }
+};
+NotebookCellPausing = ( __decorate([
+    ( __param(0, IDebugService)),
+    ( __param(1, INotebookExecutionStateService))
+], NotebookCellPausing));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(NotebookCellPausing, 3 );