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

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

@@ -1,37 +1,36 @@
 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 { 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 { Selection, SelectionDirection } from 'vscode/vscode/vs/editor/common/core/selection';
+import { cursorStyleFromString, cursorBlinkingStyleFromString, TextEditorCursorStyle } from 'vscode/vscode/vs/editor/common/config/editorOptions';
+import { Selection } 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 { WordHighlighterContribution } from 'vscode/vscode/vs/editor/contrib/wordHighlighter/browser/wordHighlighter';
 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 { registerWorkbenchContribution2 } 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 '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;
@@ -40,12 +39,15 @@ var NotebookMultiCursorState;
     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))),
+const NOTEBOOK_MULTI_CURSOR_CONTEXT = {
+    IsNotebookMultiCursor: ( (new RawContextKey('isNotebookMultiSelect', false))),
+    NotebookMultiSelectCursorState: ( (new RawContextKey('notebookMultiSelectCursorState', NotebookMultiCursorState.Idle))),
 };
 let NotebookMultiCursorController = class NotebookMultiCursorController extends Disposable {
     static { this.id = 'notebook.multiCursorController'; }
+    getState() {
+        return this.state;
+    }
     constructor(notebookEditor, contextKeyService, textModelService, languageConfigurationService, accessibilityService, configurationService, undoRedoService) {
         super();
         this.notebookEditor = notebookEditor;
@@ -55,7 +57,6 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
         this.accessibilityService = accessibilityService;
         this.configurationService = configurationService;
         this.undoRedoService = undoRedoService;
-        this.state = NotebookMultiCursorState.Idle;
         this.word = '';
         this.trackedMatches = [];
         this._onDidChangeAnchorCell = this._register(( (new Emitter())));
@@ -63,11 +64,9 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
         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.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();
@@ -84,7 +83,7 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
             }
             const cursorSimpleModel = this.constructCursorSimpleModel(match.cellViewModel);
             const converter = this.constructCoordinatesConverter();
-            const editorConfig = match.config;
+            const editorConfig = match.editorConfig;
             const controller = this.cursorsDisposables.add(( (new CursorsController(
                 textModel,
                 cursorSimpleModel,
@@ -96,7 +95,7 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
                     this.languageConfigurationService
                 ))
             ))));
-            controller.setSelections(( (new ViewModelEventsCollector())), undefined, match.wordSelections, CursorChangeReason.Explicit);
+            controller.setSelections(( (new ViewModelEventsCollector())), undefined, match.wordSelections, 3 );
             this.cursorsControllers.set(match.cellViewModel.uri, controller);
         });
     }
@@ -187,7 +186,7 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
             if (!activeSelections) {
                 return;
             }
-            anchorController.setSelections(( (new ViewModelEventsCollector())), 'keyboard', activeSelections, CursorChangeReason.Explicit);
+            anchorController.setSelections(( (new ViewModelEventsCollector())), 'keyboard', activeSelections, 3 );
             this.trackedMatches.forEach(match => {
                 const controller = this.cursorsControllers.get(match.cellViewModel.uri);
                 if (!controller) {
@@ -199,9 +198,73 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
             this.updateLazyDecorations();
         }));
         this.anchorDisposables.add(this.anchorCell[1].onDidChangeCursorSelection((e) => {
-            if (e.source === 'mouse' || e.source === 'deleteRight') {
+            if (e.source === 'mouse') {
                 this.resetToIdleState();
+                return;
             }
+            if (!e.oldSelections || e.reason === 0  || e.reason === 2 ) {
+                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) {
@@ -235,7 +298,7 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
             });
         });
         this.undoRedoService.pushElement({
-            type: UndoRedoElementType.Workspace,
+            type: 1 ,
             resources: resources,
             label: 'Multi Cursor Edit',
             code: 'multiCursorEdit',
@@ -266,6 +329,7 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
             match.cellViewModel.setSelections([match.initialSelection]);
         });
         this.anchorDisposables.clear();
+        this.anchorCell = undefined;
         this.cursorsDisposables.clear();
         this.cursorsControllers.clear();
         this.trackedMatches = [];
@@ -299,16 +363,22 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
             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],
-                config: editorConfig,
+                editorConfig: editorConfig,
+                cursorConfig: cursorConfig,
                 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);
@@ -333,35 +403,54 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
                 return;
             }
             let newMatch;
