@codingame/monaco-vscode-notebook-service-override 25.1.2 → 26.0.0

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

@@ -37,27 +37,37 @@ import { NotebookAction } from '@codingame/monaco-vscode-api/vscode/vs/workbench
 import { getNotebookEditorFromEditorPane } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
 import { registerNotebookContribution } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
 import { CellEditorOptions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/view/cellParts/cellEditorOptions';
-import { NotebookFindContrib } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/contrib/find/notebookFindWidget';
+import { NotebookFindContrib } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/notebook/browser/contrib/find/notebookFindWidget';
 import { NotebookCellTextModel } from '@codingame/monaco-vscode-api/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';
+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 = {}));
 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'; }
+    static {
+        this.id = "notebook.multiCursorController";
+    }
     getState() {
         return this.state;
     }
-    constructor(notebookEditor, contextKeyService, textModelService, languageConfigurationService, accessibilityService, configurationService, undoRedoService) {
+    constructor(
+        notebookEditor,
+        contextKeyService,
+        textModelService,
+        languageConfigurationService,
+        accessibilityService,
+        configurationService,
+        undoRedoService
+    ) {
         super();
         this.notebookEditor = notebookEditor;
         this.contextKeyService = contextKeyService;
@@ -66,7 +76,7 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
         this.accessibilityService = accessibilityService;
         this.configurationService = configurationService;
         this.undoRedoService = undoRedoService;
-        this.word = '';
+        this.word = "";
         this.trackedCells = [];
         this.totalMatchesCount = 0;
         this._onDidChangeAnchorCell = this._register(( new Emitter()));
@@ -86,9 +96,9 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
     syncAnchorListeners() {
         this.anchorDisposables.clear();
         if (!this.anchorCell) {
-            throw ( new Error('Anchor cell is undefined'));
+            throw ( new Error("Anchor cell is undefined"));
         }
-        this.anchorDisposables.add(this.anchorCell[1].onWillType((input) => {
+        this.anchorDisposables.add(this.anchorCell[1].onWillType(input => {
             const collector = ( new ViewModelEventsCollector());
             this.trackedCells.forEach(cell => {
                 const controller = this.cursorsControllers.get(cell.cellViewModel.uri);
@@ -96,7 +106,7 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
                     return;
                 }
                 if (cell.cellViewModel.handle !== this.anchorCell?.[0].handle) {
-                    controller.type(collector, input, 'keyboard');
+                    controller.type(collector, input, "keyboard");
                 }
             });
         }));
@@ -111,7 +121,7 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
             if (!activeSelections) {
                 return;
             }
-            anchorController.setSelections(( new ViewModelEventsCollector()), 'keyboard', activeSelections, CursorChangeReason.Explicit);
+            anchorController.setSelections(( new ViewModelEventsCollector()), "keyboard", activeSelections, CursorChangeReason.Explicit);
             this.trackedCells.forEach(cell => {
                 const controller = this.cursorsControllers.get(cell.cellViewModel.uri);
                 if (!controller) {
@@ -122,8 +132,8 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
             });
             this.updateLazyDecorations();
         }));
-        this.anchorDisposables.add(this.anchorCell[1].onDidChangeCursorSelection((e) => {
-            if (e.source === 'mouse') {
+        this.anchorDisposables.add(this.anchorCell[1].onDidChangeCursorSelection(e => {
+            if (e.source === "mouse") {
                 this.resetToIdleState();
                 return;
             }
@@ -134,7 +144,7 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
                 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,
+                deltaEndLine: e.selection.endLineNumber - e.oldSelections[0].endLineNumber
             };
             const translationDir = e.selection.getDirection();
             this.trackedCells.forEach(cell => {
@@ -153,7 +163,7 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
             });
             this.updateLazyDecorations();
         }));
-        this.anchorDisposables.add(this.anchorCell[1].onWillTriggerEditorOperationEvent((e) => {
+        this.anchorDisposables.add(this.anchorCell[1].onWillTriggerEditorOperationEvent(e => {
             this.handleEditorOperationEvent(e);
         }));
         this.anchorDisposables.add(this.anchorCell[1].onDidBlurEditorWidget(() => {
@@ -164,7 +174,7 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
     }
     async syncCursorsControllers() {
         this.cursorsDisposables.clear();
-        await Promise.all(( this.trackedCells.map(async (cell) => {
+        await Promise.all(( this.trackedCells.map(async cell => {
             const controller = await this.createCursorController(cell);
             if (!controller) {
                 return;
@@ -267,30 +277,46 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
     }
     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: {
+        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);
+                controller.compositionType(eventsCollector, args.text || "", args.replaceCharCnt || 0, 0, 0, e.source);
                 break;
             }
-            case Handler.CompositionType: {
+        case Handler.CompositionType:
+            {
                 const args = e.payload;
-                controller.compositionType(eventsCollector, args.text || '', args.replacePrevCharCnt || 0, args.replaceNextCharCnt || 0, args.positionDelta || 0, e.source);
+                controller.compositionType(
+                    eventsCollector,
+                    args.text || "",
+                    args.replacePrevCharCnt || 0,
+                    args.replaceNextCharCnt || 0,
+                    args.positionDelta || 0,
+                    e.source
+                );
                 break;
             }
-            case Handler.Paste: {
+        case Handler.Paste:
+            {
                 const args = e.payload;
-                controller.paste(eventsCollector, args.text || '', args.pasteOnNewLine || false, args.multicursorText || null, e.source);
+                controller.paste(
+                    eventsCollector,
+                    args.text || "",
+                    args.pasteOnNewLine || false,
+                    args.multicursorText || null,
+                    e.source
+                );
                 break;
             }
-            case Handler.Cut:
-                controller.cut(eventsCollector, e.source);
-                break;
+        case Handler.Cut:
+            controller.cut(eventsCollector, e.source);
+            break;
         }
     }
     updateViewModelSelections() {
@@ -330,19 +356,19 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
         this.undoRedoService.pushElement({
             type: UndoRedoElementType.Workspace,
             resources: resources,
-            label: 'Multi Cursor Edit',
-            code: 'multiCursorEdit',
+            label: "Multi Cursor Edit",
+            code: "multiCursorEdit",
             confirmBeforeUndo: false,
             undo: async () => {
-                newElementsMap.forEach(async (value) => {
-                    value.reverse().forEach(async (element) => {
+                newElementsMap.forEach(async value => {
+                    value.reverse().forEach(async element => {
                         await element.undo();
                     });
                 });
             },
             redo: async () => {
-                newElementsMap.forEach(async (value) => {
-                    value.forEach(async (element) => {
+                newElementsMap.forEach(async value => {
+                    value.forEach(async element => {
                         await element.redo();
                     });
                 });
@@ -365,7 +391,7 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
         this.trackedCells = [];
         this.totalMatchesCount = 0;
         this.startPosition = undefined;
-        this.word = '';
+        this.word = "";
     }
     async findAndTrackNextSelection(focusedCell) {
         if (this.state === NotebookMultiCursorState.Idle) {
@@ -390,7 +416,7 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
             }
             this.startPosition = {
                 cellIndex: index,
-                position: ( new Position(inputSelection.startLineNumber, word.startColumn)),
+                position: ( new Position(inputSelection.startLineNumber, word.startColumn))
             };
             const newSelection = ( new Selection(
                 inputSelection.startLineNumber,
@@ -401,18 +427,17 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
             focusedCell.setSelections([newSelection]);
             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'));
+                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"));
             }
             await this.updateTrackedCell(focusedCell, [newSelection]);
             this._nbIsMultiSelectSession.set(true);
             this.state = NotebookMultiCursorState.Selecting;
             this._nbMultiSelectState.set(NotebookMultiCursorState.Selecting);
             this._onDidChangeAnchorCell.fire();
-        }
-        else if (this.state === NotebookMultiCursorState.Selecting) {
+        } else if (this.state === NotebookMultiCursorState.Selecting) {
             const notebookTextModel = this.notebookEditor.textModel;
             if (!notebookTextModel) {
                 return;
@@ -428,7 +453,10 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
             if (totalSelections >= this.totalMatchesCount) {
                 return;
             }
-            const findResult = notebookTextModel.findNextMatch(this.word, { cellIndex: index, position: focusedCell.getSelections()[focusedCell.getSelections().length - 1].getEndPosition() }, false, true, USUAL_WORD_SEPARATORS, this.startPosition);
+            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;
             }
@@ -437,21 +465,28 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
                 return;
             }
             if (findResult.cell.handle === focusedCell.handle) {
-                const selections = [...focusedCell.getSelections(), Selection.fromRange(findResult.match.range, SelectionDirection.LTR)];
+                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) {
+            } 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)]);
+                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"));
                 }
                 this._onDidChangeAnchorCell.fire();
-                this.initializeMultiSelectDecorations(this.trackedCells.find(trackedCell => trackedCell.cellViewModel.handle === focusedCell.handle));
+                this.initializeMultiSelectDecorations(
+                    this.trackedCells.find(trackedCell => trackedCell.cellViewModel.handle === focusedCell.handle)
+                );
             }
         }
     }
@@ -462,8 +497,7 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
         }
         if (matches) {
             await this.handleFindWidgetSelectAllMatches(matches);
-        }
-        else {
+        } else {
             await this.handleCellEditorSelectAllMatches(notebookTextModel, focusedCell);
         }
         await this.syncCursorsControllers();
@@ -477,7 +511,7 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
         if (!matches.length) {
             return;
         }
-        await this.notebookEditor.focusNotebookCell(matches[0].cell, 'editor');
+        await this.notebookEditor.focusNotebookCell(matches[0].cell, "editor");
         this.anchorCell = this.notebookEditor.activeCellAndCodeEditor;
         this.trackedCells = [];
         for (const match of matches) {
@@ -508,14 +542,14 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
             }
             this.startPosition = {
                 cellIndex: index,
-                position: ( new Position(inputSelection.startLineNumber, word.startColumn)),
+                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'));
+                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"));
             }
             const findResults = notebookTextModel.findMatches(this.word, false, true, USUAL_WORD_SEPARATORS);
             this.trackedCells = [];
@@ -531,8 +565,7 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
             this._nbIsMultiSelectSession.set(true);
             this.state = NotebookMultiCursorState.Selecting;
             this._nbMultiSelectState.set(NotebookMultiCursorState.Selecting);
-        }
-        else if (this.state === 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))));
@@ -542,14 +575,13 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
     async updateTrackedCell(cell, selections) {
         const cellViewModel = cell instanceof NotebookCellTextModel ? this.notebookEditor.getCellByHandle(cell.handle) : cell;
         if (!cellViewModel) {
-            throw ( new Error('Cell not found'));
+            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 {
+        } else {
             const initialSelection = cellViewModel.getSelections()[0];
             const textModel = await cellViewModel.resolveTextModel();
             textModel.pushStackElement();
@@ -579,7 +611,13 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
             if (!controller) {
                 return;
             }
-            const [, commands] = DeleteOperations.deleteLeft(controller.getPrevEditOperationType(), controller.context.cursorConfig, controller.context.model, controller.getSelections(), controller.getAutoClosedCharacters());
+            const [, commands] = DeleteOperations.deleteLeft(
+                controller.getPrevEditOperationType(),
+                controller.context.cursorConfig,
+                controller.context.model,
+                controller.getSelections(),
+                controller.getAutoClosedCharacters()
+            );
             const delSelections = CommandExecutor.executeCommands(controller.context.model, controller.getSelections(), commands);
             if (!delSelections) {
                 return;
@@ -594,15 +632,19 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
             if (!controller) {
                 return;
             }
-            const [, commands] = DeleteOperations.deleteRight(controller.getPrevEditOperationType(), controller.context.cursorConfig, controller.context.model, controller.getSelections());
+            const [, commands] = DeleteOperations.deleteRight(
+                controller.getPrevEditOperationType(),
+                controller.context.cursorConfig,
+                controller.context.model,
+                controller.getSelections()
+            );
             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, CursorChangeReason.Explicit);
-            }
-            else {
+            } else {
                 controller.setSelections(( new ViewModelEventsCollector()), undefined, cell.cellViewModel.getSelections(), CursorChangeReason.Explicit);
             }
         });
@@ -658,8 +700,8 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
             decorations.push({
                 range: Selection.fromPositions(selection.getEndPosition()),
                 options: {
-                    description: '',
-                    className: this.getClassName(cell.cursorConfig, true),
+                    description: "",
+                    className: this.getClassName(cell.cursorConfig, true)
                 }
             });
         });
@@ -682,17 +724,17 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
                     newDecorations.push({
                         range: selection,
                         options: {
-                            description: '',
-                            className: this.getClassName(cell.cursorConfig, false),
+                            description: "",
+                            className: this.getClassName(cell.cursorConfig, false)
                         }
                     });
                 }
                 newDecorations.push({
                     range: Selection.fromPositions(selection.getPosition()),
                     options: {
-                        description: '',
+                        description: "",
                         zIndex: 10000,
-                        className: this.getClassName(cell.cursorConfig, true),
+                        className: this.getClassName(cell.cursorConfig, true)
                     }
                 });
             });
@@ -714,49 +756,49 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
         });
     }
     getClassName(cursorConfig, isCursor) {
-        let result = isCursor ? '.nb-multicursor-cursor' : '.nb-multicursor-selection';
+        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;
+            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 TextEditorCursorBlinkingStyle.Blink:
-                    result += '.nb-blink';
-                    break;
-                case TextEditorCursorBlinkingStyle.Smooth:
-                    result += '.nb-smooth';
-                    break;
-                case TextEditorCursorBlinkingStyle.Phase:
-                    result += '.nb-phase';
-                    break;
-                case TextEditorCursorBlinkingStyle.Expand:
-                    result += '.nb-expand';
-                    break;
-                case TextEditorCursorBlinkingStyle.Solid:
-                    result += '.nb-solid';
-                    break;
-                default:
-                    result += '.nb-solid';
-                    break;
-            }
-            if (cursorConfig.cursorSmoothCaretAnimation === 'on' || cursorConfig.cursorSmoothCaretAnimation === 'explicit') {
-                result += '.nb-smooth-caret-animation';
+            case TextEditorCursorBlinkingStyle.Blink:
+                result += ".nb-blink";
+                break;
+            case TextEditorCursorBlinkingStyle.Smooth:
+                result += ".nb-smooth";
+                break;
+            case TextEditorCursorBlinkingStyle.Phase:
+                result += ".nb-phase";
+                break;
+            case TextEditorCursorBlinkingStyle.Expand:
+                result += ".nb-expand";
+                break;
+            case TextEditorCursorBlinkingStyle.Solid:
+                result += ".nb-solid";
+                break;
+            default:
+                result += ".nb-solid";
+                break;
+            }
+            if (cursorConfig.cursorSmoothCaretAnimation === "on" || cursorConfig.cursorSmoothCaretAnimation === "explicit") {
+                result += ".nb-smooth-caret-animation";
             }
         }
         return result;
@@ -771,22 +813,15 @@ let NotebookMultiCursorController = class NotebookMultiCursorController extends
         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(9299, "Select All Occurrences of Find Match")),
-            precondition: ( ContextKeyExpr.and(( ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)))),
+            title: ( localize(9619, "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)))),
+                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
             }
@@ -806,8 +841,7 @@ class NotebookSelectAllFindMatches extends NotebookAction {
         if (findController.widget.isFocused) {
             const findModel = findController.widget.findModel;
             cursorController.selectAllMatches(context.cell, findModel.findMatches);
-        }
-        else {
+        } else {
             cursorController.selectAllMatches(context.cell);
         }
     }
@@ -816,10 +850,10 @@ class NotebookAddMatchToMultiSelectionAction extends NotebookAction {
     constructor() {
         super({
             id: NOTEBOOK_ADD_FIND_MATCH_TO_SELECTION_ID,
-            title: ( localize(9300, "Add Selection to Next Find Match")),
-            precondition: ( ContextKeyExpr.and(( ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)), NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_CELL_EDITOR_FOCUSED)),
+            title: ( localize(9620, "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)),
+                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
             }
@@ -841,11 +875,11 @@ class NotebookAddMatchToMultiSelectionAction extends NotebookAction {
 class NotebookExitMultiSelectionAction extends NotebookAction {
     constructor() {
         super({
-            id: 'noteMultiCursor.exit',
-            title: ( localize(9301, "Exit Multi Cursor Mode")),
-            precondition: ( ContextKeyExpr.and(( ContextKeyExpr.equals('config.notebook.multiCursor.enabled', true)), NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_MULTI_CURSOR_CONTEXT.IsNotebookMultiCursor)),
+            id: "noteMultiCursor.exit",
+            title: ( localize(9621, "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)),
+                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
             }
@@ -864,11 +898,11 @@ class NotebookExitMultiSelectionAction extends NotebookAction {
 class NotebookDeleteLeftMultiSelectionAction extends NotebookAction {
     constructor() {
         super({
-            id: 'noteMultiCursor.deleteLeft',
-            title: ( localize(9302, "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)))))),
+            id: "noteMultiCursor.deleteLeft",
+            title: ( localize(9622, "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)))))),
+                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
             }
@@ -887,11 +921,11 @@ class NotebookDeleteLeftMultiSelectionAction extends NotebookAction {
 class NotebookDeleteRightMultiSelectionAction extends NotebookAction {
     constructor() {
         super({
-            id: 'noteMultiCursor.deleteRight',
-            title: ( localize(9303, "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)))))),
+            id: "noteMultiCursor.deleteRight",
+            title: ( localize(9623, "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)))))),
+                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
             }
@@ -913,45 +947,52 @@ class NotebookDeleteRightMultiSelectionAction extends NotebookAction {
     }
 }
 let NotebookMultiCursorUndoRedoContribution = class NotebookMultiCursorUndoRedoContribution extends Disposable {
-    static { this.ID = 'workbench.contrib.notebook.multiCursorUndoRedo'; }
+    static {
+        this.ID = "workbench.contrib.notebook.multiCursorUndoRedo";
+    }
     constructor(_editorService, configurationService) {
         super();
         this._editorService = _editorService;
         this.configurationService = configurationService;
-        if (!this.configurationService.getValue('notebook.multiCursor.enabled')) {
+        if (!this.configurationService.getValue("notebook.multiCursor.enabled")) {
             return;
         }
         const PRIORITY = 10005;
-        this._register(UndoCommand.addImplementation(PRIORITY, 'notebook-multicursor-undo-redo', () => {
-            const editor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
-            if (!editor) {
-                return false;
-            }
-            if (!editor.hasModel()) {
-                return false;
-            }
-            const controller = editor.getContribution(NotebookMultiCursorController.id);
-            return controller.undo();
-        }, ( ContextKeyExpr.and(( ContextKeyExpr.equals('config.notebook.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) {
-                return false;
-            }
-            if (!editor.hasModel()) {
-                return false;
-            }
-            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))));
+        this._register(
+            UndoCommand.addImplementation(PRIORITY, "notebook-multicursor-undo-redo", () => {
+                const editor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
+                if (!editor) {
+                    return false;
+                }
+                if (!editor.hasModel()) {
+                    return false;
+                }
+                const controller = editor.getContribution(NotebookMultiCursorController.id);
+                return controller.undo();
+            }, ( ContextKeyExpr.and(( ContextKeyExpr.equals("config.notebook.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) {
+                    return false;
+                }
+                if (!editor.hasModel()) {
+                    return false;
+                }
+                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)))
+        );
     }
 };
-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, WorkbenchPhase.BlockRestore);
+registerWorkbenchContribution2(
+    NotebookMultiCursorUndoRedoContribution.ID,
+    NotebookMultiCursorUndoRedoContribution,
+    WorkbenchPhase.BlockRestore
+);
 registerAction2(NotebookSelectAllFindMatches);
 registerAction2(NotebookAddMatchToMultiSelectionAction);
 registerAction2(NotebookExitMultiSelectionAction);