@codingame/monaco-vscode-notebook-service-override 1.85.1

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/format/formatting.js

@@ -0,0 +1,209 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { DisposableStore, Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { registerEditorAction, EditorAction } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { IBulkEditService, ResourceTextEdit } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
+import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
+import { IEditorWorkerService } from 'monaco-editor/esm/vs/editor/common/services/editorWorker.js';
+import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { getDocumentFormattingEditsUntilResult, formatDocumentWithSelectedProvider } from 'monaco-editor/esm/vs/editor/contrib/format/browser/format.js';
+import { registerAction2, Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Progress } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { NOTEBOOK_ACTIONS_CATEGORY } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/coreActions';
+import { getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_EDITOR_EDITABLE } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { INotebookExecutionService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionService';
+import { NotebookSetting } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
+
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'notebook.format',
+            title: { value: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/format/formatting',
+                'format.title',
+                "Format Notebook"
+            )), original: 'Format Notebook' },
+            category: NOTEBOOK_ACTIONS_CATEGORY,
+            precondition: ( ContextKeyExpr.and(NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_EDITOR_EDITABLE)),
+            keybinding: {
+                when: ( EditorContextKeys.editorTextFocus.toNegated()),
+                primary: 1024  | 512  | 36 ,
+                linux: { primary: 2048  | 1024  | 39  },
+                weight: 200
+            },
+            f1: true,
+            menu: {
+                id: MenuId.EditorContext,
+                when: ( ContextKeyExpr.and(
+                    EditorContextKeys.inCompositeEditor,
+                    EditorContextKeys.hasDocumentFormattingProvider
+                )),
+                group: '1_modification',
+                order: 1.3
+            }
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const textModelService = accessor.get(ITextModelService);
+        const editorWorkerService = accessor.get(IEditorWorkerService);
+        const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+        const bulkEditService = accessor.get(IBulkEditService);
+        const editor = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
+        if (!editor || !editor.hasModel()) {
+            return;
+        }
+        const notebook = editor.textModel;
+        const disposable = ( new DisposableStore());
+        try {
+            const allCellEdits = await Promise.all(( notebook.cells.map(async (cell) => {
+                const ref = await textModelService.createModelReference(cell.uri);
+                disposable.add(ref);
+                const model = ref.object.textEditorModel;
+                const formatEdits = await getDocumentFormattingEditsUntilResult(editorWorkerService, languageFeaturesService, model, model.getOptions(), CancellationToken.None);
+                const edits = [];
+                if (formatEdits) {
+                    for (const edit of formatEdits) {
+                        edits.push(( new ResourceTextEdit(model.uri, edit, model.getVersionId())));
+                    }
+                    return edits;
+                }
+                return [];
+            })));
+            await bulkEditService.apply( allCellEdits.flat(), { label: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/format/formatting',
+                'label',
+                "Format Notebook"
+            )), code: 'undoredo.formatNotebook', });
+        }
+        finally {
+            disposable.dispose();
+        }
+    }
+});
+registerEditorAction(class FormatCellAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'notebook.formatCell',
+            label: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/format/formatting',
+                'formatCell.label',
+                "Format Cell"
+            )),
+            alias: 'Format Cell',
+            precondition: ( ContextKeyExpr.and(
+                NOTEBOOK_IS_ACTIVE_EDITOR,
+                NOTEBOOK_EDITOR_EDITABLE,
+                EditorContextKeys.inCompositeEditor,
+                EditorContextKeys.writable,
+                EditorContextKeys.hasDocumentFormattingProvider
+            )),
+            kbOpts: {
+                kbExpr: ( ContextKeyExpr.and(EditorContextKeys.editorTextFocus)),
+                primary: 1024  | 512  | 36 ,
+                linux: { primary: 2048  | 1024  | 39  },
+                weight: 100
+            },
+            contextMenuOpts: {
+                group: '1_modification',
+                order: 1.301
+            }
+        });
+    }
+    async run(accessor, editor) {
+        if (editor.hasModel()) {
+            const instaService = accessor.get(IInstantiationService);
+            await instaService.invokeFunction(formatDocumentWithSelectedProvider, editor, 1 , Progress.None, CancellationToken.None, true);
+        }
+    }
+});
+let FormatOnCellExecutionParticipant = class FormatOnCellExecutionParticipant {
+    constructor(bulkEditService, languageFeaturesService, textModelService, editorWorkerService, configurationService, _notebookService) {
+        this.bulkEditService = bulkEditService;
+        this.languageFeaturesService = languageFeaturesService;
+        this.textModelService = textModelService;
+        this.editorWorkerService = editorWorkerService;
+        this.configurationService = configurationService;
+        this._notebookService = _notebookService;
+    }
+    async onWillExecuteCell(executions) {
+        const enabled = this.configurationService.getValue(NotebookSetting.formatOnCellExecution);
+        if (!enabled) {
+            return;
+        }
+        const disposable = ( new DisposableStore());
+        try {
+            const allCellEdits = await Promise.all(( executions.map(async (cellExecution) => {
+                const nbModel = this._notebookService.getNotebookTextModel(cellExecution.notebook);
+                if (!nbModel) {
+                    return [];
+                }
+                let activeCell;
+                for (const cell of nbModel.cells) {
+                    if (cell.handle === cellExecution.cellHandle) {
+                        activeCell = cell;
+                        break;
+                    }
+                }
+                if (!activeCell) {
+                    return [];
+                }
+                const ref = await this.textModelService.createModelReference(activeCell.uri);
+                disposable.add(ref);
+                const model = ref.object.textEditorModel;
+                const formatEdits = await getDocumentFormattingEditsUntilResult(this.editorWorkerService, this.languageFeaturesService, model, model.getOptions(), CancellationToken.None);
+                const edits = [];
+                if (formatEdits) {
+                    edits.push(...( formatEdits.map(edit => ( new ResourceTextEdit(model.uri, edit, model.getVersionId())))));
+                    return edits;
+                }
+                return [];
+            })));
+            await this.bulkEditService.apply( allCellEdits.flat(), { label: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/format/formatting',
+                'formatCells.label',
+                "Format Cells"
+            )), code: 'undoredo.notebooks.onWillExecuteFormat', });
+        }
+        finally {
+            disposable.dispose();
+        }
+    }
+};
+FormatOnCellExecutionParticipant = ( __decorate([
+    ( __param(0, IBulkEditService)),
+    ( __param(1, ILanguageFeaturesService)),
+    ( __param(2, ITextModelService)),
+    ( __param(3, IEditorWorkerService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, INotebookService))
+], FormatOnCellExecutionParticipant));
+let CellExecutionParticipantsContribution = class CellExecutionParticipantsContribution extends Disposable {
+    constructor(instantiationService, notebookExecutionService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.notebookExecutionService = notebookExecutionService;
+        this.registerKernelExecutionParticipants();
+    }
+    registerKernelExecutionParticipants() {
+        this._register(this.notebookExecutionService.registerExecutionParticipant(this.instantiationService.createInstance(FormatOnCellExecutionParticipant)));
+    }
+};
+CellExecutionParticipantsContribution = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, INotebookExecutionService))
+], CellExecutionParticipantsContribution));
+const workbenchContributionsRegistry = ( Registry.as(Extensions.Workbench));
+workbenchContributionsRegistry.registerWorkbenchContribution(CellExecutionParticipantsContribution, 3 );
+
+export { CellExecutionParticipantsContribution };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/gettingStarted/notebookGettingStarted.js

