@codingame/monaco-vscode-notebook-service-override 11.1.2 → 12.0.0

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

@@ -1,18 +1,23 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 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 { CoreEditingCommands } from 'vscode/vscode/vs/editor/browser/coreCommands';
 import { UndoCommand, RedoCommand } from 'vscode/vscode/vs/editor/browser/editorExtensions';
 import { CodeEditorWidget } from 'vscode/vscode/vs/editor/browser/widget/codeEditor/codeEditorWidget';
-import { cursorStyleFromString, cursorBlinkingStyleFromString, TextEditorCursorStyle } from 'vscode/vscode/vs/editor/common/config/editorOptions';
-import { Selection } from 'vscode/vscode/vs/editor/common/core/selection';
+import { cursorStyleFromString, cursorBlinkingStyleFromString, TextEditorCursorStyle, TextEditorCursorBlinkingStyle } from 'vscode/vscode/vs/editor/common/config/editorOptions';
+import { Position } from 'vscode/vscode/vs/editor/common/core/position';
+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 { Handler } from 'vscode/vscode/vs/editor/common/editorCommon';
 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';
@@ -23,25 +28,30 @@ import { MenuId, registerAction2 } from 'vscode/vscode/vs/platform/actions/commo
 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 { registerWorkbenchContribution2 } from 'vscode/vscode/vs/workbench/common/contributions';
