@codingame/monaco-vscode-api 37.2.0 → 37.3.1

package/vscode/src/vs/workbench/contrib/notebook/browser/notebookEditorWidget.js

@@ -0,0 +1,2932 @@
+
+import { registerCss } from '../../../../../../../css.js';
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as notebook from './media/notebook.css';
+import * as notebookCellChat from './media/notebookCellChat.css';
+import * as notebookCellEditorHint from './media/notebookCellEditorHint.css';
+import * as notebookCellInsertToolbar from './media/notebookCellInsertToolbar.css';
+import * as notebookCellStatusBar from './media/notebookCellStatusBar.css';
+import * as notebookCellTitleToolbar from './media/notebookCellTitleToolbar.css';
+import * as notebookFocusIndicator from './media/notebookFocusIndicator.css';
+import * as notebookToolbar from './media/notebookToolbar.css';
+import * as notebookDnd from './media/notebookDnd.css';
+import * as notebookFolding from './media/notebookFolding.css';
+import * as notebookCellOutput from './media/notebookCellOutput.css';
+import * as notebookEditorStickyScroll from './media/notebookEditorStickyScroll.css';
+import * as notebookKernelActionViewItem from './media/notebookKernelActionViewItem.css';
+import * as notebookOutline from './media/notebookOutline.css';
+import * as notebookChatEditController from './media/notebookChatEditController.css';
+import * as notebookChatEditorOverlay from './media/notebookChatEditorOverlay.css';
+import { $ as $$1, getWindow, createElement, append, addStandardDisposableGenericMouseDownListener, addStandardDisposableGenericMouseUpListener, trackFocus, runWhenWindowIdle, scheduleAtNextAnimationFrame, getActiveElement, size, isHTMLElement, isAncestorOfActiveElement } from '../../../../base/browser/dom.js';
+import { createStyleSheet } from '../../../../base/browser/domStylesheets.js';
+import { OverlayLayoutElement } from '../../../../base/browser/overlayLayoutElement.js';
+import { mainWindow } from '../../../../base/browser/window.js';
+import { SequencerByKey } from '../../../../base/common/async.js';
+import { Color, RGBA } from '../../../../base/common/color.js';
+import { onUnexpectedError } from '../../../../base/common/errors.js';
+import { Emitter, Event } from '../../../../base/common/event.js';
+import { Disposable, DisposableStore, combinedDisposable, dispose, MutableDisposable } from '../../../../base/common/lifecycle.js';
+import { setTimeout0 } from '../../../../base/common/platform.js';
+import { isEqual, extname } from '../../../../base/common/resources.js';
+import { generateUuid } from '../../../../base/common/uuid.js';
+import { FontMeasurements } from '../../../../editor/browser/config/fontMeasurements.js';
+import { createBareFontInfoFromRawSettings } from '../../../../editor/common/config/fontInfoFromSettings.js';
+import { Range } from '../../../../editor/common/core/range.js';
+import { SuggestController } from '../../../../editor/contrib/suggest/browser/suggestController.js';
+import { localize } from '../../../../nls.js';
+import { MenuId } from '../../../../platform/actions/common/actions.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
+import { IContextMenuService } from '../../../../platform/contextview/browser/contextView.service.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ServiceCollection } from '../../../../platform/instantiation/common/serviceCollection.js';
+import { Parts } from '../../../services/layout/browser/layoutService.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.service.js';
+import { registerZIndex, ZIndex } from '../../../../platform/layout/browser/zIndexRegistry.js';
+import { IEditorProgressService } from '../../../../platform/progress/common/progress.service.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.service.js';
+import { registerColor, transparent } from '../../../../platform/theme/common/colorUtils.js';
+import { foreground, focusBorder, errorForeground, contrastBorder } from '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import '../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../platform/theme/common/colors/inputColors.js';
+import { listInactiveSelectionBackground } from '../../../../platform/theme/common/colors/listColors.js';
+import '../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../platform/theme/common/colors/minimapColors.js';
+import { scrollbarSliderBackground, scrollbarSliderHoverBackground, scrollbarSliderActiveBackground } from '../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
+import { PANEL_BORDER, SIDE_BAR_BACKGROUND, EDITOR_PANE_BACKGROUND } from '../../../common/theme.js';
+import { debugIconStartForeground } from '../../debug/browser/debugColors.js';
+import { CellEditState, CellFocusMode, CellRevealType, CellRevealRangeType, ScrollToRevealBehavior, RenderOutputType } from './notebookBrowser.js';
+import { NotebookEditorExtensionsRegistry } from './notebookEditorExtensions.js';
+import { INotebookEditorService } from './services/notebookEditorService.service.js';
+import { notebookDebug } from './notebookLogger.js';
+import { NotebookLayoutChangedEvent } from './notebookViewEvents.js';
+import { CellContextKeyManager } from './view/cellParts/cellContextKeys.js';
+import { CellDragAndDropController } from './view/cellParts/cellDnd.js';
+import { NotebookCellList, ListViewInfoAccessor, NOTEBOOK_WEBVIEW_BOUNDARY } from './view/notebookCellList.js';
+import { BackLayerWebView } from './view/renderers/backLayerWebView.js';
+import { CodeCellRenderer, MarkupCellRenderer, NotebookCellListDelegate } from './view/renderers/cellRenderer.js';
+import { outputDisplayLimit, CodeCellViewModel } from './viewModel/codeCellViewModel.js';
+import { NotebookEventDispatcher } from './viewModel/eventDispatcher.js';
+import { MarkupCellViewModel } from './viewModel/markupCellViewModel.js';
+import { NotebookViewModel } from './viewModel/notebookViewModelImpl.js';
+import { ViewContext } from './viewModel/viewContext.js';
+import { NotebookEditorWorkbenchToolbar } from './viewParts/notebookEditorToolbar.js';
+import { NotebookEditorContextKeys } from './viewParts/notebookEditorWidgetContextKeys.js';
+import { NotebookOverviewRuler } from './viewParts/notebookOverviewRuler.js';
+import { ListTopCellToolbar } from './viewParts/notebookTopCellToolbar.js';
+import { SelectionStateType, RENDERER_NOT_AVAILABLE, CellKind, NotebookFindScopeType, CellEditType } from '../common/notebookCommon.js';
+import { NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_OUTPUT_FOCUSED, NOTEBOOK_OUTPUT_INPUT_FOCUSED, NOTEBOOK_EDITOR_EDITABLE, NOTEBOOK_CURSOR_NAVIGATION_MODE } from '../common/notebookContextKeys.js';
+import { INotebookExecutionService } from '../common/notebookExecutionService.service.js';
+import { INotebookKernelService } from '../common/notebookKernelService.service.js';
+import { NotebookOptions, OutputInnerContainerTopPadding } from './notebookOptions.js';
+import { cellRangesToIndexes } from '../common/notebookRange.js';
+import { INotebookRendererMessagingService } from '../common/notebookRendererMessagingService.service.js';
+import { INotebookService } from '../common/notebookService.service.js';
+import { EditorExtensionsRegistry } from '../../../../editor/browser/editorExtensions.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.service.js';
+import { BaseCellEditorOptions } from './viewModel/cellEditorOptions.js';
+import { FloatingEditorClickMenu } from '../../../browser/codeeditor.js';
+import { CellFindMatchModel } from './contrib/find/findModel.js';
+import { INotebookLoggingService } from '../common/notebookLoggingService.service.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { DropIntoEditorController } from '../../../../editor/contrib/dropOrPasteInto/browser/dropIntoEditorController.js';
+import { CopyPasteController } from '../../../../editor/contrib/dropOrPasteInto/browser/copyPasteController.js';
+import { NotebookStickyScroll } from './viewParts/notebookEditorStickyScroll.js';
+import { PixelRatio } from '../../../../base/browser/pixelRatio.js';
+import { PreventDefaultContextMenuItemsContextKeyName } from '../../webview/browser/webview.contribution.js';
+import { NotebookAccessibilityProvider } from './notebookAccessibilityProvider.js';
+import { NotebookHorizontalTracker } from './viewParts/notebookHorizontalTracker.js';
+import { NotebookCellEditorPool } from './view/notebookCellEditorPool.js';
+import { InlineCompletionsController } from '../../../../editor/contrib/inlineCompletions/browser/controller/inlineCompletionsController.js';
+import { NotebookCellLayoutManager } from './notebookCellLayoutManager.js';
+import { FloatingEditorToolbar } from '../../../../editor/contrib/floatingMenu/browser/floatingMenu.js';
+
+registerCss(notebook, 1);
+registerCss(notebookCellChat, 1);
+registerCss(notebookCellEditorHint, 1);
+registerCss(notebookCellInsertToolbar, 1);
+registerCss(notebookCellStatusBar, 1);
+registerCss(notebookCellTitleToolbar, 1);
+registerCss(notebookFocusIndicator, 1);
+registerCss(notebookToolbar, 1);
+registerCss(notebookDnd, 1);
+registerCss(notebookFolding, 1);
+registerCss(notebookCellOutput, 1);
+registerCss(notebookEditorStickyScroll, 1);
+registerCss(notebookKernelActionViewItem, 1);
+registerCss(notebookOutline, 1);
+registerCss(notebookChatEditController, 1);
+registerCss(notebookChatEditorOverlay, 1);
+const $ = $$1;
+function getDefaultNotebookCreationOptions() {
+    const skipContributions = [
+        "editor.contrib.review",
+        FloatingEditorClickMenu.ID,
+        FloatingEditorToolbar.ID,
+        "editor.contrib.dirtydiff",
+        "editor.contrib.testingOutputPeek",
+        "editor.contrib.testingDecorations",
+        "store.contrib.stickyScrollController",
+        "editor.contrib.findController",
+        "editor.contrib.emptyTextEditorHint"
+    ];
+    const contributions = EditorExtensionsRegistry.getEditorContributions().filter(c => skipContributions.indexOf(c.id) === -1);
+    return {
+        menuIds: {
+            notebookToolbar: MenuId.NotebookToolbar,
+            cellTitleToolbar: MenuId.NotebookCellTitle,
+            cellDeleteToolbar: MenuId.NotebookCellDelete,
+            cellInsertToolbar: MenuId.NotebookCellBetween,
+            cellTopInsertToolbar: MenuId.NotebookCellListTop,
+            cellExecuteToolbar: MenuId.NotebookCellExecute,
+            cellExecutePrimary: MenuId.NotebookCellExecutePrimary
+        },
+        cellEditorContributions: contributions
+    };
+}
+let NotebookEditorWidget = class NotebookEditorWidget extends Disposable {
+    get isVisible() {
+        return this._isVisible;
+    }
+    get isDisposed() {
+        return this._isDisposed;
+    }
+    set viewModel(newModel) {
+        this._onWillChangeModel.fire(this._notebookViewModel?.notebookDocument);
+        this._notebookViewModel = newModel;
+        this._onDidChangeModel.fire(newModel?.notebookDocument);
+    }
+    get viewModel() {
+        return this._notebookViewModel;
+    }
+    get textModel() {
+        return this._notebookViewModel?.notebookDocument;
+    }
+    get isReadOnly() {
+        return this._notebookViewModel?.options.isReadOnly ?? false;
+    }
+    get activeCodeEditor() {
+        if (this._isDisposed) {
+            return;
+        }
+        const [focused] = this._list.getFocusedElements();
+        return this._renderedEditors.get(focused);
+    }
+    get activeCellAndCodeEditor() {
+        if (this._isDisposed) {
+            return;
+        }
+        const [focused] = this._list.getFocusedElements();
+        const editor = this._renderedEditors.get(focused);
+        if (!editor) {
+            return;
+        }
+        return [focused, editor];
+    }
+    get codeEditors() {
+        return [...this._renderedEditors];
+    }
+    get visibleRanges() {
+        return this._list ? (this._list.visibleRanges || []) : [];
+    }
+    get notebookOptions() {
+        return this._notebookOptions;
+    }
+    constructor(
+        creationOptions,
+        dimension,
+        instantiationService,
+        editorGroupsService,
+        notebookRendererMessaging,
+        notebookEditorService,
+        notebookKernelService,
+        _notebookService,
+        configurationService,
+        contextKeyService,
+        layoutService,
+        contextMenuService,
+        telemetryService,
+        notebookExecutionService,
+        editorProgressService,
+        logService
+    ) {
+        super();
+        this.creationOptions = creationOptions;
+        this.editorGroupsService = editorGroupsService;
+        this.notebookRendererMessaging = notebookRendererMessaging;
+        this.notebookEditorService = notebookEditorService;
+        this.notebookKernelService = notebookKernelService;
+        this._notebookService = _notebookService;
+        this.configurationService = configurationService;
+        this.layoutService = layoutService;
+        this.contextMenuService = contextMenuService;
+        this.telemetryService = telemetryService;
+        this.notebookExecutionService = notebookExecutionService;
+        this.editorProgressService = editorProgressService;
+        this.logService = logService;
+        this._onDidChangeCellState = this._register(( new Emitter()));
+        this.onDidChangeCellState = this._onDidChangeCellState.event;
+        this._onDidChangeViewCells = this._register(( new Emitter()));
+        this.onDidChangeViewCells = this._onDidChangeViewCells.event;
+        this._onWillChangeModel = this._register(( new Emitter()));
+        this.onWillChangeModel = this._onWillChangeModel.event;
+        this._onDidChangeModel = this._register(( new Emitter()));
+        this.onDidChangeModel = this._onDidChangeModel.event;
+        this._onDidAttachViewModel = this._register(( new Emitter()));
+        this.onDidAttachViewModel = this._onDidAttachViewModel.event;
+        this._onDidChangeOptions = this._register(( new Emitter()));
+        this.onDidChangeOptions = this._onDidChangeOptions.event;
+        this._onDidChangeDecorations = this._register(( new Emitter()));
+        this.onDidChangeDecorations = this._onDidChangeDecorations.event;
+        this._onDidScroll = this._register(( new Emitter()));
+        this.onDidScroll = this._onDidScroll.event;
+        this._onDidChangeLayout = this._register(( new Emitter()));
+        this.onDidChangeLayout = this._onDidChangeLayout.event;
+        this._onDidChangeActiveCell = this._register(( new Emitter()));
+        this.onDidChangeActiveCell = this._onDidChangeActiveCell.event;
+        this._onDidChangeFocus = this._register(( new Emitter()));
+        this.onDidChangeFocus = this._onDidChangeFocus.event;
+        this._onDidChangeSelection = this._register(( new Emitter()));
+        this.onDidChangeSelection = this._onDidChangeSelection.event;
+        this._onDidChangeVisibleRanges = this._register(( new Emitter()));
+        this.onDidChangeVisibleRanges = this._onDidChangeVisibleRanges.event;
+        this._onDidFocusEmitter = this._register(( new Emitter()));
+        this.onDidFocusWidget = this._onDidFocusEmitter.event;
+        this._onDidBlurEmitter = this._register(( new Emitter()));
+        this.onDidBlurWidget = this._onDidBlurEmitter.event;
+        this._onDidChangeActiveEditor = this._register(( new Emitter()));
+        this.onDidChangeActiveEditor = this._onDidChangeActiveEditor.event;
+        this._onDidChangeActiveKernel = this._register(( new Emitter()));
+        this.onDidChangeActiveKernel = this._onDidChangeActiveKernel.event;
+        this._onMouseUp = this._register(( new Emitter()));
+        this.onMouseUp = this._onMouseUp.event;
+        this._onMouseDown = this._register(( new Emitter()));
+        this.onMouseDown = this._onMouseDown.event;
+        this._onDidReceiveMessage = this._register(( new Emitter()));
+        this.onDidReceiveMessage = this._onDidReceiveMessage.event;
+        this._onDidRenderOutput = this._register(( new Emitter()));
+        this.onDidRenderOutput = this._onDidRenderOutput.event;
+        this._onDidRemoveOutput = this._register(( new Emitter()));
+        this.onDidRemoveOutput = this._onDidRemoveOutput.event;
+        this._onDidResizeOutputEmitter = this._register(( new Emitter()));
+        this.onDidResizeOutput = this._onDidResizeOutputEmitter.event;
+        this._webview = null;
+        this._webviewResolvePromise = null;
+        this._webviewTransparentCover = null;
+        this._listDelegate = null;
+        this._dndController = null;
+        this._listTopCellToolbar = null;
+        this._renderedEditors = ( new Map());
+        this._localStore = this._register(( new DisposableStore()));
+        this._localCellStateListeners = [];
+        this._contributions = ( new Map());
+        this._insetModifyQueueByOutputId = ( new SequencerByKey());
+        this._cellContextKeyManager = null;
+        this._uuid = generateUuid();
+        this._webviewFocused = false;
+        this._isVisible = false;
+        this._isDisposed = false;
+        this._baseCellEditorOptions = ( new Map());
+        this._debugFlag = false;
+        this._backgroundMarkdownRenderRunning = false;
+        this._lastCellWithEditorFocus = null;
+        this._pendingOutputHeightAcks = ( new Map());
+        this._dimension = dimension;
+        this.isReplHistory = creationOptions.isReplHistory ?? false;
+        this._readOnly = creationOptions.isReadOnly ?? false;
+        this._overlayLayout = this._register(( new OverlayLayoutElement()));
+        this._overlayContainer = this._overlayLayout.content;
+        this.scopedContextKeyService = this._register(contextKeyService.createScoped(this._overlayContainer));
+        this.instantiationService = this._register(instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.scopedContextKeyService]))));
+        this._notebookOptions = creationOptions.options ?? this.instantiationService.createInstance(
+            NotebookOptions,
+            this.creationOptions?.codeWindow ?? mainWindow,
+            this._readOnly,
+            undefined
+        );
+        this._register(this._notebookOptions);
+        const eventDispatcher = this._register(( new NotebookEventDispatcher()));
+        this._viewContext = ( new ViewContext(
+            this._notebookOptions,
+            eventDispatcher,
+            language => this.getBaseCellEditorOptions(language)
+        ));
+        this._register(this._viewContext.eventDispatcher.onDidChangeLayout(() => {
+            this._onDidChangeLayout.fire();
+        }));
+        this._register(this._viewContext.eventDispatcher.onDidChangeCellState(e => {
+            this._onDidChangeCellState.fire(e);
+        }));
+        this._register(_notebookService.onDidChangeOutputRenderers(() => {
+            this._updateOutputRenderers();
+        }));
+        this._register(this.instantiationService.createInstance(NotebookEditorContextKeys, this));
+        this._register(notebookKernelService.onDidChangeSelectedNotebooks(e => {
+            if (isEqual(e.notebook, this.viewModel?.uri)) {
+                this._loadKernelPreloads();
+                this._onDidChangeActiveKernel.fire();
+            }
+        }));
+        this._scrollBeyondLastLine = this.configurationService.getValue("editor.scrollBeyondLastLine");
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration("editor.scrollBeyondLastLine")) {
+                this._scrollBeyondLastLine = this.configurationService.getValue("editor.scrollBeyondLastLine");
+                if (this._dimension && this._isVisible) {
+                    this.layout(this._dimension);
+                }
+            }
+        }));
+        this._register(this._notebookOptions.onDidChangeOptions(e => {
+            if (e.cellStatusBarVisibility || e.cellToolbarLocation || e.cellToolbarInteraction) {
+                this._updateForNotebookConfiguration();
+            }
+            if (e.fontFamily) {
+                this._generateFontInfo();
+            }
+            if (e.compactView || e.focusIndicator || e.insertToolbarPosition || e.cellToolbarLocation || e.dragAndDropEnabled || e.fontSize || e.markupFontSize || e.markdownLineHeight || e.fontFamily || e.insertToolbarAlignment || e.outputFontSize || e.outputLineHeight || e.outputFontFamily || e.outputWordWrap || e.outputScrolling || e.outputLinkifyFilePaths || e.minimalError) {
+                this._styleElement?.remove();
+                this._createLayoutStyles();
+                this._webview?.updateOptions({
+                    ...this.notebookOptions.computeWebviewOptions(),
+                    fontFamily: this._generateFontFamily()
+                });
+            }
+            if (this._dimension && this._isVisible) {
+                this.layout(this._dimension);
+            }
+        }));
+        const container = creationOptions.codeWindow ? this.layoutService.getContainer(creationOptions.codeWindow) : this.layoutService.mainContainer;
+        this.notebookEditorService.addNotebookEditor(this);
+        const id = generateUuid();
+        this._overlayContainer.id = `notebook-${id}`;
+        this._overlayContainer.className = "notebookOverlay";
+        this._overlayContainer.classList.add("notebook-editor");
+        this._overlayContainer.inert = true;
+        this._overlayContainer.style.visibility = "hidden";
+        container.appendChild(this._overlayLayout.root);
+        this._createBody(this._overlayContainer);
+        this._generateFontInfo();
+        this._isVisible = true;
+        this._editorFocus = NOTEBOOK_EDITOR_FOCUSED.bindTo(this.scopedContextKeyService);
+        this._outputFocus = NOTEBOOK_OUTPUT_FOCUSED.bindTo(this.scopedContextKeyService);
+        this._outputInputFocus = NOTEBOOK_OUTPUT_INPUT_FOCUSED.bindTo(this.scopedContextKeyService);
+        this._editorEditable = NOTEBOOK_EDITOR_EDITABLE.bindTo(this.scopedContextKeyService);
+        this._cursorNavMode = NOTEBOOK_CURSOR_NAVIGATION_MODE.bindTo(this.scopedContextKeyService);
+        new RawContextKey(PreventDefaultContextMenuItemsContextKeyName, false).bindTo(this.scopedContextKeyService).set(true);
+        this._editorEditable.set(!creationOptions.isReadOnly);
+        let contributions;
+        if (Array.isArray(this.creationOptions.contributions)) {
+            contributions = this.creationOptions.contributions;
+        } else {
+            contributions = NotebookEditorExtensionsRegistry.getEditorContributions();
+        }
+        for (const desc of contributions) {
+            let contribution;
+            try {
+                contribution = this.instantiationService.createInstance(desc.ctor, this);
+            } catch (err) {
+                onUnexpectedError(err);
+            }
+            if (contribution) {
+                if (!( this._contributions.has(desc.id))) {
+                    this._contributions.set(desc.id, contribution);
+                } else {
+                    contribution.dispose();
+                    throw ( new Error(`DUPLICATE notebook editor contribution: '${desc.id}'`));
+                }
+            }
+        }
+        this._updateForNotebookConfiguration();
+    }
+    _debug(...args) {
+        if (!this._debugFlag) {
+            return;
+        }
+        notebookDebug(...args);
+    }
+    getId() {
+        return this._uuid;
+    }
+    getViewModel() {
+        return this.viewModel;
+    }
+    getLength() {
+        return this.viewModel?.length ?? 0;
+    }
+    getSelections() {
+        return this.viewModel?.getSelections() ?? [{
+            start: 0,
+            end: 0
+        }];
+    }
+    setSelections(selections) {
+        if (!this.viewModel) {
+            return;
+        }
+        const focus = this.viewModel.getFocus();
+        this.viewModel.updateSelectionsState({
+            kind: SelectionStateType.Index,
+            focus: focus,
+            selections: selections
+        });
+    }
+    getFocus() {
+        return this.viewModel?.getFocus() ?? {
+            start: 0,
+            end: 0
+        };
+    }
+    setFocus(focus) {
+        if (!this.viewModel) {
+            return;
+        }
+        const selections = this.viewModel.getSelections();
+        this.viewModel.updateSelectionsState({
+            kind: SelectionStateType.Index,
+            focus: focus,
+            selections: selections
+        });
+    }
+    getSelectionViewModels() {
+        if (!this.viewModel) {
+            return [];
+        }
+        const cellsSet = ( new Set());
+        return this.viewModel.getSelections().map(range => this.viewModel.viewCells.slice(range.start, range.end)).reduce((a, b) => {
+            b.forEach(cell => {
+                if (!( cellsSet.has(cell.handle))) {
+                    cellsSet.add(cell.handle);
+                    a.push(cell);
+                }
+            });
+            return a;
+        }, []);
+    }
+    hasModel() {
+        return !!this._notebookViewModel;
+    }
+    showProgress() {
+        this._currentProgress = this.editorProgressService.show(true);
+    }
+    hideProgress() {
+        if (this._currentProgress) {
+            this._currentProgress.done();
+            this._currentProgress = undefined;
+        }
+    }
+    getBaseCellEditorOptions(language) {
+        const existingOptions = this._baseCellEditorOptions.get(language);
+        if (existingOptions) {
+            return existingOptions;
+        } else {
+            const options = ( new BaseCellEditorOptions(this, this.notebookOptions, this.configurationService, language));
+            this._baseCellEditorOptions.set(language, options);
+            return options;
+        }
+    }
+    _updateForNotebookConfiguration() {
+        if (!this._overlayContainer) {
+            return;
+        }
+        this._overlayContainer.classList.remove("cell-title-toolbar-left");
+        this._overlayContainer.classList.remove("cell-title-toolbar-right");
+        this._overlayContainer.classList.remove("cell-title-toolbar-hidden");
+        const cellToolbarLocation = this._notebookOptions.computeCellToolbarLocation(this.viewModel?.viewType);
+        this._overlayContainer.classList.add(`cell-title-toolbar-${cellToolbarLocation}`);
+        const cellToolbarInteraction = this._notebookOptions.getDisplayOptions().cellToolbarInteraction;
+        let cellToolbarInteractionState = "hover";
+        this._overlayContainer.classList.remove("cell-toolbar-hover");
+        this._overlayContainer.classList.remove("cell-toolbar-click");
+        if (cellToolbarInteraction === "hover" || cellToolbarInteraction === "click") {
+            cellToolbarInteractionState = cellToolbarInteraction;
+        }
+        this._overlayContainer.classList.add(`cell-toolbar-${cellToolbarInteractionState}`);
+    }
+    _generateFontInfo() {
+        const editorOptions = this.configurationService.getValue("editor");
+        const targetWindow = getWindow(this.getDomNode());
+        this._fontInfo = FontMeasurements.readFontInfo(
+            targetWindow,
+            createBareFontInfoFromRawSettings(editorOptions, PixelRatio.getInstance(targetWindow).value)
+        );
+    }
+    _createBody(parent) {
+        this._notebookTopToolbarContainer = createElement("div");
+        this._notebookTopToolbarContainer.classList.add("notebook-toolbar-container");
+        this._notebookTopToolbarContainer.style.display = "none";
+        append(parent, this._notebookTopToolbarContainer);
+        this._notebookStickyScrollContainer = createElement("div");
+        this._notebookStickyScrollContainer.classList.add("notebook-sticky-scroll-container");
+        append(parent, this._notebookStickyScrollContainer);
+        this._body = createElement("div");
+        append(parent, this._body);
+        this._body.classList.add("cell-list-container");
+        this._createLayoutStyles();
+        this._createCellList();
+        this._notebookOverviewRulerContainer = createElement("div");
+        this._notebookOverviewRulerContainer.classList.add("notebook-overview-ruler-container");
+        this._list.scrollableElement.appendChild(this._notebookOverviewRulerContainer);
+        this._registerNotebookOverviewRuler();
+        this._register(
+            this.instantiationService.createInstance(NotebookHorizontalTracker, this, this._list.scrollableElement)
+        );
+        this._overflowContainer = createElement("div");
+        this._overflowContainer.classList.add("notebook-overflow-widget-container", "monaco-editor");
+        append(parent, this._overflowContainer);
+    }
+    _generateFontFamily() {
+        return this._fontInfo?.fontFamily ?? `"SF Mono", Monaco, Menlo, Consolas, "Ubuntu Mono", "Liberation Mono", "DejaVu Sans Mono", "Courier New", monospace`;
+    }
+    _createLayoutStyles() {
+        this._styleElement = createStyleSheet(this._body);
+        const {
+            cellRightMargin,
+            cellTopMargin,
+            cellRunGutter,
+            cellBottomMargin,
+            codeCellLeftMargin,
+            markdownCellGutter,
+            markdownCellLeftMargin,
+            markdownCellBottomMargin,
+            markdownCellTopMargin,
+            collapsedIndicatorHeight,
+            focusIndicator,
+            insertToolbarPosition,
+            outputFontSize,
+            focusIndicatorLeftMargin,
+            focusIndicatorGap
+        } = this._notebookOptions.getLayoutConfiguration();
+        const {
+            insertToolbarAlignment,
+            compactView,
+            fontSize
+        } = this._notebookOptions.getDisplayOptions();
+        const getCellEditorContainerLeftMargin = this._notebookOptions.getCellEditorContainerLeftMargin();
+        const {
+            bottomToolbarGap,
+            bottomToolbarHeight
+        } = this._notebookOptions.computeBottomToolbarDimensions(this.viewModel?.viewType);
+        const styleSheets = [];
+        if (!this._fontInfo) {
+            this._generateFontInfo();
+        }
+        const fontFamily = this._generateFontFamily();
+        styleSheets.push(`
+        .notebook-editor {
+            --notebook-cell-output-font-size: ${outputFontSize}px;
+            --notebook-cell-input-preview-font-size: ${fontSize}px;
+            --notebook-cell-input-preview-font-family: ${fontFamily};
+        }
+        `);
+        if (compactView) {
+            styleSheets.push(
+                `.notebookOverlay .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .markdown-cell-row div.cell.code { margin-left: ${getCellEditorContainerLeftMargin}px; }`
+            );
+        } else {
+            styleSheets.push(
+                `.notebookOverlay .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .markdown-cell-row div.cell.code { margin-left: ${codeCellLeftMargin}px; }`
+            );
+        }
+        if (focusIndicator === "border") {
+            styleSheets.push(`
+            .monaco-workbench .notebookOverlay .monaco-list .monaco-list-row .cell-focus-indicator-top:before,
+            .monaco-workbench .notebookOverlay .monaco-list .monaco-list-row .cell-focus-indicator-bottom:before,
+            .monaco-workbench .notebookOverlay .monaco-list .markdown-cell-row .cell-inner-container:before,
+            .monaco-workbench .notebookOverlay .monaco-list .markdown-cell-row .cell-inner-container:after {
+                content: "";
+                position: absolute;
+                width: 100%;
+                height: 1px;
+            }
+
+            .monaco-workbench .notebookOverlay .monaco-list .monaco-list-row .cell-focus-indicator-left:before,
+            .monaco-workbench .notebookOverlay .monaco-list .monaco-list-row .cell-focus-indicator-right:before {
+                content: "";
+                position: absolute;
+                width: 1px;
+                height: 100%;
+                z-index: 10;
+            }
+
+            /* top border */
+            .monaco-workbench .notebookOverlay .monaco-list .monaco-list-row .cell-focus-indicator-top:before {
+                border-top: 1px solid transparent;
+            }
+
+            /* left border */
+            .monaco-workbench .notebookOverlay .monaco-list .monaco-list-row .cell-focus-indicator-left:before {
+                border-left: 1px solid transparent;
+            }
+
+            /* bottom border */
+            .monaco-workbench .notebookOverlay .monaco-list .monaco-list-row .cell-focus-indicator-bottom:before {
+                border-bottom: 1px solid transparent;
+            }
+
+            /* right border */
+            .monaco-workbench .notebookOverlay .monaco-list .monaco-list-row .cell-focus-indicator-right:before {
+                border-right: 1px solid transparent;
+            }
+            `);
+            styleSheets.push(`
+            .monaco-workbench .notebookOverlay .monaco-list .monaco-list-row.code-cell-row.focused .cell-focus-indicator-left:before,
+            .monaco-workbench .notebookOverlay .monaco-list .monaco-list-row.code-cell-row.focused .cell-focus-indicator-right:before,
+            .monaco-workbench .notebookOverlay .monaco-list.selection-multiple .monaco-list-row.code-cell-row.selected .cell-focus-indicator-left:before,
+            .monaco-workbench .notebookOverlay .monaco-list.selection-multiple .monaco-list-row.code-cell-row.selected .cell-focus-indicator-right:before {
+                top: -${cellTopMargin}px; height: calc(100% + ${cellTopMargin + cellBottomMargin}px)
+            }`);
+        } else {
+            styleSheets.push(`
+            .monaco-workbench .notebookOverlay .monaco-list .monaco-list-row .cell-focus-indicator-left .codeOutput-focus-indicator {
+                border-left: 3px solid transparent;
+                border-radius: 4px;
+                width: 0px;
+                margin-left: ${focusIndicatorLeftMargin}px;
+                border-color: var(--vscode-notebook-inactiveFocusedCellBorder) !important;
+            }
+
+            .monaco-workbench .notebookOverlay .monaco-list .monaco-list-row.focused .cell-focus-indicator-left .codeOutput-focus-indicator-container,
+            .monaco-workbench .notebookOverlay .monaco-list .monaco-list-row .cell-output-hover .cell-focus-indicator-left .codeOutput-focus-indicator-container,
+            .monaco-workbench .notebookOverlay .monaco-list .monaco-list-row .markdown-cell-hover .cell-focus-indicator-left .codeOutput-focus-indicator-container,
+            .monaco-workbench .notebookOverlay .monaco-list .monaco-list-row:hover .cell-focus-indicator-left .codeOutput-focus-indicator-container {
+                display: block;
+            }
+
+            .monaco-workbench .notebookOverlay .monaco-list .monaco-list-row .cell-focus-indicator-left .codeOutput-focus-indicator-container:hover .codeOutput-focus-indicator {
+                border-left: 5px solid transparent;
+                margin-left: ${focusIndicatorLeftMargin - 1}px;
+            }
+            `);
+            styleSheets.push(`
+            .monaco-workbench .notebookOverlay .monaco-list .monaco-list-row.focused .cell-inner-container.cell-output-focus .cell-focus-indicator-left .codeOutput-focus-indicator,
+            .monaco-workbench .notebookOverlay .monaco-list:focus-within .monaco-list-row.focused .cell-inner-container .cell-focus-indicator-left .codeOutput-focus-indicator {
+                border-color: var(--vscode-notebook-focusedCellBorder) !important;
+            }
+
+            .monaco-workbench .notebookOverlay .monaco-list .monaco-list-row .cell-inner-container .cell-focus-indicator-left .output-focus-indicator {
+                margin-top: ${focusIndicatorGap}px;
+            }
+            `);
+        }
+        if (insertToolbarPosition === "betweenCells" || insertToolbarPosition === "both") {
+            styleSheets.push(
+                `.monaco-workbench .notebookOverlay > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .monaco-list-row .cell-bottom-toolbar-container { display: flex; }`
+            );
+            styleSheets.push(
+                `.monaco-workbench .notebookOverlay > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .view-zones .cell-list-top-cell-toolbar-container { display: flex; }`
+            );
+        } else {
+            styleSheets.push(
+                `.monaco-workbench .notebookOverlay > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .monaco-list-row .cell-bottom-toolbar-container { display: none; }`
+            );
+            styleSheets.push(
+                `.monaco-workbench .notebookOverlay > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .view-zones .cell-list-top-cell-toolbar-container { display: none; }`
+            );
+        }
+        if (insertToolbarAlignment === "left") {
+            styleSheets.push(`
+            .monaco-workbench .notebookOverlay .cell-list-top-cell-toolbar-container .action-item:first-child,
+            .monaco-workbench .notebookOverlay .cell-list-top-cell-toolbar-container .action-item:first-child, .monaco-workbench .notebookOverlay > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .monaco-list-row .cell-bottom-toolbar-container .action-item:first-child {
+                margin-right: 0px !important;
+            }`);
+            styleSheets.push(`
+            .monaco-workbench .notebookOverlay .cell-list-top-cell-toolbar-container .monaco-toolbar .action-label,
+            .monaco-workbench .notebookOverlay .cell-list-top-cell-toolbar-container .monaco-toolbar .action-label, .monaco-workbench .notebookOverlay > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .monaco-list-row .cell-bottom-toolbar-container .monaco-toolbar .action-label {
+                padding: 0px !important;
+                justify-content: center;
+                border-radius: 4px;
+            }`);
+            styleSheets.push(`
+            .monaco-workbench .notebookOverlay .cell-list-top-cell-toolbar-container,
+            .monaco-workbench .notebookOverlay .cell-list-top-cell-toolbar-container, .monaco-workbench .notebookOverlay > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .monaco-list-row .cell-bottom-toolbar-container {
+                align-items: flex-start;
+                justify-content: left;
+                margin: 0 16px 0 ${8 + codeCellLeftMargin}px;
+            }`);
+            styleSheets.push(`
+            .monaco-workbench .notebookOverlay .cell-list-top-cell-toolbar-container,
+            .notebookOverlay .cell-bottom-toolbar-container .action-item {
+                border: 0px;
+            }`);
+        }
+        styleSheets.push(
+            `.notebookOverlay .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .code-cell-row div.cell.code { margin-left: ${getCellEditorContainerLeftMargin}px; }`
+        );
+        styleSheets.push(
+            `.notebookOverlay .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .view-zones .code-cell-row div.cell.code { margin-left: ${getCellEditorContainerLeftMargin}px; }`
+        );
+        styleSheets.push(
+            `.notebookOverlay .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .view-zones .code-cell-row div.cell { margin-right: ${cellRightMargin}px; }`
+        );
+        styleSheets.push(
+            `.notebookOverlay .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .monaco-list-row div.cell { margin-right: ${cellRightMargin}px; }`
+        );
+        styleSheets.push(
+            `.notebookOverlay .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .monaco-list-row > .cell-inner-container { padding-top: ${cellTopMargin}px; }`
+        );
+        styleSheets.push(
+            `.notebookOverlay .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .markdown-cell-row > .cell-inner-container { padding-bottom: ${markdownCellBottomMargin}px; padding-top: ${markdownCellTopMargin}px; }`
+        );
+        styleSheets.push(
+            `.notebookOverlay .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .markdown-cell-row > .cell-inner-container.webview-backed-markdown-cell { padding: 0; }`
+        );
+        styleSheets.push(
+            `.notebookOverlay .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .markdown-cell-row > .webview-backed-markdown-cell.markdown-cell-edit-mode .cell.code { padding-bottom: ${markdownCellBottomMargin}px; padding-top: ${markdownCellTopMargin}px; }`
+        );
+        styleSheets.push(
+            `.notebookOverlay .output { margin: 0px ${cellRightMargin}px 0px ${getCellEditorContainerLeftMargin}px; }`
+        );
+        styleSheets.push(
+            `.notebookOverlay .output { width: calc(100% - ${getCellEditorContainerLeftMargin + cellRightMargin}px); }`
+        );
+        styleSheets.push(
+            `.notebookOverlay .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .monaco-list-row .cell-comment-container { left: ${getCellEditorContainerLeftMargin}px; }`
+        );
+        styleSheets.push(
+            `.notebookOverlay .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .monaco-list-row .cell-comment-container { width: calc(100% - ${getCellEditorContainerLeftMargin + cellRightMargin}px); }`
+        );
+        styleSheets.push(
+            `.monaco-workbench .notebookOverlay .output .output-collapse-container .expandButton { left: -${cellRunGutter}px; }`
+        );
+        styleSheets.push(
+            `.monaco-workbench .notebookOverlay .output .output-collapse-container .expandButton {
+            position: absolute;
+            width: ${cellRunGutter}px;
+            padding: 6px 0px;
+        }`
+        );
+        styleSheets.push(
+            `.notebookOverlay .output-show-more-container { margin: 0px ${cellRightMargin}px 0px ${getCellEditorContainerLeftMargin}px; }`
+        );
+        styleSheets.push(
+            `.notebookOverlay .output-show-more-container { width: calc(100% - ${getCellEditorContainerLeftMargin + cellRightMargin}px); }`
+        );
+        styleSheets.push(
+            `.notebookOverlay .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .monaco-list-row div.cell.markdown { padding-left: ${cellRunGutter}px; }`
+        );
+        styleSheets.push(
+            `.monaco-workbench .notebookOverlay > .cell-list-container .notebook-folding-indicator { left: ${(markdownCellGutter - 20) / 2 + markdownCellLeftMargin}px; }`
+        );
+        styleSheets.push(
+            `.notebookOverlay > .cell-list-container .notebook-folded-hint { left: ${markdownCellGutter + markdownCellLeftMargin + 8}px; }`
+        );
+        styleSheets.push(
+            `.notebookOverlay .monaco-list .monaco-list-row :not(.webview-backed-markdown-cell) .cell-focus-indicator-top { height: ${cellTopMargin}px; }`
+        );
+        styleSheets.push(
+            `.notebookOverlay .monaco-list .monaco-list-row .cell-focus-indicator-side { bottom: ${bottomToolbarGap}px; }`
+        );
+        styleSheets.push(
+            `.notebookOverlay .monaco-list .monaco-list-row.code-cell-row .cell-focus-indicator-left { width: ${getCellEditorContainerLeftMargin}px; }`
+        );
+        styleSheets.push(
+            `.notebookOverlay .monaco-list .monaco-list-row.markdown-cell-row .cell-focus-indicator-left { width: ${codeCellLeftMargin}px; }`
+        );
+        styleSheets.push(
+            `.notebookOverlay .monaco-list .monaco-list-row .cell-focus-indicator.cell-focus-indicator-right { width: ${cellRightMargin}px; }`
+        );
+        styleSheets.push(
+            `.notebookOverlay .monaco-list .monaco-list-row .cell-focus-indicator-bottom { height: ${cellBottomMargin}px; }`
+        );
+        styleSheets.push(
+            `.notebookOverlay .monaco-list .monaco-list-row .cell-shadow-container-bottom { top: ${cellBottomMargin}px; }`
+        );
+        styleSheets.push(`
+            .notebookOverlay .monaco-list.selection-multiple .monaco-list-row:has(+ .monaco-list-row.selected) .cell-focus-indicator-bottom {
+                height: ${bottomToolbarGap + cellBottomMargin}px;
+            }
+        `);
+        styleSheets.push(`
+            .notebookOverlay .monaco-list .monaco-list-row.code-cell-row.nb-multiCellHighlight:has(+ .monaco-list-row.nb-multiCellHighlight) .cell-focus-indicator-bottom {
+                height: ${bottomToolbarGap + cellBottomMargin}px;
+                background-color: var(--vscode-notebook-symbolHighlightBackground) !important;
+            }
+
+            .notebookOverlay .monaco-list .monaco-list-row.markdown-cell-row.nb-multiCellHighlight:has(+ .monaco-list-row.nb-multiCellHighlight) .cell-focus-indicator-bottom {
+                height: ${bottomToolbarGap + cellBottomMargin - 6}px;
+                background-color: var(--vscode-notebook-symbolHighlightBackground) !important;
+            }
+        `);
+        styleSheets.push(`
+            .monaco-workbench .notebookOverlay > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .monaco-list-row .input-collapse-container .cell-collapse-preview {
+                line-height: ${collapsedIndicatorHeight}px;
+            }
+
+            .monaco-workbench .notebookOverlay > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .monaco-list-row .input-collapse-container .cell-collapse-preview .monaco-tokenized-source {
+                max-height: ${collapsedIndicatorHeight}px;
+            }
+        `);
+        styleSheets.push(
+            `.monaco-workbench .notebookOverlay > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .monaco-list-row .cell-bottom-toolbar-container .monaco-toolbar { height: ${bottomToolbarHeight}px }`
+        );
+        styleSheets.push(
+            `.monaco-workbench .notebookOverlay > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .view-zones .cell-list-top-cell-toolbar-container .monaco-toolbar { height: ${bottomToolbarHeight}px }`
+        );
+        styleSheets.push(
+            `.monaco-workbench .notebookOverlay.cell-title-toolbar-right > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .monaco-list-row .cell-title-toolbar {
+            right: ${cellRightMargin + 26}px;
+        }
+        .monaco-workbench .notebookOverlay.cell-title-toolbar-left > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .monaco-list-row .cell-title-toolbar {
+            left: ${getCellEditorContainerLeftMargin + 16}px;
+        }
+        .monaco-workbench .notebookOverlay.cell-title-toolbar-hidden > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .monaco-list-row .cell-title-toolbar {
+            display: none;
+        }`
+        );
+        styleSheets.push(`
+        .monaco-workbench .notebookOverlay .output > div.foreground.output-inner-container {
+            padding: ${OutputInnerContainerTopPadding}px 8px;
+        }
+        .monaco-workbench .notebookOverlay > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .monaco-list-row .output-collapse-container {
+            padding: ${OutputInnerContainerTopPadding}px 8px;
+        }
+        `);
+        styleSheets.push(`
+        .monaco-workbench .notebookOverlay .cell-chat-part {
+            margin: 0 ${cellRightMargin}px 6px 4px;
+        }
+        `);
+        this._styleElement.textContent = styleSheets.join("\n");
+    }
+    _createCellList() {
+        this._body.classList.add("cell-list-container");
+        this._dndController = this._register(( new CellDragAndDropController(this, this._body)));
+        const getScopedContextKeyService = container => this._list.contextKeyService.createScoped(container);
+        this._editorPool = this._register(
+            this.instantiationService.createInstance(NotebookCellEditorPool, this, getScopedContextKeyService)
+        );
+        const renderers = [this.instantiationService.createInstance(
+            CodeCellRenderer,
+            this,
+            this._renderedEditors,
+            this._editorPool,
+            this._dndController,
+            getScopedContextKeyService
+        ), this.instantiationService.createInstance(
+            MarkupCellRenderer,
+            this,
+            this._dndController,
+            this._renderedEditors,
+            getScopedContextKeyService
+        )];
+        renderers.forEach(renderer => {
+            this._register(renderer);
+        });
+        this._listDelegate = this.instantiationService.createInstance(NotebookCellListDelegate, getWindow(this.getDomNode()));
+        this._register(this._listDelegate);
+        const accessibilityProvider = this.instantiationService.createInstance(NotebookAccessibilityProvider, () => this.viewModel, this.isReplHistory);
+        this._register(accessibilityProvider);
+        this._list = this.instantiationService.createInstance(
+            NotebookCellList,
+            "NotebookCellList",
+            this._body,
+            this._viewContext.notebookOptions,
+            this._listDelegate,
+            renderers,
+            this.scopedContextKeyService,
+            {
+                setRowLineHeight: false,
+                setRowHeight: false,
+                supportDynamicHeights: true,
+                horizontalScrolling: false,
+                keyboardSupport: false,
+                mouseSupport: true,
+                multipleSelectionSupport: true,
+                selectionNavigation: true,
+                typeNavigationEnabled: true,
+                paddingTop: 0,
+                paddingBottom: 0,
+                transformOptimization: false,
+                initialSize: this._dimension,
+                styleController: _suffix => {
+                    return this._list;
+                },
+                overrideStyles: {
+                    listBackground: notebookEditorBackground,
+                    listActiveSelectionBackground: notebookEditorBackground,
+                    listActiveSelectionForeground: foreground,
+                    listFocusAndSelectionBackground: notebookEditorBackground,
+                    listFocusAndSelectionForeground: foreground,
+                    listFocusBackground: notebookEditorBackground,
+                    listFocusForeground: foreground,
+                    listHoverForeground: foreground,
+                    listHoverBackground: notebookEditorBackground,
+                    listHoverOutline: focusBorder,
+                    listFocusOutline: focusBorder,
+                    listInactiveSelectionBackground: notebookEditorBackground,
+                    listInactiveSelectionForeground: foreground,
+                    listInactiveFocusBackground: notebookEditorBackground,
+                    listInactiveFocusOutline: notebookEditorBackground
+                },
+                accessibilityProvider
+            }
+        );
+        this._cellLayoutManager = ( new NotebookCellLayoutManager(this, this._list, this.logService));
+        this._dndController.setList(this._list);
+        this._register(this._list);
+        this._listViewInfoAccessor = ( new ListViewInfoAccessor(this._list));
+        this._register(this._listViewInfoAccessor);
+        this._register(combinedDisposable(...renderers));
+        this._listTopCellToolbar = this._register(
+            this.instantiationService.createInstance(ListTopCellToolbar, this, this.notebookOptions)
+        );
+        this._webviewTransparentCover = append(this._list.rowsContainer, $(".webview-cover"));
+        this._webviewTransparentCover.style.display = "none";
+        this._register(
+            addStandardDisposableGenericMouseDownListener(this._overlayContainer, e => {
+                if (e.target.classList.contains("slider") && this._webviewTransparentCover) {
+                    this._webviewTransparentCover.style.display = "block";
+                }
+            })
+        );
+        this._register(
+            addStandardDisposableGenericMouseUpListener(this._overlayContainer, () => {
+                if (this._webviewTransparentCover) {
+                    this._webviewTransparentCover.style.display = "none";
+                }
+            })
+        );
+        this._register(this._list.onMouseDown(e => {
+            if (e.element) {
+                this._onMouseDown.fire({
+                    event: e.browserEvent,
+                    target: e.element
+                });
+            }
+        }));
+        this._register(this._list.onMouseUp(e => {
+            if (e.element) {
+                this._onMouseUp.fire({
+                    event: e.browserEvent,
+                    target: e.element
+                });
+            }
+        }));
+        this._register(this._list.onDidChangeFocus(_e => {
+            this._onDidChangeActiveEditor.fire(this);
+            this._onDidChangeActiveCell.fire();
+            this._onDidChangeFocus.fire();
+            this._cursorNavMode.set(false);
+        }));
+        this._register(this._list.onContextMenu(e => {
+            this.showListContextMenu(e);
+        }));
+        this._register(this._list.onDidChangeVisibleRanges(() => {
+            this._onDidChangeVisibleRanges.fire();
+        }));
+        this._register(this._list.onDidScroll(e => {
+            if (e.scrollTop !== e.oldScrollTop) {
+                this._onDidScroll.fire();
+                this.clearActiveCellWidgets();
+            }
+            if (e.scrollTop === e.oldScrollTop && e.scrollHeightChanged) {
+                this._onDidChangeLayout.fire();
+            }
+        }));
+        this._focusTracker = this._register(trackFocus(this.getDomNode()));
+        this._register(this._focusTracker.onDidBlur(() => {
+            this._editorFocus.set(false);
+            this.viewModel?.setEditorFocus(false);
+            this._onDidBlurEmitter.fire();
+        }));
+        this._register(this._focusTracker.onDidFocus(() => {
+            this._editorFocus.set(true);
+            this.viewModel?.setEditorFocus(true);
+            this._onDidFocusEmitter.fire();
+        }));
+        this._registerNotebookActionsToolbar();
+        this._registerNotebookStickyScroll();
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(accessibilityProvider.verbositySettingId)) {
+                this._list.ariaLabel = accessibilityProvider?.getWidgetAriaLabel();
+            }
+        }));
+    }
+    showListContextMenu(e) {
+        this.contextMenuService.showContextMenu({
+            menuId: MenuId.NotebookCellTitle,
+            menuActionOptions: {
+                shouldForwardArgs: true
+            },
+            contextKeyService: this.scopedContextKeyService,
+            getAnchor: () => e.anchor,
+            getActionsContext: () => {
+                return {
+                    from: "cellContainer"
+                };
+            }
+        });
+    }
+    _registerNotebookOverviewRuler() {
+        this._notebookOverviewRuler = this._register(
+            this.instantiationService.createInstance(NotebookOverviewRuler, this, this._notebookOverviewRulerContainer)
+        );
+    }
+    _registerNotebookActionsToolbar() {
+        this._notebookTopToolbar = this._register(this.instantiationService.createInstance(
+            NotebookEditorWorkbenchToolbar,
+            this,
+            this.scopedContextKeyService,
+            this._notebookOptions,
+            this._notebookTopToolbarContainer
+        ));
+        this._register(this._notebookTopToolbar.onDidChangeVisibility(() => {
+            if (this._dimension && this._isVisible) {
+                this.layout(this._dimension);
+            }
+        }));
+    }
+    _registerNotebookStickyScroll() {
+        this._notebookStickyScroll = this._register(this.instantiationService.createInstance(
+            NotebookStickyScroll,
+            this._notebookStickyScrollContainer,
+            this,
+            this._list,
+            sizeDelta => {
+                if (this.isDisposed) {
+                    return;
+                }
+                if (this._dimension && this._isVisible) {
+                    if (sizeDelta > 0) {
+                        this.layout(this._dimension);
+                        this.setScrollTop(this.scrollTop + sizeDelta);
+                    } else if (sizeDelta < 0) {
+                        this.setScrollTop(this.scrollTop + sizeDelta);
+                        this.layout(this._dimension);
+                    }
+                }
+                this._onDidScroll.fire();
+            }
+        ));
+    }
+    _updateOutputRenderers() {
+        if (!this.viewModel || !this._webview) {
+            return;
+        }
+        this._webview.updateOutputRenderers();
+        this.viewModel.viewCells.forEach(cell => {
+            cell.outputsViewModels.forEach(output => {
+                if (output.pickedMimeType?.rendererId === RENDERER_NOT_AVAILABLE) {
+                    output.resetRenderer();
+                }
+            });
+        });
+    }
+    getDomNode() {
+        return this._overlayContainer;
+    }
+    getOverflowContainerDomNode() {
+        return this._overflowContainer;
+    }
+    getInnerWebview() {
+        return this._webview?.webview;
+    }
+    setEditorProgressService(editorProgressService) {
+        this.editorProgressService = editorProgressService;
+    }
+    setParentContextKeyService(parentContextKeyService) {
+        this.scopedContextKeyService.updateParent(parentContextKeyService);
+    }
+    async setModel(textModel, viewState, perf, viewType) {
+        if (this.viewModel === undefined || !this.viewModel.equal(textModel)) {
+            const oldBottomToolbarDimensions = this._notebookOptions.computeBottomToolbarDimensions(this.viewModel?.viewType);
+            this._detachModel();
+            await this._attachModel(textModel, viewType ?? textModel.viewType, viewState, perf);
+            const newBottomToolbarDimensions = this._notebookOptions.computeBottomToolbarDimensions(this.viewModel?.viewType);
+            if (oldBottomToolbarDimensions.bottomToolbarGap !== newBottomToolbarDimensions.bottomToolbarGap || oldBottomToolbarDimensions.bottomToolbarHeight !== newBottomToolbarDimensions.bottomToolbarHeight) {
+                this._styleElement?.remove();
+                this._createLayoutStyles();
+                this._webview?.updateOptions({
+                    ...this.notebookOptions.computeWebviewOptions(),
+                    fontFamily: this._generateFontFamily()
+                });
+            }
+            this.telemetryService.publicLog2("notebook/editorOpened", {
+                scheme: textModel.uri.scheme,
+                ext: extname(textModel.uri),
+                viewType: textModel.viewType,
+                isRepl: this.isReplHistory
+            });
+        } else {
+            this.restoreListViewState(viewState);
+        }
+        this._restoreSelectedKernel(viewState);
+        this._loadKernelPreloads();
+        this._dndController?.clearGlobalDragState();
+        this._localStore.add(this._list.onDidChangeFocus(() => {
+            this.updateContextKeysOnFocusChange();
+        }));
+        this.updateContextKeysOnFocusChange();
+        this._backgroundMarkdownRendering();
+    }
+    _backgroundMarkdownRendering() {
+        if (this._backgroundMarkdownRenderRunning) {
+            return;
+        }
+        this._backgroundMarkdownRenderRunning = true;
+        runWhenWindowIdle(getWindow(this.getDomNode()), deadline => {
+            this._backgroundMarkdownRenderingWithDeadline(deadline);
+        });
+    }
+    _backgroundMarkdownRenderingWithDeadline(deadline) {
+        const endTime = Date.now() + deadline.timeRemaining();
+        const execute = () => {
+            try {
+                this._backgroundMarkdownRenderRunning = true;
+                if (this._isDisposed) {
+                    return;
+                }
+                if (!this.viewModel) {
+                    return;
+                }
+                const firstMarkupCell = this.viewModel.viewCells.find(
+                    cell => cell.cellKind === CellKind.Markup && !this._webview?.markupPreviewMapping.has(cell.id) && !this.cellIsHidden(cell)
+                );
+                if (!firstMarkupCell) {
+                    return;
+                }
+                this.createMarkupPreview(firstMarkupCell);
+            } finally {
+                this._backgroundMarkdownRenderRunning = false;
+            }
+            if (Date.now() < endTime) {
+                setTimeout0(execute);
+            } else {
+                this._backgroundMarkdownRendering();
+            }
+        };
+        execute();
+    }
+    updateContextKeysOnFocusChange() {
+        if (!this.viewModel) {
+            return;
+        }
+        const focused = this._list.getFocusedElements()[0];
+        if (focused) {
+            if (!this._cellContextKeyManager) {
+                this._cellContextKeyManager = this._localStore.add(
+                    this.instantiationService.createInstance(CellContextKeyManager, this, focused)
+                );
+            }
+            this._cellContextKeyManager.updateForElement(focused);
+        }
+    }
+    async setOptions(options) {
+        if (options?.isReadOnly !== undefined) {
+            this._readOnly = options?.isReadOnly;
+        }
+        if (!this.viewModel) {
+            return;
+        }
+        this.viewModel.updateOptions({
+            isReadOnly: this._readOnly
+        });
+        this.notebookOptions.updateOptions(this._readOnly);
+        const cellOptions = options?.cellOptions ?? this._parseIndexedCellOptions(options);
+        if (cellOptions) {
+            const cell = this.viewModel.viewCells.find(cell => ( cell.uri.toString()) === ( cellOptions.resource.toString()));
+            if (cell) {
+                this.focusElement(cell);
+                const selection = cellOptions.options?.selection;
+                if (selection) {
+                    cell.updateEditState(CellEditState.Editing, "setOptions");
+                    cell.focusMode = CellFocusMode.Editor;
+                    await this.revealRangeInCenterIfOutsideViewportAsync(cell, ( new Range(
+                        selection.startLineNumber,
+                        selection.startColumn,
+                        selection.endLineNumber || selection.startLineNumber,
+                        selection.endColumn || selection.startColumn
+                    )));
+                } else {
+                    this._list.revealCell(cell, options?.cellRevealType ?? CellRevealType.CenterIfOutsideViewport);
+                }
+                const editor = this._renderedEditors.get(cell);
+                if (editor) {
+                    if (cellOptions.options?.selection) {
+                        const {
+                            selection
+                        } = cellOptions.options;
+                        const editorSelection = ( new Range(
+                            selection.startLineNumber,
+                            selection.startColumn,
+                            selection.endLineNumber || selection.startLineNumber,
+                            selection.endColumn || selection.startColumn
+                        ));
+                        editor.setSelection(editorSelection);
+                        editor.revealPositionInCenterIfOutsideViewport({
+                            lineNumber: selection.startLineNumber,
+                            column: selection.startColumn
+                        });
+                        await this.revealRangeInCenterIfOutsideViewportAsync(cell, editorSelection);
+                    }
+                    if (!cellOptions.options?.preserveFocus) {
+                        editor.focus();
+                    }
+                }
+            }
+        }
+        if (options?.cellSelections) {
+            const focusCellIndex = options.cellSelections[0].start;
+            const focusedCell = this.viewModel.cellAt(focusCellIndex);
+            if (focusedCell) {
+                this.viewModel.updateSelectionsState({
+                    kind: SelectionStateType.Index,
+                    focus: {
+                        start: focusCellIndex,
+                        end: focusCellIndex + 1
+                    },
+                    selections: options.cellSelections
+                });
+                this.revealInCenterIfOutsideViewport(focusedCell);
+            }
+        }
+        this._updateForOptions();
+        this._onDidChangeOptions.fire();
+    }
+    _parseIndexedCellOptions(options) {
+        if (options?.indexedCellOptions) {
+            const cell = this.cellAt(options.indexedCellOptions.index);
+            if (cell) {
+                return {
+                    resource: cell.uri,
+                    options: {
+                        selection: options.indexedCellOptions.selection,
+                        preserveFocus: false
+                    }
+                };
+            }
+        }
+        return undefined;
+    }
+    _detachModel() {
+        this._localStore.clear();
+        dispose(this._localCellStateListeners);
+        this._list.detachViewModel();
+        this.viewModel?.dispose();
+        this.viewModel = undefined;
+        this._webview?.dispose();
+        this._webview?.element.remove();
+        this._webview = null;
+        this._list.clear();
+    }
+    _updateForOptions() {
+        if (!this.viewModel) {
+            return;
+        }
+        this._editorEditable.set(!this.viewModel.options.isReadOnly);
+        this._overflowContainer.classList.toggle("notebook-editor-editable", !this.viewModel.options.isReadOnly);
+        this.getDomNode().classList.toggle("notebook-editor-editable", !this.viewModel.options.isReadOnly);
+    }
+    async _resolveWebview() {
+        if (!this.textModel) {
+            return null;
+        }
+        if (this._webviewResolvePromise) {
+            return this._webviewResolvePromise;
+        }
+        if (!this._webview) {
+            this._ensureWebview(this.getId(), this.textModel.viewType, this.textModel.uri);
+        }
+        this._webviewResolvePromise = (async () => {
+            if (!this._webview) {
+                throw ( new Error("Notebook output webview object is not created successfully."));
+            }
+            await this._webview.createWebview(this.creationOptions.codeWindow ?? mainWindow);
+            if (!this._webview.webview) {
+                throw ( new Error("Notebook output webview element was not created successfully."));
+            }
+            this._localStore.add(this._webview.webview.onDidBlur(() => {
+                this._outputFocus.set(false);
+                this._webviewFocused = false;
+                this.updateEditorFocus();
+                this.updateCellFocusMode();
+            }));
+            this._localStore.add(this._webview.webview.onDidFocus(() => {
+                this._outputFocus.set(true);
+                this.updateEditorFocus();
+                this._webviewFocused = true;
+            }));
+            this._localStore.add(this._webview.onMessage(e => {
+                this._onDidReceiveMessage.fire(e);
+            }));
+            return this._webview;
+        })();
+        return this._webviewResolvePromise;
+    }
+    _ensureWebview(id, viewType, resource) {
+        if (this._webview) {
+            return;
+        }
+        const that = this;
+        this._webview = this.instantiationService.createInstance(BackLayerWebView, {
+            get creationOptions() {
+                return that.creationOptions;
+            },
+            setScrollTop(scrollTop) {
+                that._list.scrollTop = scrollTop;
+            },
+            triggerScroll(event) {
+                that._list.triggerScrollFromMouseWheelEvent(event);
+            },
+            getCellByInfo: that.getCellByInfo.bind(that),
+            getCellById: that._getCellById.bind(that),
+            toggleNotebookCellSelection: that._toggleNotebookCellSelection.bind(that),
+            focusNotebookCell: that.focusNotebookCell.bind(that),
+            focusNextNotebookCell: that.focusNextNotebookCell.bind(that),
+            updateOutputHeight: that._updateOutputHeight.bind(that),
+            scheduleOutputHeightAck: that._scheduleOutputHeightAck.bind(that),
+            updateMarkupCellHeight: that._updateMarkupCellHeight.bind(that),
+            setMarkupCellEditState: that._setMarkupCellEditState.bind(that),
+            didStartDragMarkupCell: that._didStartDragMarkupCell.bind(that),
+            didDragMarkupCell: that._didDragMarkupCell.bind(that),
+            didDropMarkupCell: that._didDropMarkupCell.bind(that),
+            didEndDragMarkupCell: that._didEndDragMarkupCell.bind(that),
+            didResizeOutput: that._didResizeOutput.bind(that),
+            updatePerformanceMetadata: that._updatePerformanceMetadata.bind(that),
+            didFocusOutputInputChange: that._didFocusOutputInputChange.bind(that)
+        }, id, viewType, resource, {
+            ...this._notebookOptions.computeWebviewOptions(),
+            fontFamily: this._generateFontFamily()
+        }, this.notebookRendererMessaging.getScoped(this._uuid));
+        this._webview.element.style.width = "100%";
+        this._list.attachWebview(this._webview.element);
+    }
+    async _attachModel(textModel, viewType, viewState, perf) {
+        this._ensureWebview(this.getId(), textModel.viewType, textModel.uri);
+        this.viewModel = this.instantiationService.createInstance(
+            NotebookViewModel,
+            viewType,
+            textModel,
+            this._viewContext,
+            this.getLayoutInfo(),
+            {
+                isReadOnly: this._readOnly
+            }
+        );
+        this._viewContext.eventDispatcher.emit([( new NotebookLayoutChangedEvent({
+            width: true,
+            fontInfo: true
+        }, this.getLayoutInfo()))]);
+        this.notebookOptions.updateOptions(this._readOnly);
+        this._updateForOptions();
+        this._updateForNotebookConfiguration();
+        {
+            this.viewModel.restoreEditorViewState(viewState);
+            const contributionsState = viewState?.contributionsState || {};
+            for (const [id, contribution] of this._contributions) {
+                if (typeof contribution.restoreViewState === "function") {
+                    contribution.restoreViewState(contributionsState[id]);
+                }
+            }
+        }
+        this._localStore.add(this.viewModel.onDidChangeViewCells(e => {
+            this._onDidChangeViewCells.fire(e);
+        }));
+        this._localStore.add(this.viewModel.onDidChangeSelection(() => {
+            this._onDidChangeSelection.fire();
+            this.updateSelectedMarkdownPreviews();
+        }));
+        this._localStore.add(this._list.onWillScroll(e => {
+            if (this._webview?.isResolved()) {
+                this._webviewTransparentCover.style.transform = `translateY(${e.scrollTop})`;
+            }
+        }));
+        let hasPendingChangeContentHeight = false;
+        const renderScrollHeightDisposable = this._localStore.add(( new MutableDisposable()));
+        this._localStore.add(this._list.onDidChangeContentHeight(() => {
+            if (hasPendingChangeContentHeight) {
+                return;
+            }
+            hasPendingChangeContentHeight = true;
+            renderScrollHeightDisposable.value = scheduleAtNextAnimationFrame(getWindow(this.getDomNode()), () => {
+                hasPendingChangeContentHeight = false;
+                this._updateScrollHeight();
+            }, 100);
+        }));
+        this._localStore.add(this._list.onDidRemoveOutputs(outputs => {
+            outputs.forEach(output => this.removeInset(output));
+        }));
+        this._localStore.add(this._list.onDidHideOutputs(outputs => {
+            outputs.forEach(output => this.hideInset(output));
+        }));
+        this._localStore.add(this._list.onDidRemoveCellsFromView(cells => {
+            const hiddenCells = [];
+            const deletedCells = [];
+            for (const cell of cells) {
+                if (cell.cellKind === CellKind.Markup) {
+                    const mdCell = cell;
+                    if (this.viewModel?.viewCells.find(cell => cell.handle === mdCell.handle)) {
+                        hiddenCells.push(mdCell);
+                    } else {
+                        deletedCells.push(mdCell);
+                    }
+                }
+            }
+            this.hideMarkupPreviews(hiddenCells);
+            this.deleteMarkupPreviews(deletedCells);
+        }));
+        await this._warmupWithMarkdownRenderer(this.viewModel, viewState, perf);
+        perf?.mark("customMarkdownLoaded");
+        this._localCellStateListeners = this.viewModel.viewCells.map(cell => this._bindCellListener(cell));
+        this._lastCellWithEditorFocus = this.viewModel.viewCells.find(
+            viewCell => this.getActiveCell() === viewCell && viewCell.focusMode === CellFocusMode.Editor
+        ) ?? null;
+        this._localStore.add(this.viewModel.onDidChangeViewCells(e => {
+            if (this._isDisposed) {
+                return;
+            }
+            [...e.splices].reverse().forEach(splice => {
+                const [start, deleted, newCells] = splice;
+                const deletedCells = this._localCellStateListeners.splice(start, deleted, ...newCells.map(cell => this._bindCellListener(cell)));
+                dispose(deletedCells);
+            });
+            if (( e.splices.some(s => ( s[2].some(cell => cell.cellKind === CellKind.Markup))))) {
+                this._backgroundMarkdownRendering();
+            }
+        }));
+        if (this._dimension) {
+            this._list.layout(this.getBodyHeight(this._dimension.height), this._dimension.width);
+        } else {
+            this._list.layout();
+        }
+        this._dndController?.clearGlobalDragState();
+        this.restoreListViewState(viewState);
+    }
+    _bindCellListener(cell) {
+        const store = ( new DisposableStore());
+        store.add(cell.onDidChangeLayout(e => {
+            if (e.totalHeight || e.outerWidth) {
+                this.layoutNotebookCell(cell, cell.layoutInfo.totalHeight, e.context);
+            }
+        }));
+        if (cell.cellKind === CellKind.Code) {
+            store.add(cell.onDidRemoveOutputs(outputs => {
+                outputs.forEach(output => this.removeInset(output));
+            }));
+        }
+        store.add(cell.onDidChangeState(e => {
+            if (e.inputCollapsedChanged && cell.isInputCollapsed && cell.cellKind === CellKind.Markup) {
+                this.hideMarkupPreviews([cell]);
+            }
+            if (e.outputCollapsedChanged && cell.isOutputCollapsed && cell.cellKind === CellKind.Code) {
+                cell.outputsViewModels.forEach(output => this.hideInset(output));
+            }
+            if (e.focusModeChanged) {
+                this._validateCellFocusMode(cell);
+            }
+        }));
+        store.add(cell.onCellDecorationsChanged(e => {
+            e.added.forEach(options => {
+                if (options.className) {
+                    this.deltaCellContainerClassNames(cell.id, [options.className], [], cell.cellKind);
+                }
+                if (options.outputClassName) {
+                    this.deltaCellContainerClassNames(cell.id, [options.outputClassName], [], cell.cellKind);
+                }
+            });
+            e.removed.forEach(options => {
+                if (options.className) {
+                    this.deltaCellContainerClassNames(cell.id, [], [options.className], cell.cellKind);
+                }
+                if (options.outputClassName) {
+                    this.deltaCellContainerClassNames(cell.id, [], [options.outputClassName], cell.cellKind);
+                }
+            });
+        }));
+        return store;
+    }
+    _validateCellFocusMode(cell) {
+        if (cell.focusMode !== CellFocusMode.Editor) {
+            return;
+        }
+        if (this._lastCellWithEditorFocus && this._lastCellWithEditorFocus !== cell) {
+            this._lastCellWithEditorFocus.focusMode = CellFocusMode.Container;
+        }
+        this._lastCellWithEditorFocus = cell;
+    }
+    async _warmupWithMarkdownRenderer(viewModel, viewState, perf) {
+        this.logService.debug("NotebookEditorWidget", "warmup " + this.viewModel?.uri.toString());
+        await this._resolveWebview();
+        perf?.mark("webviewCommLoaded");
+        this.logService.debug("NotebookEditorWidget", "warmup - webview resolved");
+        this._webview.element.style.visibility = "hidden";
+        await this._warmupViewportMarkdownCells(viewModel, viewState);
+        this.logService.debug("NotebookEditorWidget", "warmup - viewport warmed up");
+        this._list.layout(0, 0);
+        this._list.attachViewModel(viewModel);
+        this._list.scrollTop = viewState?.scrollPosition?.top ?? 0;
+        this._debug("finish initial viewport warmup and view state restore.");
+        this._webview.element.style.visibility = "visible";
+        this.logService.debug(
+            "NotebookEditorWidget",
+            "warmup - list view model attached, set to visible"
+        );
+        this._onDidAttachViewModel.fire();
+    }
+    async _warmupViewportMarkdownCells(viewModel, viewState) {
+        if (viewState && viewState.cellTotalHeights) {
+            const totalHeightCache = viewState.cellTotalHeights;
+            const scrollTop = viewState.scrollPosition?.top ?? 0;
+            const scrollBottom = scrollTop + Math.max(this._dimension?.height ?? 0, 1080);
+            let offset = 0;
+            const requests = [];
+            for (let i = 0; i < viewModel.length; i++) {
+                const cell = viewModel.cellAt(i);
+                const cellHeight = totalHeightCache[i] ?? 0;
+                if (offset + cellHeight < scrollTop) {
+                    offset += cellHeight;
+                    continue;
+                }
+                if (cell.cellKind === CellKind.Markup) {
+                    requests.push([cell, offset]);
+                }
+                offset += cellHeight;
+                if (offset > scrollBottom) {
+                    break;
+                }
+            }
+            await this._webview.initializeMarkup(
+                requests.map(([model, offset]) => this.createMarkupCellInitialization(model, offset))
+            );
+        } else {
+            const initRequests = viewModel.viewCells.filter(cell => cell.cellKind === CellKind.Markup).slice(0, 5).map(cell => this.createMarkupCellInitialization(cell, -1e4));
+            await this._webview.initializeMarkup(initRequests);
+            let offset = 0;
+            const offsetUpdateRequests = [];
+            const scrollBottom = Math.max(this._dimension?.height ?? 0, 1080);
+            for (const cell of viewModel.viewCells) {
+                if (cell.cellKind === CellKind.Markup) {
+                    offsetUpdateRequests.push({
+                        id: cell.id,
+                        top: offset
+                    });
+                }
+                offset += cell.getHeight(this.getLayoutInfo().fontInfo.lineHeight);
+                if (offset > scrollBottom) {
+                    break;
+                }
+            }
+            this._webview?.updateScrollTops([], offsetUpdateRequests);
+        }
+    }
+    createMarkupCellInitialization(model, offset) {
+        return ({
+            mime: model.mime,
+            cellId: model.id,
+            cellHandle: model.handle,
+            content: model.getText(),
+            offset: offset,
+            visible: false,
+            metadata: model.metadata
+        });
+    }
+    restoreListViewState(viewState) {
+        if (!this.viewModel) {
+            return;
+        }
+        if (viewState?.scrollPosition !== undefined) {
+            this._list.scrollTop = viewState.scrollPosition.top;
+            this._list.scrollLeft = viewState.scrollPosition.left;
+        } else {
+            this._list.scrollTop = 0;
+            this._list.scrollLeft = 0;
+        }
+        const focusIdx = typeof viewState?.focus === "number" ? viewState.focus : 0;
+        if (focusIdx < this.viewModel.length) {
+            const element = this.viewModel.cellAt(focusIdx);
+            if (element) {
+                this.viewModel?.updateSelectionsState({
+                    kind: SelectionStateType.Handle,
+                    primary: element.handle,
+                    selections: [element.handle]
+                });
+            }
+        } else if (this._list.length > 0) {
+            this.viewModel.updateSelectionsState({
+                kind: SelectionStateType.Index,
+                focus: {
+                    start: 0,
+                    end: 1
+                },
+                selections: [{
+                    start: 0,
+                    end: 1
+                }]
+            });
+        }
+        if (viewState?.editorFocused) {
+            const cell = this.viewModel.cellAt(focusIdx);
+            if (cell) {
+                cell.focusMode = CellFocusMode.Editor;
+            }
+        }
+    }
+    _restoreSelectedKernel(viewState) {
+        if (viewState?.selectedKernelId && this.textModel) {
+            const matching = this.notebookKernelService.getMatchingKernel(this.textModel);
+            const kernel = matching.all.find(k => k.id === viewState.selectedKernelId);
+            if (kernel && !matching.selected) {
+                this.notebookKernelService.selectKernelForNotebook(kernel, this.textModel);
+            }
+        }
+    }
+    getEditorViewState() {
+        const state = this.viewModel?.getEditorViewState();
+        if (!state) {
+            return {
+                editingCells: {},
+                cellLineNumberStates: {},
+                editorViewStates: {},
+                collapsedInputCells: {},
+                collapsedOutputCells: {}
+            };
+        }
+        if (this._list) {
+            state.scrollPosition = {
+                left: this._list.scrollLeft,
+                top: this._list.scrollTop
+            };
+            const cellHeights = {};
+            for (let i = 0; i < this.viewModel.length; i++) {
+                const elm = this.viewModel.cellAt(i);
+                cellHeights[i] = elm.layoutInfo.totalHeight;
+            }
+            state.cellTotalHeights = cellHeights;
+            if (this.viewModel) {
+                const focusRange = this.viewModel.getFocus();
+                const element = this.viewModel.cellAt(focusRange.start);
+                if (element) {
+                    const itemDOM = this._list.domElementOfElement(element);
+                    const editorFocused = element.getEditState() === CellEditState.Editing && !!(itemDOM && getActiveElement(itemDOM.ownerDocument) && itemDOM.contains(getActiveElement(itemDOM.ownerDocument)));
+                    state.editorFocused = editorFocused;
+                    state.focus = focusRange.start;
+                }
+            }
+        }
+        const contributionsState = {};
+        for (const [id, contribution] of this._contributions) {
+            if (typeof contribution.saveViewState === "function") {
+                contributionsState[id] = contribution.saveViewState();
+            }
+        }
+        state.contributionsState = contributionsState;
+        if (this.textModel?.uri.scheme === Schemas.untitled) {
+            state.selectedKernelId = this.activeKernel?.id;
+        }
+        return state;
+    }
+    _allowScrollBeyondLastLine() {
+        return this._scrollBeyondLastLine && !this.isReplHistory;
+    }
+    getBodyHeight(dimensionHeight) {
+        return Math.max(
+            dimensionHeight - (this._notebookTopToolbar?.useGlobalToolbar ?  26 : 0),
+            0
+        );
+    }
+    layout(dimension, shadowElement, position) {
+        if (!shadowElement && !this._shadowElement) {
+            this._dimension = dimension;
+            return;
+        }
+        if (dimension.width <= 0 || dimension.height <= 0) {
+            this.onWillHide();
+            return;
+        }
+        const whenContainerStylesLoaded = this.layoutService.whenContainerStylesLoaded(getWindow(this.getDomNode()));
+        if (whenContainerStylesLoaded) {
+            whenContainerStylesLoaded.then(() => this.layoutNotebook(dimension, shadowElement));
+        } else {
+            this.layoutNotebook(dimension, shadowElement);
+        }
+    }
+    layoutNotebook(dimension, shadowElement) {
+        if (shadowElement) {
+            this._shadowElement = shadowElement;
+        }
+        this._dimension = dimension;
+        const newBodyHeight = this.getBodyHeight(dimension.height) - this.getLayoutInfo().stickyHeight;
+        size(this._body, dimension.width, newBodyHeight);
+        const newCellListHeight = newBodyHeight;
+        if (this._list.getRenderHeight() < newCellListHeight) {
+            this._list.updateOptions({
+                paddingBottom: this._allowScrollBeyondLastLine() ? Math.max(0, (newCellListHeight - 50)) : 0,
+                paddingTop: 0
+            });
+            this._list.layout(newCellListHeight, dimension.width);
+        } else {
+            this._list.layout(newCellListHeight, dimension.width);
+            this._list.updateOptions({
+                paddingBottom: this._allowScrollBeyondLastLine() ? Math.max(0, (newCellListHeight - 50)) : 0,
+                paddingTop: 0
+            });
+        }
+        this._overlayContainer.inert = false;
+        this.layoutContainerOverShadowElement(shadowElement ?? this._shadowElement);
+        if (this._webviewTransparentCover) {
+            this._webviewTransparentCover.style.height = `${dimension.height}px`;
+            this._webviewTransparentCover.style.width = `${dimension.width}px`;
+        }
+        this._notebookTopToolbar.layout(this._dimension);
+        this._notebookOverviewRuler.layout();
+        this._viewContext?.eventDispatcher.emit([( new NotebookLayoutChangedEvent({
+            width: true,
+            fontInfo: true
+        }, this.getLayoutInfo()))]);
+    }
+    layoutContainerOverShadowElement(anchorElement) {
+        if (!anchorElement) {
+            return;
+        }
+        const modalEditorContainer = this.editorGroupsService.activeModalEditorPart?.modalElement;
+        const isModal = isHTMLElement(modalEditorContainer) && modalEditorContainer.contains(anchorElement);
+        const clippingContainer = isModal ? undefined : this.layoutService.getContainer(getWindow(this.getDomNode()), Parts.EDITOR_PART);
+        this._overlayContainer.style.visibility = "visible";
+        this._overlayLayout.setAnchorElement(anchorElement, {
+            clippingContainer
+        });
+        this._overlayLayout.reapplyLayoutStyles();
+    }
+    focus() {
+        this._isVisible = true;
+        this._editorFocus.set(true);
+        if (this._webviewFocused) {
+            this._webview?.focusWebview();
+        } else {
+            if (this.viewModel) {
+                const focusRange = this.viewModel.getFocus();
+                const element = this.viewModel.cellAt(focusRange.start);
+                if (!this.hasEditorFocus()) {
+                    this.focusContainer();
+                    this.updateEditorFocus();
+                }
+                if (element && element.focusMode === CellFocusMode.Editor) {
+                    element.updateEditState(CellEditState.Editing, "editorWidget.focus");
+                    element.focusMode = CellFocusMode.Editor;
+                    this.focusEditor(element);
+                    return;
+                }
+            }
+            this._list.domFocus();
+        }
+        if (this._currentProgress) {
+            this.showProgress();
+        }
+    }
+    onShow() {
+        this._isVisible = true;
+    }
+    focusEditor(activeElement) {
+        for (const [element, editor] of this._renderedEditors.entries()) {
+            if (element === activeElement) {
+                editor.focus();
+                return;
+            }
+        }
+    }
+    focusContainer(clearSelection = false) {
+        if (this._webviewFocused) {
+            this._webview?.focusWebview();
+        } else {
+            this._list.focusContainer(clearSelection);
+        }
+    }
+    selectOutputContent(cell) {
+        this._webview?.selectOutputContents(cell);
+    }
+    selectInputContents(cell) {
+        this._webview?.selectInputContents(cell);
+    }
+    onWillHide() {
+        this._isVisible = false;
+        this._editorFocus.set(false);
+        this._overlayContainer.inert = true;
+        this._overlayContainer.style.visibility = "hidden";
+        this._overlayContainer.style.left = "-50000px";
+        this._notebookTopToolbarContainer.style.display = "none";
+        this.clearActiveCellWidgets();
+    }
+    clearActiveCellWidgets() {
+        this._renderedEditors.forEach((editor, cell) => {
+            if (this.getActiveCell() === cell && editor) {
+                SuggestController.get(editor)?.cancelSuggestWidget();
+                DropIntoEditorController.get(editor)?.clearWidgets();
+                CopyPasteController.get(editor)?.clearWidgets();
+            }
+        });
+        this._renderedEditors.forEach((editor, cell) => {
+            const controller = InlineCompletionsController.get(editor);
+            if (controller?.model.get()?.inlineEditState.get()) {
+                editor.render(true);
+            }
+        });
+    }
+    editorHasDomFocus() {
+        return isAncestorOfActiveElement(this.getDomNode());
+    }
+    updateEditorFocus() {
+        this._focusTracker.refreshState();
+        const focused = this.editorHasDomFocus();
+        this._editorFocus.set(focused);
+        this.viewModel?.setEditorFocus(focused);
+    }
+    updateCellFocusMode() {
+        const activeCell = this.getActiveCell();
+        if (activeCell?.focusMode === CellFocusMode.Output && !this._webviewFocused) {
+            activeCell.focusMode = CellFocusMode.Container;
+        }
+    }
+    hasEditorFocus() {
+        this.updateEditorFocus();
+        return this.editorHasDomFocus();
+    }
+    hasWebviewFocus() {
+        return this._webviewFocused;
+    }
+    hasOutputTextSelection() {
+        if (!this.hasEditorFocus()) {
+            return false;
+        }
+        const windowSelection = getWindow(this.getDomNode()).getSelection();
+        if (windowSelection?.rangeCount !== 1) {
+            return false;
+        }
+        const activeSelection = windowSelection.getRangeAt(0);
+        if (activeSelection.startContainer === activeSelection.endContainer && activeSelection.endOffset - activeSelection.startOffset === 0) {
+            return false;
+        }
+        let container = activeSelection.commonAncestorContainer;
+        if (!this._body.contains(container)) {
+            return false;
+        }
+        while (container && container !== this._body) {
+            if (container.classList && container.classList.contains("output")) {
+                return true;
+            }
+            container = container.parentNode;
+        }
+        return false;
+    }
+    _didFocusOutputInputChange(hasFocus) {
+        this._outputInputFocus.set(hasFocus);
+    }
+    focusElement(cell) {
+        this.viewModel?.updateSelectionsState({
+            kind: SelectionStateType.Handle,
+            primary: cell.handle,
+            selections: [cell.handle]
+        });
+    }
+    get scrollTop() {
+        return this._list.scrollTop;
+    }
+    get scrollBottom() {
+        return this._list.scrollTop + this._list.getRenderHeight();
+    }
+    getAbsoluteTopOfElement(cell) {
+        return this._list.getCellViewScrollTop(cell);
+    }
+    getAbsoluteBottomOfElement(cell) {
+        return this._list.getCellViewScrollBottom(cell);
+    }
+    getHeightOfElement(cell) {
+        return this._list.elementHeight(cell);
+    }
+    scrollToBottom() {
+        this._list.scrollToBottom();
+    }
+    setScrollTop(scrollTop) {
+        this._list.scrollTop = scrollTop;
+    }
+    revealCellRangeInView(range) {
+        return this._list.revealCells(range);
+    }
+    revealInView(cell) {
+        return this._list.revealCell(cell, CellRevealType.Default);
+    }
+    revealInViewAtTop(cell) {
+        this._list.revealCell(cell, CellRevealType.Top);
+    }
+    revealInCenter(cell) {
+        this._list.revealCell(cell, CellRevealType.Center);
+    }
+    async revealInCenterIfOutsideViewport(cell) {
+        await this._list.revealCell(cell, CellRevealType.CenterIfOutsideViewport);
+    }
+    async revealFirstLineIfOutsideViewport(cell) {
+        await this._list.revealCell(cell, CellRevealType.FirstLineIfOutsideViewport);
+    }
+    async revealLineInViewAsync(cell, line) {
+        return this._list.revealRangeInCell(cell, ( new Range(line, 1, line, 1)), CellRevealRangeType.Default);
+    }
+    async revealLineInCenterAsync(cell, line) {
+        return this._list.revealRangeInCell(cell, ( new Range(line, 1, line, 1)), CellRevealRangeType.Center);
+    }
+    async revealLineInCenterIfOutsideViewportAsync(cell, line) {
+        return this._list.revealRangeInCell(cell, ( new Range(line, 1, line, 1)), CellRevealRangeType.CenterIfOutsideViewport);
+    }
+    async revealRangeInViewAsync(cell, range) {
+        return this._list.revealRangeInCell(cell, range, CellRevealRangeType.Default);
+    }
+    async revealRangeInCenterAsync(cell, range) {
+        return this._list.revealRangeInCell(cell, range, CellRevealRangeType.Center);
+    }
+    async revealRangeInCenterIfOutsideViewportAsync(cell, range) {
+        return this._list.revealRangeInCell(cell, range, CellRevealRangeType.CenterIfOutsideViewport);
+    }
+    revealCellOffsetInCenter(cell, offset) {
+        return this._list.revealCellOffsetInCenter(cell, offset);
+    }
+    revealOffsetInCenterIfOutsideViewport(offset) {
+        return this._list.revealOffsetInCenterIfOutsideViewport(offset);
+    }
+    getViewIndexByModelIndex(index) {
+        if (!this._listViewInfoAccessor) {
+            return -1;
+        }
+        const cell = this.viewModel?.viewCells[index];
+        if (!cell) {
+            return -1;
+        }
+        return this._listViewInfoAccessor.getViewIndex(cell);
+    }
+    getViewHeight(cell) {
+        if (!this._listViewInfoAccessor) {
+            return -1;
+        }
+        return this._listViewInfoAccessor.getViewHeight(cell);
+    }
+    getCellRangeFromViewRange(startIndex, endIndex) {
+        return this._listViewInfoAccessor.getCellRangeFromViewRange(startIndex, endIndex);
+    }
+    getCellsInRange(range) {
+        return this._listViewInfoAccessor.getCellsInRange(range);
+    }
+    setCellEditorSelection(cell, range) {
+        this._list.setCellEditorSelection(cell, range);
+    }
+    setHiddenAreas(_ranges) {
+        return this._list.setHiddenAreas(_ranges, true);
+    }
+    getVisibleRangesPlusViewportAboveAndBelow() {
+        return this._listViewInfoAccessor.getVisibleRangesPlusViewportAboveAndBelow();
+    }
+    deltaCellDecorations(oldDecorations, newDecorations) {
+        const ret = this.viewModel?.deltaCellDecorations(oldDecorations, newDecorations) || [];
+        this._onDidChangeDecorations.fire();
+        return ret;
+    }
+    deltaCellContainerClassNames(cellId, added, removed, cellkind) {
+        if (cellkind === CellKind.Markup) {
+            this._webview?.deltaMarkupPreviewClassNames(cellId, added, removed);
+        } else {
+            this._webview?.deltaCellOutputContainerClassNames(cellId, added, removed);
+        }
+    }
+    changeModelDecorations(callback) {
+        return this.viewModel?.changeModelDecorations(callback) || null;
+    }
+    changeViewZones(callback) {
+        this._list.changeViewZones(callback);
+        this._onDidChangeLayout.fire();
+    }
+    getViewZoneLayoutInfo(id) {
+        return this._list.getViewZoneLayoutInfo(id);
+    }
+    changeCellOverlays(callback) {
+        this._list.changeCellOverlays(callback);
+    }
+    async _loadKernelPreloads() {
+        if (!this.hasModel()) {
+            return;
+        }
+        const {
+            selected
+        } = this.notebookKernelService.getMatchingKernel(this.textModel);
+        if (!this._webview?.isResolved()) {
+            await this._resolveWebview();
+        }
+        this._webview?.updateKernelPreloads(selected);
+    }
+    get activeKernel() {
+        return this.textModel && this.notebookKernelService.getSelectedOrSuggestedKernel(this.textModel);
+    }
+    async cancelNotebookCells(cells) {
+        if (!this.viewModel || !this.hasModel()) {
+            return;
+        }
+        if (!cells) {
+            cells = this.viewModel.viewCells;
+        }
+        return this.notebookExecutionService.cancelNotebookCellHandles(this.textModel, Array.from(cells).map(cell => cell.handle));
+    }
+    async executeNotebookCells(cells) {
+        if (!this.viewModel || !this.hasModel()) {
+            this.logService.info("notebookEditorWidget", "No NotebookViewModel, cannot execute cells");
+            return;
+        }
+        if (!cells) {
+            cells = this.viewModel.viewCells;
+        }
+        return this.notebookExecutionService.executeNotebookCells(
+            this.textModel,
+            Array.from(cells).map(c => c.model),
+            this.scopedContextKeyService
+        );
+    }
+    async layoutNotebookCell(cell, height, context) {
+        return this._cellLayoutManager?.layoutNotebookCell(cell, height);
+    }
+    getActiveCell() {
+        const elements = this._list.getFocusedElements();
+        if (elements && elements.length) {
+            return elements[0];
+        }
+        return undefined;
+    }
+    _toggleNotebookCellSelection(selectedCell, selectFromPrevious) {
+        const currentSelections = this._list.getSelectedElements();
+        const isSelected = currentSelections.includes(selectedCell);
+        const previousSelection = selectFromPrevious ? currentSelections[currentSelections.length - 1] ?? selectedCell : selectedCell;
+        const selectedIndex = this._list.getViewIndex(selectedCell);
+        const previousIndex = this._list.getViewIndex(previousSelection);
+        const cellsInSelectionRange = this.getCellsInViewRange(selectedIndex, previousIndex);
+        if (isSelected) {
+            this._list.selectElements(
+                currentSelections.filter(current => !cellsInSelectionRange.includes(current))
+            );
+        } else {
+            this.focusElement(selectedCell);
+            this._list.selectElements([
+                ...currentSelections.filter(current => !cellsInSelectionRange.includes(current)),
+                ...cellsInSelectionRange
+            ]);
+        }
+    }
+    getCellsInViewRange(fromInclusive, toInclusive) {
+        const selectedCellsInRange = [];
+        for (let index = 0; index < this._list.length; ++index) {
+            const cell = this._list.element(index);
+            if (cell) {
+                if ((index >= fromInclusive && index <= toInclusive) || (index >= toInclusive && index <= fromInclusive)) {
+                    selectedCellsInRange.push(cell);
+                }
+            }
+        }
+        return selectedCellsInRange;
+    }
+    async focusNotebookCell(cell, focusItem, options) {
+        if (this._isDisposed) {
+            return;
+        }
+        cell.focusedOutputId = undefined;
+        if (focusItem === "editor") {
+            cell.isInputCollapsed = false;
+            this.focusElement(cell);
+            this._list.focusView();
+            cell.updateEditState(CellEditState.Editing, "focusNotebookCell");
+            cell.focusMode = CellFocusMode.Editor;
+            if (!options?.skipReveal) {
+                if (typeof options?.focusEditorLine === "number") {
+                    this._cursorNavMode.set(true);
+                    await this.revealLineInViewAsync(cell, options.focusEditorLine);
+                    const editor = this._renderedEditors.get(cell);
+                    const focusEditorLine = options.focusEditorLine;
+                    editor?.setSelection({
+                        startLineNumber: focusEditorLine,
+                        startColumn: 1,
+                        endLineNumber: focusEditorLine,
+                        endColumn: 1
+                    });
+                } else {
+                    const selectionsStartPosition = cell.getSelectionsStartPosition();
+                    if (selectionsStartPosition?.length) {
+                        const firstSelectionPosition = selectionsStartPosition[0];
+                        await this.revealRangeInViewAsync(cell, Range.fromPositions(firstSelectionPosition, firstSelectionPosition));
+                    } else {
+                        await this.revealInView(cell);
+                    }
+                }
+            }
+        } else if (focusItem === "output") {
+            this.focusElement(cell);
+            if (!this.hasEditorFocus()) {
+                this._list.focusView();
+            }
+            if (!this._webview) {
+                return;
+            }
+            const firstOutputId = cell.outputsViewModels.find(o => o.model.alternativeOutputId)?.model.alternativeOutputId;
+            const focusElementId = options?.outputId ?? firstOutputId ?? cell.id;
+            this._webview.focusOutput(
+                focusElementId,
+                options?.altOutputId,
+                options?.outputWebviewFocused || this._webviewFocused
+            );
+            cell.updateEditState(CellEditState.Preview, "focusNotebookCell");
+            cell.focusMode = CellFocusMode.Output;
+            cell.focusedOutputId = options?.outputId;
+            this._outputFocus.set(true);
+            if (!options?.skipReveal) {
+                this.revealInCenterIfOutsideViewport(cell);
+            }
+        } else {
+            const itemDOM = this._list.domElementOfElement(cell);
+            if (itemDOM && getActiveElement(itemDOM.ownerDocument) && itemDOM.contains(getActiveElement(itemDOM.ownerDocument))) {
+                getActiveElement(itemDOM.ownerDocument).blur();
+            }
+            this._webview?.blurOutput();
+            cell.updateEditState(CellEditState.Preview, "focusNotebookCell");
+            cell.focusMode = CellFocusMode.Container;
+            this.focusElement(cell);
+            if (!options?.skipReveal) {
+                if (typeof options?.focusEditorLine === "number") {
+                    this._cursorNavMode.set(true);
+                    await this.revealInView(cell);
+                } else if (options?.revealBehavior === ScrollToRevealBehavior.firstLine) {
+                    await this.revealFirstLineIfOutsideViewport(cell);
+                } else if (options?.revealBehavior === ScrollToRevealBehavior.fullCell) {
+                    await this.revealInView(cell);
+                } else {
+                    await this.revealInCenterIfOutsideViewport(cell);
+                }
+            }
+            this._list.focusView();
+            this.updateEditorFocus();
+        }
+    }
+    async focusNextNotebookCell(cell, focusItem) {
+        const idx = this.viewModel?.getCellIndex(cell);
+        if (typeof idx !== "number") {
+            return;
+        }
+        const newCell = this.viewModel?.cellAt(idx + 1);
+        if (!newCell) {
+            return;
+        }
+        await this.focusNotebookCell(newCell, focusItem);
+    }
+    async _warmupCell(viewCell) {
+        if (viewCell.isOutputCollapsed) {
+            return;
+        }
+        const outputs = viewCell.outputsViewModels;
+        for (const output of outputs.slice(0, outputDisplayLimit)) {
+            const [mimeTypes, pick] = output.resolveMimeTypes(this.textModel, undefined);
+            if (!mimeTypes.find(mimeType => mimeType.isTrusted) || mimeTypes.length === 0) {
+                continue;
+            }
+            const pickedMimeTypeRenderer = mimeTypes[pick];
+            if (!pickedMimeTypeRenderer) {
+                return;
+            }
+            const renderer = this._notebookService.getRendererInfo(pickedMimeTypeRenderer.rendererId);
+            if (!renderer) {
+                return;
+            }
+            const result = {
+                type: RenderOutputType.Extension,
+                renderer,
+                source: output,
+                mimeType: pickedMimeTypeRenderer.mimeType
+            };
+            const inset = this._webview?.insetMapping.get(result.source);
+            if (!inset || !inset.initialized) {
+                const p = ( new Promise(resolve => {
+                    this._register(Event.any(this.onDidRenderOutput, this.onDidRemoveOutput)(e => {
+                        if (e.model === result.source.model) {
+                            resolve();
+                        }
+                    }));
+                }));
+                this.createOutput(viewCell, result, 0, false);
+                await p;
+            } else {
+                this.createOutput(viewCell, result, 0, false);
+            }
+            return;
+        }
+    }
+    async _warmupAll(includeOutput) {
+        if (!this.hasModel() || !this.viewModel) {
+            return;
+        }
+        const cells = this.viewModel.viewCells;
+        const requests = [];
+        for (let i = 0; i < cells.length; i++) {
+            if (cells[i].cellKind === CellKind.Markup && !( this._webview.markupPreviewMapping.has(cells[i].id))) {
+                requests.push(this.createMarkupPreview(cells[i]));
+            }
+        }
+        if (includeOutput && this._list) {
+            for (let i = 0; i < this._list.length; i++) {
+                const cell = this._list.element(i);
+                if (cell?.cellKind === CellKind.Code) {
+                    requests.push(this._warmupCell(cell));
+                }
+            }
+        }
+        return Promise.all(requests);
+    }
+    async _warmupSelection(includeOutput, selectedCellRanges) {
+        if (!this.hasModel() || !this.viewModel) {
+            return;
+        }
+        const cells = this.viewModel.viewCells;
+        const requests = [];
+        for (const range of selectedCellRanges) {
+            for (let i = range.start; i < range.end; i++) {
+                if (cells[i].cellKind === CellKind.Markup && !( this._webview.markupPreviewMapping.has(cells[i].id))) {
+                    requests.push(this.createMarkupPreview(cells[i]));
+                }
+            }
+        }
+        if (includeOutput && this._list) {
+            for (const range of selectedCellRanges) {
+                for (let i = range.start; i < range.end; i++) {
+                    const cell = this._list.element(i);
+                    if (cell?.cellKind === CellKind.Code) {
+                        requests.push(this._warmupCell(cell));
+                    }
+                }
+            }
+        }
+        return Promise.all(requests);
+    }
+    async find(
+        query,
+        options,
+        token,
+        skipWarmup = false,
+        shouldGetSearchPreviewInfo = false,
+        ownerID
+    ) {
+        if (!this._notebookViewModel) {
+            return [];
+        }
+        if (!ownerID) {
+            ownerID = this.getId();
+        }
+        const findMatches = this._notebookViewModel.find(query, options).filter(match => match.length > 0);
+        if ((!options.includeMarkupPreview && !options.includeOutput) || options.findScope?.findScopeType === NotebookFindScopeType.Text) {
+            this._webview?.findStop(ownerID);
+            return findMatches;
+        }
+        const matchMap = {};
+        findMatches.forEach(match => {
+            matchMap[match.cell.id] = match;
+        });
+        if (this._webview) {
+            const start = Date.now();
+            if (options.findScope && options.findScope.findScopeType === NotebookFindScopeType.Cells && options.findScope.selectedCellRanges) {
+                await this._warmupSelection(!!options.includeOutput, options.findScope.selectedCellRanges);
+            } else {
+                await this._warmupAll(!!options.includeOutput);
+            }
+            const end = Date.now();
+            this.logService.debug("Find", `Warmup time: ${end - start}ms`);
+            if (token.isCancellationRequested) {
+                return [];
+            }
+            let findIds = [];
+            if (options.findScope && options.findScope.findScopeType === NotebookFindScopeType.Cells && options.findScope.selectedCellRanges) {
+                const selectedIndexes = cellRangesToIndexes(options.findScope.selectedCellRanges);
+                findIds = selectedIndexes.map(index => this._notebookViewModel?.viewCells[index].id ?? "");
+            }
+            const webviewMatches = await this._webview.find(query, {
+                caseSensitive: options.caseSensitive,
+                wholeWord: options.wholeWord,
+                includeMarkup: !!options.includeMarkupPreview,
+                includeOutput: !!options.includeOutput,
+                shouldGetSearchPreviewInfo,
+                ownerID,
+                findIds: findIds
+            });
+            if (token.isCancellationRequested) {
+                return [];
+            }
+            webviewMatches.forEach(match => {
+                const cell = this._notebookViewModel.viewCells.find(cell => cell.id === match.cellId);
+                if (!cell) {
+                    return;
+                }
+                if (match.type === "preview") {
+                    if (cell.getEditState() === CellEditState.Preview && !options.includeMarkupPreview) {
+                        return;
+                    }
+                    if (cell.getEditState() === CellEditState.Editing && options.includeMarkupInput) {
+                        return;
+                    }
+                } else {
+                    if (!options.includeOutput) {
+                        return;
+                    }
+                }
+                const exisitingMatch = matchMap[match.cellId];
+                if (exisitingMatch) {
+                    exisitingMatch.webviewMatches.push(match);
+                } else {
+                    matchMap[match.cellId] = ( new CellFindMatchModel(
+                        this._notebookViewModel.viewCells.find(cell => cell.id === match.cellId),
+                        this._notebookViewModel.viewCells.findIndex(cell => cell.id === match.cellId),
+                        [],
+                        [match]
+                    ));
+                }
+            });
+        }
+        const ret = [];
+        this._notebookViewModel.viewCells.forEach((cell, index) => {
+            if (matchMap[cell.id]) {
+                ret.push(( new CellFindMatchModel(
+                    cell,
+                    index,
+                    matchMap[cell.id].contentMatches,
+                    matchMap[cell.id].webviewMatches
+                )));
+            }
+        });
+        return ret;
+    }
+    async findHighlightCurrent(matchIndex, ownerID) {
+        if (!this._webview) {
+            return 0;
+        }
+        return this._webview?.findHighlightCurrent(matchIndex, ownerID ?? this.getId());
+    }
+    async findUnHighlightCurrent(matchIndex, ownerID) {
+        if (!this._webview) {
+            return;
+        }
+        return this._webview?.findUnHighlightCurrent(matchIndex, ownerID ?? this.getId());
+    }
+    findStop(ownerID) {
+        this._webview?.findStop(ownerID ?? this.getId());
+    }
+    getLayoutInfo() {
+        if (!this._list) {
+            throw ( new Error("Editor is not initalized successfully"));
+        }
+        if (!this._fontInfo) {
+            this._generateFontInfo();
+        }
+        let listViewOffset = 0;
+        if (this._dimension) {
+            listViewOffset = (this._notebookTopToolbar?.useGlobalToolbar ?  26 : 0) + (this._notebookStickyScroll?.getCurrentStickyHeight() ?? 0);
+        }
+        return {
+            width: this._dimension?.width ?? 0,
+            height: this._dimension?.height ?? 0,
+            scrollHeight: this._list?.getScrollHeight() ?? 0,
+            fontInfo: this._fontInfo,
+            stickyHeight: this._notebookStickyScroll?.getCurrentStickyHeight() ?? 0,
+            listViewOffsetTop: listViewOffset
+        };
+    }
+    async createMarkupPreview(cell) {
+        if (!this._webview) {
+            return;
+        }
+        if (!this._webview.isResolved()) {
+            await this._resolveWebview();
+        }
+        if (!this._webview || !this._list.webviewElement) {
+            return;
+        }
+        if (!this.viewModel || !this._list.viewModel) {
+            return;
+        }
+        if (this.viewModel.getCellIndex(cell) === -1) {
+            return;
+        }
+        if (this.cellIsHidden(cell)) {
+            return;
+        }
+        const webviewTop = parseInt(this._list.webviewElement.domNode.style.top, 10);
+        const top = !!webviewTop ? (0 - webviewTop) : 0;
+        const cellTop = this._list.getCellViewScrollTop(cell);
+        await this._webview.showMarkupPreview({
+            mime: cell.mime,
+            cellHandle: cell.handle,
+            cellId: cell.id,
+            content: cell.getText(),
+            offset: cellTop + top,
+            visible: true,
+            metadata: cell.metadata
+        });
+    }
+    cellIsHidden(cell) {
+        const modelIndex = this.viewModel.getCellIndex(cell);
+        const foldedRanges = this.viewModel.getHiddenRanges();
+        return ( foldedRanges.some(range => modelIndex >= range.start && modelIndex <= range.end));
+    }
+    async unhideMarkupPreviews(cells) {
+        if (!this._webview) {
+            return;
+        }
+        if (!this._webview.isResolved()) {
+            await this._resolveWebview();
+        }
+        await this._webview?.unhideMarkupPreviews(cells.map(cell => cell.id));
+    }
+    async hideMarkupPreviews(cells) {
+        if (!this._webview || !cells.length) {
+            return;
+        }
+        if (!this._webview.isResolved()) {
+            await this._resolveWebview();
+        }
+        await this._webview?.hideMarkupPreviews(cells.map(cell => cell.id));
+    }
+    async deleteMarkupPreviews(cells) {
+        if (!this._webview) {
+            return;
+        }
+        if (!this._webview.isResolved()) {
+            await this._resolveWebview();
+        }
+        await this._webview?.deleteMarkupPreviews(cells.map(cell => cell.id));
+    }
+    async updateSelectedMarkdownPreviews() {
+        if (!this._webview) {
+            return;
+        }
+        if (!this._webview.isResolved()) {
+            await this._resolveWebview();
+        }
+        const selectedCells = this.getSelectionViewModels().map(cell => cell.id);
+        await this._webview?.updateMarkupPreviewSelections(selectedCells.length > 1 ? selectedCells : []);
+    }
+    async createOutput(cell, output, offset, createWhenIdle) {
+        this._insetModifyQueueByOutputId.queue(output.source.model.outputId, async () => {
+            if (this._isDisposed || !this._webview) {
+                return;
+            }
+            if (!this._webview.isResolved()) {
+                await this._resolveWebview();
+            }
+            if (!this._webview) {
+                return;
+            }
+            if (!this._list.webviewElement) {
+                return;
+            }
+            if (output.type === RenderOutputType.Extension) {
+                this.notebookRendererMessaging.prepare(output.renderer.id);
+            }
+            const webviewTop = parseInt(this._list.webviewElement.domNode.style.top, 10);
+            const top = !!webviewTop ? (0 - webviewTop) : 0;
+            const cellTop = this._list.getCellViewScrollTop(cell) + top;
+            const existingOutput = this._webview.insetMapping.get(output.source);
+            if (!existingOutput || (!existingOutput.renderer && output.type === RenderOutputType.Extension)) {
+                if (createWhenIdle) {
+                    this._webview.requestCreateOutputWhenWebviewIdle({
+                        cellId: cell.id,
+                        cellHandle: cell.handle,
+                        cellUri: cell.uri,
+                        executionId: cell.internalMetadata.executionId
+                    }, output, cellTop, offset);
+                } else {
+                    this._webview.createOutput({
+                        cellId: cell.id,
+                        cellHandle: cell.handle,
+                        cellUri: cell.uri,
+                        executionId: cell.internalMetadata.executionId
+                    }, output, cellTop, offset);
+                }
+            } else if (existingOutput.renderer && output.type === RenderOutputType.Extension && existingOutput.renderer.id !== output.renderer.id) {
+                this._webview.removeInsets([output.source]);
+                this._webview.createOutput({
+                    cellId: cell.id,
+                    cellHandle: cell.handle,
+                    cellUri: cell.uri
+                }, output, cellTop, offset);
+            } else if (existingOutput.versionId !== output.source.model.versionId) {
+                this._webview.updateOutput({
+                    cellId: cell.id,
+                    cellHandle: cell.handle,
+                    cellUri: cell.uri,
+                    executionId: cell.internalMetadata.executionId
+                }, output, cellTop, offset);
+            } else {
+                const outputIndex = cell.outputsViewModels.indexOf(output.source);
+                const outputOffset = cell.getOutputOffset(outputIndex);
+                this._webview.updateScrollTops([{
+                    cell,
+                    output: output.source,
+                    cellTop,
+                    outputOffset,
+                    forceDisplay: !cell.isOutputCollapsed
+                }], []);
+            }
+        });
+    }
+    async updateOutput(cell, output, offset) {
+        this._insetModifyQueueByOutputId.queue(output.source.model.outputId, async () => {
+            if (this._isDisposed || !this._webview || cell.isOutputCollapsed) {
+                return;
+            }
+            if (!this._webview.isResolved()) {
+                await this._resolveWebview();
+            }
+            if (!this._webview || !this._list.webviewElement) {
+                return;
+            }
+            if (!( this._webview.insetMapping.has(output.source))) {
+                return this.createOutput(cell, output, offset, false);
+            }
+            if (output.type === RenderOutputType.Extension) {
+                this.notebookRendererMessaging.prepare(output.renderer.id);
+            }
+            const webviewTop = parseInt(this._list.webviewElement.domNode.style.top, 10);
+            const top = !!webviewTop ? (0 - webviewTop) : 0;
+            const cellTop = this._list.getCellViewScrollTop(cell) + top;
+            this._webview.updateOutput({
+                cellId: cell.id,
+                cellHandle: cell.handle,
+                cellUri: cell.uri
+            }, output, cellTop, offset);
+        });
+    }
+    async copyOutputImage(cellOutput) {
+        this._webview?.copyImage(cellOutput);
+    }
+    removeInset(output) {
+        this._insetModifyQueueByOutputId.queue(output.model.outputId, async () => {
+            if (this._isDisposed || !this._webview) {
+                return;
+            }
+            if (this._webview?.isResolved()) {
+                this._webview.removeInsets([output]);
+            }
+            this._onDidRemoveOutput.fire(output);
+        });
+    }
+    hideInset(output) {
+        this._insetModifyQueueByOutputId.queue(output.model.outputId, async () => {
+            if (this._isDisposed || !this._webview) {
+                return;
+            }
+            if (this._webview?.isResolved()) {
+                this._webview.hideInset(output);
+            }
+        });
+    }
+    postMessage(message) {
+        if (this._webview?.isResolved()) {
+            this._webview.postKernelMessage(message);
+        }
+    }
+    addClassName(className) {
+        this._overlayContainer.classList.add(className);
+    }
+    removeClassName(className) {
+        this._overlayContainer.classList.remove(className);
+    }
+    cellAt(index) {
+        return this.viewModel?.cellAt(index);
+    }
+    getCellByInfo(cellInfo) {
+        const {
+            cellHandle
+        } = cellInfo;
+        return this.viewModel?.viewCells.find(vc => vc.handle === cellHandle);
+    }
+    getCellByHandle(handle) {
+        return this.viewModel?.getCellByHandle(handle);
+    }
+    getCellIndex(cell) {
+        return this.viewModel?.getCellIndexByHandle(cell.handle);
+    }
+    getNextVisibleCellIndex(index) {
+        return this.viewModel?.getNextVisibleCellIndex(index);
+    }
+    getPreviousVisibleCellIndex(index) {
+        return this.viewModel?.getPreviousVisibleCellIndex(index);
+    }
+    _updateScrollHeight() {
+        if (this._isDisposed || !this._webview?.isResolved()) {
+            return;
+        }
+        if (!this._list.webviewElement) {
+            return;
+        }
+        const scrollHeight = this._list.scrollHeight;
+        this._webview.element.style.height = `${scrollHeight + NOTEBOOK_WEBVIEW_BOUNDARY * 2}px`;
+        const webviewTop = parseInt(this._list.webviewElement.domNode.style.top, 10);
+        const top = !!webviewTop ? (0 - webviewTop) : 0;
+        const updateItems = [];
+        const removedItems = [];
+        this._webview?.insetMapping.forEach((value, key) => {
+            const cell = this.viewModel?.getCellByHandle(value.cellInfo.cellHandle);
+            if (!cell || !(cell instanceof CodeCellViewModel)) {
+                return;
+            }
+            const viewIndex = this._list.getViewIndex(cell);
+            if (viewIndex === undefined) {
+                return;
+            }
+            const outputIndex = cell.outputsViewModels.indexOf(key);
+            if (outputIndex < 0) {
+                removedItems.push(key);
+                return;
+            }
+            const cellTop = this._list.getCellViewScrollTop(cell);
+            const outputOffset = cell.getOutputOffset(outputIndex);
+            updateItems.push({
+                cell,
+                output: key,
+                cellTop: cellTop + top,
+                outputOffset,
+                forceDisplay: false
+            });
+        });
+        this._webview.removeInsets(removedItems);
+        const markdownUpdateItems = [];
+        for (const cellId of ( this._webview.markupPreviewMapping.keys())) {
+            const cell = this.viewModel?.viewCells.find(cell => cell.id === cellId);
+            if (cell) {
+                const cellTop = this._list.getCellViewScrollTop(cell);
+                markdownUpdateItems.push({
+                    id: cellId,
+                    top: cellTop + top
+                });
+            }
+        }
+        if (markdownUpdateItems.length || updateItems.length) {
+            this._debug("_list.onDidChangeContentHeight/markdown", markdownUpdateItems);
+            this._webview?.updateScrollTops(updateItems, markdownUpdateItems);
+        }
+    }
+    _updateOutputHeight(cellInfo, output, outputHeight, isInit, source) {
+        const cell = this.viewModel?.viewCells.find(vc => vc.handle === cellInfo.cellHandle);
+        if (cell && cell instanceof CodeCellViewModel) {
+            const outputIndex = cell.outputsViewModels.indexOf(output);
+            if (outputIndex > -1) {
+                this._debug("update cell output", cell.handle, outputHeight);
+                cell.updateOutputHeight(outputIndex, outputHeight, source);
+                this.layoutNotebookCell(cell, cell.layoutInfo.totalHeight);
+                if (isInit) {
+                    this._onDidRenderOutput.fire(output);
+                }
+            } else {
+                this._debug("tried to update cell output that does not exist");
+            }
+        }
+    }
+    _scheduleOutputHeightAck(cellInfo, outputId, height) {
+        const wasEmpty = this._pendingOutputHeightAcks.size === 0;
+        this._pendingOutputHeightAcks.set(outputId, {
+            cellId: cellInfo.cellId,
+            outputId,
+            height
+        });
+        if (wasEmpty) {
+            scheduleAtNextAnimationFrame(getWindow(this.getDomNode()), () => {
+                this._debug("ack height");
+                this._updateScrollHeight();
+                this._webview?.ackHeight([...( this._pendingOutputHeightAcks.values())]);
+                this._pendingOutputHeightAcks.clear();
+            }, -1);
+        }
+    }
+    _getCellById(cellId) {
+        return this.viewModel?.viewCells.find(vc => vc.id === cellId);
+    }
+    _updateMarkupCellHeight(cellId, height, isInit) {
+        const cell = this._getCellById(cellId);
+        if (cell && cell instanceof MarkupCellViewModel) {
+            const {
+                bottomToolbarGap
+            } = this._notebookOptions.computeBottomToolbarDimensions(this.viewModel?.viewType);
+            this._debug("updateMarkdownCellHeight", cell.handle, height + bottomToolbarGap, isInit);
+            cell.renderedMarkdownHeight = height;
+        }
+    }
+    _setMarkupCellEditState(cellId, editState) {
+        const cell = this._getCellById(cellId);
+        if (cell instanceof MarkupCellViewModel) {
+            this.revealInView(cell);
+            cell.updateEditState(editState, "setMarkdownCellEditState");
+        }
+    }
+    _didStartDragMarkupCell(cellId, event) {
+        const cell = this._getCellById(cellId);
+        if (cell instanceof MarkupCellViewModel) {
+            const webviewOffset = this._list.webviewElement ? -parseInt(this._list.webviewElement.domNode.style.top, 10) : 0;
+            this._dndController?.startExplicitDrag(cell, event.dragOffsetY - webviewOffset);
+        }
+    }
+    _didDragMarkupCell(cellId, event) {
+        const cell = this._getCellById(cellId);
+        if (cell instanceof MarkupCellViewModel) {
+            const webviewOffset = this._list.webviewElement ? -parseInt(this._list.webviewElement.domNode.style.top, 10) : 0;
+            this._dndController?.explicitDrag(cell, event.dragOffsetY - webviewOffset);
+        }
+    }
+    _didDropMarkupCell(cellId, event) {
+        const cell = this._getCellById(cellId);
+        if (cell instanceof MarkupCellViewModel) {
+            const webviewOffset = this._list.webviewElement ? -parseInt(this._list.webviewElement.domNode.style.top, 10) : 0;
+            event.dragOffsetY -= webviewOffset;
+            this._dndController?.explicitDrop(cell, event);
+        }
+    }
+    _didEndDragMarkupCell(cellId) {
+        const cell = this._getCellById(cellId);
+        if (cell instanceof MarkupCellViewModel) {
+            this._dndController?.endExplicitDrag(cell);
+        }
+    }
+    _didResizeOutput(cellId) {
+        const cell = this._getCellById(cellId);
+        if (cell) {
+            this._onDidResizeOutputEmitter.fire(cell);
+        }
+    }
+    _updatePerformanceMetadata(cellId, executionId, duration, rendererId) {
+        if (!this.hasModel()) {
+            return;
+        }
+        const cell = this._getCellById(cellId);
+        const cellIndex = !cell ? undefined : this.getCellIndex(cell);
+        if (cell?.internalMetadata.executionId === executionId && cellIndex !== undefined) {
+            const renderDurationMap = cell.internalMetadata.renderDuration || {};
+            renderDurationMap[rendererId] = (renderDurationMap[rendererId] ?? 0) + duration;
+            this.textModel.applyEdits([{
+                editType: CellEditType.PartialInternalMetadata,
+                index: cellIndex,
+                internalMetadata: {
+                    executionId: executionId,
+                    renderDuration: renderDurationMap
+                }
+            }], true, undefined, () => undefined, undefined, false);
+        }
+    }
+    getContribution(id) {
+        return (this._contributions.get(id) || null);
+    }
+    dispose() {
+        this._isDisposed = true;
+        this._webview?.dispose();
+        this._webview = null;
+        this.notebookEditorService.removeNotebookEditor(this);
+        dispose(( this._contributions.values()));
+        this._contributions.clear();
+        this._localStore.clear();
+        dispose(this._localCellStateListeners);
+        this._list.dispose();
+        this._cellLayoutManager?.dispose();
+        this._listTopCellToolbar?.dispose();
+        this._overlayContainer.remove();
+        this.viewModel?.dispose();
+        this._renderedEditors.clear();
+        this._baseCellEditorOptions.forEach(v => v.dispose());
+        this._baseCellEditorOptions.clear();
+        this._notebookOverviewRulerContainer.remove();
+        super.dispose();
+        this._webview = null;
+        this._webviewResolvePromise = null;
+        this._webviewTransparentCover = null;
+        this._dndController = null;
+        this._listTopCellToolbar = null;
+        this._notebookViewModel = undefined;
+        this._cellContextKeyManager = null;
+        this._notebookTopToolbar = null;
+        this._list = null;
+        this._listViewInfoAccessor = null;
+        this._listDelegate = null;
+    }
+    toJSON() {
+        return {
+            notebookUri: this.viewModel?.uri
+        };
+    }
+};
+NotebookEditorWidget = ( __decorate([( __param(2, IInstantiationService)), ( __param(3, IEditorGroupsService)), ( __param(4, INotebookRendererMessagingService)), ( __param(5, INotebookEditorService)), ( __param(6, INotebookKernelService)), ( __param(7, INotebookService)), ( __param(8, IConfigurationService)), ( __param(9, IContextKeyService)), ( __param(10, IWorkbenchLayoutService)), ( __param(11, IContextMenuService)), ( __param(12, ITelemetryService)), ( __param(13, INotebookExecutionService)), ( __param(14, IEditorProgressService)), ( __param(15, INotebookLoggingService))], NotebookEditorWidget));
+registerZIndex(ZIndex.Base, 5, "notebook-progress-bar");
+registerZIndex(ZIndex.Base, 10, "notebook-list-insertion-indicator");
+registerZIndex(ZIndex.Base, 20, "notebook-cell-editor-outline");
+registerZIndex(ZIndex.Base, 25, "notebook-scrollbar");
+registerZIndex(ZIndex.Base, 26, "notebook-cell-status");
+registerZIndex(ZIndex.Base, 26, "notebook-folding-indicator");
+registerZIndex(ZIndex.Base, 27, "notebook-output");
+registerZIndex(ZIndex.Base, 28, "notebook-cell-bottom-toolbar-container");
+registerZIndex(ZIndex.Base, 29, "notebook-run-button-container");
+registerZIndex(ZIndex.Base, 29, "notebook-input-collapse-condicon");
+registerZIndex(ZIndex.Base, 30, "notebook-cell-output-toolbar");
+registerZIndex(ZIndex.Sash, 1, "notebook-cell-expand-part-button");
+registerZIndex(ZIndex.Sash, 2, "notebook-cell-toolbar");
+registerZIndex(ZIndex.Sash, 3, "notebook-cell-toolbar-dropdown-active");
+const notebookCellBorder = registerColor("notebook.cellBorderColor", {
+    dark: ( transparent(listInactiveSelectionBackground, 1)),
+    light: ( transparent(listInactiveSelectionBackground, 1)),
+    hcDark: PANEL_BORDER,
+    hcLight: PANEL_BORDER
+}, ( localize(16860, "The border color for notebook cells.")));
+registerColor("notebook.focusedEditorBorder", focusBorder, ( localize(16861, "The color of the notebook cell editor border.")));
+const cellStatusIconSuccess = registerColor(
+    "notebookStatusSuccessIcon.foreground",
+    debugIconStartForeground,
+    ( localize(16862, "The error icon color of notebook cells in the cell status bar."))
+);
+const runningCellRulerDecorationColor = registerColor(
+    "notebookEditorOverviewRuler.runningCellForeground",
+    debugIconStartForeground,
+    ( localize(
+    16863,
+    "The color of the running cell decoration in the notebook editor overview ruler."
+))
+);
+const cellStatusIconError = registerColor("notebookStatusErrorIcon.foreground", errorForeground, ( localize(16864, "The error icon color of notebook cells in the cell status bar.")));
+registerColor("notebookStatusRunningIcon.foreground", foreground, ( localize(16865, "The running icon color of notebook cells in the cell status bar.")));
+registerColor("notebook.outputContainerBorderColor", null, ( localize(16866, "The border color of the notebook output container.")));
+registerColor("notebook.outputContainerBackgroundColor", null, ( localize(16867, "The color of the notebook output container background.")));
+registerColor("notebook.cellToolbarSeparator", {
+    dark: ( ( Color.fromHex("#808080")).transparent(0.35)),
+    light: ( ( Color.fromHex("#808080")).transparent(0.35)),
+    hcDark: contrastBorder,
+    hcLight: contrastBorder
+}, ( localize(16868, "The color of the separator in the cell bottom toolbar")));
+const focusedCellBackground = registerColor("notebook.focusedCellBackground", null, ( localize(16869, "The background color of a cell when the cell is focused.")));
+registerColor("notebook.selectedCellBackground", {
+    dark: listInactiveSelectionBackground,
+    light: listInactiveSelectionBackground,
+    hcDark: null,
+    hcLight: null
+}, ( localize(16870, "The background color of a cell when the cell is selected.")));
+registerColor("notebook.cellHoverBackground", {
+    dark: ( transparent(focusedCellBackground, .5)),
+    light: ( transparent(focusedCellBackground, .7)),
+    hcDark: null,
+    hcLight: null
+}, ( localize(16871, "The background color of a cell when the cell is hovered.")));
+registerColor("notebook.selectedCellBorder", {
+    dark: notebookCellBorder,
+    light: notebookCellBorder,
+    hcDark: contrastBorder,
+    hcLight: contrastBorder
+}, ( localize(
+    16872,
+    "The color of the cell's top and bottom border when the cell is selected but not focused."
+)));
+registerColor("notebook.inactiveSelectedCellBorder", {
+    dark: null,
+    light: null,
+    hcDark: focusBorder,
+    hcLight: focusBorder
+}, ( localize(16873, "The color of the cell's borders when multiple cells are selected.")));
+registerColor("notebook.focusedCellBorder", focusBorder, ( localize(
+    16874,
+    "The color of the cell's focus indicator borders when the cell is focused."
+)));
+registerColor("notebook.inactiveFocusedCellBorder", notebookCellBorder, ( localize(
+    16875,
+    "The color of the cell's top and bottom border when a cell is focused while the primary focus is outside of the editor."
+)));
+registerColor("notebook.cellStatusBarItemHoverBackground", {
+    light: ( new Color(( new RGBA(0, 0, 0, 0.08)))),
+    dark: ( new Color(( new RGBA(255, 255, 255, 0.15)))),
+    hcDark: ( new Color(( new RGBA(255, 255, 255, 0.15)))),
+    hcLight: ( new Color(( new RGBA(0, 0, 0, 0.08))))
+}, ( localize(16876, "The background color of notebook cell status bar items.")));
+registerColor("notebook.cellInsertionIndicator", focusBorder, ( localize(16877, "The color of the notebook cell insertion indicator.")));
+registerColor(
+    "notebookScrollbarSlider.background",
+    scrollbarSliderBackground,
+    ( localize(16878, "Notebook scrollbar slider background color."))
+);
+registerColor(
+    "notebookScrollbarSlider.hoverBackground",
+    scrollbarSliderHoverBackground,
+    ( localize(16879, "Notebook scrollbar slider background color when hovering."))
+);
+registerColor(
+    "notebookScrollbarSlider.activeBackground",
+    scrollbarSliderActiveBackground,
+    ( localize(16880, "Notebook scrollbar slider background color when clicked on."))
+);
+registerColor("notebook.symbolHighlightBackground", {
+    dark: ( Color.fromHex("#ffffff0b")),
+    light: ( Color.fromHex("#fdff0033")),
+    hcDark: null,
+    hcLight: null
+}, ( localize(16881, "Background color of highlighted cell")));
+registerColor("notebook.cellEditorBackground", {
+    light: SIDE_BAR_BACKGROUND,
+    dark: SIDE_BAR_BACKGROUND,
+    hcDark: null,
+    hcLight: null
+}, ( localize(16882, "Cell editor background color.")));
+const notebookEditorBackground = registerColor("notebook.editorBackground", {
+    light: EDITOR_PANE_BACKGROUND,
+    dark: EDITOR_PANE_BACKGROUND,
+    hcDark: null,
+    hcLight: null
+}, ( localize(16883, "Notebook background color.")));
+
+export { NotebookEditorWidget, cellStatusIconError, cellStatusIconSuccess, focusedCellBackground, getDefaultNotebookCreationOptions, notebookCellBorder, runningCellRulerDecorationColor };