-            if (findResult.cell.handle !== cell.handle) {
+            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, SelectionDirection.LTR);
+                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')));
+                }
                 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();
+                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],
-                    config: this.constructCellEditorOptions(this.anchorCell[0]),
+                    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));
             }
             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);
+                return;
             }
-            this.initializeMultiSelectDecorations(newMatch);
         }
     }
     async deleteLeft() {
@@ -375,8 +464,29 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
             if (!delSelections) {
                 return;
             }
-            controller.setSelections(( (new ViewModelEventsCollector())), undefined, delSelections, CursorChangeReason.Explicit);
+            controller.setSelections(( (new ViewModelEventsCollector())), undefined, delSelections, 3 );
+        });
+        this.updateLazyDecorations();
+    }
+    async deleteRight() {
+        this.trackedMatches.forEach(match => {
+            const controller = this.cursorsControllers.get(match.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) {
+                const delSelections = CommandExecutor.executeCommands(controller.context.model, controller.getSelections(), commands);
+                if (!delSelections) {
+                    return;
+                }
+                controller.setSelections(( (new ViewModelEventsCollector())), undefined, delSelections, 3 );
+            }
+            else {
+                controller.setSelections(( (new ViewModelEventsCollector())), undefined, match.cellViewModel.getSelections(), 3 );
+            }
         });
+        this.updateLazyDecorations();
     }
     async undo() {
         const models = [];
@@ -385,8 +495,14 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
             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()))));
+        this.updateLazyDecorations();
     }
     async redo() {
         const models = [];
@@ -395,8 +511,14 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
             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()))));
+        this.updateLazyDecorations();
     }
     constructCellEditorOptions(cell) {
         const cellEditorOptions = ( (new CellEditorOptions(
@@ -416,14 +538,17 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
             ))
         );
     }
-    initializeMultiSelectDecorations(match) {
+    initializeMultiSelectDecorations(match, isCurrentWord) {
+        if (!match) {
+            return;
+        }
         const decorations = [];
         match.wordSelections.forEach(selection => {
             decorations.push({
-                range: selection,
+                range: Selection.fromPositions(selection.getEndPosition()),
                 options: {
                     description: '',
-                    className: 'nb-multicursor-selection',
+                    className: this.getClassName(match.cursorConfig, true),
                 }
             });
         });
@@ -431,8 +556,7 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
     }
     updateLazyDecorations() {
         this.trackedMatches.forEach(match => {
-            const cellIndex = this.notebookEditor.getCellIndex(match.cellViewModel);
-            if (cellIndex === undefined) {
+            if (match.cellViewModel.handle === this.anchorCell?.[0].handle) {
                 return;
             }
             const controller = this.cursorsControllers.get(match.cellViewModel.uri);
@@ -440,16 +564,32 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
                 return;
             }
             const selections = controller.getSelections();
-            const newDecorations = selections?.map(selection => {
-                return {
-                    range: selection,
+            const newDecorations = [];
+            selections?.map(selection => {
+                const isEmpty = selection.isEmpty();
+                if (!isEmpty) {
+                    newDecorations.push({
+                        range: selection,
+                        options: {
+                            description: '',
+                            className: this.getClassName(match.cursorConfig, false),
+                        }
+                    });
+                }
+                newDecorations.push({
+                    range: Selection.fromPositions(selection.getPosition()),
                     options: {
                         description: '',
-                        className: 'nb-multicursor-selection',
+                        zIndex: 10000,
+                        className: this.getClassName(match.cursorConfig, true),
                     }
-                };
+                });
             });
-            match.decorationIds = match.cellViewModel.deltaModelDecorations(match.decorationIds, newDecorations ?? []);
+            match.decorationIds = match.cellViewModel.deltaModelDecorations(match.decorationIds, newDecorations);
+            const matchingEditor = this.notebookEditor.codeEditors.find(cellEditor => cellEditor[0] === match.cellViewModel);
+            if (matchingEditor) {
+                WordHighlighterContribution.get(matchingEditor[1])?.wordHighlighter?.trigger();
+            }
         });
     }
     clearDecorations(match) {
@@ -466,6 +606,54 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
             column: startColumn
         });
     }
+    getClassName(cursorConfig, isCursor) {
+        let result = isCursor ? '.nb-multicursor-cursor' : '.nb-multicursor-selection';
+        if (isCursor) {
+            switch (cursorConfig.cursorStyle) {
+                case TextEditorCursorStyle.Line:
+                    break;
+                case TextEditorCursorStyle.Block:
+                    result += '.nb-cursor-block-style';
+                    break;
+                case TextEditorCursorStyle.Underline:
+                    result += '.nb-cursor-underline-style';
+                    break;
+                case TextEditorCursorStyle.LineThin:
+                    result += '.nb-cursor-line-thin-style';
+                    break;
+                case TextEditorCursorStyle.BlockOutline:
+                    result += '.nb-cursor-block-outline-style';
+                    break;
+                case TextEditorCursorStyle.UnderlineThin:
+                    result += '.nb-cursor-underline-thin-style';
+                    break;
+            }
+            switch (cursorConfig.cursorBlinking) {
+                case 1 :
+                    result += '.nb-blink';
+                    break;
+                case 2 :
+                    result += '.nb-smooth';
+                    break;
+                case 3 :
+                    result += '.nb-phase';
+                    break;
+                case 4 :
+                    result += '.nb-expand';
+                    break;
+                case 5 :
+                    result += '.nb-solid';
+                    break;
+                default:
+                    result += '.nb-solid';
+                    break;
+            }
+            if (cursorConfig.cursorSmoothCaretAnimation === 'on' || cursorConfig.cursorSmoothCaretAnimation === 'explicit') {
+                result += '.nb-smooth-caret-animation';
+            }
+        }
+        return result;
+    }
     dispose() {
         super.dispose();
         this.anchorDisposables.dispose();
@@ -488,15 +676,20 @@ class NotebookAddMatchToMultiSelectionAction extends NotebookAction {
     constructor() {
         super({
             id: NOTEBOOK_ADD_FIND_MATCH_TO_SELECTION_ID,
-            title: ( localize(8049, "Add Find Match to Selection")),
+            title: ( localize(8109, "Add Find Match to Selection")),
+            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.multiSelect.enabled', true)),
+                     (ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)),
                     NOTEBOOK_IS_ACTIVE_EDITOR,
                     NOTEBOOK_CELL_EDITOR_FOCUSED
                 ))),
-                primary: KeyMod.CtrlCmd | KeyCode.KeyD,
-                weight: KeybindingWeight.WorkbenchContrib
+                primary: 2048  | 34 ,
+                weight: 200
             }
         });
     }