+import { registerWorkbenchContribution2, WorkbenchPhase } from 'vscode/vscode/vs/workbench/common/contributions';
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
-import { NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_CELL_EDITOR_FOCUSED } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
-import { NotebookAction } from '@codingame/monaco-vscode-chat-interactive-notebook-search-common/vscode/vs/workbench/contrib/notebook/browser/controller/coreActions';
-import { getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
-import { registerNotebookContribution } from '@codingame/monaco-vscode-chat-interactive-notebook-search-common/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
-import { CellEditorOptions } from '@codingame/monaco-vscode-chat-interactive-notebook-search-common/vscode/vs/workbench/contrib/notebook/browser/view/cellParts/cellEditorOptions';
+import { NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_CELL_EDITOR_FOCUSED, KEYBINDING_CONTEXT_NOTEBOOK_FIND_WIDGET_FOCUSED } from '@codingame/monaco-vscode-4a36e358-d94d-55e0-86ee-3bcd543d9d3f-common/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
+import { NotebookAction } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/browser/controller/coreActions';
+import { getNotebookEditorFromEditorPane } from '@codingame/monaco-vscode-271a23cd-c7d7-5761-ae35-a923a42987b8-common/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { registerNotebookContribution } from '@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
+import { CellEditorOptions } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/browser/view/cellParts/cellEditorOptions';
+import { NotebookFindContrib } from '@codingame/monaco-vscode-1ae7d696-d960-5ac6-97a3-9fe7c8c3a793-common/vscode/vs/workbench/contrib/notebook/browser/contrib/find/notebookFindWidget';
+import { NotebookCellTextModel } from '@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/notebook/common/model/notebookCellTextModel';
 
 const NOTEBOOK_ADD_FIND_MATCH_TO_SELECTION_ID = 'notebook.addFindMatchToSelection';
+const NOTEBOOK_SELECT_ALL_FIND_MATCHES_ID = 'notebook.selectAllFindMatches';
 var NotebookMultiCursorState;
-( ((function(NotebookMultiCursorState) {
+(function (NotebookMultiCursorState) {
     NotebookMultiCursorState[NotebookMultiCursorState["Idle"] = 0] = "Idle";
     NotebookMultiCursorState[NotebookMultiCursorState["Selecting"] = 1] = "Selecting";
     NotebookMultiCursorState[NotebookMultiCursorState["Editing"] = 2] = "Editing";
-})(NotebookMultiCursorState || (NotebookMultiCursorState = {}))));
+})(NotebookMultiCursorState || (NotebookMultiCursorState = {}));
 const NOTEBOOK_MULTI_CURSOR_CONTEXT = {
-    IsNotebookMultiCursor: ( (new RawContextKey('isNotebookMultiSelect', false))),
-    NotebookMultiSelectCursorState: ( (new RawContextKey('notebookMultiSelectCursorState', NotebookMultiCursorState.Idle))),
+    IsNotebookMultiCursor: ( new RawContextKey('isNotebookMultiSelect', false)),
+    NotebookMultiSelectCursorState: ( new RawContextKey('notebookMultiSelectCursorState', NotebookMultiCursorState.Idle)),
 };
 let NotebookMultiCursorController = class NotebookMultiCursorController extends Disposable {
     static { this.id = 'notebook.multiCursorController'; }
@@ -58,46 +68,130 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
         this.configurationService = configurationService;
         this.undoRedoService = undoRedoService;
         this.word = '';
-        this.trackedMatches = [];
-        this._onDidChangeAnchorCell = this._register(( (new Emitter())));
+        this.trackedCells = [];
+        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.anchorDisposables = this._register(( new DisposableStore()));
+        this.cursorsDisposables = this._register(( new DisposableStore()));
+        this.cursorsControllers = ( new ResourceMap());
         this.state = NotebookMultiCursorState.Idle;
         this._nbIsMultiSelectSession = NOTEBOOK_MULTI_CURSOR_CONTEXT.IsNotebookMultiCursor.bindTo(this.contextKeyService);
         this._nbMultiSelectState = NOTEBOOK_MULTI_CURSOR_CONTEXT.NotebookMultiSelectCursorState.bindTo(this.contextKeyService);
         this.anchorCell = this.notebookEditor.activeCellAndCodeEditor;
-        this._register(this.onDidChangeAnchorCell(() => {
-            this.updateCursorsControllers();
-            this.updateAnchorListeners();
+        this._register(this.onDidChangeAnchorCell(async () => {
+            await this.syncCursorsControllers();
+            this.syncAnchorListeners();
+        }));
+    }
+    syncAnchorListeners() {
+        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.trackedCells.forEach(cell => {
+                const controller = this.cursorsControllers.get(cell.cellViewModel.uri);
+                if (!controller) {
+                    return;
+                }
+                if (cell.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.trackedCells.forEach(cell => {
+                const controller = this.cursorsControllers.get(cell.cellViewModel.uri);
+                if (!controller) {
+                    return;
+                }
+                cell.initialSelection = controller.getSelection();
+                cell.matchSelections = [];
+            });
+            this.updateLazyDecorations();
+        }));
+        this.anchorDisposables.add(this.anchorCell[1].onDidChangeCursorSelection((e) => {
+            if (e.source === 'mouse') {
+                this.resetToIdleState();
+                return;
+            }
+            if (!e.oldSelections || e.reason === CursorChangeReason.NotSet || e.reason === CursorChangeReason.RecoverFromMarkers) {
+                return;
+            }
+            const translation = {
+                deltaStartCol: e.selection.startColumn - e.oldSelections[0].startColumn,
+                deltaStartLine: e.selection.startLineNumber - e.oldSelections[0].startLineNumber,
+                deltaEndCol: e.selection.endColumn - e.oldSelections[0].endColumn,
+                deltaEndLine: e.selection.endLineNumber - e.oldSelections[0].endLineNumber,
+            };
+            const translationDir = e.selection.getDirection();
+            this.trackedCells.forEach(cell => {
+                const controller = this.cursorsControllers.get(cell.cellViewModel.uri);
+                if (!controller) {
+                    return;
+                }
+                const newSelections = ( controller.getSelections().map(selection => {
+                    const newStartCol = selection.startColumn + translation.deltaStartCol;
+                    const newStartLine = selection.startLineNumber + translation.deltaStartLine;
+                    const newEndCol = selection.endColumn + translation.deltaEndCol;
+                    const newEndLine = selection.endLineNumber + translation.deltaEndLine;
+                    return Selection.createWithDirection(newStartLine, newStartCol, newEndLine, newEndCol, translationDir);
+                }));
+                controller.setSelections(( new ViewModelEventsCollector()), e.source, newSelections, CursorChangeReason.Explicit);
+            });
+            this.updateLazyDecorations();
+        }));
+        this.anchorDisposables.add(this.anchorCell[1].onWillTriggerEditorOperationEvent((e) => {
+            this.handleEditorOperationEvent(e);
+        }));
+        this.anchorDisposables.add(this.anchorCell[1].onDidBlurEditorWidget(() => {
+            if (this.state === NotebookMultiCursorState.Selecting || this.state === NotebookMultiCursorState.Editing) {
+                this.resetToIdleState();
+            }
         }));
     }
-    updateCursorsControllers() {
+    async syncCursorsControllers() {
         this.cursorsDisposables.clear();
-        this.trackedMatches.forEach(async (match) => {
-            const textModelRef = await this.textModelService.createModelReference(match.cellViewModel.uri);
-            const textModel = textModelRef.object.textEditorModel;
-            if (!textModel) {
+        await Promise.all(( this.trackedCells.map(async (cell) => {
+            const controller = await this.createCursorController(cell);
+            if (!controller) {
                 return;
             }
-            const cursorSimpleModel = this.constructCursorSimpleModel(match.cellViewModel);
-            const converter = this.constructCoordinatesConverter();
-            const editorConfig = match.editorConfig;
-            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, 3 );
-            this.cursorsControllers.set(match.cellViewModel.uri, controller);
-        });
+            this.cursorsControllers.set(cell.cellViewModel.uri, controller);
+            const selections = cell.matchSelections;
+            controller.setSelections(( new ViewModelEventsCollector()), undefined, selections, CursorChangeReason.Explicit);
+        })));
+        this.updateLazyDecorations();
+    }
+    async createCursorController(cell) {
+        const textModelRef = await this.textModelService.createModelReference(cell.cellViewModel.uri);
+        const textModel = textModelRef.object.textEditorModel;
+        if (!textModel) {
+            return undefined;
+        }
+        const cursorSimpleModel = this.constructCursorSimpleModel(cell.cellViewModel);
+        const converter = this.constructCoordinatesConverter();
+        const editorConfig = cell.editorConfig;
+        const controller = this.cursorsDisposables.add(( new CursorsController(textModel, cursorSimpleModel, converter, ( new CursorConfiguration(
+            textModel.getLanguageId(),
+            textModel.getOptions(),
+            editorConfig,
+            this.languageConfigurationService
+        )))));
+        controller.setSelections(( new ViewModelEventsCollector()), undefined, cell.matchSelections, CursorChangeReason.Explicit);
+        return controller;
     }
     constructCoordinatesConverter() {
         return {
@@ -158,128 +252,64 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
             }
         };
     }
-    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) {
+    async handleEditorOperationEvent(e) {
+        this.trackedCells.forEach(cell => {
+            if (cell.cellViewModel.handle === this.anchorCell?.[0].handle) {
                 return;
             }
-            const activeSelections = this.notebookEditor.activeCodeEditor?.getSelections();
-            if (!activeSelections) {
-                return;
-            }
-            anchorController.setSelections(( (new ViewModelEventsCollector())), 'keyboard', activeSelections, 3 );
-            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') {
-                this.resetToIdleState();
+            const eventsCollector = ( new ViewModelEventsCollector());
+            const controller = this.cursorsControllers.get(cell.cellViewModel.uri);
+            if (!controller) {
                 return;
             }
-            if (!e.oldSelections || e.reason === 0  || e.reason === 2 ) {
+            this.executeEditorOperation(controller, eventsCollector, e);
+        });
+    }
+    executeEditorOperation(controller, eventsCollector, e) {
+        switch (e.handlerId) {
+            case Handler.CompositionStart:
+                controller.startComposition(eventsCollector);
+                break;
+            case Handler.CompositionEnd:
+                controller.endComposition(eventsCollector, e.source);
+                break;
+            case Handler.ReplacePreviousChar: {
+                const args = e.payload;
+                controller.compositionType(eventsCollector, args.text || '', args.replaceCharCnt || 0, 0, 0, e.source);
+                break;
+            }
+            case Handler.CompositionType: {
+                const args = e.payload;
+                controller.compositionType(eventsCollector, args.text || '', args.replacePrevCharCnt || 0, args.replaceNextCharCnt || 0, args.positionDelta || 0, e.source);
+                break;
+            }
+            case Handler.Paste: {
+                const args = e.payload;
+                controller.paste(eventsCollector, args.text || '', args.pasteOnNewLine || false, args.multicursorText || null, e.source);
+                break;
+            }
+            case Handler.Cut:
+                controller.cut(eventsCollector, e.source);
+                break;
+        }
+    }
+    updateViewModelSelections() {
+        for (const cell of this.trackedCells) {
+            const controller = this.cursorsControllers.get(cell.cellViewModel.uri);
+            if (!controller) {
                 return;
             }
-            const translation = {
-                deltaStartCol: e.selection.startColumn - e.oldSelections[0].startColumn,
-                deltaStartLine: e.selection.startLineNumber - e.oldSelections[0].startLineNumber,
-                deltaEndCol: e.selection.endColumn - e.oldSelections[0].endColumn,
-                deltaEndLine: e.selection.endLineNumber - e.oldSelections[0].endLineNumber,
-            };
-            const translationDir = e.selection.getDirection();
-            this.trackedMatches.forEach(match => {
-                const controller = this.cursorsControllers.get(match.cellViewModel.uri);
-                if (!controller) {
-                    return;
-                }
-                const newSelections = ( (controller.getSelections().map(selection => {
-                    const newStartCol = selection.startColumn + translation.deltaStartCol;
-                    const newStartLine = selection.startLineNumber + translation.deltaStartLine;
-                    const newEndCol = selection.endColumn + translation.deltaEndCol;
-                    const newEndLine = selection.endLineNumber + translation.deltaEndLine;
-                    return Selection.createWithDirection(newStartLine, newStartCol, newEndLine, newEndCol, translationDir);
-                })));
-                controller.setSelections(( (new ViewModelEventsCollector())), e.source, newSelections, 3 );
-            });
-            this.updateLazyDecorations();
-        }));
-        this.anchorDisposables.add(this.anchorCell[1].onWillTriggerEditorOperationEvent((e) => {
-            this.trackedMatches.forEach(match => {
-                if (match.cellViewModel.handle === this.anchorCell?.[0].handle) {
-                    return;
-                }
-                const eventsCollector = ( (new ViewModelEventsCollector()));
-                const controller = this.cursorsControllers.get(match.cellViewModel.uri);
-                if (!controller) {
-                    return;
-                }
-                switch (e.handlerId) {
-                    case "compositionStart" :
-                        controller.startComposition(eventsCollector);
-                        return;
-                    case "compositionEnd" :
-                        controller.endComposition(eventsCollector, e.source);
-                        return;
-                    case "replacePreviousChar" : {
-                        const args = e.payload;
-                        controller.compositionType(eventsCollector, args.text || '', args.replaceCharCnt || 0, 0, 0, e.source);
-                        return;
-                    }
-                    case "compositionType" : {
-                        const args = e.payload;
-                        controller.compositionType(eventsCollector, args.text || '', args.replacePrevCharCnt || 0, args.replaceNextCharCnt || 0, args.positionDelta || 0, e.source);
-                        return;
-                    }
-                    case "paste" : {
-                        const args = e.payload;
-                        controller.paste(eventsCollector, args.text || '', args.pasteOnNewLine || false, args.multicursorText || null, e.source);
-                        return;
-                    }
-                    case "cut" :
-                        controller.cut(eventsCollector, e.source);
-                        return;
-                }
-            });
-        }));
-        this.anchorDisposables.add(this.anchorCell[1].onDidBlurEditorWidget(() => {
-            if (this.state === NotebookMultiCursorState.Selecting || this.state === NotebookMultiCursorState.Editing) {
-                this.resetToIdleState();
-            }
-        }));
+            cell.cellViewModel.setSelections(controller.getSelections());
+        }
     }
     updateFinalUndoRedo() {
         const anchorCellModel = this.anchorCell?.[1].getModel();
         if (!anchorCellModel) {
             return;
         }
-        const newElementsMap = ( (new ResourceMap()));
+        const newElementsMap = ( new ResourceMap());
         const resources = [];
-        this.trackedMatches.forEach(trackedMatch => {
+        this.trackedCells.forEach(trackedMatch => {
             const undoRedoState = trackedMatch.undoRedoHistory;
             if (!undoRedoState) {
                 return;
@@ -298,7 +328,7 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
             });
         });
         this.undoRedoService.pushElement({
-            type: 1 ,
+            type: UndoRedoElementType.Workspace,
             resources: resources,
             label: 'Multi Cursor Edit',
             code: 'multiCursorEdit',
@@ -324,61 +354,53 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
         this._nbMultiSelectState.set(NotebookMultiCursorState.Idle);
         this._nbIsMultiSelectSession.set(false);
         this.updateFinalUndoRedo();
-        this.trackedMatches.forEach(match => {
-            this.clearDecorations(match);
-            match.cellViewModel.setSelections([match.initialSelection]);
+        this.trackedCells.forEach(cell => {
+            this.clearDecorations(cell);
+            cell.cellViewModel.setSelections([cell.initialSelection]);
         });
         this.anchorDisposables.clear();
         this.anchorCell = undefined;
         this.cursorsDisposables.clear();
         this.cursorsControllers.clear();
-        this.trackedMatches = [];
+        this.trackedCells = [];
+        this.startPosition = undefined;
+        this.word = '';
     }
-    async findAndTrackNextSelection(cell) {
+    async findAndTrackNextSelection(focusedCell) {
         if (this.state === NotebookMultiCursorState.Idle) {
-            const textModel = cell.textModel;
+            const textModel = focusedCell.textModel;
             if (!textModel) {
                 return;
             }
-            const inputSelection = cell.getSelections()[0];
+            const inputSelection = focusedCell.getSelections()[0];
             const word = this.getWord(inputSelection, textModel);
             if (!word) {
                 return;
             }
             this.word = word.word;
-            const newSelection = ( (new Selection(
+            const index = this.notebookEditor.getCellIndex(focusedCell);
+            if (index === undefined) {
+                return;
+            }
+            this.startPosition = {
+                cellIndex: index,
+                position: ( new Position(inputSelection.startLineNumber, word.startColumn)),
+            };
+            const newSelection = ( new Selection(
                 inputSelection.startLineNumber,
                 word.startColumn,
                 inputSelection.startLineNumber,
                 word.endColumn
-            )));
-            cell.setSelections([newSelection]);
+            ));
+            focusedCell.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 || this.anchorCell[0].handle !== focusedCell.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')));
+                throw ( new Error('Active cell is not an instance of CodeEditorWidget'));
             }
-            textModel.pushStackElement();
-            this.trackedMatches = [];
-            const editorConfig = this.constructCellEditorOptions(this.anchorCell[0]);
-            const rawEditorOptions = editorConfig.getRawOptions();
-            const cursorConfig = {
-                cursorStyle: cursorStyleFromString(rawEditorOptions.cursorStyle),
-                cursorBlinking: cursorBlinkingStyleFromString(rawEditorOptions.cursorBlinking),
-                cursorSmoothCaretAnimation: rawEditorOptions.cursorSmoothCaretAnimation
-            };
-            const newMatch = {
-                cellViewModel: cell,
-                initialSelection: inputSelection,
-                wordSelections: [newSelection],
-                editorConfig: editorConfig,
-                cursorConfig: cursorConfig,
-                decorationIds: [],
-                undoRedoHistory: this.undoRedoService.getElements(cell.uri)
-            };
-            this.trackedMatches.push(newMatch);
+            await this.updateTrackedCell(focusedCell, [newSelection]);
             this._nbIsMultiSelectSession.set(true);
             this.state = NotebookMultiCursorState.Selecting;
             this._nbMultiSelectState.set(NotebookMultiCursorState.Selecting);
@@ -389,73 +411,161 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
             if (!notebookTextModel) {
                 return;
             }
-            const index = this.notebookEditor.getCellIndex(cell);
+            const index = this.notebookEditor.getCellIndex(focusedCell);
             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 (!this.startPosition) {
+                return;
+            }
+            const findResult = notebookTextModel.findNextMatch(this.word, { cellIndex: index, position: focusedCell.getSelections()[focusedCell.getSelections().length - 1].getEndPosition() }, false, true, USUAL_WORD_SEPARATORS, this.startPosition);
             if (!findResult) {
                 return;
             }
-            const resultCellViewModel = this.notebookEditor.getCellByHandle(findResult.cell.handle);
-            if (!resultCellViewModel) {
+            const findResultCellViewModel = this.notebookEditor.getCellByHandle(findResult.cell.handle);
+            if (!findResultCellViewModel) {
                 return;
             }
-            let newMatch;
-            if (findResult.cell.handle === cell.handle) {
-                newMatch = this.trackedMatches.find(match => match.cellViewModel.handle === findResult.cell.handle);
-                newMatch.wordSelections.push(Selection.fromRange(findResult.match.range, 0 ));
-                resultCellViewModel.setSelections(newMatch.wordSelections);
-                const controller = this.cursorsControllers.get(newMatch.cellViewModel.uri);
-                if (!controller) {
-                    return;
-                }
-                controller.setSelections(( (new ViewModelEventsCollector())), undefined, newMatch.wordSelections, 3 );
-            }
-            else 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, 0 );
-                resultCellViewModel.setSelections([newSelection]);
-                if (this.notebookEditor.activeCellAndCodeEditor?.[0].handle !== resultCellViewModel.handle) {
-                    throw ( (new Error('Focused cell does not match the find match data')));
-                }
+            if (findResult.cell.handle === focusedCell.handle) {
+                const selections = [...focusedCell.getSelections(), Selection.fromRange(findResult.match.range, SelectionDirection.LTR)];
+                const trackedCell = await this.updateTrackedCell(focusedCell, selections);
+                findResultCellViewModel.setSelections(trackedCell.matchSelections);
+            }
+            else if (findResult.cell.handle !== focusedCell.handle) {
+                await this.notebookEditor.revealRangeInViewAsync(findResultCellViewModel, findResult.match.range);
+                await this.notebookEditor.focusNotebookCell(findResultCellViewModel, 'editor');
+                const trackedCell = await this.updateTrackedCell(findResultCellViewModel, [Selection.fromRange(findResult.match.range, SelectionDirection.LTR)]);
+                findResultCellViewModel.setSelections(trackedCell.matchSelections);
                 this.anchorCell = this.notebookEditor.activeCellAndCodeEditor;
                 if (!this.anchorCell || !(this.anchorCell[1] instanceof CodeEditorWidget)) {
-                    throw ( (new Error('Active cell is not an instance of CodeEditorWidget')));
+                    throw ( new Error('Active cell is not an instance of CodeEditorWidget'));
                 }
-                const textModel = await resultCellViewModel.resolveTextModel();
-                textModel.pushStackElement();
-                const editorConfig = this.constructCellEditorOptions(this.anchorCell[0]);
-                const rawEditorOptions = editorConfig.getRawOptions();
-                const cursorConfig = {
-                    cursorStyle: cursorStyleFromString(rawEditorOptions.cursorStyle),
-                    cursorBlinking: cursorBlinkingStyleFromString(rawEditorOptions.cursorBlinking),
-                    cursorSmoothCaretAnimation: rawEditorOptions.cursorSmoothCaretAnimation
-                };
-                newMatch = {
-                    cellViewModel: resultCellViewModel,
-                    initialSelection: initialSelection,
-                    wordSelections: [newSelection],
-                    editorConfig: editorConfig,
-                    cursorConfig: cursorConfig,
-                    decorationIds: [],
-                    undoRedoHistory: this.undoRedoService.getElements(resultCellViewModel.uri)
-                };
-                this.trackedMatches.push(newMatch);
                 this._onDidChangeAnchorCell.fire();
-                this.initializeMultiSelectDecorations(this.trackedMatches.find(match => match.cellViewModel.handle === cell.handle));
+                this.initializeMultiSelectDecorations(this.trackedCells.find(trackedCell => trackedCell.cellViewModel.handle === focusedCell.handle));
             }
-            else {
+        }
+    }
+    async selectAllMatches(focusedCell, matches) {
+        const notebookTextModel = this.notebookEditor.textModel;
+        if (!notebookTextModel) {
+            return;
+        }
+        if (matches) {
+            await this.handleFindWidgetSelectAllMatches(matches);
+        }
+        else {
+            await this.handleCellEditorSelectAllMatches(notebookTextModel, focusedCell);
+        }
+        await this.syncCursorsControllers();
+        this.syncAnchorListeners();
+        this.updateLazyDecorations();
+    }
+    async handleFindWidgetSelectAllMatches(matches) {
+        if (this.state !== NotebookMultiCursorState.Idle) {
+            return;
+        }
+        if (!matches.length) {
+            return;
+        }
+        await this.notebookEditor.focusNotebookCell(matches[0].cell, 'editor');
+        this.anchorCell = this.notebookEditor.activeCellAndCodeEditor;
+        this.trackedCells = [];
+        for (const match of matches) {
+            this.updateTrackedCell(match.cell, ( match.contentMatches.map(match => Selection.fromRange(match.range, SelectionDirection.LTR))));
+            if (this.anchorCell && match.cell.handle === this.anchorCell[0].handle) {
+                match.cell.setSelections(( match.contentMatches.map(match => Selection.fromRange(match.range, SelectionDirection.LTR))));
+            }
+        }
+        this._nbIsMultiSelectSession.set(true);
+        this.state = NotebookMultiCursorState.Selecting;
+        this._nbMultiSelectState.set(NotebookMultiCursorState.Selecting);
+    }
+    async handleCellEditorSelectAllMatches(notebookTextModel, focusedCell) {
+        if (this.state === NotebookMultiCursorState.Idle) {
+            const textModel = focusedCell.textModel;
+            if (!textModel) {
                 return;
             }
+            const inputSelection = focusedCell.getSelections()[0];
+            const word = this.getWord(inputSelection, textModel);
+            if (!word) {
+                return;
+            }
+            this.word = word.word;
+            const index = this.notebookEditor.getCellIndex(focusedCell);
+            if (index === undefined) {
+                return;
+            }
+            this.startPosition = {
+                cellIndex: index,
+                position: ( new Position(inputSelection.startLineNumber, word.startColumn)),
+            };
+            this.anchorCell = this.notebookEditor.activeCellAndCodeEditor;
+            if (!this.anchorCell || this.anchorCell[0].handle !== focusedCell.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'));
+            }
+            const findResults = notebookTextModel.findMatches(this.word, false, true, USUAL_WORD_SEPARATORS);
+            this.trackedCells = [];
+            for (const res of findResults) {
+                await this.updateTrackedCell(res.cell, ( res.matches.map(match => Selection.fromRange(match.range, SelectionDirection.LTR))));
+                if (res.cell.handle === focusedCell.handle) {
+                    const cellViewModel = this.notebookEditor.getCellByHandle(res.cell.handle);
+                    if (cellViewModel) {
+                        cellViewModel.setSelections(( res.matches.map(match => Selection.fromRange(match.range, SelectionDirection.LTR))));
+                    }
+                }
+            }
+            this._nbIsMultiSelectSession.set(true);
+            this.state = NotebookMultiCursorState.Selecting;
+            this._nbMultiSelectState.set(NotebookMultiCursorState.Selecting);
+        }
+        else if (this.state === NotebookMultiCursorState.Selecting) {
+            const findResults = notebookTextModel.findMatches(this.word, false, true, USUAL_WORD_SEPARATORS);
+            for (const res of findResults) {
+                await this.updateTrackedCell(res.cell, ( res.matches.map(match => Selection.fromRange(match.range, SelectionDirection.LTR))));
+            }
         }
     }
+    async updateTrackedCell(cell, selections) {
+        const cellViewModel = cell instanceof NotebookCellTextModel ? this.notebookEditor.getCellByHandle(cell.handle) : cell;
+        if (!cellViewModel) {
+            throw ( new Error('Cell not found'));
+        }
+        let trackedMatch = this.trackedCells.find(trackedCell => trackedCell.cellViewModel.handle === cellViewModel.handle);
+        if (trackedMatch) {
+            this.clearDecorations(trackedMatch);
+            trackedMatch.matchSelections = selections;
+        }
+        else {
+            const initialSelection = cellViewModel.getSelections()[0];
+            const textModel = await cellViewModel.resolveTextModel();
+            textModel.pushStackElement();
+            const editorConfig = this.constructCellEditorOptions(cellViewModel);
+            const rawEditorOptions = editorConfig.getRawOptions();
+            const cursorConfig = {
+                cursorStyle: cursorStyleFromString(rawEditorOptions.cursorStyle),
+                cursorBlinking: cursorBlinkingStyleFromString(rawEditorOptions.cursorBlinking),
+                cursorSmoothCaretAnimation: rawEditorOptions.cursorSmoothCaretAnimation
+            };
+            trackedMatch = {
+                cellViewModel: cellViewModel,
+                initialSelection: initialSelection,
+                matchSelections: selections,
+                editorConfig: editorConfig,
+                cursorConfig: cursorConfig,
+                decorationIds: [],
+                undoRedoHistory: this.undoRedoService.getElements(cellViewModel.uri)
+            };
+            this.trackedCells.push(trackedMatch);
+        }
+        return trackedMatch;
+    }
     async deleteLeft() {
-        this.trackedMatches.forEach(match => {
-            const controller = this.cursorsControllers.get(match.cellViewModel.uri);
+        this.trackedCells.forEach(cell => {
+            const controller = this.cursorsControllers.get(cell.cellViewModel.uri);
             if (!controller) {
                 return;
             }
@@ -464,102 +574,92 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
             if (!delSelections) {
                 return;
             }
-            controller.setSelections(( (new ViewModelEventsCollector())), undefined, delSelections, 3 );
+            controller.setSelections(( new ViewModelEventsCollector()), undefined, delSelections, CursorChangeReason.Explicit);
         });
         this.updateLazyDecorations();
     }
     async deleteRight() {
-        this.trackedMatches.forEach(match => {
-            const controller = this.cursorsControllers.get(match.cellViewModel.uri);
+        this.trackedCells.forEach(cell => {
+            const controller = this.cursorsControllers.get(cell.cellViewModel.uri);
             if (!controller) {
                 return;
             }
             const [, commands] = DeleteOperations.deleteRight(controller.getPrevEditOperationType(), controller.context.cursorConfig, controller.context.model, controller.getSelections());
-            if (match.cellViewModel.handle !== this.anchorCell?.[0].handle) {
+            if (cell.cellViewModel.handle !== this.anchorCell?.[0].handle) {
                 const delSelections = CommandExecutor.executeCommands(controller.context.model, controller.getSelections(), commands);
                 if (!delSelections) {
                     return;
                 }
-                controller.setSelections(( (new ViewModelEventsCollector())), undefined, delSelections, 3 );
+                controller.setSelections(( new ViewModelEventsCollector()), undefined, delSelections, CursorChangeReason.Explicit);
             }
             else {
-                controller.setSelections(( (new ViewModelEventsCollector())), undefined, match.cellViewModel.getSelections(), 3 );
+                controller.setSelections(( new ViewModelEventsCollector()), undefined, cell.cellViewModel.getSelections(), CursorChangeReason.Explicit);
             }
         });
         this.updateLazyDecorations();
     }
     async undo() {
         const models = [];
-        for (const match of this.trackedMatches) {
-            const model = await match.cellViewModel.resolveTextModel();
+        for (const cell of this.trackedCells) {
+            const model = await cell.cellViewModel.resolveTextModel();
             if (model) {
                 models.push(model);
             }
-            const controller = this.cursorsControllers.get(match.cellViewModel.uri);
-            if (!controller) {
-                return;
-            }
-            controller.setSelections(( (new ViewModelEventsCollector())), undefined, match.cellViewModel.getSelections(), 3 );
         }
-        await Promise.all(( (models.map(model => model.undo()))));
+        await Promise.all(( models.map(model => model.undo())));
+        this.updateViewModelSelections();
         this.updateLazyDecorations();
     }
     async redo() {
         const models = [];
-        for (const match of this.trackedMatches) {
-            const model = await match.cellViewModel.resolveTextModel();
+        for (const cell of this.trackedCells) {
+            const model = await cell.cellViewModel.resolveTextModel();
             if (model) {
                 models.push(model);
             }
-            const controller = this.cursorsControllers.get(match.cellViewModel.uri);
-            if (!controller) {
-                return;
-            }
-            controller.setSelections(( (new ViewModelEventsCollector())), undefined, match.cellViewModel.getSelections(), 3 );
         }
-        await Promise.all(( (models.map(model => model.redo()))));
+        await Promise.all(( models.map(model => model.redo())));
+        this.updateViewModelSelections();
         this.updateLazyDecorations();
     }
     constructCellEditorOptions(cell) {
-        const cellEditorOptions = ( (new CellEditorOptions(
+        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, isCurrentWord) {
-        if (!match) {
+        return ( new EditorConfiguration(
+            false,
+            MenuId.EditorContent,
+            false,
+            options,
+            null,
+            this.accessibilityService
+        ));
+    }
+    initializeMultiSelectDecorations(cell) {
+        if (!cell) {
             return;
         }
         const decorations = [];
-        match.wordSelections.forEach(selection => {
+        cell.matchSelections.forEach(selection => {
             decorations.push({
                 range: Selection.fromPositions(selection.getEndPosition()),
                 options: {
                     description: '',
-                    className: this.getClassName(match.cursorConfig, true),
+                    className: this.getClassName(cell.cursorConfig, true),
                 }
             });
         });
-        match.decorationIds = match.cellViewModel.deltaModelDecorations(match.decorationIds, decorations);
+        cell.decorationIds = cell.cellViewModel.deltaModelDecorations(cell.decorationIds, decorations);
     }
     updateLazyDecorations() {
-        this.trackedMatches.forEach(match => {
-            if (match.cellViewModel.handle === this.anchorCell?.[0].handle) {
+        this.trackedCells.forEach(cell => {
+            if (cell.cellViewModel.handle === this.anchorCell?.[0].handle) {
                 return;
             }
-            const controller = this.cursorsControllers.get(match.cellViewModel.uri);
+            const controller = this.cursorsControllers.get(cell.cellViewModel.uri);
             if (!controller) {
                 return;
             }
@@ -572,7 +672,7 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
                         range: selection,
                         options: {
                             description: '',
-                            className: this.getClassName(match.cursorConfig, false),
+                            className: this.getClassName(cell.cursorConfig, false),
                         }
                     });
                 }
@@ -581,19 +681,19 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
                     options: {
                         description: '',
                         zIndex: 10000,
-                        className: this.getClassName(match.cursorConfig, true),
+                        className: this.getClassName(cell.cursorConfig, true),
                     }
                 });
             });
-            match.decorationIds = match.cellViewModel.deltaModelDecorations(match.decorationIds, newDecorations);
-            const matchingEditor = this.notebookEditor.codeEditors.find(cellEditor => cellEditor[0] === match.cellViewModel);
+            cell.decorationIds = cell.cellViewModel.deltaModelDecorations(cell.decorationIds, newDecorations);
+            const matchingEditor = this.notebookEditor.codeEditors.find(cellEditor => cellEditor[0] === cell.cellViewModel);
             if (matchingEditor) {
                 WordHighlighterContribution.get(matchingEditor[1])?.wordHighlighter?.trigger();
             }
         });
     }
-    clearDecorations(match) {
-        match.decorationIds = match.cellViewModel.deltaModelDecorations(match.decorationIds, []);
+    clearDecorations(cell) {
+        cell.decorationIds = cell.cellViewModel.deltaModelDecorations(cell.decorationIds, []);
     }
     getWord(selection, model) {
         const lineNumber = selection.startLineNumber;
@@ -629,19 +729,19 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
                     break;
             }
             switch (cursorConfig.cursorBlinking) {
-                case 1 :
+                case TextEditorCursorBlinkingStyle.Blink:
                     result += '.nb-blink';
                     break;
-                case 2 :
+                case TextEditorCursorBlinkingStyle.Smooth:
                     result += '.nb-smooth';
                     break;
-                case 3 :
+                case TextEditorCursorBlinkingStyle.Phase:
                     result += '.nb-phase';
                     break;
-                case 4 :
+                case TextEditorCursorBlinkingStyle.Expand:
                     result += '.nb-expand';
                     break;
-                case 5 :
+                case TextEditorCursorBlinkingStyle.Solid:
                     result += '.nb-solid';
                     break;
                 default:
@@ -658,38 +758,63 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
         super.dispose();
         this.anchorDisposables.dispose();
         this.cursorsDisposables.dispose();
-        this.trackedMatches.forEach(match => {
-            this.clearDecorations(match);
+        this.trackedCells.forEach(cell => {
+            this.clearDecorations(cell);
         });
-        this.trackedMatches = [];
+        this.trackedCells = [];
     }
 };
-NotebookMultiCursorController = ( (__decorate([
-    ( (__param(1, IContextKeyService))),
-    ( (__param(2, ITextModelService))),
-    ( (__param(3, ILanguageConfigurationService))),
-    ( (__param(4, IAccessibilityService))),
-    ( (__param(5, IConfigurationService))),
-    ( (__param(6, IUndoRedoService)))
-], NotebookMultiCursorController)));
+NotebookMultiCursorController = ( __decorate([
+    ( __param(1, IContextKeyService)),
+    ( __param(2, ITextModelService)),
+    ( __param(3, ILanguageConfigurationService)),
+    ( __param(4, IAccessibilityService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IUndoRedoService))
+], NotebookMultiCursorController));
+class NotebookSelectAllFindMatches extends NotebookAction {
+    constructor() {
+        super({
+            id: NOTEBOOK_SELECT_ALL_FIND_MATCHES_ID,
+            title: ( localize(7358, "Select All Occurrences of Find Match")),
+            precondition: ( ContextKeyExpr.and(( ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)))),
+            keybinding: {
+                when: ( ContextKeyExpr.or(( ContextKeyExpr.and(( ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)), NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_CELL_EDITOR_FOCUSED)), ( ContextKeyExpr.and(( ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)), KEYBINDING_CONTEXT_NOTEBOOK_FIND_WIDGET_FOCUSED)))),
+                primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.KeyL,
+                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 cursorController = editor.getContribution(NotebookMultiCursorController.id);
+        const findController = editor.getContribution(NotebookFindContrib.id);
+        if (findController.widget.isFocused) {
+            const findModel = findController.widget.findModel;
+            cursorController.selectAllMatches(context.cell, findModel.findMatches);
+        }
+        else {
+            cursorController.selectAllMatches(context.cell);
+        }
+    }
+}
 class NotebookAddMatchToMultiSelectionAction extends NotebookAction {
     constructor() {
         super({
             id: NOTEBOOK_ADD_FIND_MATCH_TO_SELECTION_ID,
-            title: ( localize(8199, "Add Find Match to Selection")),
-            precondition: ( (ContextKeyExpr.and(
-                 (ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)),
-                NOTEBOOK_IS_ACTIVE_EDITOR,
-                NOTEBOOK_CELL_EDITOR_FOCUSED
-            ))),
+            title: ( localize(7359, "Add Selection To Next Find Match")),
+            precondition: ( ContextKeyExpr.and(( ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)), NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_CELL_EDITOR_FOCUSED)),
             keybinding: {
-                when: ( (ContextKeyExpr.and(
-                     (ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)),
-                    NOTEBOOK_IS_ACTIVE_EDITOR,
-                    NOTEBOOK_CELL_EDITOR_FOCUSED
-                ))),
-                primary: 2048  | 34 ,
-                weight: 200
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)), NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_CELL_EDITOR_FOCUSED)),
+                primary: KeyMod.CtrlCmd | KeyCode.KeyD,
+                weight: KeybindingWeight.WorkbenchContrib
             }
         });
     }
@@ -710,20 +835,12 @@ class NotebookExitMultiSelectionAction extends NotebookAction {
     constructor() {
         super({
             id: 'noteMultiCursor.exit',
-            title: ( localize(8200, "Exit Multi Cursor Mode")),
-            precondition: ( (ContextKeyExpr.and(
-                 (ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)),
-                NOTEBOOK_IS_ACTIVE_EDITOR,
-                NOTEBOOK_MULTI_CURSOR_CONTEXT.IsNotebookMultiCursor
-            ))),
+            title: ( localize(7360, "Exit Multi Cursor Mode")),
+            precondition: ( ContextKeyExpr.and(( ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)), NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_MULTI_CURSOR_CONTEXT.IsNotebookMultiCursor)),
             keybinding: {
-                when: ( (ContextKeyExpr.and(
-                     (ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)),
-                    NOTEBOOK_IS_ACTIVE_EDITOR,
-                    NOTEBOOK_MULTI_CURSOR_CONTEXT.IsNotebookMultiCursor
-                ))),
-                primary: 9 ,
-                weight: 200
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)), NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_MULTI_CURSOR_CONTEXT.IsNotebookMultiCursor)),
+                primary: KeyCode.Escape,
+                weight: KeybindingWeight.WorkbenchContrib
             }
         });
     }
@@ -741,28 +858,12 @@ class NotebookDeleteLeftMultiSelectionAction extends NotebookAction {
     constructor() {
         super({
             id: 'noteMultiCursor.deleteLeft',
-            title: ( localize(8201, "Delete Left")),
-            precondition: ( (ContextKeyExpr.and(
-                 (ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)),
-                NOTEBOOK_IS_ACTIVE_EDITOR,
-                NOTEBOOK_MULTI_CURSOR_CONTEXT.IsNotebookMultiCursor,
-                 (ContextKeyExpr.or(
-                     (NOTEBOOK_MULTI_CURSOR_CONTEXT.NotebookMultiSelectCursorState.isEqualTo(NotebookMultiCursorState.Selecting)),
-                     (NOTEBOOK_MULTI_CURSOR_CONTEXT.NotebookMultiSelectCursorState.isEqualTo(NotebookMultiCursorState.Editing))
-                ))
-            ))),
+            title: ( localize(7361, "Delete Left")),
+            precondition: ( ContextKeyExpr.and(( ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)), NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_MULTI_CURSOR_CONTEXT.IsNotebookMultiCursor, ( ContextKeyExpr.or(( NOTEBOOK_MULTI_CURSOR_CONTEXT.NotebookMultiSelectCursorState.isEqualTo(NotebookMultiCursorState.Selecting)), ( NOTEBOOK_MULTI_CURSOR_CONTEXT.NotebookMultiSelectCursorState.isEqualTo(NotebookMultiCursorState.Editing)))))),
             keybinding: {
-                when: ( (ContextKeyExpr.and(
-                     (ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)),
-                    NOTEBOOK_IS_ACTIVE_EDITOR,
-                    NOTEBOOK_MULTI_CURSOR_CONTEXT.IsNotebookMultiCursor,
-                     (ContextKeyExpr.or(
-                         (NOTEBOOK_MULTI_CURSOR_CONTEXT.NotebookMultiSelectCursorState.isEqualTo(NotebookMultiCursorState.Selecting)),
-                         (NOTEBOOK_MULTI_CURSOR_CONTEXT.NotebookMultiSelectCursorState.isEqualTo(NotebookMultiCursorState.Editing))
-                    ))
-                ))),
-                primary: 1 ,
-                weight: 200
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)), NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_MULTI_CURSOR_CONTEXT.IsNotebookMultiCursor, ( ContextKeyExpr.or(( NOTEBOOK_MULTI_CURSOR_CONTEXT.NotebookMultiSelectCursorState.isEqualTo(NotebookMultiCursorState.Selecting)), ( NOTEBOOK_MULTI_CURSOR_CONTEXT.NotebookMultiSelectCursorState.isEqualTo(NotebookMultiCursorState.Editing)))))),
+                primary: KeyCode.Backspace,
+                weight: KeybindingWeight.WorkbenchContrib
             }
         });
     }
@@ -780,28 +881,12 @@ class NotebookDeleteRightMultiSelectionAction extends NotebookAction {
     constructor() {
         super({
             id: 'noteMultiCursor.deleteRight',
-            title: ( localize(8202, "Delete Right")),
-            precondition: ( (ContextKeyExpr.and(
-                 (ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)),
-                NOTEBOOK_IS_ACTIVE_EDITOR,
-                NOTEBOOK_MULTI_CURSOR_CONTEXT.IsNotebookMultiCursor,
-                 (ContextKeyExpr.or(
-                     (NOTEBOOK_MULTI_CURSOR_CONTEXT.NotebookMultiSelectCursorState.isEqualTo(NotebookMultiCursorState.Selecting)),
-                     (NOTEBOOK_MULTI_CURSOR_CONTEXT.NotebookMultiSelectCursorState.isEqualTo(NotebookMultiCursorState.Editing))
-                ))
-            ))),
+            title: ( localize(7362, "Delete Right")),
+            precondition: ( ContextKeyExpr.and(( ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)), NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_MULTI_CURSOR_CONTEXT.IsNotebookMultiCursor, ( ContextKeyExpr.or(( NOTEBOOK_MULTI_CURSOR_CONTEXT.NotebookMultiSelectCursorState.isEqualTo(NotebookMultiCursorState.Selecting)), ( NOTEBOOK_MULTI_CURSOR_CONTEXT.NotebookMultiSelectCursorState.isEqualTo(NotebookMultiCursorState.Editing)))))),
             keybinding: {
-                when: ( (ContextKeyExpr.and(
-                     (ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)),
-                    NOTEBOOK_IS_ACTIVE_EDITOR,
-                    NOTEBOOK_MULTI_CURSOR_CONTEXT.IsNotebookMultiCursor,
-                     (ContextKeyExpr.or(
-                         (NOTEBOOK_MULTI_CURSOR_CONTEXT.NotebookMultiSelectCursorState.isEqualTo(NotebookMultiCursorState.Selecting)),
-                         (NOTEBOOK_MULTI_CURSOR_CONTEXT.NotebookMultiSelectCursorState.isEqualTo(NotebookMultiCursorState.Editing))
-                    ))
-                ))),
-                primary: 20 ,
-                weight: 200
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)), NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_MULTI_CURSOR_CONTEXT.IsNotebookMultiCursor, ( ContextKeyExpr.or(( NOTEBOOK_MULTI_CURSOR_CONTEXT.NotebookMultiSelectCursorState.isEqualTo(NotebookMultiCursorState.Selecting)), ( NOTEBOOK_MULTI_CURSOR_CONTEXT.NotebookMultiSelectCursorState.isEqualTo(NotebookMultiCursorState.Editing)))))),
+                primary: KeyCode.Delete,
+                weight: KeybindingWeight.WorkbenchContrib
             }
         });
     }