@@ -0,0 +1,87 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { registerAction2, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { Memento } from 'vscode/vscode/vs/workbench/common/memento';
+import { HAS_OPENED_NOTEBOOK } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
+import { NotebookSetting } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { NotebookEditorInput } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorInput';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+
+const hasOpenedNotebookKey = 'hasOpenedNotebook';
+const hasShownGettingStartedKey = 'hasShownNotebookGettingStarted';
+let NotebookGettingStarted = class NotebookGettingStarted extends Disposable {
+    constructor(_editorService, _storageService, _contextKeyService, _commandService, _configurationService) {
+        super();
+        const hasOpenedNotebook = HAS_OPENED_NOTEBOOK.bindTo(_contextKeyService);
+        const memento = ( new Memento('notebookGettingStarted2', _storageService));
+        const storedValue = memento.getMemento(0 , 0 );
+        if (storedValue[hasOpenedNotebookKey]) {
+            hasOpenedNotebook.set(true);
+        }
+        const needToShowGettingStarted = _configurationService.getValue(NotebookSetting.openGettingStarted) && !storedValue[hasShownGettingStartedKey];
+        if (!storedValue[hasOpenedNotebookKey] || needToShowGettingStarted) {
+            const onDidOpenNotebook = () => {
+                hasOpenedNotebook.set(true);
+                storedValue[hasOpenedNotebookKey] = true;
+                if (needToShowGettingStarted) {
+                    _commandService.executeCommand('workbench.action.openWalkthrough', { category: 'notebooks', step: 'notebookProfile' }, true);
+                    storedValue[hasShownGettingStartedKey] = true;
+                }
+                memento.saveMemento();
+            };
+            if (_editorService.activeEditor?.typeId === NotebookEditorInput.ID) {
+                onDidOpenNotebook();
+                return;
+            }
+            const listener = this._register(_editorService.onDidActiveEditorChange(() => {
+                if (_editorService.activeEditor?.typeId === NotebookEditorInput.ID) {
+                    listener.dispose();
+                    onDidOpenNotebook();
+                }
+            }));
+        }
+    }
+};
+NotebookGettingStarted = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IStorageService)),
+    ( __param(2, IContextKeyService)),
+    ( __param(3, ICommandService)),
+    ( __param(4, IConfigurationService))
+], NotebookGettingStarted));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(NotebookGettingStarted, 3 );
+registerAction2(class NotebookClearNotebookLayoutAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.notebook.layout.gettingStarted',
+            title: {
+                value: ( localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/contrib/gettingStarted/notebookGettingStarted',
+                    'workbench.notebook.layout.gettingStarted.label',
+                    "Reset notebook getting started"
+                )),
+                original: 'Reset notebook getting started'
+            },
+            f1: true,
+            precondition: ( ContextKeyExpr.equals(`config.${NotebookSetting.openGettingStarted}`, true)),
+            category: Categories.Developer,
+        });
+    }
+    run(accessor) {
+        const storageService = accessor.get(IStorageService);
+        const memento = ( new Memento('notebookGettingStarted', storageService));
+        const storedValue = memento.getMemento(0 , 0 );
+        storedValue[hasOpenedNotebookKey] = undefined;
+        memento.saveMemento();
+    }
+});
+
+export { NotebookGettingStarted };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/kernelDetection/notebookKernelDetection.js

