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

package/vscode/src/vs/workbench/contrib/notebook/browser/services/notebookExecutionServiceImpl.js

@@ -11,7 +11,14 @@ import { INotebookKernelService, INotebookKernelHistoryService } from '@codingam
 import { INotebookLoggingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookLoggingService.service';
 
 let NotebookExecutionService = class NotebookExecutionService {
-    constructor(_commandService, _notebookKernelService, _notebookKernelHistoryService, _workspaceTrustRequestService, _logService, _notebookExecutionStateService) {
+    constructor(
+        _commandService,
+        _notebookKernelService,
+        _notebookKernelHistoryService,
+        _workspaceTrustRequestService,
+        _logService,
+        _notebookExecutionStateService
+    ) {
         this._commandService = _commandService;
         this._notebookKernelService = _notebookKernelService;
         this._notebookKernelHistoryService = _notebookKernelHistoryService;
@@ -21,14 +28,15 @@ let NotebookExecutionService = class NotebookExecutionService {
         this.cellExecutionParticipants = ( new Set());
     }
     async executeNotebookCells(notebook, cells, contextKeyService) {
-        const cellsArr = Array.from(cells)
-            .filter(c => c.cellKind === CellKind.Code);
+        const cellsArr = Array.from(cells).filter(c => c.cellKind === CellKind.Code);
         if (!cellsArr.length) {
             return;
         }
         this._logService.debug(`Execution`, `${JSON.stringify(( cellsArr.map(c => c.handle)))}`);
-        const message = ( localize(9685, "Executing a notebook cell will run code from this workspace."));
-        const trust = await this._workspaceTrustRequestService.requestWorkspaceTrust({ message });
+        const message = ( localize(10005, "Executing a notebook cell will run code from this workspace."));
+        const trust = await this._workspaceTrustRequestService.requestWorkspaceTrust({
+            message
+        });
         if (!trust) {
             return;
         }
@@ -38,9 +46,17 @@ let NotebookExecutionService = class NotebookExecutionService {
             if (!!cellExe) {
                 continue;
             }
-            cellExecutions.push([cell, this._notebookExecutionStateService.createCellExecution(notebook.uri, cell.handle)]);
+            cellExecutions.push([
+                cell,
+                this._notebookExecutionStateService.createCellExecution(notebook.uri, cell.handle)
+            ]);
         }
-        const kernel = await KernelPickerMRUStrategy.resolveKernel(notebook, this._notebookKernelService, this._notebookKernelHistoryService, this._commandService);
+        const kernel = await KernelPickerMRUStrategy.resolveKernel(
+            notebook,
+            this._notebookKernelService,
+            this._notebookKernelHistoryService,
+            this._commandService
+        );
         if (!kernel) {
             cellExecutions.forEach(cellExe => cellExe[1].complete({}));
             return;
@@ -50,8 +66,7 @@ let NotebookExecutionService = class NotebookExecutionService {
         for (const [cell, cellExecution] of cellExecutions) {
             if (!kernel.supportedLanguages.includes(cell.language)) {
                 cellExecution.complete({});
-            }
-            else {
+            } else {
                 validCellExecutions.push(cellExecution);
             }
         }
@@ -61,7 +76,10 @@ let NotebookExecutionService = class NotebookExecutionService {
             await kernel.executeNotebookCellsRequest(notebook.uri, ( validCellExecutions.map(c => c.cellHandle)));
             const unconfirmed = validCellExecutions.filter(exe => exe.state === NotebookCellExecutionState.Unconfirmed);
             if (unconfirmed.length) {
-                this._logService.debug(`Execution`, `Completing unconfirmed executions ${JSON.stringify(( unconfirmed.map(exe => exe.cellHandle)))}`);
+                this._logService.debug(
+                    `Execution`,
+                    `Completing unconfirmed executions ${JSON.stringify(( unconfirmed.map(exe => exe.cellHandle)))}`
+                );
                 unconfirmed.forEach(exe => exe.complete({}));
             }
             this._logService.debug(`Execution`, `Completed executions ${JSON.stringify(( validCellExecutions.map(exe => exe.cellHandle)))}`);
@@ -92,13 +110,6 @@ let NotebookExecutionService = class NotebookExecutionService {
         this._activeProxyKernelExecutionToken?.dispose(true);
     }
 };
-NotebookExecutionService = ( __decorate([
-    ( __param(0, ICommandService)),
-    ( __param(1, INotebookKernelService)),
-    ( __param(2, INotebookKernelHistoryService)),
-    ( __param(3, IWorkspaceTrustRequestService)),
-    ( __param(4, INotebookLoggingService)),
-    ( __param(5, INotebookExecutionStateService))
-], NotebookExecutionService));
+NotebookExecutionService = ( __decorate([( __param(0, ICommandService)), ( __param(1, INotebookKernelService)), ( __param(2, INotebookKernelHistoryService)), ( __param(3, IWorkspaceTrustRequestService)), ( __param(4, INotebookLoggingService)), ( __param(5, INotebookExecutionStateService))], NotebookExecutionService));
 
 export { NotebookExecutionService };

package/vscode/src/vs/workbench/contrib/notebook/browser/services/notebookExecutionStateServiceImpl.js

@@ -18,7 +18,12 @@ import { INotebookKernelService } from '@codingame/monaco-vscode-api/vscode/vs/w
 import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
 
 let NotebookExecutionStateService = class NotebookExecutionStateService extends Disposable {
-    constructor(_instantiationService, _logService, _notebookService, _accessibilitySignalService) {
+    constructor(
+        _instantiationService,
+        _logService,
+        _notebookService,
+        _accessibilitySignalService
+    ) {
         super();
         this._instantiationService = _instantiationService;
         this._logService = _logService;
@@ -81,7 +86,9 @@ let NotebookExecutionStateService = class NotebookExecutionStateService extends
     _onCellExecutionDidComplete(notebookUri, cellHandle, exe, lastRunSuccess) {
         const notebookExecutions = this._executions.get(notebookUri);
         if (!notebookExecutions) {
-            this._logService.debug(`NotebookExecutionStateService#_onCellExecutionDidComplete - unknown notebook ${( notebookUri.toString())}`);
+            this._logService.debug(
+                `NotebookExecutionStateService#_onCellExecutionDidComplete - unknown notebook ${( notebookUri.toString())}`
+            );
             return;
         }
         exe.dispose();
@@ -100,8 +107,7 @@ let NotebookExecutionStateService = class NotebookExecutionStateService extends
                     this._accessibilitySignalService.playSignal(AccessibilitySignal.notebookCellCompleted);
                 }
                 this._clearLastFailedCell(notebookUri);
-            }
-            else {
+            } else {
                 this._accessibilitySignalService.playSignal(AccessibilitySignal.notebookCellFailed);
                 this._setLastFailedCell(notebookUri, cellHandle);
             }
@@ -115,7 +121,9 @@ let NotebookExecutionStateService = class NotebookExecutionStateService extends
     _onExecutionDidComplete(notebookUri) {
         const disposables = this._notebookExecutions.get(notebookUri);
         if (!Array.isArray(disposables)) {
-            this._logService.debug(`NotebookExecutionStateService#_onCellExecutionDidComplete - unknown notebook ${( notebookUri.toString())}`);
+            this._logService.debug(
+                `NotebookExecutionStateService#_onCellExecutionDidComplete - unknown notebook ${( notebookUri.toString())}`
+            );
             return;
         }
         this._notebookExecutions.delete(notebookUri);
@@ -163,14 +171,22 @@ let NotebookExecutionStateService = class NotebookExecutionStateService extends
     _createNotebookCellExecution(notebook, cellHandle) {
         const notebookUri = notebook.uri;
         const exe = this._instantiationService.createInstance(CellExecution, cellHandle, notebook);
-        const disposable = combinedDisposable(exe.onDidUpdate(() => this._onCellExecutionDidChange(notebookUri, cellHandle, exe)), exe.onDidComplete(lastRunSuccess => this._onCellExecutionDidComplete(notebookUri, cellHandle, exe, lastRunSuccess)));
+        const disposable = combinedDisposable(
+            exe.onDidUpdate(() => this._onCellExecutionDidChange(notebookUri, cellHandle, exe)),
+            exe.onDidComplete(
+                lastRunSuccess => this._onCellExecutionDidComplete(notebookUri, cellHandle, exe, lastRunSuccess)
+            )
+        );
         this._cellListeners.set(CellUri.generate(notebookUri, cellHandle), disposable);
         return exe;
     }
     _createNotebookExecution(notebook) {
         const notebookUri = notebook.uri;
         const exe = this._instantiationService.createInstance(NotebookExecution, notebook);
-        const disposable = combinedDisposable(exe.onDidUpdate(() => this._onExecutionDidChange(notebookUri, exe)), exe.onDidComplete(() => this._onExecutionDidComplete(notebookUri)));
+        const disposable = combinedDisposable(
+            exe.onDidUpdate(() => this._onExecutionDidChange(notebookUri, exe)),
+            exe.onDidComplete(() => this._onExecutionDidComplete(notebookUri))
+        );
         return [exe, disposable];
     }
     _setLastFailedCell(notebookURI, cellHandle) {
@@ -185,7 +201,10 @@ let NotebookExecutionStateService = class NotebookExecutionStateService extends
             visible: true
         };
         this._lastFailedCells.set(notebookURI, newLastFailedCellInfo);
-        this._onDidChangeLastRunFailState.fire({ visible: true, notebook: notebookURI });
+        this._onDidChangeLastRunFailState.fire({
+            visible: true,
+            notebook: notebookURI
+        });
     }
     _setLastFailedCellVisibility(notebookURI, visible) {
         const lastFailedCellInfo = this._lastFailedCells.get(notebookURI);
@@ -193,10 +212,13 @@ let NotebookExecutionStateService = class NotebookExecutionStateService extends
             this._lastFailedCells.set(notebookURI, {
                 cellHandle: lastFailedCellInfo.cellHandle,
                 disposable: lastFailedCellInfo.disposable,
-                visible: visible,
+                visible: visible
             });
         }
-        this._onDidChangeLastRunFailState.fire({ visible: visible, notebook: notebookURI });
+        this._onDidChangeLastRunFailState.fire({
+            visible: visible,
+            notebook: notebookURI
+        });
     }
     _clearLastFailedCell(notebookURI) {
         const lastFailedCellInfo = this._lastFailedCells.get(notebookURI);
@@ -204,10 +226,13 @@ let NotebookExecutionStateService = class NotebookExecutionStateService extends
             lastFailedCellInfo.disposable?.dispose();
             this._lastFailedCells.delete(notebookURI);
         }
-        this._onDidChangeLastRunFailState.fire({ visible: false, notebook: notebookURI });
+        this._onDidChangeLastRunFailState.fire({
+            visible: false,
+            notebook: notebookURI
+        });
     }
     _getFailedCellListener(notebook) {
-        return notebook.onWillAddRemoveCells((e) => {
+        return notebook.onWillAddRemoveCells(e => {
             const lastFailedCell = this._lastFailedCells.get(notebook.uri)?.cellHandle;
             if (lastFailedCell !== undefined) {
                 const lastFailedCellPos = notebook.cells.findIndex(c => c.handle === lastFailedCell);
@@ -240,12 +265,7 @@ let NotebookExecutionStateService = class NotebookExecutionStateService extends
         this._lastFailedCells.forEach(elem => elem.disposable.dispose());
     }
 };
-NotebookExecutionStateService = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, ILogService)),
-    ( __param(2, INotebookService)),
-    ( __param(3, IAccessibilitySignalService))
-], NotebookExecutionStateService));
+NotebookExecutionStateService = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, ILogService)), ( __param(2, INotebookService)), ( __param(3, IAccessibilitySignalService))], NotebookExecutionStateService));
 class NotebookCellExecutionEvent {
     constructor(notebook, cellHandle, changed) {
         this.notebook = notebook;
@@ -272,7 +292,14 @@ class NotebookExecutionEvent {
     }
 }
 let NotebookExecutionListeners = class NotebookExecutionListeners extends Disposable {
-    constructor(notebook, _notebookService, _notebookKernelService, _notebookExecutionService, _notebookExecutionStateService, _logService) {
+    constructor(
+        notebook,
+        _notebookService,
+        _notebookKernelService,
+        _notebookExecutionService,
+        _notebookExecutionStateService,
+        _logService
+    ) {
         super();
         this._notebookService = _notebookService;
         this._notebookKernelService = _notebookKernelService;
@@ -282,10 +309,12 @@ let NotebookExecutionListeners = class NotebookExecutionListeners extends Dispos
         this._logService.debug(`NotebookExecution#ctor ${( notebook.toString())}`);
         const notebookModel = this._notebookService.getNotebookTextModel(notebook);
         if (!notebookModel) {
-            throw ( new Error('Notebook not found: ' + notebook));
+            throw ( new Error("Notebook not found: " + notebook));
         }
         this._notebookModel = notebookModel;
-        this._register(this._notebookModel.onWillAddRemoveCells(e => this.onWillAddRemoveCells(e)));
+        this._register(
+            this._notebookModel.onWillAddRemoveCells(e => this.onWillAddRemoveCells(e))
+        );
         this._register(this._notebookModel.onWillDispose(() => this.onWillDisposeDocument()));
     }
     cancelAll() {
@@ -309,8 +338,7 @@ let NotebookExecutionListeners = class NotebookExecutionListeners extends Dispos
                         const exe = notebookExes.get(h);
                         if (exe?.state === NotebookCellExecutionState.Executing) {
                             executingDeletedHandles.add(h);
-                        }
-                        else if (exe) {
+                        } else if (exe) {
                             pendingDeletedHandles.add(h);
                         }
                     });
@@ -322,7 +350,9 @@ let NotebookExecutionListeners = class NotebookExecutionListeners extends Dispos
             if (kernel) {
                 const implementsInterrupt = kernel.implementsInterrupt;
                 const handlesToCancel = implementsInterrupt ? [...executingDeletedHandles] : [...executingDeletedHandles, ...pendingDeletedHandles];
-                this._logService.debug(`NotebookExecution#onWillAddRemoveCells, ${JSON.stringify([...handlesToCancel])}`);
+                this._logService.debug(
+                    `NotebookExecution#onWillAddRemoveCells, ${JSON.stringify([...handlesToCancel])}`
+                );
                 if (handlesToCancel.length) {
                     kernel.cancelNotebookCellExecution(this._notebookModel.uri, handlesToCancel);
                 }
@@ -330,36 +360,28 @@ let NotebookExecutionListeners = class NotebookExecutionListeners extends Dispos
         }
     }
 };
-NotebookExecutionListeners = ( __decorate([
-    ( __param(1, INotebookService)),
-    ( __param(2, INotebookKernelService)),
-    ( __param(3, INotebookExecutionService)),
-    ( __param(4, INotebookExecutionStateService)),
-    ( __param(5, ILogService))
-], NotebookExecutionListeners));
+NotebookExecutionListeners = ( __decorate([( __param(1, INotebookService)), ( __param(2, INotebookKernelService)), ( __param(3, INotebookExecutionService)), ( __param(4, INotebookExecutionStateService)), ( __param(5, ILogService))], NotebookExecutionListeners));
 function updateToEdit(update, cellHandle) {
     if (update.editType === CellExecutionUpdateType.Output) {
         return {
             editType: CellEditType.Output,
             handle: update.cellHandle,
             append: update.append,
-            outputs: update.outputs,
+            outputs: update.outputs
         };
-    }
-    else if (update.editType === CellExecutionUpdateType.OutputItems) {
+    } else if (update.editType === CellExecutionUpdateType.OutputItems) {
         return {
             editType: CellEditType.OutputItems,
             items: update.items,
             append: update.append,
             outputId: update.outputId
         };
-    }
-    else if (update.editType === CellExecutionUpdateType.ExecutionState) {
+    } else if (update.editType === CellExecutionUpdateType.ExecutionState) {
         const newInternalMetadata = {};
-        if (typeof update.executionOrder !== 'undefined') {
+        if (typeof update.executionOrder !== "undefined") {
             newInternalMetadata.executionOrder = update.executionOrder;
         }
-        if (typeof update.runStartTime !== 'undefined') {
+        if (typeof update.runStartTime !== "undefined") {
             newInternalMetadata.runStartTime = update.runStartTime;
         }
         return {
@@ -368,7 +390,7 @@ function updateToEdit(update, cellHandle) {
             internalMetadata: newInternalMetadata
         };
     }
-    throw ( new Error('Unknown cell update type'));
+    throw ( new Error("Unknown cell update type"));
 }
 let CellExecution = class CellExecution extends Disposable {
     get state() {
@@ -407,7 +429,7 @@ let CellExecution = class CellExecution extends Disposable {
                 runEndTime: null,
                 lastRunSuccess: null,
                 executionOrder: null,
-                renderDuration: null,
+                renderDuration: null
             }
         };
         this._applyExecutionEdits([startExecuteEdit]);
@@ -416,7 +438,7 @@ let CellExecution = class CellExecution extends Disposable {
         return `${( this._notebookModel.uri.toString())}, ${this.cellHandle}`;
     }
     logUpdates(updates) {
-        const updateTypes = ( updates.map(u => CellExecutionUpdateType[u.editType])).join(', ');
+        const updateTypes = ( updates.map(u => CellExecutionUpdateType[u.editType])).join(", ");
         this._logService.debug(`CellExecution#updateExecution ${this.getCellLog()}, [${updateTypes}]`);
     }
     confirm() {
@@ -432,15 +454,16 @@ let CellExecution = class CellExecution extends Disposable {
         if (!this._didPause && ( updates.some(u => u.editType === CellExecutionUpdateType.ExecutionState && u.didPause))) {
             this._didPause = true;
         }
-        const lastIsPausedUpdate = [...updates].reverse().find(u => u.editType === CellExecutionUpdateType.ExecutionState && typeof u.isPaused === 'boolean');
+        const lastIsPausedUpdate = [...updates].reverse().find(
+            u => u.editType === CellExecutionUpdateType.ExecutionState && typeof u.isPaused === "boolean"
+        );
         if (lastIsPausedUpdate) {
             this._isPaused = lastIsPausedUpdate.isPaused;
         }
         const cellModel = this._notebookModel.cells.find(c => c.handle === this.cellHandle);
         if (!cellModel) {
             this._logService.debug(`CellExecution#update, updating cell not in notebook: ${( this._notebookModel.uri.toString())}, ${this.cellHandle}`);
-        }
-        else {
+        } else {
             const edits = ( updates.map(update => updateToEdit(update, this.cellHandle)));
             this._applyExecutionEdits(edits);
         }
@@ -452,8 +475,7 @@ let CellExecution = class CellExecution extends Disposable {
         const cellModel = this._notebookModel.cells.find(c => c.handle === this.cellHandle);
         if (!cellModel) {
             this._logService.debug(`CellExecution#complete, completing cell not in notebook: ${( this._notebookModel.uri.toString())}, ${this.cellHandle}`);
-        }
-        else {
+        } else {
             const edit = {
                 editType: CellEditType.PartialInternalMetadata,
                 handle: this.cellHandle,
@@ -472,9 +494,7 @@ let CellExecution = class CellExecution extends Disposable {
         this._notebookModel.applyEdits(edits, true, undefined, () => undefined, undefined, false);
     }
 };
-CellExecution = ( __decorate([
-    ( __param(2, ILogService))
-], CellExecution));
+CellExecution = ( __decorate([( __param(2, ILogService))], CellExecution));
 let NotebookExecution = class NotebookExecution extends Disposable {
     get state() {
         return this._state;
@@ -512,8 +532,6 @@ let NotebookExecution = class NotebookExecution extends Disposable {
         this._onDidComplete.fire();
     }
 };
-NotebookExecution = ( __decorate([
-    ( __param(1, ILogService))
-], NotebookExecution));
+NotebookExecution = ( __decorate([( __param(1, ILogService))], NotebookExecution));
 
 export { NotebookExecutionStateService };

package/vscode/src/vs/workbench/contrib/notebook/browser/services/notebookKernelHistoryServiceImpl.js

@@ -13,8 +13,12 @@ import { INotebookLoggingService } from '@codingame/monaco-vscode-api/vscode/vs/
 var NotebookKernelHistoryService_1;
 const MAX_KERNELS_IN_HISTORY = 5;
 let NotebookKernelHistoryService = class NotebookKernelHistoryService extends Disposable {
-    static { NotebookKernelHistoryService_1 = this; }
-    static { this.STORAGE_KEY = 'notebook.kernelHistory'; }
+    static {
+        NotebookKernelHistoryService_1 = this;
+    }
+    static {
+        this.STORAGE_KEY = "notebook.kernelHistory";
+    }
     constructor(_storageService, _notebookKernelService, _notebookLoggingService) {
         super();
         this._storageService = _storageService;
@@ -23,7 +27,11 @@ let NotebookKernelHistoryService = class NotebookKernelHistoryService extends Di
         this._mostRecentKernelsMap = {};
         this._loadState();
         this._register(this._storageService.onWillSaveState(() => this._saveState()));
-        this._register(this._storageService.onDidChangeValue(StorageScope.WORKSPACE, NotebookKernelHistoryService_1.STORAGE_KEY, this._store)(() => {
+        this._register(this._storageService.onDidChangeValue(
+            StorageScope.WORKSPACE,
+            NotebookKernelHistoryService_1.STORAGE_KEY,
+            this._store
+        )(() => {
             this._loadState();
         }));
     }
@@ -32,10 +40,16 @@ let NotebookKernelHistoryService = class NotebookKernelHistoryService extends Di
         const allKernels = allAvailableKernels.all;
         const selectedKernel = allAvailableKernels.selected;
         const suggested = allAvailableKernels.all.length === 1 ? allAvailableKernels.all[0] : undefined;
-        this._notebookLoggingService.debug('History', `getMatchingKernels: ${allAvailableKernels.all.length} kernels available for ${notebook.uri.path}. Selected: ${allAvailableKernels.selected?.label}. Suggested: ${suggested?.label}`);
+        this._notebookLoggingService.debug(
+            "History",
+            `getMatchingKernels: ${allAvailableKernels.all.length} kernels available for ${notebook.uri.path}. Selected: ${allAvailableKernels.selected?.label}. Suggested: ${suggested?.label}`
+        );
         const mostRecentKernelIds = this._mostRecentKernelsMap[notebook.notebookType] ? [...( this._mostRecentKernelsMap[notebook.notebookType].values())] : [];
         const all = ( mostRecentKernelIds.map(kernelId => allKernels.find(kernel => kernel.id === kernelId))).filter(kernel => !!kernel);
-        this._notebookLoggingService.debug('History', `mru: ${mostRecentKernelIds.length} kernels in history, ${all.length} registered already.`);
+        this._notebookLoggingService.debug(
+            "History",
+            `mru: ${mostRecentKernelIds.length} kernels in history, ${all.length} registered already.`
+        );
         return {
             selected: selectedKernel ?? suggested,
             all
@@ -59,9 +73,13 @@ let NotebookKernelHistoryService = class NotebookKernelHistoryService extends Di
         }
         if (notEmpty) {
             const serialized = this._serialize();
-            this._storageService.store(NotebookKernelHistoryService_1.STORAGE_KEY, JSON.stringify(serialized), StorageScope.WORKSPACE, StorageTarget.USER);
-        }
-        else {
+            this._storageService.store(
+                NotebookKernelHistoryService_1.STORAGE_KEY,
+                JSON.stringify(serialized),
+                StorageScope.WORKSPACE,
+                StorageTarget.USER
+            );
+        } else {
             this._storageService.remove(NotebookKernelHistoryService_1.STORAGE_KEY, StorageScope.WORKSPACE);
         }
     }
@@ -70,12 +88,10 @@ let NotebookKernelHistoryService = class NotebookKernelHistoryService extends Di
         if (serialized) {
             try {
                 this._deserialize(JSON.parse(serialized));
-            }
-            catch (e) {
+            } catch (e) {
                 this._mostRecentKernelsMap = {};
             }
-        }
-        else {
+        } else {
             this._mostRecentKernelsMap = {};
         }
     }
@@ -105,16 +121,12 @@ let NotebookKernelHistoryService = class NotebookKernelHistoryService extends Di
         this._saveState();
     }
 };
-NotebookKernelHistoryService = NotebookKernelHistoryService_1 = ( __decorate([
-    ( __param(0, IStorageService)),
-    ( __param(1, INotebookKernelService)),
-    ( __param(2, INotebookLoggingService))
-], NotebookKernelHistoryService));
+NotebookKernelHistoryService = NotebookKernelHistoryService_1 = ( __decorate([( __param(0, IStorageService)), ( __param(1, INotebookKernelService)), ( __param(2, INotebookLoggingService))], NotebookKernelHistoryService));
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: 'notebook.clearNotebookKernelsMRUCache',
-            title: ( localize2(9686, "Clear Notebook Kernels MRU Cache")),
+            id: "notebook.clearNotebookKernelsMRUCache",
+            title: ( localize2(10006, "Clear Notebook Kernels MRU Cache")),
             category: Categories.Developer,
             f1: true
         });