@@ -840,11 +925,7 @@ let NotebookMultiCursorUndoRedoContribution = class NotebookMultiCursorUndoRedoC
             }
             const controller = editor.getContribution(NotebookMultiCursorController.id);
             return controller.undo();
-        }, ( (ContextKeyExpr.and(
-             (ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)),
-            NOTEBOOK_IS_ACTIVE_EDITOR,
-            NOTEBOOK_MULTI_CURSOR_CONTEXT.IsNotebookMultiCursor
-        )))));
+        }, ( ContextKeyExpr.and(( ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)), NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_MULTI_CURSOR_CONTEXT.IsNotebookMultiCursor))));
         this._register(RedoCommand.addImplementation(PRIORITY, 'notebook-multicursor-undo-redo', () => {
             const editor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
             if (!editor) {
@@ -855,19 +936,16 @@ let NotebookMultiCursorUndoRedoContribution = class NotebookMultiCursorUndoRedoC
             }
             const controller = editor.getContribution(NotebookMultiCursorController.id);
             return controller.redo();
-        }, ( (ContextKeyExpr.and(
-             (ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)),
-            NOTEBOOK_IS_ACTIVE_EDITOR,
-            NOTEBOOK_MULTI_CURSOR_CONTEXT.IsNotebookMultiCursor
-        )))));
+        }, ( ContextKeyExpr.and(( ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)), NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_MULTI_CURSOR_CONTEXT.IsNotebookMultiCursor))));
     }
 };
-NotebookMultiCursorUndoRedoContribution = ( (__decorate([
-    ( (__param(0, IEditorService))),
-    ( (__param(1, IConfigurationService)))
-], NotebookMultiCursorUndoRedoContribution)));
+NotebookMultiCursorUndoRedoContribution = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IConfigurationService))
+], NotebookMultiCursorUndoRedoContribution));
 registerNotebookContribution(NotebookMultiCursorController.id, NotebookMultiCursorController);
-registerWorkbenchContribution2(NotebookMultiCursorUndoRedoContribution.ID, NotebookMultiCursorUndoRedoContribution, 2 );
+registerWorkbenchContribution2(NotebookMultiCursorUndoRedoContribution.ID, NotebookMultiCursorUndoRedoContribution, WorkbenchPhase.BlockRestore);
+registerAction2(NotebookSelectAllFindMatches);
 registerAction2(NotebookAddMatchToMultiSelectionAction);
 registerAction2(NotebookExitMultiSelectionAction);
 registerAction2(NotebookDeleteLeftMultiSelectionAction);