@@ -0,0 +1,82 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { INotebookKernelService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService';
+import { INotebookLoggingService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookLoggingService';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+
+let NotebookKernelDetection = class NotebookKernelDetection extends Disposable {
+    constructor(_notebookKernelService, _extensionService, _notebookLoggingService) {
+        super();
+        this._notebookKernelService = _notebookKernelService;
+        this._extensionService = _extensionService;
+        this._notebookLoggingService = _notebookLoggingService;
+        this._detectionMap = ( new Map());
+        this._localDisposableStore = this._register(( new DisposableStore()));
+        this._registerListeners();
+    }
+    _registerListeners() {
+        this._localDisposableStore.clear();
+        this._localDisposableStore.add(this._extensionService.onWillActivateByEvent(e => {
+            if (e.event.startsWith('onNotebook:')) {
+                if (this._extensionService.activationEventIsDone(e.event)) {
+                    return;
+                }
+                const notebookType = e.event.substring('onNotebook:'.length);
+                if (notebookType === '*') {
+                    return;
+                }
+                let shouldStartDetection = false;
+                const extensionStatus = this._extensionService.getExtensionsStatus();
+                this._extensionService.extensions.forEach(extension => {
+                    if (extensionStatus[extension.identifier.value].activationTimes) {
+                        return;
+                    }
+                    if (extension.activationEvents?.includes(e.event)) {
+                        shouldStartDetection = true;
+                    }
+                });
+                if (shouldStartDetection && !( this._detectionMap.has(notebookType))) {
+                    this._notebookLoggingService.debug('KernelDetection', `start extension activation for ${notebookType}`);
+                    const task = this._notebookKernelService.registerNotebookKernelDetectionTask({
+                        notebookType: notebookType
+                    });
+                    this._detectionMap.set(notebookType, task);
+                }
+            }
+        }));
+        let timer = null;
+        this._localDisposableStore.add(this._extensionService.onDidChangeExtensionsStatus(() => {
+            if (timer) {
+                clearTimeout(timer);
+            }
+            timer = setTimeout(() => {
+                const taskToDelete = [];
+                for (const [notebookType, task] of this._detectionMap) {
+                    if (this._extensionService.activationEventIsDone(`onNotebook:${notebookType}`)) {
+                        this._notebookLoggingService.debug('KernelDetection', `finish extension activation for ${notebookType}`);
+                        taskToDelete.push(notebookType);
+                        task.dispose();
+                    }
+                }
+                taskToDelete.forEach(notebookType => {
+                    this._detectionMap.delete(notebookType);
+                });
+            });
+        }));
+        this._localDisposableStore.add({
+            dispose: () => {
+                if (timer) {
+                    clearTimeout(timer);
+                }
+            }
+        });
+    }
+};
+NotebookKernelDetection = ( __decorate([
+    ( __param(0, INotebookKernelService)),
+    ( __param(1, IExtensionService)),
+    ( __param(2, INotebookLoggingService))
+], NotebookKernelDetection));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(NotebookKernelDetection, 3 );

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/layout/layoutActions.js

@@ -0,0 +1,67 @@
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { registerAction2, Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { NOTEBOOK_ACTIONS_CATEGORY } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/coreActions';
+import { NotebookSetting } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+
+const TOGGLE_CELL_TOOLBAR_POSITION = 'notebook.toggleCellToolbarPosition';
+class ToggleCellToolbarPositionAction extends Action2 {
+    constructor() {
+        super({
+            id: TOGGLE_CELL_TOOLBAR_POSITION,
+            title: { value: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/layout/layoutActions',
+                'notebook.toggleCellToolbarPosition',
+                "Toggle Cell Toolbar Position"
+            )), original: 'Toggle Cell Toolbar Position' },
+            menu: [{
+                    id: MenuId.NotebookCellTitle,
+                    group: 'View',
+                    order: 1
+                }],
+            category: NOTEBOOK_ACTIONS_CATEGORY,
+            f1: false
+        });
+    }
+    async run(accessor, context) {
+        const editor = context && context.ui ? context.notebookEditor : undefined;
+        if (editor && editor.hasModel()) {
+            const viewType = editor.textModel.viewType;
+            const configurationService = accessor.get(IConfigurationService);
+            const toolbarPosition = configurationService.getValue(NotebookSetting.cellToolbarLocation);
+            const newConfig = this.togglePosition(viewType, toolbarPosition);
+            await configurationService.updateValue(NotebookSetting.cellToolbarLocation, newConfig);
+        }
+    }
+    togglePosition(viewType, toolbarPosition) {
+        if (typeof toolbarPosition === 'string') {
+            if (['left', 'right', 'hidden'].indexOf(toolbarPosition) >= 0) {
+                const newViewValue = toolbarPosition === 'right' ? 'left' : 'right';
+                const config = {
+                    default: toolbarPosition
+                };
+                config[viewType] = newViewValue;
+                return config;
+            }
+            else {
+                const config = {
+                    default: 'right',
+                };
+                config[viewType] = 'left';
+                return config;
+            }
+        }
+        else {
+            const oldValue = toolbarPosition[viewType] ?? toolbarPosition['default'] ?? 'right';
+            const newViewValue = oldValue === 'right' ? 'left' : 'right';
+            const newConfig = {
+                ...toolbarPosition
+            };
+            newConfig[viewType] = newViewValue;
+            return newConfig;
+        }
+    }
+}
+registerAction2(ToggleCellToolbarPositionAction);
+
+export { ToggleCellToolbarPositionAction };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/marker/markerProvider.js

@@ -0,0 +1,93 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { MarkerList, IMarkerNavigationService } from 'monaco-editor/esm/vs/editor/contrib/gotoError/browser/markerNavigationService.js';
+import { CellUri } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { MarkerSeverity, IMarkerService } from 'monaco-editor/esm/vs/platform/markers/common/markers.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { NotebookOverviewRulerLane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { registerNotebookContribution } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
+import { throttle } from 'monaco-editor/esm/vs/base/common/decorators.js';
+import { editorErrorForeground, editorWarningForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+
+let MarkerListProvider = class MarkerListProvider {
+    constructor(_markerService, markerNavigation, _configService) {
+        this._markerService = _markerService;
+        this._configService = _configService;
+        this._dispoables = markerNavigation.registerProvider(this);
+    }
+    dispose() {
+        this._dispoables.dispose();
+    }
+    getMarkerList(resource) {
+        if (!resource) {
+            return undefined;
+        }
+        const data = CellUri.parse(resource);
+        if (!data) {
+            return undefined;
+        }
+        return ( new MarkerList(uri => {
+            const otherData = CellUri.parse(uri);
+            return otherData?.notebook.toString() === ( data.notebook.toString());
+        }, this._markerService, this._configService));
+    }
+};
+MarkerListProvider = ( __decorate([
+    ( __param(0, IMarkerService)),
+    ( __param(1, IMarkerNavigationService)),
+    ( __param(2, IConfigurationService))
+], MarkerListProvider));
+let NotebookMarkerDecorationContribution = class NotebookMarkerDecorationContribution extends Disposable {
+    static { this.id = 'workbench.notebook.markerDecoration'; }
+    constructor(_notebookEditor, _markerService) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this._markerService = _markerService;
+        this._markersOverviewRulerDecorations = [];
+        this._update();
+        this._register(this._notebookEditor.onDidChangeModel(() => this._update()));
+        this._register(this._markerService.onMarkerChanged(e => {
+            if (( e.some(uri => ( this._notebookEditor.getCellsInRange().some(cell => isEqual(cell.uri, uri)))))) {
+                this._update();
+            }
+        }));
+    }
+    _update() {
+        if (!this._notebookEditor.hasModel()) {
+            return;
+        }
+        const cellDecorations = [];
+        this._notebookEditor.getCellsInRange().forEach(cell => {
+            const marker = this._markerService.read({ resource: cell.uri, severities: MarkerSeverity.Error | MarkerSeverity.Warning });
+            marker.forEach(m => {
+                const color = m.severity === MarkerSeverity.Error ? editorErrorForeground : editorWarningForeground;
+                const range = { startLineNumber: m.startLineNumber, startColumn: m.startColumn, endLineNumber: m.endLineNumber, endColumn: m.endColumn };
+                cellDecorations.push({
+                    handle: cell.handle,
+                    options: {
+                        overviewRuler: {
+                            color: color,
+                            modelRanges: [range],
+                            includeOutput: false,
+                            position: NotebookOverviewRulerLane.Right
+                        }
+                    }
+                });
+            });
+        });
+        this._markersOverviewRulerDecorations = this._notebookEditor.deltaCellDecorations(this._markersOverviewRulerDecorations, cellDecorations);
+    }
+};
+NotebookMarkerDecorationContribution.__decorator = ( __decorate([
+    throttle(100)
+], NotebookMarkerDecorationContribution.prototype, "_update", null));
+NotebookMarkerDecorationContribution = ( __decorate([
+    ( __param(1, IMarkerService))
+], NotebookMarkerDecorationContribution));
+( Registry
+    .as(Extensions.Workbench))
+    .registerWorkbenchContribution(MarkerListProvider, 2 );
+registerNotebookContribution(NotebookMarkerDecorationContribution.id, NotebookMarkerDecorationContribution);