@codingame/monaco-vscode-api 4.5.1 → 5.0.0

package/vscode/src/vs/workbench/contrib/notebook/browser/view/renderers/cellRenderer.js

@@ -39,6 +39,7 @@ import { MarkupCell } from '../cellParts/markupCell.js';
 import { CellKind } from '../../../common/notebookCommon.js';
 import { INotebookExecutionStateService } from '../../../common/notebookExecutionStateService.service.js';
 var MarkupCellRenderer_1, CodeCellRenderer_1;
+const _moduleId = "vs/workbench/contrib/notebook/browser/view/renderers/cellRenderer";
 const $ = $$1;
 let NotebookCellListDelegate = class NotebookCellListDelegate extends Disposable {
     constructor(targetWindow, configurationService) {
@@ -62,9 +63,9 @@ let NotebookCellListDelegate = class NotebookCellListDelegate extends Disposable
         }
     }
 };
-NotebookCellListDelegate = ( __decorate([
-    ( __param(1, IConfigurationService))
-], NotebookCellListDelegate));
+NotebookCellListDelegate = ( (__decorate([
+    ( (__param(1, IConfigurationService)))
+], NotebookCellListDelegate)));
 class AbstractCellRenderer {
     constructor(instantiationService, notebookEditor, contextMenuService, menuService, configurationService, keybindingService, notificationService, contextKeyServiceProvider, language, dndController) {
         this.instantiationService = instantiationService;
@@ -75,11 +76,11 @@ class AbstractCellRenderer {
         this.notificationService = notificationService;
         this.contextKeyServiceProvider = contextKeyServiceProvider;
         this.dndController = dndController;
-        this.editorOptions = ( new CellEditorOptions(
+        this.editorOptions = ( (new CellEditorOptions(
             this.notebookEditor.getBaseCellEditorOptions(language),
             this.notebookEditor.notebookOptions,
             configurationService
-        ));
+        )));
     }
     dispose() {
         this.editorOptions.dispose();
@@ -100,18 +101,18 @@ let MarkupCellRenderer = class MarkupCellRenderer extends AbstractCellRenderer {
     renderTemplate(rootContainer) {
         rootContainer.classList.add('markdown-cell-row');
         const container = append(rootContainer, $$1('.cell-inner-container'));
-        const templateDisposables = ( new DisposableStore());
+        const templateDisposables = ( (new DisposableStore()));
         const contextKeyService = templateDisposables.add(this.contextKeyServiceProvider(container));
         const decorationContainer = append(rootContainer, $('.cell-decoration'));
         const titleToolbarContainer = append(container, $('.cell-title-toolbar'));
-        const focusIndicatorTop = ( new FastDomNode(append(container, $('.cell-focus-indicator.cell-focus-indicator-top'))));
-        const focusIndicatorLeft = ( new FastDomNode(
+        const focusIndicatorTop = ( (new FastDomNode(append(container, $('.cell-focus-indicator.cell-focus-indicator-top')))));
+        const focusIndicatorLeft = ( (new FastDomNode(
             append(container, $$1('.cell-focus-indicator.cell-focus-indicator-side.cell-focus-indicator-left'))
-        ));
+        )));
         const foldingIndicator = append(focusIndicatorLeft.domNode, $$1('.notebook-folding-indicator'));
-        const focusIndicatorRight = ( new FastDomNode(
+        const focusIndicatorRight = ( (new FastDomNode(
             append(container, $$1('.cell-focus-indicator.cell-focus-indicator-side.cell-focus-indicator-right'))
-        ));
+        )));
         const codeInnerContent = append(container, $('.cell.code'));
         const editorPart = append(codeInnerContent, $('.cell-editor-part'));
         const cellChatPart = append(editorPart, $('.cell-chat-part'));
@@ -122,40 +123,38 @@ let MarkupCellRenderer = class MarkupCellRenderer extends AbstractCellRenderer {
         const cellCommentPartContainer = append(container, $('.cell-comment-container'));
         const innerContent = append(container, $('.cell.markdown'));
         const bottomCellContainer = append(container, $('.cell-bottom-toolbar-container'));
-        const scopedInstaService = this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, contextKeyService])));
+        const scopedInstaService = this.instantiationService.createChild(( (new ServiceCollection([IContextKeyService, contextKeyService]))));
         const rootClassDelegate = {
             toggle: (className, force) => container.classList.toggle(className, force)
         };
         const titleToolbar = templateDisposables.add(scopedInstaService.createInstance(CellTitleToolbarPart, titleToolbarContainer, rootClassDelegate, this.notebookEditor.creationOptions.menuIds.cellTitleToolbar, this.notebookEditor.creationOptions.menuIds.cellDeleteToolbar, this.notebookEditor));
-        const focusIndicatorBottom = ( new FastDomNode(
-            append(container, $('.cell-focus-indicator.cell-focus-indicator-bottom'))
-        ));
-        const cellParts = ( new CellPartsCollection(getWindow(rootContainer), [
+        const focusIndicatorBottom = ( (new FastDomNode(append(container, $('.cell-focus-indicator.cell-focus-indicator-bottom')))));
+        const cellParts = ( (new CellPartsCollection(getWindow(rootContainer), [
             templateDisposables.add(scopedInstaService.createInstance(CellChatPart, this.notebookEditor, cellChatPart)),
             templateDisposables.add(scopedInstaService.createInstance(CellEditorStatusBar, this.notebookEditor, container, editorPart, undefined)),
-            templateDisposables.add(( new CellFocusIndicator(
+            templateDisposables.add(( (new CellFocusIndicator(
                 this.notebookEditor,
                 titleToolbar,
                 focusIndicatorTop,
                 focusIndicatorLeft,
                 focusIndicatorRight,
                 focusIndicatorBottom
-            ))),
-            templateDisposables.add(( new FoldedCellHint(
+            )))),
+            templateDisposables.add(( (new FoldedCellHint(
                 this.notebookEditor,
                 append(container, $('.notebook-folded-hint')),
                 this._notebookExecutionStateService
-            ))),
-            templateDisposables.add(( new CellDecorations(rootContainer, decorationContainer))),
+            )))),
+            templateDisposables.add(( (new CellDecorations(rootContainer, decorationContainer)))),
             templateDisposables.add(scopedInstaService.createInstance(CellComments, this.notebookEditor, cellCommentPartContainer)),
-            templateDisposables.add(( new CollapsedCellInput(this.notebookEditor, cellInputCollapsedContainer))),
-            templateDisposables.add(( new CellFocusPart(container, undefined, this.notebookEditor))),
-            templateDisposables.add(( new CellDragAndDropPart(container))),
+            templateDisposables.add(( (new CollapsedCellInput(this.notebookEditor, cellInputCollapsedContainer)))),
+            templateDisposables.add(( (new CellFocusPart(container, undefined, this.notebookEditor)))),
+            templateDisposables.add(( (new CellDragAndDropPart(container)))),
             templateDisposables.add(scopedInstaService.createInstance(CellContextKeyPart, this.notebookEditor)),
         ], [
             titleToolbar,
             templateDisposables.add(scopedInstaService.createInstance(BetweenCellToolbar, this.notebookEditor, titleToolbarContainer, bottomCellContainer))
-        ]));
+        ])));
         templateDisposables.add(cellParts);
         const templateData = {
             rootContainer,
@@ -167,7 +166,7 @@ let MarkupCellRenderer = class MarkupCellRenderer extends AbstractCellRenderer {
             editorContainer,
             foldingIndicator,
             templateDisposables,
-            elementDisposables: ( new DisposableStore()),
+            elementDisposables: ( (new DisposableStore())),
             cellParts,
             toJSON: () => { return {}; }
         };
@@ -175,7 +174,7 @@ let MarkupCellRenderer = class MarkupCellRenderer extends AbstractCellRenderer {
     }
     renderElement(element, index, templateData, height) {
         if (!this.notebookEditor.hasModel()) {
-            throw new Error('The notebook editor is not attached with view model yet.');
+            throw ( (new Error('The notebook editor is not attached with view model yet.')));
         }
         templateData.currentRenderedCell = element;
         templateData.currentEditor = undefined;
@@ -194,15 +193,15 @@ let MarkupCellRenderer = class MarkupCellRenderer extends AbstractCellRenderer {
         templateData.elementDisposables.clear();
     }
 };
-MarkupCellRenderer = MarkupCellRenderer_1 = ( __decorate([
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IInstantiationService)),
-    ( __param(6, IContextMenuService)),
-    ( __param(7, IMenuService)),
-    ( __param(8, IKeybindingService)),
-    ( __param(9, INotificationService)),
-    ( __param(10, INotebookExecutionStateService))
-], MarkupCellRenderer));
+MarkupCellRenderer = MarkupCellRenderer_1 = ( (__decorate([
+    ( (__param(4, IConfigurationService))),
+    ( (__param(5, IInstantiationService))),
+    ( (__param(6, IContextMenuService))),
+    ( (__param(7, IMenuService))),
+    ( (__param(8, IKeybindingService))),
+    ( (__param(9, INotificationService))),
+    ( (__param(10, INotebookExecutionStateService)))
+], MarkupCellRenderer)));
 let CodeCellRenderer = class CodeCellRenderer extends AbstractCellRenderer {
     static { CodeCellRenderer_1 = this; }
     static { this.TEMPLATE_ID = 'code_cell'; }
@@ -216,30 +215,26 @@ let CodeCellRenderer = class CodeCellRenderer extends AbstractCellRenderer {
     renderTemplate(rootContainer) {
         rootContainer.classList.add('code-cell-row');
         const container = append(rootContainer, $$1('.cell-inner-container'));
-        const templateDisposables = ( new DisposableStore());
+        const templateDisposables = ( (new DisposableStore()));
         const contextKeyService = templateDisposables.add(this.contextKeyServiceProvider(container));
         const decorationContainer = append(rootContainer, $('.cell-decoration'));
-        const focusIndicatorTop = ( new FastDomNode(append(container, $('.cell-focus-indicator.cell-focus-indicator-top'))));
+        const focusIndicatorTop = ( (new FastDomNode(append(container, $('.cell-focus-indicator.cell-focus-indicator-top')))));
         const titleToolbarContainer = append(container, $('.cell-title-toolbar'));
-        const focusIndicatorLeft = ( new FastDomNode(
+        const focusIndicatorLeft = ( (new FastDomNode(
             append(container, $$1('.cell-focus-indicator.cell-focus-indicator-side.cell-focus-indicator-left'))
-        ));
+        )));
         const cellChatPart = append(container, $('.cell-chat-part'));
         const cellContainer = append(container, $('.cell.code'));
         const runButtonContainer = append(cellContainer, $('.run-button-container'));
         const cellInputCollapsedContainer = append(cellContainer, $('.input-collapse-container'));
         cellInputCollapsedContainer.style.display = 'none';
         const executionOrderLabel = append(focusIndicatorLeft.domNode, $('div.execution-count-label'));
-        executionOrderLabel.title = ( localizeWithPath(
-            'vs/workbench/contrib/notebook/browser/view/renderers/cellRenderer',
-            'cellExecutionOrderCountLabel',
-            'Execution Order'
-        ));
+        executionOrderLabel.title = ( localizeWithPath(_moduleId, 0, 'Execution Order'));
         const editorPart = append(cellContainer, $('.cell-editor-part'));
         const editorContainer = append(editorPart, $('.cell-editor-container'));
         const cellCommentPartContainer = append(container, $('.cell-comment-container'));
         const editorContextKeyService = templateDisposables.add(this.contextKeyServiceProvider(editorPart));
-        const editorInstaService = this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, editorContextKeyService])));
+        const editorInstaService = this.instantiationService.createChild(( (new ServiceCollection([IContextKeyService, editorContextKeyService]))));
         EditorContextKeys.inCompositeEditor.bindTo(editorContextKeyService).set(true);
         const editor = editorInstaService.createInstance(CodeEditorWidget, editorContainer, {
             ...this.editorOptions.getDefaultValue(),
@@ -251,49 +246,47 @@ let CodeCellRenderer = class CodeCellRenderer extends AbstractCellRenderer {
             contributions: this.notebookEditor.creationOptions.cellEditorContributions
         });
         templateDisposables.add(editor);
-        const outputContainer = ( new FastDomNode(append(container, $('.output'))));
+        const outputContainer = ( (new FastDomNode(append(container, $('.output')))));
         const cellOutputCollapsedContainer = append(outputContainer.domNode, $('.output-collapse-container'));
-        const outputShowMoreContainer = ( new FastDomNode(append(container, $('.output-show-more-container'))));
-        const focusIndicatorRight = ( new FastDomNode(
+        const outputShowMoreContainer = ( (new FastDomNode(append(container, $('.output-show-more-container')))));
+        const focusIndicatorRight = ( (new FastDomNode(
             append(container, $$1('.cell-focus-indicator.cell-focus-indicator-side.cell-focus-indicator-right'))
-        ));
+        )));
         const focusSinkElement = append(container, $('.cell-editor-focus-sink'));
         focusSinkElement.setAttribute('tabindex', '0');
         const bottomCellToolbarContainer = append(container, $('.cell-bottom-toolbar-container'));
-        const focusIndicatorBottom = ( new FastDomNode(
-            append(container, $('.cell-focus-indicator.cell-focus-indicator-bottom'))
-        ));
-        const scopedInstaService = this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, contextKeyService])));
+        const focusIndicatorBottom = ( (new FastDomNode(append(container, $('.cell-focus-indicator.cell-focus-indicator-bottom')))));
+        const scopedInstaService = this.instantiationService.createChild(( (new ServiceCollection([IContextKeyService, contextKeyService]))));
         const rootClassDelegate = {
             toggle: (className, force) => container.classList.toggle(className, force)
         };
         const titleToolbar = templateDisposables.add(scopedInstaService.createInstance(CellTitleToolbarPart, titleToolbarContainer, rootClassDelegate, this.notebookEditor.creationOptions.menuIds.cellTitleToolbar, this.notebookEditor.creationOptions.menuIds.cellDeleteToolbar, this.notebookEditor));