@@ -517,15 +710,20 @@ class NotebookExitMultiSelectionAction extends NotebookAction {
     constructor() {
         super({
             id: 'noteMultiCursor.exit',
-            title: ( localize(8050, "Exit Multi Cursor Mode")),
+            title: ( localize(8110, "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.multiSelect.enabled', true)),
+                     (ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)),
                     NOTEBOOK_IS_ACTIVE_EDITOR,
-                    NOTEBOOK_MULTI_SELECTION_CONTEXT.IsNotebookMultiSelect
+                    NOTEBOOK_MULTI_CURSOR_CONTEXT.IsNotebookMultiCursor
                 ))),
-                primary: KeyCode.Escape,
-                weight: KeybindingWeight.WorkbenchContrib
+                primary: 9 ,
+                weight: 200
             }
         });
     }
@@ -543,19 +741,28 @@ class NotebookDeleteLeftMultiSelectionAction extends NotebookAction {
     constructor() {
         super({
             id: 'noteMultiCursor.deleteLeft',
-            title: ( localize(8051, "Delete Left")),
+            title: ( localize(8111, "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.multiSelect.enabled', true)),
+                     (ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)),
                     NOTEBOOK_IS_ACTIVE_EDITOR,
-                    NOTEBOOK_MULTI_SELECTION_CONTEXT.IsNotebookMultiSelect,
+                    NOTEBOOK_MULTI_CURSOR_CONTEXT.IsNotebookMultiCursor,
                      (ContextKeyExpr.or(
-                         (NOTEBOOK_MULTI_SELECTION_CONTEXT.NotebookMultiSelectState.isEqualTo(NotebookMultiCursorState.Selecting)),
-                         (NOTEBOOK_MULTI_SELECTION_CONTEXT.NotebookMultiSelectState.isEqualTo(NotebookMultiCursorState.Editing))
+                         (NOTEBOOK_MULTI_CURSOR_CONTEXT.NotebookMultiSelectCursorState.isEqualTo(NotebookMultiCursorState.Selecting)),
+                         (NOTEBOOK_MULTI_CURSOR_CONTEXT.NotebookMultiSelectCursorState.isEqualTo(NotebookMultiCursorState.Editing))
                     ))
                 ))),
-                primary: KeyCode.Backspace,
-                weight: KeybindingWeight.WorkbenchContrib
+                primary: 1 ,
+                weight: 200
             }
         });
     }
