@codingame/monaco-vscode-notebook-service-override 8.0.4 → 9.0.2

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/multicursor/notebookMulticursor.js

@@ -0,0 +1,624 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { localize } from 'vscode/vscode/vs/nls';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { KeyMod, KeyCode } from 'vscode/vscode/vs/base/common/keyCodes';
+import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
+import { EditorConfiguration } from 'vscode/vscode/vs/editor/browser/config/editorConfiguration';
+import { CodeEditorWidget } from 'vscode/vscode/vs/editor/browser/widget/codeEditor/codeEditorWidget';
+import { Selection, SelectionDirection } from 'vscode/vscode/vs/editor/common/core/selection';
+import { USUAL_WORD_SEPARATORS } from 'vscode/vscode/vs/editor/common/core/wordHelper';
+import { CursorsController, CommandExecutor } from 'vscode/vscode/vs/editor/common/cursor/cursor';
+import { DeleteOperations } from 'vscode/vscode/vs/editor/common/cursor/cursorDeleteOperations';
+import { CursorConfiguration } from 'vscode/vscode/vs/editor/common/cursorCommon';
+import { CursorChangeReason } from 'vscode/vscode/vs/editor/common/cursorEvents';
+import { ILanguageConfigurationService } from 'vscode/vscode/vs/editor/common/languages/languageConfigurationRegistry';
+import { indentOfLine } from 'vscode/vscode/vs/editor/common/model/textModel';
+import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
+import { ViewModelEventsCollector } from 'vscode/vscode/vs/editor/common/viewModelEventDispatcher';
+import { IAccessibilityService } from 'vscode/vscode/vs/platform/accessibility/common/accessibility.service';
+import { MenuId, registerAction2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
+import { RawContextKey, ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
+import { KeybindingWeight } from 'vscode/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { UndoRedoElementType } from 'vscode/vscode/vs/platform/undoRedo/common/undoRedo';
+import { IUndoRedoService } from 'vscode/vscode/vs/platform/undoRedo/common/undoRedo.service';
+import { NotebookAction } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/coreActions';
+import { getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { registerNotebookContribution } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
+import { CellEditorOptions } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/view/cellParts/cellEditorOptions';
+import { NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_CELL_EDITOR_FOCUSED } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
+import { UndoCommand, RedoCommand } from 'vscode/vscode/vs/editor/browser/editorExtensions';
+import { registerWorkbenchContribution2, WorkbenchPhase } from 'vscode/vscode/vs/workbench/common/contributions';
+
+const NOTEBOOK_ADD_FIND_MATCH_TO_SELECTION_ID = 'notebook.addFindMatchToSelection';
+var NotebookMultiCursorState;
+( ((function(NotebookMultiCursorState) {
+    NotebookMultiCursorState[NotebookMultiCursorState["Idle"] = 0] = "Idle";
+    NotebookMultiCursorState[NotebookMultiCursorState["Selecting"] = 1] = "Selecting";
+    NotebookMultiCursorState[NotebookMultiCursorState["Editing"] = 2] = "Editing";
+})(NotebookMultiCursorState || (NotebookMultiCursorState = {}))));
+const NOTEBOOK_MULTI_SELECTION_CONTEXT = {
+    IsNotebookMultiSelect: ( (new RawContextKey('isNotebookMultiSelect', false))),
+    NotebookMultiSelectState: ( (new RawContextKey('notebookMultiSelectState', NotebookMultiCursorState.Idle))),
+};
+let NotebookMultiCursorController = class NotebookMultiCursorController extends Disposable {
+    static { this.id = 'notebook.multiCursorController'; }
+    constructor(notebookEditor, contextKeyService, textModelService, languageConfigurationService, accessibilityService, configurationService, undoRedoService) {
+        super();
+        this.notebookEditor = notebookEditor;
+        this.contextKeyService = contextKeyService;
+        this.textModelService = textModelService;
+        this.languageConfigurationService = languageConfigurationService;
+        this.accessibilityService = accessibilityService;
+        this.configurationService = configurationService;
+        this.undoRedoService = undoRedoService;
+        this.state = NotebookMultiCursorState.Idle;
+        this.word = '';
+        this.trackedMatches = [];
+        this._onDidChangeAnchorCell = this._register(( (new Emitter())));
+        this.onDidChangeAnchorCell = this._onDidChangeAnchorCell.event;
+        this.anchorDisposables = this._register(( (new DisposableStore())));
+        this.cursorsDisposables = this._register(( (new DisposableStore())));
+        this.cursorsControllers = ( (new ResourceMap()));
+        this._nbIsMultiSelectSession = NOTEBOOK_MULTI_SELECTION_CONTEXT.IsNotebookMultiSelect.bindTo(this.contextKeyService);
+        this._nbMultiSelectState = NOTEBOOK_MULTI_SELECTION_CONTEXT.NotebookMultiSelectState.bindTo(this.contextKeyService);
+        if (!this.configurationService.getValue('notebook.multiSelect.enabled')) {
+            return;
+        }
+        this.anchorCell = this.notebookEditor.activeCellAndCodeEditor;
+        this._register(this.onDidChangeAnchorCell(() => {
+            this.updateCursorsControllers();
+            this.updateAnchorListeners();
+        }));
+    }
+    updateCursorsControllers() {
+        this.cursorsDisposables.clear();
+        this.trackedMatches.forEach(async (match) => {
+            const textModelRef = await this.textModelService.createModelReference(match.cellViewModel.uri);
+            const textModel = textModelRef.object.textEditorModel;
+            if (!textModel) {
+                return;
+            }
+            const cursorSimpleModel = this.constructCursorSimpleModel(match.cellViewModel);
+            const converter = this.constructCoordinatesConverter();
+            const editorConfig = match.config;
+            const controller = this.cursorsDisposables.add(( (new CursorsController(
+                textModel,
+                cursorSimpleModel,
+                converter,
+                 (new CursorConfiguration(
+                    textModel.getLanguageId(),
+                    textModel.getOptions(),
+                    editorConfig,
+                    this.languageConfigurationService
+                ))
+            ))));
+            controller.setSelections(( (new ViewModelEventsCollector())), undefined, match.wordSelections, CursorChangeReason.Explicit);
+            this.cursorsControllers.set(match.cellViewModel.uri, controller);
+        });
+    }
+    constructCoordinatesConverter() {
+        return {
+            convertViewPositionToModelPosition(viewPosition) {
+                return viewPosition;
+            },
+            convertViewRangeToModelRange(viewRange) {
+                return viewRange;
+            },
+            validateViewPosition(viewPosition, expectedModelPosition) {
+                return viewPosition;
+            },
+            validateViewRange(viewRange, expectedModelRange) {
+                return viewRange;
+            },
+            convertModelPositionToViewPosition(modelPosition, affinity, allowZeroLineNumber, belowHiddenRanges) {
+                return modelPosition;
+            },
+            convertModelRangeToViewRange(modelRange, affinity) {
+                return modelRange;
+            },
+            modelPositionIsVisible(modelPosition) {
+                return true;
+            },
+            getModelLineViewLineCount(modelLineNumber) {
+                return 1;
+            },
+            getViewLineNumberOfModelPosition(modelLineNumber, modelColumn) {
+                return modelLineNumber;
+            }
+        };
+    }
+    constructCursorSimpleModel(cell) {
+        return {
+            getLineCount() {
+                return cell.textBuffer.getLineCount();
+            },
+            getLineContent(lineNumber) {
+                return cell.textBuffer.getLineContent(lineNumber);
+            },
+            getLineMinColumn(lineNumber) {
+                return cell.textBuffer.getLineMinColumn(lineNumber);
+            },
+            getLineMaxColumn(lineNumber) {
+                return cell.textBuffer.getLineMaxColumn(lineNumber);
+            },
+            getLineFirstNonWhitespaceColumn(lineNumber) {
+                return cell.textBuffer.getLineFirstNonWhitespaceColumn(lineNumber);
+            },
+            getLineLastNonWhitespaceColumn(lineNumber) {
+                return cell.textBuffer.getLineLastNonWhitespaceColumn(lineNumber);
+            },
+            normalizePosition(position, affinity) {
+                return position;
+            },
+            getLineIndentColumn(lineNumber) {
+                return indentOfLine(cell.textBuffer.getLineContent(lineNumber)) + 1;
+            }
+        };
+    }
+    updateAnchorListeners() {
+        this.anchorDisposables.clear();
+        if (!this.anchorCell) {
+            throw ( (new Error('Anchor cell is undefined')));
+        }
+        this.anchorDisposables.add(this.anchorCell[1].onWillType((input) => {
+            const collector = ( (new ViewModelEventsCollector()));
+            this.trackedMatches.forEach(match => {
+                const controller = this.cursorsControllers.get(match.cellViewModel.uri);
+                if (!controller) {
+                    return;
+                }
+                if (match.cellViewModel.handle !== this.anchorCell?.[0].handle) {
+                    controller.type(collector, input, 'keyboard');
+                }
+            });
+        }));
+        this.anchorDisposables.add(this.anchorCell[1].onDidType(() => {
+            this.state = NotebookMultiCursorState.Editing;
+            this._nbMultiSelectState.set(NotebookMultiCursorState.Editing);
+            const anchorController = this.cursorsControllers.get(this.anchorCell[0].uri);
+            if (!anchorController) {
+                return;
+            }
+            const activeSelections = this.notebookEditor.activeCodeEditor?.getSelections();
+            if (!activeSelections) {
+                return;
+            }
+            anchorController.setSelections(( (new ViewModelEventsCollector())), 'keyboard', activeSelections, CursorChangeReason.Explicit);
+            this.trackedMatches.forEach(match => {
+                const controller = this.cursorsControllers.get(match.cellViewModel.uri);
+                if (!controller) {
+                    return;
+                }
+                match.initialSelection = controller.getSelection();
+                match.wordSelections = [];
+            });
+            this.updateLazyDecorations();
+        }));
+        this.anchorDisposables.add(this.anchorCell[1].onDidChangeCursorSelection((e) => {
+            if (e.source === 'mouse' || e.source === 'deleteRight') {
+                this.resetToIdleState();
+            }
+        }));
+        this.anchorDisposables.add(this.anchorCell[1].onDidBlurEditorWidget(() => {
+            if (this.state === NotebookMultiCursorState.Selecting || this.state === NotebookMultiCursorState.Editing) {
+                this.resetToIdleState();
+            }
+        }));
+    }
+    updateFinalUndoRedo() {
+        const anchorCellModel = this.anchorCell?.[1].getModel();
+        if (!anchorCellModel) {
+            return;
+        }
+        const newElementsMap = ( (new ResourceMap()));
+        const resources = [];
+        this.trackedMatches.forEach(trackedMatch => {
+            const undoRedoState = trackedMatch.undoRedoHistory;
+            if (!undoRedoState) {
+                return;
+            }
+            resources.push(trackedMatch.cellViewModel.uri);
+            const currentPastElements = this.undoRedoService.getElements(trackedMatch.cellViewModel.uri).past.slice();
+            const oldPastElements = trackedMatch.undoRedoHistory.past.slice();
+            const newElements = currentPastElements.slice(oldPastElements.length);
+            if (newElements.length === 0) {
+                return;
+            }
+            newElementsMap.set(trackedMatch.cellViewModel.uri, newElements);
+            this.undoRedoService.removeElements(trackedMatch.cellViewModel.uri);
+            oldPastElements.forEach(element => {
+                this.undoRedoService.pushElement(element);
+            });
+        });
+        this.undoRedoService.pushElement({
+            type: UndoRedoElementType.Workspace,
+            resources: resources,
+            label: 'Multi Cursor Edit',
+            code: 'multiCursorEdit',
+            confirmBeforeUndo: false,
+            undo: async () => {
+                newElementsMap.forEach(async (value) => {
+                    value.reverse().forEach(async (element) => {
+                        await element.undo();
+                    });
+                });
+            },
+            redo: async () => {
+                newElementsMap.forEach(async (value) => {
+                    value.forEach(async (element) => {
+                        await element.redo();
+                    });
+                });
+            }
+        });
+    }
+    resetToIdleState() {
+        this.state = NotebookMultiCursorState.Idle;
+        this._nbMultiSelectState.set(NotebookMultiCursorState.Idle);
+        this._nbIsMultiSelectSession.set(false);
+        this.updateFinalUndoRedo();
+        this.trackedMatches.forEach(match => {
+            this.clearDecorations(match);
+            match.cellViewModel.setSelections([match.initialSelection]);
+        });
+        this.anchorDisposables.clear();
+        this.cursorsDisposables.clear();
+        this.cursorsControllers.clear();
+        this.trackedMatches = [];
+    }
+    async findAndTrackNextSelection(cell) {
+        if (this.state === NotebookMultiCursorState.Idle) {
+            const textModel = cell.textModel;
+            if (!textModel) {
+                return;
+            }
+            const inputSelection = cell.getSelections()[0];
+            const word = this.getWord(inputSelection, textModel);
+            if (!word) {
+                return;
+            }
+            this.word = word.word;
+            const newSelection = ( (new Selection(
+                inputSelection.startLineNumber,
+                word.startColumn,
+                inputSelection.startLineNumber,
+                word.endColumn
+            )));
+            cell.setSelections([newSelection]);
+            this.anchorCell = this.notebookEditor.activeCellAndCodeEditor;
+            if (!this.anchorCell || this.anchorCell[0].handle !== cell.handle) {
+                throw ( (new Error('Active cell is not the same as the cell passed as context')));
+            }
+            if (!(this.anchorCell[1] instanceof CodeEditorWidget)) {
+                throw ( (new Error('Active cell is not an instance of CodeEditorWidget')));
+            }
+            textModel.pushStackElement();
+            this.trackedMatches = [];
+            const editorConfig = this.constructCellEditorOptions(this.anchorCell[0]);
+            const newMatch = {
+                cellViewModel: cell,
+                initialSelection: inputSelection,
+                wordSelections: [newSelection],
+                config: editorConfig,
+                decorationIds: [],
+                undoRedoHistory: this.undoRedoService.getElements(cell.uri)
+            };
+            this.trackedMatches.push(newMatch);
+            this.initializeMultiSelectDecorations(newMatch);
+            this._nbIsMultiSelectSession.set(true);
+            this.state = NotebookMultiCursorState.Selecting;
+            this._nbMultiSelectState.set(NotebookMultiCursorState.Selecting);
+            this._onDidChangeAnchorCell.fire();
+        }
+        else if (this.state === NotebookMultiCursorState.Selecting) {
+            const notebookTextModel = this.notebookEditor.textModel;
+            if (!notebookTextModel) {
+                return;
+            }
+            const index = this.notebookEditor.getCellIndex(cell);
+            if (index === undefined) {
+                return;
+            }
+            const findResult = notebookTextModel.findNextMatch(this.word, { cellIndex: index, position: cell.getSelections()[cell.getSelections().length - 1].getEndPosition() }, false, true, USUAL_WORD_SEPARATORS
+            );
+            if (!findResult) {
+                return;
+            }
+            const resultCellViewModel = this.notebookEditor.getCellByHandle(findResult.cell.handle);
+            if (!resultCellViewModel) {
+                return;
+            }
+            let newMatch;
+            if (findResult.cell.handle !== cell.handle) {
+                await this.notebookEditor.revealRangeInViewAsync(resultCellViewModel, findResult.match.range);
+                this.notebookEditor.focusNotebookCell(resultCellViewModel, 'editor');
+                const initialSelection = resultCellViewModel.getSelections()[0];
+                const newSelection = Selection.fromRange(findResult.match.range, SelectionDirection.LTR);
+                resultCellViewModel.setSelections([newSelection]);
+                this.anchorCell = this.notebookEditor.activeCellAndCodeEditor;
+                if (!this.anchorCell || !(this.anchorCell[1] instanceof CodeEditorWidget)) {
+                    throw ( (new Error('Active cell is not an instance of CodeEditorWidget')));
+                }
+                const textModel = await resultCellViewModel.resolveTextModel();
+                textModel.pushStackElement();
+                newMatch = {
+                    cellViewModel: resultCellViewModel,
+                    initialSelection: initialSelection,
+                    wordSelections: [newSelection],
+                    config: this.constructCellEditorOptions(this.anchorCell[0]),
+                    decorationIds: [],
+                    undoRedoHistory: this.undoRedoService.getElements(resultCellViewModel.uri)
+                };
+                this.trackedMatches.push(newMatch);
+                this._onDidChangeAnchorCell.fire();
+            }
+            else {
+                newMatch = this.trackedMatches.find(match => match.cellViewModel.handle === findResult.cell.handle);
+                newMatch.wordSelections.push(Selection.fromRange(findResult.match.range, SelectionDirection.LTR));
+                resultCellViewModel.setSelections(newMatch.wordSelections);
+            }
+            this.initializeMultiSelectDecorations(newMatch);
+        }
+    }
+    async deleteLeft() {
+        this.trackedMatches.forEach(match => {
+            const controller = this.cursorsControllers.get(match.cellViewModel.uri);
+            if (!controller) {
+                return;
+            }
+            const [, commands] = DeleteOperations.deleteLeft(controller.getPrevEditOperationType(), controller.context.cursorConfig, controller.context.model, controller.getSelections(), controller.getAutoClosedCharacters());
+            const delSelections = CommandExecutor.executeCommands(controller.context.model, controller.getSelections(), commands);
+            if (!delSelections) {
+                return;
+            }
+            controller.setSelections(( (new ViewModelEventsCollector())), undefined, delSelections, CursorChangeReason.Explicit);
+        });
+    }
+    async undo() {
+        const models = [];
+        for (const match of this.trackedMatches) {
+            const model = await match.cellViewModel.resolveTextModel();
+            if (model) {
+                models.push(model);
+            }
+        }
+        await Promise.all(( (models.map(model => model.undo()))));
+    }
+    async redo() {
+        const models = [];
+        for (const match of this.trackedMatches) {
+            const model = await match.cellViewModel.resolveTextModel();
+            if (model) {
+                models.push(model);
+            }
+        }
+        await Promise.all(( (models.map(model => model.redo()))));
+    }
+    constructCellEditorOptions(cell) {
+        const cellEditorOptions = ( (new CellEditorOptions(
+            this.notebookEditor.getBaseCellEditorOptions(cell.language),
+            this.notebookEditor.notebookOptions,
+            this.configurationService
+        )));
+        const options = cellEditorOptions.getUpdatedValue(cell.internalMetadata, cell.uri);
+        return (
+             (new EditorConfiguration(
+                false,
+                MenuId.EditorContent,
+                false,
+                options,
+                null,
+                this.accessibilityService
+            ))
+        );
+    }
+    initializeMultiSelectDecorations(match) {
+        const decorations = [];
+        match.wordSelections.forEach(selection => {
+            decorations.push({
+                range: selection,
+                options: {
+                    description: '',
+                    className: 'nb-multicursor-selection',
+                }
+            });
+        });
+        match.decorationIds = match.cellViewModel.deltaModelDecorations(match.decorationIds, decorations);
+    }
+    updateLazyDecorations() {
+        this.trackedMatches.forEach(match => {
+            const cellIndex = this.notebookEditor.getCellIndex(match.cellViewModel);
+            if (cellIndex === undefined) {
+                return;
+            }
+            const controller = this.cursorsControllers.get(match.cellViewModel.uri);
+            if (!controller) {
+                return;
+            }
+            const selections = controller.getSelections();
+            const newDecorations = selections?.map(selection => {
+                return {
+                    range: selection,
+                    options: {
+                        description: '',
+                        className: 'nb-multicursor-selection',
+                    }
+                };
+            });
+            match.decorationIds = match.cellViewModel.deltaModelDecorations(match.decorationIds, newDecorations ?? []);
+        });
+    }
+    clearDecorations(match) {
+        match.decorationIds = match.cellViewModel.deltaModelDecorations(match.decorationIds, []);
+    }
+    getWord(selection, model) {
+        const lineNumber = selection.startLineNumber;
+        const startColumn = selection.startColumn;
+        if (model.isDisposed()) {
+            return null;
+        }
+        return model.getWordAtPosition({
+            lineNumber: lineNumber,
+            column: startColumn
+        });
+    }
+    dispose() {
+        super.dispose();
+        this.anchorDisposables.dispose();
+        this.cursorsDisposables.dispose();
+        this.trackedMatches.forEach(match => {
+            this.clearDecorations(match);
+        });
+        this.trackedMatches = [];
+    }
+};
+NotebookMultiCursorController = ( (__decorate([
+    ( (__param(1, IContextKeyService))),
+    ( (__param(2, ITextModelService))),
+    ( (__param(3, ILanguageConfigurationService))),
+    ( (__param(4, IAccessibilityService))),
+    ( (__param(5, IConfigurationService))),
+    ( (__param(6, IUndoRedoService)))
+], NotebookMultiCursorController)));
+class NotebookAddMatchToMultiSelectionAction extends NotebookAction {
+    constructor() {
+        super({
+            id: NOTEBOOK_ADD_FIND_MATCH_TO_SELECTION_ID,
+            title: ( localize(8049, "Add Find Match to Selection")),
+            keybinding: {
+                when: ( (ContextKeyExpr.and(
+                     (ContextKeyExpr.equals('config.notebook.multiSelect.enabled', true)),
+                    NOTEBOOK_IS_ACTIVE_EDITOR,
+                    NOTEBOOK_CELL_EDITOR_FOCUSED
+                ))),
+                primary: KeyMod.CtrlCmd | KeyCode.KeyD,
+                weight: KeybindingWeight.WorkbenchContrib
+            }
+        });
+    }
+    async runWithContext(accessor, context) {
+        const editorService = accessor.get(IEditorService);
+        const editor = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
+        if (!editor) {
+            return;
+        }
+        if (!context.cell) {
+            return;
+        }
+        const controller = editor.getContribution(NotebookMultiCursorController.id);
+        controller.findAndTrackNextSelection(context.cell);
+    }
+}
+class NotebookExitMultiSelectionAction extends NotebookAction {
+    constructor() {
+        super({
+            id: 'noteMultiCursor.exit',
+            title: ( localize(8050, "Exit Multi Cursor Mode")),
+            keybinding: {
+                when: ( (ContextKeyExpr.and(
+                     (ContextKeyExpr.equals('config.notebook.multiSelect.enabled', true)),
+                    NOTEBOOK_IS_ACTIVE_EDITOR,
+                    NOTEBOOK_MULTI_SELECTION_CONTEXT.IsNotebookMultiSelect
+                ))),
+                primary: KeyCode.Escape,
+                weight: KeybindingWeight.WorkbenchContrib
+            }
+        });
+    }
+    async runWithContext(accessor, context) {
+        const editorService = accessor.get(IEditorService);
+        const editor = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
+        if (!editor) {
+            return;
+        }
+        const controller = editor.getContribution(NotebookMultiCursorController.id);
+        controller.resetToIdleState();
+    }
+}
+class NotebookDeleteLeftMultiSelectionAction extends NotebookAction {
+    constructor() {
+        super({
+            id: 'noteMultiCursor.deleteLeft',
+            title: ( localize(8051, "Delete Left")),
+            keybinding: {
+                when: ( (ContextKeyExpr.and(
+                     (ContextKeyExpr.equals('config.notebook.multiSelect.enabled', true)),
+                    NOTEBOOK_IS_ACTIVE_EDITOR,
+                    NOTEBOOK_MULTI_SELECTION_CONTEXT.IsNotebookMultiSelect,
+                     (ContextKeyExpr.or(
+                         (NOTEBOOK_MULTI_SELECTION_CONTEXT.NotebookMultiSelectState.isEqualTo(NotebookMultiCursorState.Selecting)),
+                         (NOTEBOOK_MULTI_SELECTION_CONTEXT.NotebookMultiSelectState.isEqualTo(NotebookMultiCursorState.Editing))
+                    ))
+                ))),
+                primary: KeyCode.Backspace,
+                weight: KeybindingWeight.WorkbenchContrib
+            }
+        });
+    }
+    async runWithContext(accessor, context) {
+        const editorService = accessor.get(IEditorService);
+        const editor = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
+        if (!editor) {
+            return;
+        }
+        const controller = editor.getContribution(NotebookMultiCursorController.id);
+        controller.deleteLeft();
+    }
+}
+let NotebookMultiCursorUndoRedoContribution = class NotebookMultiCursorUndoRedoContribution extends Disposable {
+    static { this.ID = 'workbench.contrib.notebook.multiCursorUndoRedo'; }
+    constructor(_editorService, configurationService) {
+        super();
+        this._editorService = _editorService;
+        this.configurationService = configurationService;
+        if (!this.configurationService.getValue('notebook.multiSelect.enabled')) {
+            return;
+        }
+        const PRIORITY = 10005;
+        this._register(UndoCommand.addImplementation(PRIORITY, 'notebook-multicursor-undo-redo', () => {
+            const editor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
+            if (!editor) {
+                return false;
+            }
+            if (!editor.hasModel()) {
+                return false;
+            }
+            const controller = editor.getContribution(NotebookMultiCursorController.id);
+            return controller.undo();
+        }, ( (ContextKeyExpr.and(
+             (ContextKeyExpr.equals('config.notebook.multiSelect.enabled', true)),
+            NOTEBOOK_IS_ACTIVE_EDITOR,
+            NOTEBOOK_MULTI_SELECTION_CONTEXT.IsNotebookMultiSelect
+        )))));
+        this._register(RedoCommand.addImplementation(PRIORITY, 'notebook-multicursor-undo-redo', () => {
+            const editor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
+            if (!editor) {
+                return false;
+            }
+            if (!editor.hasModel()) {
+                return false;
+            }
+            const controller = editor.getContribution(NotebookMultiCursorController.id);
+            return controller.redo();
+        }, ( (ContextKeyExpr.and(
+             (ContextKeyExpr.equals('config.notebook.multiSelect.enabled', true)),
+            NOTEBOOK_IS_ACTIVE_EDITOR,
+            NOTEBOOK_MULTI_SELECTION_CONTEXT.IsNotebookMultiSelect
+        )))));
+    }
+};
+NotebookMultiCursorUndoRedoContribution = ( (__decorate([
+    ( (__param(0, IEditorService))),
+    ( (__param(1, IConfigurationService)))
+], NotebookMultiCursorUndoRedoContribution)));
+registerNotebookContribution(NotebookMultiCursorController.id, NotebookMultiCursorController);
+registerAction2(NotebookAddMatchToMultiSelectionAction);
+registerAction2(NotebookExitMultiSelectionAction);
+registerAction2(NotebookDeleteLeftMultiSelectionAction);
+registerWorkbenchContribution2(NotebookMultiCursorUndoRedoContribution.ID, NotebookMultiCursorUndoRedoContribution, WorkbenchPhase.BlockRestore);
+
+export { NOTEBOOK_MULTI_SELECTION_CONTEXT, NotebookMultiCursorController };