-        const focusIndicatorPart = templateDisposables.add(( new CellFocusIndicator(
+        const focusIndicatorPart = templateDisposables.add(( (new CellFocusIndicator(
             this.notebookEditor,
             titleToolbar,
             focusIndicatorTop,
             focusIndicatorLeft,
             focusIndicatorRight,
             focusIndicatorBottom
-        )));
-        const cellParts = ( new CellPartsCollection(getWindow(rootContainer), [
+        ))));
+        const cellParts = ( (new CellPartsCollection(getWindow(rootContainer), [
             focusIndicatorPart,
             templateDisposables.add(scopedInstaService.createInstance(CellChatPart, this.notebookEditor, cellChatPart)),
             templateDisposables.add(scopedInstaService.createInstance(CellEditorStatusBar, this.notebookEditor, container, editorPart, editor)),
             templateDisposables.add(scopedInstaService.createInstance(CellProgressBar, editorPart, cellInputCollapsedContainer)),
             templateDisposables.add(scopedInstaService.createInstance(RunToolbar, this.notebookEditor, contextKeyService, container, runButtonContainer)),
-            templateDisposables.add(( new CellDecorations(rootContainer, decorationContainer))),
+            templateDisposables.add(( (new CellDecorations(rootContainer, decorationContainer)))),
             templateDisposables.add(scopedInstaService.createInstance(CellComments, this.notebookEditor, cellCommentPartContainer)),
             templateDisposables.add(scopedInstaService.createInstance(CellExecutionPart, this.notebookEditor, executionOrderLabel)),
             templateDisposables.add(scopedInstaService.createInstance(CollapsedCellOutput, this.notebookEditor, cellOutputCollapsedContainer)),
-            templateDisposables.add(( new CollapsedCellInput(this.notebookEditor, cellInputCollapsedContainer))),
-            templateDisposables.add(( new CellFocusPart(container, focusSinkElement, this.notebookEditor))),
-            templateDisposables.add(( new CellDragAndDropPart(container))),
+            templateDisposables.add(( (new CollapsedCellInput(this.notebookEditor, cellInputCollapsedContainer)))),
+            templateDisposables.add(( (new CellFocusPart(container, focusSinkElement, this.notebookEditor)))),
+            templateDisposables.add(( (new CellDragAndDropPart(container)))),
             templateDisposables.add(scopedInstaService.createInstance(CellContextKeyPart, this.notebookEditor)),
         ], [
             titleToolbar,
             templateDisposables.add(scopedInstaService.createInstance(BetweenCellToolbar, this.notebookEditor, titleToolbarContainer, bottomCellToolbarContainer))
-        ]));
+        ])));
         templateDisposables.add(cellParts);
         const templateData = {
             rootContainer,
@@ -308,17 +301,17 @@ let CodeCellRenderer = class CodeCellRenderer extends AbstractCellRenderer {
             outputShowMoreContainer,
             editor,
             templateDisposables,
-            elementDisposables: ( new DisposableStore()),
+            elementDisposables: ( (new DisposableStore())),
             cellParts,
             toJSON: () => { return {}; }
         };
         const dragHandles = [focusIndicatorLeft.domNode, focusIndicatorPart.codeFocusIndicator.domNode, focusIndicatorPart.outputFocusIndicator.domNode];
-        this.dndController?.registerDragHandle(templateData, rootContainer, dragHandles, () => ( new CodeCellDragImageRenderer()).getDragImage(templateData, templateData.editor, 'code'));
+        this.dndController?.registerDragHandle(templateData, rootContainer, dragHandles, () => ( (new CodeCellDragImageRenderer())).getDragImage(templateData, templateData.editor, 'code'));
         return templateData;
     }
     renderElement(element, index, templateData, height) {
         if (!this.notebookEditor.hasModel()) {
-            throw new Error('The notebook editor is not attached with view model yet.');
+            throw ( (new Error('The notebook editor is not attached with view model yet.')));
         }
         templateData.currentRenderedCell = element;
         if (height === undefined) {
@@ -337,12 +330,12 @@ let CodeCellRenderer = class CodeCellRenderer extends AbstractCellRenderer {
         this.renderedEditors.delete(element);
     }
 };
-CodeCellRenderer = CodeCellRenderer_1 = ( __decorate([
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IContextMenuService)),
-    ( __param(6, IMenuService)),
-    ( __param(7, IInstantiationService)),
-    ( __param(8, IKeybindingService)),
-    ( __param(9, INotificationService))
-], CodeCellRenderer));
+CodeCellRenderer = CodeCellRenderer_1 = ( (__decorate([
+    ( (__param(4, IConfigurationService))),
+    ( (__param(5, IContextMenuService))),
+    ( (__param(6, IMenuService))),
+    ( (__param(7, IInstantiationService))),
+    ( (__param(8, IKeybindingService))),
+    ( (__param(9, INotificationService)))
+], CodeCellRenderer)));
 export { CodeCellRenderer, MarkupCellRenderer, NotebookCellListDelegate };