@@ -569,13 +776,57 @@ class NotebookDeleteLeftMultiSelectionAction extends NotebookAction {
         controller.deleteLeft();
     }
 }
+class NotebookDeleteRightMultiSelectionAction extends NotebookAction {
+    constructor() {
+        super({
+            id: 'noteMultiCursor.deleteRight',
+            title: ( localize(8112, "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
+            }
+        });
+    }
+    async runWithContext(accessor, context) {
+        const editorService = accessor.get(IEditorService);
+        const nbEditor = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
+        if (!nbEditor) {
+            return;
+        }
+        const cellEditor = nbEditor.activeCodeEditor;
+        if (!cellEditor) {
+            return;
+        }
+        CoreEditingCommands.DeleteRight.runEditorCommand(accessor, cellEditor, null);
+        const controller = nbEditor.getContribution(NotebookMultiCursorController.id);
+        controller.deleteRight();
+    }
+}
 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')) {
+        if (!this.configurationService.getValue('notebook.multiCursor.enabled')) {
             return;
         }
         const PRIORITY = 10005;
@@ -590,9 +841,9 @@ let NotebookMultiCursorUndoRedoContribution = class NotebookMultiCursorUndoRedoC
             const controller = editor.getContribution(NotebookMultiCursorController.id);
             return controller.undo();
         }, ( (ContextKeyExpr.and(
-             (ContextKeyExpr.equals('config.notebook.multiSelect.enabled', true)),
+             (ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)),
             NOTEBOOK_IS_ACTIVE_EDITOR,
-            NOTEBOOK_MULTI_SELECTION_CONTEXT.IsNotebookMultiSelect
+            NOTEBOOK_MULTI_CURSOR_CONTEXT.IsNotebookMultiCursor
         )))));
         this._register(RedoCommand.addImplementation(PRIORITY, 'notebook-multicursor-undo-redo', () => {
             const editor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
@@ -605,9 +856,9 @@ let NotebookMultiCursorUndoRedoContribution = class NotebookMultiCursorUndoRedoC
             const controller = editor.getContribution(NotebookMultiCursorController.id);
             return controller.redo();
         }, ( (ContextKeyExpr.and(
-             (ContextKeyExpr.equals('config.notebook.multiSelect.enabled', true)),
+             (ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)),
             NOTEBOOK_IS_ACTIVE_EDITOR,
-            NOTEBOOK_MULTI_SELECTION_CONTEXT.IsNotebookMultiSelect
+            NOTEBOOK_MULTI_CURSOR_CONTEXT.IsNotebookMultiCursor
         )))));
     }
 };
@@ -616,9 +867,10 @@ NotebookMultiCursorUndoRedoContribution = ( (__decorate([
     ( (__param(1, IConfigurationService)))
 ], NotebookMultiCursorUndoRedoContribution)));
 registerNotebookContribution(NotebookMultiCursorController.id, NotebookMultiCursorController);
+registerWorkbenchContribution2(NotebookMultiCursorUndoRedoContribution.ID, NotebookMultiCursorUndoRedoContribution, 2 );
 registerAction2(NotebookAddMatchToMultiSelectionAction);
 registerAction2(NotebookExitMultiSelectionAction);
 registerAction2(NotebookDeleteLeftMultiSelectionAction);
-registerWorkbenchContribution2(NotebookMultiCursorUndoRedoContribution.ID, NotebookMultiCursorUndoRedoContribution, WorkbenchPhase.BlockRestore);
+registerAction2(NotebookDeleteRightMultiSelectionAction);
 
-export { NOTEBOOK_MULTI_SELECTION_CONTEXT, NotebookMultiCursorController };
+export { NOTEBOOK_MULTI_CURSOR_CONTEXT, NotebookMultiCursorController, NotebookMultiCursorState };