package/vscode/src/vs/workbench/contrib/notebook/browser/view/renderers/webviewPreloads.js

@@ -89,7 +89,7 @@ async function webviewPreloads(ctx) {
             return;
         }
         const id = lastFocusedOutput?.id;
-        if (id && (activeElement.tagName === 'INPUT' || activeElement.tagName === 'TEXTAREA')) {
+        if (id && (activeElement.tagName === 'INPUT' || activeElement.tagName === 'TEXTAREA' || activeElement.tagName === 'SELECT')) {
             postNotebookMessage('outputInputFocus', { inputFocused: true, id });
             activeElement.addEventListener('blur', () => {
                 postNotebookMessage('outputInputFocus', { inputFocused: false, id });
@@ -154,6 +154,13 @@ async function webviewPreloads(ctx) {
             postNotebookMessage('outputFocus', outputFocus);
         }
     };
+    const blurOutput = () => {
+        const selection = window.getSelection();
+        if (!selection) {
+            return;
+        }
+        selection.removeAllRanges();
+    };
     const selectOutputContents = (cellOrOutputId) => {
         const selection = window.getSelection();
         if (!selection) {
@@ -182,6 +189,10 @@ async function webviewPreloads(ctx) {
         if (!lastFocusedOutput?.id || !e.shiftKey) {
             return;
         }
+        if (e.shiftKey && (e.code === 'ArrowUp' || e.code === 'ArrowDown')) {
+            e.stopPropagation();
+            return;
+        }
         if (!(e.code === 'PageUp' || e.code === 'PageDown') && !(e.metaKey && (e.code === 'ArrowDown' || e.code === 'ArrowUp'))) {
             return;
         }
@@ -389,13 +400,13 @@ async function webviewPreloads(ctx) {
             return true;
         }
         if (node.hasAttribute('recentlyScrolled')) {
-            if (lastTimeScrolled && Date.now() - lastTimeScrolled > 300) {
-                if (!!previousDelta && deltaY < 0 && deltaY < previousDelta - 2) {
+            if (lastTimeScrolled && Date.now() - lastTimeScrolled > 400) {
+                if (!!previousDelta && deltaY < 0 && deltaY < previousDelta - 8) {
                     clearTimeout(scrollTimeout);
                     scrolledElement?.removeAttribute('recentlyScrolled');
                     return false;
                 }
-                else if (!!previousDelta && deltaY > 0 && deltaY > previousDelta + 2) {
+                else if (!!previousDelta && deltaY > 0 && deltaY > previousDelta + 8) {
                     clearTimeout(scrollTimeout);
                     scrolledElement?.removeAttribute('recentlyScrolled');
                     return false;
@@ -1110,7 +1121,7 @@ async function webviewPreloads(ctx) {
     };
     const copyOutputImage = async (outputId, altOutputId, retries = 5) => {
         if (!window.document.hasFocus() && retries > 0) {
-            setTimeout(() => { copyOutputImage(outputId, altOutputId, retries - 1); }, 20);
+            setTimeout(() => { copyOutputImage(outputId, altOutputId, retries - 1); }, 50);
             return;
         }
         try {
@@ -1268,6 +1279,9 @@ async function webviewPreloads(ctx) {
             case 'focus-output':
                 focusFirstFocusableOrContainerInOutput(event.data.cellOrOutputId, event.data.alternateId);
                 break;
+            case 'blur-output':
+                blurOutput();
+                break;
             case 'select-output-contents':
                 selectOutputContents(event.data.cellOrOutputId);
                 break;
@@ -1410,6 +1424,7 @@ async function webviewPreloads(ctx) {
                     get outputScrolling() { return currentRenderOptions.outputScrolling; },
                     get outputWordWrap() { return currentRenderOptions.outputWordWrap; },
                     get linkifyFilePaths() { return currentRenderOptions.linkifyFilePaths; },
+                    get minimalError() { return currentRenderOptions.minimalError; },
                 },
                 get onDidChangeSettings() { return settingChange.event; }
             };
@@ -1443,7 +1458,7 @@ async function webviewPreloads(ctx) {
                 await Promise.all(( dependantRenderers.map(async (d) => {
                     const renderer = renderers.getRenderer(d.id);
                     if (!renderer) {
-                        throw new Error(`Could not find extending renderer: ${d.id}`);
+                        throw ( new Error(`Could not find extending renderer: ${d.id}`));
                     }
                     try {
                         return await renderer.load();
@@ -2039,7 +2054,20 @@ async function webviewPreloads(ctx) {
             await outputElement.render(data.content, data.rendererId, preloadErrors, signal);
             outputElement .element.style.visibility = data.initiallyHidden ? 'hidden' : '';
             if (!!data.executionId && !!data.rendererId) {
-                postNotebookMessage('notebookPerformanceMessage', { cellId: data.cellId, executionId: data.executionId, duration: Date.now() - startTime, rendererId: data.rendererId });
+                let outputSize = undefined;
+                let mimeType = undefined;
+                if (data.content.type === 1 ) {
+                    outputSize = data.content.output.valueBytes.length;
+                    mimeType = data.content.output.mime;
+                }
+                postNotebookMessage('notebookPerformanceMessage', {
+                    cellId: data.cellId,
+                    executionId: data.executionId,
+                    duration: Date.now() - startTime,
+                    rendererId: data.rendererId,
+                    outputSize,
+                    mimeType
+                });
             }
         }
         clearOutput(outputId, rendererId) {

package/vscode/src/vs/workbench/contrib/notebook/browser/viewModel/baseCellViewModel.js

@@ -5,6 +5,7 @@ import { Range } from '../../../../../editor/common/core/range.js';
 import { Selection } from '../../../../../editor/common/core/selection.js';
 import { SearchParams } from '../../../../../editor/common/model/textModelSearch.js';
 import { writeTransientState, readTransientState } from '../../../codeEditor/browser/toggleWordWrap.js';
+import { InlineChatController } from '../../../inlineChat/browser/inlineChatController.js';
 import { CellEditState, CellFocusMode, CursorAtLineBoundary, CursorAtBoundary } from '../notebookBrowser.js';
 class BaseCellViewModel extends Disposable {
     get handle() {
@@ -149,7 +150,7 @@ class BaseCellViewModel extends Disposable {
     }
     attachTextEditor(editor, estimatedHasHorizontalScrolling) {
         if (!editor.hasModel()) {
-            throw new Error('Invalid editor: model is missing');
+            throw ( new Error('Invalid editor: model is missing'));
         }
         if (this._textEditor === editor) {
             if (this._editorListeners.length === 0) {
@@ -191,6 +192,14 @@ class BaseCellViewModel extends Disposable {
             });
         });
         this._editorListeners.push(this._textEditor.onDidChangeCursorSelection(() => { this._onDidChangeState.fire({ selectionChanged: true }); }));
+        const inlineChatController = InlineChatController.get(this._textEditor);
+        if (inlineChatController) {
+            this._editorListeners.push(inlineChatController.onWillStartSession(() => {
+                if (this.textBuffer.getLength() === 0) {
+                    this.enableAutoLanguageDetection();
+                }
+            }));
+        }
         this._onDidChangeState.fire({ selectionChanged: true });
         this._onDidChangeEditorAttachState.fire();
     }
@@ -218,9 +227,15 @@ class BaseCellViewModel extends Disposable {
     getText() {
         return this.model.getValue();
     }
+    getAlternativeId() {
+        return this.model.alternativeId;
+    }
     getTextLength() {
         return this.model.getTextLength();
     }
+    enableAutoLanguageDetection() {
+        this.model.enableAutoLanguageDetection();
+    }
     saveViewState() {
         if (!this._textEditor) {
             return;
@@ -462,7 +477,7 @@ class BaseCellViewModel extends Disposable {
                 return this.textModel;
             }
             if (!this._textModelRef) {
-                throw new Error(`Cannot resolve text model for ${this.uri}`);
+                throw ( new Error(`Cannot resolve text model for ${this.uri}`));
             }
             this._textModelRefChangeDisposable.value = this.textModel.onDidChangeContent(() => this.onDidChangeTextModelContent());
         }

package/vscode/src/vs/workbench/contrib/notebook/browser/viewModel/cellEditorOptions.js

@@ -65,11 +65,13 @@ class BaseCellEditorOptions extends Disposable {
     }
     _computeEditorOptions() {
         const editorOptions = deepClone(this.configurationService.getValue('editor', { overrideIdentifier: this.language }));
-        const editorOptionsOverrideRaw = this.notebookOptions.getDisplayOptions().editorOptionsCustomizations ?? {};
+        const editorOptionsOverrideRaw = this.notebookOptions.getDisplayOptions().editorOptionsCustomizations;
         const editorOptionsOverride = {};
-        for (const key in editorOptionsOverrideRaw) {
-            if (key.indexOf('editor.') === 0) {
-                editorOptionsOverride[key.substring(7)] = editorOptionsOverrideRaw[key];
+        if (editorOptionsOverrideRaw) {
+            for (const key in editorOptionsOverrideRaw) {
+                if (key.indexOf('editor.') === 0) {
+                    editorOptionsOverride[key.substring(7)] = editorOptionsOverrideRaw[key];
+                }
             }
         }
         const computed = ( Object.freeze({

package/vscode/src/vs/workbench/contrib/notebook/browser/viewModel/codeCellViewModel.js

@@ -27,7 +27,7 @@ let CodeCellViewModel = class CodeCellViewModel extends BaseCellViewModel {
         this.layoutChange({ editorHeight: true }, 'CodeCellViewModel#editorHeight');
     }
     get editorHeight() {
-        throw new Error('editorHeight is write-only');
+        throw ( new Error('editorHeight is write-only'));
     }
     set chatHeight(height) {
         if (this._chatHeight === height) {
@@ -384,7 +384,7 @@ let CodeCellViewModel = class CodeCellViewModel extends BaseCellViewModel {
     }
     updateOutputHeight(index, height, source) {
         if (index >= this._outputCollection.length) {
-            throw new Error('Output index out of range!');
+            throw ( new Error('Output index out of range!'));
         }
         this._ensureOutputsTop();
         if (height < 28 && this._outputViewModels[index].hasMultiMimeType()) {
@@ -398,7 +398,7 @@ let CodeCellViewModel = class CodeCellViewModel extends BaseCellViewModel {
     getOutputOffsetInContainer(index) {
         this._ensureOutputsTop();
         if (index >= this._outputCollection.length) {
-            throw new Error('Output index out of range!');
+            throw ( new Error('Output index out of range!'));
         }
         return this._outputsTop.getPrefixSum(index - 1);
     }

package/vscode/src/vs/workbench/contrib/notebook/browser/viewModel/markupCellViewModel.js

@@ -37,7 +37,7 @@ let MarkupCellViewModel = class MarkupCellViewModel extends BaseCellViewModel {
         this._updateTotalHeight(this._computeTotalHeight());
     }
     get editorHeight() {
-        throw new Error('MarkdownCellViewModel.editorHeight is write only');
+        throw ( new Error('MarkdownCellViewModel.editorHeight is write only'));
     }
     get foldingState() {
         return this.foldingDelegate.getFoldingState(this.foldingDelegate.getCellIndex(this));

package/vscode/src/vs/workbench/contrib/notebook/browser/viewModel/notebookOutlineProviderFactory.service.js

@@ -0,0 +1,3 @@
+import { createDecorator } from '../../../../../platform/instantiation/common/instantiation.js';
+const INotebookCellOutlineProviderFactory = ( createDecorator('INotebookCellOutlineProviderFactory'));
+export { INotebookCellOutlineProviderFactory };

package/vscode/src/vs/workbench/contrib/notebook/browser/viewModel/notebookViewModelImpl.js

@@ -23,7 +23,7 @@ import { NotebookMetadataChangedEvent } from '../notebookViewEvents.js';
 import { CellFindMatchModel } from '../contrib/find/findModel.js';
 import { NotebookExecutionType } from '../../common/notebookExecutionStateService.js';
 import { INotebookExecutionStateService } from '../../common/notebookExecutionStateService.service.js';
-const invalidFunc = () => { throw new Error(`Invalid change accessor`); };
+const invalidFunc = () => { throw ( new Error(`Invalid change accessor`)); };
 class DecorationsTree {
     constructor() {
         this._decorationsTree = ( new IntervalTree());
@@ -76,7 +76,7 @@ let NotebookViewModel = class NotebookViewModel extends Disposable {
         return this._viewCells;
     }
     set viewCells(_) {
-        throw new Error('NotebookViewModel.viewCells is readonly');
+        throw ( new Error('NotebookViewModel.viewCells is readonly'));
     }
     get length() {
         return this._viewCells.length;

package/vscode/src/vs/workbench/contrib/notebook/browser/viewParts/notebookEditorStickyScroll.js

@@ -11,6 +11,8 @@ import { Delayer } from '../../../../../base/common/async.js';
 import { ThemeIcon } from '../../../../../base/common/themables.js';
 import { foldingCollapsedIcon, foldingExpandedIcon } from '../../../../../editor/contrib/folding/browser/foldingDecorations.js';
 import { FoldingController } from '../controller/foldingController.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { INotebookCellOutlineProviderFactory } from '../viewModel/notebookOutlineProviderFactory.service.js';
 var NotebookStickyScroll_1;
 class NotebookStickyLine extends Disposable {
     constructor(element, foldingIcon, header, entry, notebookEditor) {
@@ -95,13 +97,13 @@ let NotebookStickyScroll = NotebookStickyScroll_1 = class NotebookStickyScroll e
         }
         return true;
     }
-    constructor(domNode, notebookEditor, notebookOutline, notebookCellList, _contextMenuService) {
+    constructor(domNode, notebookEditor, notebookCellList, _contextMenuService, instantiationService) {
         super();
         this.domNode = domNode;
         this.notebookEditor = notebookEditor;
-        this.notebookOutline = notebookOutline;
         this.notebookCellList = notebookCellList;
         this._contextMenuService = _contextMenuService;
+        this.instantiationService = instantiationService;
         this._disposables = ( new DisposableStore());
         this.currentStickyLines = ( new Map());
         this._onDidChangeNotebookStickyScroll = this._register(( new Emitter()));
@@ -142,34 +144,34 @@ let NotebookStickyScroll = NotebookStickyScroll_1 = class NotebookStickyScroll e
             }
             else {
                 this._disposables.clear();
-                this.notebookOutline.dispose();
+                this.notebookOutlineReference?.dispose();
                 this.disposeCurrentStickyLines();
                 clearNode(this.domNode);
                 this.updateDisplay();
             }
         }
-        else if (e.stickyScrollMode && this.notebookEditor.notebookOptions.getDisplayOptions().stickyScrollEnabled) {
-            this.updateContent(computeContent(this.notebookEditor, this.notebookCellList, this.notebookOutline.entries, this.getCurrentStickyHeight()));
+        else if (e.stickyScrollMode && this.notebookEditor.notebookOptions.getDisplayOptions().stickyScrollEnabled && this.notebookOutlineReference?.object) {
+            this.updateContent(computeContent(this.notebookEditor, this.notebookCellList, this.notebookOutlineReference?.object?.entries, this.getCurrentStickyHeight()));
         }
     }
     init() {
-        this.notebookOutline.init();
-        this.updateContent(computeContent(this.notebookEditor, this.notebookCellList, this.notebookOutline.entries, this.getCurrentStickyHeight()));
-        this._disposables.add(this.notebookOutline.onDidChange(() => {
-            const recompute = computeContent(this.notebookEditor, this.notebookCellList, this.notebookOutline.entries, this.getCurrentStickyHeight());
+        const { object: notebookOutlineReference } = this.notebookOutlineReference = this.instantiationService.invokeFunction((accessor) => accessor.get(INotebookCellOutlineProviderFactory).getOrCreate(this.notebookEditor, 1 ));
+        this._register(this.notebookOutlineReference);
+        this.updateContent(computeContent(this.notebookEditor, this.notebookCellList, notebookOutlineReference.entries, this.getCurrentStickyHeight()));
+        this._disposables.add(notebookOutlineReference.onDidChange(() => {
+            const recompute = computeContent(this.notebookEditor, this.notebookCellList, notebookOutlineReference.entries, this.getCurrentStickyHeight());
             if (!this.compareStickyLineMaps(recompute, this.currentStickyLines)) {
                 this.updateContent(recompute);
             }
         }));
         this._disposables.add(this.notebookEditor.onDidAttachViewModel(() => {
-            this.notebookOutline.init();
-            this.updateContent(computeContent(this.notebookEditor, this.notebookCellList, this.notebookOutline.entries, this.getCurrentStickyHeight()));
+            this.updateContent(computeContent(this.notebookEditor, this.notebookCellList, notebookOutlineReference.entries, this.getCurrentStickyHeight()));
         }));
         this._disposables.add(this.notebookEditor.onDidScroll(() => {
             const d = ( new Delayer(100));
             d.trigger(() => {
                 d.dispose();
-                const recompute = computeContent(this.notebookEditor, this.notebookCellList, this.notebookOutline.entries, this.getCurrentStickyHeight());
+                const recompute = computeContent(this.notebookEditor, this.notebookCellList, notebookOutlineReference.entries, this.getCurrentStickyHeight());
                 if (!this.compareStickyLineMaps(recompute, this.currentStickyLines)) {
                     this.updateContent(recompute);
                 }
@@ -293,12 +295,13 @@ let NotebookStickyScroll = NotebookStickyScroll_1 = class NotebookStickyScroll e
     dispose() {
         this._disposables.dispose();
         this.disposeCurrentStickyLines();
-        this.notebookOutline.dispose();
+        this.notebookOutlineReference?.dispose();
         super.dispose();
     }
 };
 NotebookStickyScroll = NotebookStickyScroll_1 = ( __decorate([
-    ( __param(4, IContextMenuService))
+    ( __param(3, IContextMenuService)),
+    ( __param(4, IInstantiationService))
 ], NotebookStickyScroll));
 function computeContent(notebookEditor, notebookCellList, notebookOutlineEntries, renderedStickyHeight) {
     const editorScrollTop = notebookEditor.scrollTop - renderedStickyHeight;

package/vscode/src/vs/workbench/contrib/notebook/browser/viewParts/notebookEditorToolbar.js

@@ -229,7 +229,8 @@ let NotebookEditorWorkbenchToolbar = class NotebookEditorWorkbenchToolbar extend
         this._updateStrategy();
         const context = {
             ui: true,
-            notebookEditor: this.notebookEditor
+            notebookEditor: this.notebookEditor,
+            source: 'notebookToolbar'
         };
         const actionProvider = (action, options) => {
             if (action.id === SELECT_KERNEL_ID) {