@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/contrib/interactive/browser/interactiveCommon.js

@@ -0,0 +1,6 @@
+import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
+const INTERACTIVE_INPUT_CURSOR_BOUNDARY = ( new RawContextKey('interactiveInputCursorAtBoundary', 'none'));
+const InteractiveWindowSetting = {
+    interactiveWindowAlwaysScrollOnNewCell: 'interactiveWindow.alwaysScrollOnNewCell'
+};
+export { INTERACTIVE_INPUT_CURSOR_BOUNDARY, InteractiveWindowSetting };

package/vscode/src/vs/workbench/contrib/interactive/browser/interactiveEditor.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".interactive-editor .input-cell-container:focus-within .input-editor-container .monaco-editor{outline:solid 1px var(--vscode-notebook-focusedCellBorder)}.interactive-editor .input-cell-container .input-editor-container .monaco-editor{outline:solid 1px var(--vscode-notebook-inactiveFocusedCellBorder)}.interactive-editor .input-cell-container .input-focus-indicator{top:8px}.interactive-editor .input-cell-container .margin-view-overlays,.interactive-editor .input-cell-container .monaco-editor-background{background-color:var(--vscode-notebook-cellEditorBackground,var(--vscode-editor-background))}";
+n(css,{});
+export { css, css as default };

package/vscode/src/vs/workbench/contrib/interactive/browser/interactiveEditor.js

@@ -0,0 +1,600 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/interactive.css.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { append, $, createStyleSheet, Dimension } from '../../../../base/browser/dom.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { DisposableStore, MutableDisposable } from '../../../../base/common/lifecycle.js';
+import { ICodeEditorService } from '../../../../editor/browser/services/codeEditorService.js';
+import { CodeEditorWidget } from '../../../../editor/browser/widget/codeEditor/codeEditorWidget.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+import { resolveColorValue } from '../../../../platform/theme/common/colorUtils.js';
+import '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import { editorForeground } from '../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../platform/theme/common/colors/inputColors.js';
+import '../../../../platform/theme/common/colors/listColors.js';
+import '../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { EditorPane } from '../../../browser/parts/editor/editorPane.js';
+import { getSimpleEditorOptions } from '../../codeEditor/browser/simpleEditorOptions.js';
+import { InteractiveEditorInput } from './interactiveEditorInput.js';
+import { NotebookEditorExtensionsRegistry } from '../../notebook/browser/notebookEditorExtensions.js';
+import { INotebookEditorService } from '../../notebook/browser/services/notebookEditorService.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
+import { ExecutionStateCellStatusBarContrib, TimerCellStatusBarContrib } from '../../notebook/browser/contrib/cellStatusBar/executionStatusBarItemController.js';
+import { INotebookKernelService } from '../../notebook/common/notebookKernelService.js';
+import { PLAINTEXT_LANGUAGE_ID } from '../../../../editor/common/languages/modesRegistry.js';
+import { ILanguageService } from '../../../../editor/common/languages/language.js';
+import { MenuId, IMenuService } from '../../../../platform/actions/common/actions.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { INTERACTIVE_INPUT_CURSOR_BOUNDARY, InteractiveWindowSetting } from './interactiveCommon.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { NotebookOptions } from '../../notebook/browser/notebookOptions.js';
+import { ToolBar } from '../../../../base/browser/ui/toolbar/toolbar.js';
+import { IContextMenuService } from '../../../../platform/contextview/browser/contextView.js';
+import { createActionViewItem, createAndFillInActionBarActions } from '../../../../platform/actions/browser/menuEntryActionViewItem.js';
+import { EditorExtensionsRegistry } from '../../../../editor/browser/editorExtensions.js';
+import { ParameterHintsController } from '../../../../editor/contrib/parameterHints/browser/parameterHints.js';
+import { MenuPreventer } from '../../codeEditor/browser/menuPreventer.js';
+import { SelectionClipboardContributionID } from '../../codeEditor/browser/selectionClipboard.js';
+import { ContextMenuController } from '../../../../editor/contrib/contextmenu/browser/contextmenu.js';
+import { SuggestController } from '../../../../editor/contrib/suggest/browser/suggestController.js';
+import { SnippetController2 } from '../../../../editor/contrib/snippet/browser/snippetController2.js';
+import { TabCompletionController } from '../../snippets/browser/tabCompletion.js';
+import { HoverController } from '../../../../editor/contrib/hover/browser/hover.js';
+import { MarkerController } from '../../../../editor/contrib/gotoError/browser/gotoError.js';
+import { ITextResourceConfigurationService } from '../../../../editor/common/services/textResourceConfiguration.js';
+import { NotebookExecutionType, INotebookExecutionStateService } from '../../notebook/common/notebookExecutionStateService.js';
+import { NOTEBOOK_KERNEL } from '../../notebook/common/notebookContextKeys.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+import { isEqual } from '../../../../base/common/resources.js';
+import { NotebookFindContrib } from '../../notebook/browser/contrib/find/notebookFindWidget.js';
+import { INTERACTIVE_WINDOW_EDITOR_ID } from '../../notebook/common/notebookCommon.js';
+import './interactiveEditor.css.js';
+import { deepClone } from '../../../../base/common/objects.js';
+const DECORATION_KEY = 'interactiveInputDecoration';
+const INTERACTIVE_EDITOR_VIEW_STATE_PREFERENCE_KEY = 'InteractiveEditorViewState';
+const INPUT_CELL_VERTICAL_PADDING = 8;
+const INPUT_CELL_HORIZONTAL_PADDING_RIGHT = 10;
+const INPUT_EDITOR_PADDING = 8;
+let InteractiveEditor = class InteractiveEditor extends EditorPane {
+    get onDidFocus() { return this._onDidFocusWidget.event; }
+    constructor(group, telemetryService, themeService, storageService, instantiationService, notebookWidgetService, contextKeyService, codeEditorService, notebookKernelService, languageService, keybindingService, configurationService, menuService, contextMenuService, editorGroupService, textResourceConfigurationService, notebookExecutionStateService, extensionService) {
+        super(INTERACTIVE_WINDOW_EDITOR_ID, group, telemetryService, themeService, storageService);
+        this._notebookWidget = { value: undefined };
+        this._widgetDisposableStore = this._register(( new DisposableStore()));
+        this._groupListener = this._register(( new MutableDisposable()));
+        this._onDidFocusWidget = this._register(( new Emitter()));
+        this._onDidChangeSelection = this._register(( new Emitter()));
+        this.onDidChangeSelection = this._onDidChangeSelection.event;
+        this._onDidChangeScroll = this._register(( new Emitter()));
+        this.onDidChangeScroll = this._onDidChangeScroll.event;
+        this._instantiationService = instantiationService;
+        this._notebookWidgetService = notebookWidgetService;
+        this._contextKeyService = contextKeyService;
+        this._configurationService = configurationService;
+        this._notebookKernelService = notebookKernelService;
+        this._languageService = languageService;
+        this._keybindingService = keybindingService;
+        this._menuService = menuService;
+        this._contextMenuService = contextMenuService;
+        this._editorGroupService = editorGroupService;
+        this._notebookExecutionStateService = notebookExecutionStateService;
+        this._extensionService = extensionService;
+        this._editorOptions = this._computeEditorOptions();
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('editor') || e.affectsConfiguration('notebook')) {
+                this._editorOptions = this._computeEditorOptions();
+            }
+        }));
+        this._notebookOptions = ( new NotebookOptions(
+            this.window,
+            configurationService,
+            notebookExecutionStateService,
+            codeEditorService,
+            true,
+            { cellToolbarInteraction: 'hover', globalToolbar: true, stickyScrollEnabled: false, dragAndDropEnabled: false }
+        ));
+        this._editorMemento = this.getEditorMemento(editorGroupService, textResourceConfigurationService, INTERACTIVE_EDITOR_VIEW_STATE_PREFERENCE_KEY);
+        codeEditorService.registerDecorationType('interactive-decoration', DECORATION_KEY, {});
+        this._register(this._keybindingService.onDidUpdateKeybindings(this._updateInputDecoration, this));
+        this._register(this._notebookExecutionStateService.onDidChangeExecution((e) => {
+            if (e.type === NotebookExecutionType.cell && isEqual(e.notebook, this._notebookWidget.value?.viewModel?.notebookDocument.uri)) {
+                const cell = this._notebookWidget.value?.getCellByHandle(e.cellHandle);
+                if (cell && e.changed?.state) {
+                    this._scrollIfNecessary(cell);
+                }
+            }
+        }));
+    }
+    get inputCellContainerHeight() {
+        return 19 + 2 + INPUT_CELL_VERTICAL_PADDING * 2 + INPUT_EDITOR_PADDING * 2;
+    }
+    get inputCellEditorHeight() {
+        return 19 + INPUT_EDITOR_PADDING * 2;
+    }
+    createEditor(parent) {
+        this._rootElement = append(parent, $('.interactive-editor'));
+        this._rootElement.style.position = 'relative';
+        this._notebookEditorContainer = append(this._rootElement, $('.notebook-editor-container'));
+        this._inputCellContainer = append(this._rootElement, $('.input-cell-container'));
+        this._inputCellContainer.style.position = 'absolute';
+        this._inputCellContainer.style.height = `${this.inputCellContainerHeight}px`;
+        this._inputFocusIndicator = append(this._inputCellContainer, $('.input-focus-indicator'));
+        this._inputRunButtonContainer = append(this._inputCellContainer, $('.run-button-container'));
+        this._setupRunButtonToolbar(this._inputRunButtonContainer);
+        this._inputEditorContainer = append(this._inputCellContainer, $('.input-editor-container'));
+        this._createLayoutStyles();
+    }
+    _setupRunButtonToolbar(runButtonContainer) {
+        const menu = this._register(this._menuService.createMenu(MenuId.InteractiveInputExecute, this._contextKeyService));
+        this._runbuttonToolbar = this._register(( new ToolBar(runButtonContainer, this._contextMenuService, {
+            getKeyBinding: action => this._keybindingService.lookupKeybinding(action.id),
+            actionViewItemProvider: (action, options) => {
+                return createActionViewItem(this._instantiationService, action, options);
+            },
+            renderDropdownAsChildElement: true
+        })));
+        const primary = [];
+        const secondary = [];
+        const result = { primary, secondary };
+        createAndFillInActionBarActions(menu, { shouldForwardArgs: true }, result);
+        this._runbuttonToolbar.setActions([...primary, ...secondary]);
+    }
+    _createLayoutStyles() {
+        this._styleElement = createStyleSheet(this._rootElement);
+        const styleSheets = [];
+        const { codeCellLeftMargin, cellRunGutter } = this._notebookOptions.getLayoutConfiguration();
+        const { focusIndicator } = this._notebookOptions.getDisplayOptions();
+        const leftMargin = this._notebookOptions.getCellEditorContainerLeftMargin();
+        styleSheets.push(`
+			.interactive-editor .input-cell-container {
+				padding: ${INPUT_CELL_VERTICAL_PADDING}px ${INPUT_CELL_HORIZONTAL_PADDING_RIGHT}px ${INPUT_CELL_VERTICAL_PADDING}px ${leftMargin}px;
+			}
+		`);
+        if (focusIndicator === 'gutter') {
+            styleSheets.push(`
+				.interactive-editor .input-cell-container:focus-within .input-focus-indicator::before {
+					border-color: var(--vscode-notebook-focusedCellBorder) !important;
+				}
+				.interactive-editor .input-focus-indicator::before {
+					border-color: var(--vscode-notebook-inactiveFocusedCellBorder) !important;
+				}
+				.interactive-editor .input-cell-container .input-focus-indicator {
+					display: block;
+					top: ${INPUT_CELL_VERTICAL_PADDING}px;
+				}
+				.interactive-editor .input-cell-container {
+					border-top: 1px solid var(--vscode-notebook-inactiveFocusedCellBorder);
+				}
+			`);
+        }
+        else {
+            styleSheets.push(`
+				.interactive-editor .input-cell-container {
+					border-top: 1px solid var(--vscode-notebook-inactiveFocusedCellBorder);
+				}
+				.interactive-editor .input-cell-container .input-focus-indicator {
+					display: none;
+				}
+			`);
+        }
+        styleSheets.push(`
+			.interactive-editor .input-cell-container .run-button-container {
+				width: ${cellRunGutter}px;
+				left: ${codeCellLeftMargin}px;
+				margin-top: ${INPUT_EDITOR_PADDING - 2}px;
+			}
+		`);
+        this._styleElement.textContent = styleSheets.join('\n');
+    }
+    _computeEditorOptions() {
+        let overrideIdentifier = undefined;
+        if (this._codeEditorWidget) {
+            overrideIdentifier = this._codeEditorWidget.getModel()?.getLanguageId();
+        }
+        const editorOptions = deepClone(this._configurationService.getValue('editor', { overrideIdentifier }));
+        const editorOptionsOverride = getSimpleEditorOptions(this._configurationService);
+        const computed = ( Object.freeze({
+            ...editorOptions,
+            ...editorOptionsOverride,
+            ...{
+                glyphMargin: true,
+                padding: {
+                    top: INPUT_EDITOR_PADDING,
+                    bottom: INPUT_EDITOR_PADDING
+                },
+                hover: {
+                    enabled: true
+                }
+            }
+        }));
+        return computed;
+    }
+    saveState() {
+        this._saveEditorViewState(this.input);
+        super.saveState();
+    }
+    getViewState() {
+        const input = this.input;
+        if (!(input instanceof InteractiveEditorInput)) {
+            return undefined;
+        }
+        this._saveEditorViewState(input);
+        return this._loadNotebookEditorViewState(input);
+    }
+    _saveEditorViewState(input) {
+        if (this._notebookWidget.value && input instanceof InteractiveEditorInput) {
+            if (this._notebookWidget.value.isDisposed) {
+                return;
+            }
+            const state = this._notebookWidget.value.getEditorViewState();
+            const editorState = this._codeEditorWidget.saveViewState();
+            this._editorMemento.saveEditorState(this.group, input.notebookEditorInput.resource, {
+                notebook: state,
+                input: editorState
+            });
+        }
+    }
+    _loadNotebookEditorViewState(input) {
+        const result = this._editorMemento.loadEditorState(this.group, input.notebookEditorInput.resource);
+        if (result) {
+            return result;
+        }
+        for (const group of this._editorGroupService.getGroups(1 )) {
+            if (group.activeEditorPane !== this && group.activeEditorPane === this && group.activeEditor?.matches(input)) {
+                const notebook = this._notebookWidget.value?.getEditorViewState();
+                const input = this._codeEditorWidget.saveViewState();
+                return {
+                    notebook,
+                    input
+                };
+            }
+        }
+        return;
+    }
+    async setInput(input, options, context, token) {
+        const notebookInput = input.notebookEditorInput;
+        this._notebookWidget.value?.onWillHide();
+        this._codeEditorWidget?.dispose();
+        this._widgetDisposableStore.clear();
+        this._notebookWidget = this._instantiationService.invokeFunction(this._notebookWidgetService.retrieveWidget, this.group, notebookInput, {
+            isEmbedded: true,
+            isReadOnly: true,
+            contributions: NotebookEditorExtensionsRegistry.getSomeEditorContributions([
+                ExecutionStateCellStatusBarContrib.id,
+                TimerCellStatusBarContrib.id,
+                NotebookFindContrib.id
+            ]),
+            menuIds: {
+                notebookToolbar: MenuId.InteractiveToolbar,
+                cellTitleToolbar: MenuId.InteractiveCellTitle,
+                cellDeleteToolbar: MenuId.InteractiveCellDelete,
+                cellInsertToolbar: MenuId.NotebookCellBetween,
+                cellTopInsertToolbar: MenuId.NotebookCellListTop,
+                cellExecuteToolbar: MenuId.InteractiveCellExecute,
+                cellExecutePrimary: undefined
+            },
+            cellEditorContributions: EditorExtensionsRegistry.getSomeEditorContributions([
+                SelectionClipboardContributionID,
+                ContextMenuController.ID,
+                HoverController.ID,
+                MarkerController.ID
+            ]),
+            options: this._notebookOptions,
+            codeWindow: this.window
+        }, undefined, this.window);
+        this._codeEditorWidget = this._instantiationService.createInstance(CodeEditorWidget, this._inputEditorContainer, this._editorOptions, {
+            ...{
+                isSimpleWidget: false,
+                contributions: EditorExtensionsRegistry.getSomeEditorContributions([
+                    MenuPreventer.ID,
+                    SelectionClipboardContributionID,
+                    ContextMenuController.ID,
+                    SuggestController.ID,
+                    ParameterHintsController.ID,
+                    SnippetController2.ID,
+                    TabCompletionController.ID,
+                    HoverController.ID,
+                    MarkerController.ID
+                ])
+            }
+        });
+        if (this._lastLayoutDimensions) {
+            this._notebookEditorContainer.style.height = `${this._lastLayoutDimensions.dimension.height - this.inputCellContainerHeight}px`;
+            this._notebookWidget.value.layout(new Dimension(this._lastLayoutDimensions.dimension.width, this._lastLayoutDimensions.dimension.height - this.inputCellContainerHeight), this._notebookEditorContainer);
+            const leftMargin = this._notebookOptions.getCellEditorContainerLeftMargin();
+            const maxHeight = Math.min(this._lastLayoutDimensions.dimension.height / 2, this.inputCellEditorHeight);
+            this._codeEditorWidget.layout(this._validateDimension(this._lastLayoutDimensions.dimension.width - leftMargin - INPUT_CELL_HORIZONTAL_PADDING_RIGHT, maxHeight));
+            this._inputFocusIndicator.style.height = `${this.inputCellEditorHeight}px`;
+            this._inputCellContainer.style.top = `${this._lastLayoutDimensions.dimension.height - this.inputCellContainerHeight}px`;
+            this._inputCellContainer.style.width = `${this._lastLayoutDimensions.dimension.width}px`;
+        }
+        await super.setInput(input, options, context, token);
+        const model = await input.resolve();
+        if (this._runbuttonToolbar) {
+            this._runbuttonToolbar.context = input.resource;
+        }
+        if (model === null) {
+            throw new Error('The Interactive Window model could not be resolved');
+        }
+        this._notebookWidget.value?.setParentContextKeyService(this._contextKeyService);
+        const viewState = options?.viewState ?? this._loadNotebookEditorViewState(input);
+        await this._extensionService.whenInstalledExtensionsRegistered();
+        await this._notebookWidget.value.setModel(model.notebook, viewState?.notebook);
+        model.notebook.setCellCollapseDefault(this._notebookOptions.getCellCollapseDefault());
+        this._notebookWidget.value.setOptions({
+            isReadOnly: true
+        });
+        this._widgetDisposableStore.add(this._notebookWidget.value.onDidResizeOutput((cvm) => {
+            this._scrollIfNecessary(cvm);
+        }));
+        this._widgetDisposableStore.add(this._notebookWidget.value.onDidFocusWidget(() => this._onDidFocusWidget.fire()));
+        this._widgetDisposableStore.add(this._notebookOptions.onDidChangeOptions(e => {
+            if (e.compactView || e.focusIndicator) {
+                this._styleElement?.remove();
+                this._createLayoutStyles();
+            }
+            if (this._lastLayoutDimensions && this.isVisible()) {
+                this.layout(this._lastLayoutDimensions.dimension, this._lastLayoutDimensions.position);
+            }
+            if (e.interactiveWindowCollapseCodeCells) {
+                model.notebook.setCellCollapseDefault(this._notebookOptions.getCellCollapseDefault());
+            }
+        }));
+        const languageId = this._notebookWidget.value?.activeKernel?.supportedLanguages[0] ?? input.language ?? PLAINTEXT_LANGUAGE_ID;
+        const editorModel = await input.resolveInput(languageId);
+        editorModel.setLanguage(languageId);
+        this._codeEditorWidget.setModel(editorModel);
+        if (viewState?.input) {
+            this._codeEditorWidget.restoreViewState(viewState.input);
+        }
+        this._editorOptions = this._computeEditorOptions();
+        this._codeEditorWidget.updateOptions(this._editorOptions);
+        this._widgetDisposableStore.add(this._codeEditorWidget.onDidFocusEditorWidget(() => this._onDidFocusWidget.fire()));
+        this._widgetDisposableStore.add(this._codeEditorWidget.onDidContentSizeChange(e => {
+            if (!e.contentHeightChanged) {
+                return;
+            }
+            if (this._lastLayoutDimensions) {
+                this._layoutWidgets(this._lastLayoutDimensions.dimension, this._lastLayoutDimensions.position);
+            }
+        }));
+        this._widgetDisposableStore.add(this._codeEditorWidget.onDidChangeCursorPosition(e => this._onDidChangeSelection.fire({ reason: this._toEditorPaneSelectionChangeReason(e) })));
+        this._widgetDisposableStore.add(this._codeEditorWidget.onDidChangeModelContent(() => this._onDidChangeSelection.fire({ reason: 3  })));
+        this._widgetDisposableStore.add(this._notebookKernelService.onDidChangeNotebookAffinity(this._syncWithKernel, this));
+        this._widgetDisposableStore.add(this._notebookKernelService.onDidChangeSelectedNotebooks(this._syncWithKernel, this));
+        this._widgetDisposableStore.add(this.themeService.onDidColorThemeChange(() => {
+            if (this.isVisible()) {
+                this._updateInputDecoration();
+            }
+        }));
+        this._widgetDisposableStore.add(this._codeEditorWidget.onDidChangeModelContent(() => {
+            if (this.isVisible()) {
+                this._updateInputDecoration();
+            }
+        }));
+        const cursorAtBoundaryContext = INTERACTIVE_INPUT_CURSOR_BOUNDARY.bindTo(this._contextKeyService);
+        if (input.resource && ( input.historyService.has(input.resource))) {
+            cursorAtBoundaryContext.set('top');
+        }
+        else {
+            cursorAtBoundaryContext.set('none');
+        }
+        this._widgetDisposableStore.add(this._codeEditorWidget.onDidChangeCursorPosition(({ position }) => {
+            const viewModel = this._codeEditorWidget._getViewModel();
+            const lastLineNumber = viewModel.getLineCount();
+            const lastLineCol = viewModel.getLineLength(lastLineNumber) + 1;
+            const viewPosition = viewModel.coordinatesConverter.convertModelPositionToViewPosition(position);
+            const firstLine = viewPosition.lineNumber === 1 && viewPosition.column === 1;
+            const lastLine = viewPosition.lineNumber === lastLineNumber && viewPosition.column === lastLineCol;
+            if (firstLine) {
+                if (lastLine) {
+                    cursorAtBoundaryContext.set('both');
+                }
+                else {
+                    cursorAtBoundaryContext.set('top');
+                }
+            }
+            else {
+                if (lastLine) {
+                    cursorAtBoundaryContext.set('bottom');
+                }
+                else {
+                    cursorAtBoundaryContext.set('none');
+                }
+            }
+        }));
+        this._widgetDisposableStore.add(editorModel.onDidChangeContent(() => {
+            const value = editorModel.getValue();
+            if (this.input?.resource && value !== '') {
+                this.input.historyService.replaceLast(this.input.resource, value);
+            }
+        }));
+        this._widgetDisposableStore.add(this._notebookWidget.value.onDidScroll(() => this._onDidChangeScroll.fire()));
+        this._syncWithKernel();
+    }
+    setOptions(options) {
+        this._notebookWidget.value?.setOptions(options);
+        super.setOptions(options);
+    }
+    _toEditorPaneSelectionChangeReason(e) {
+        switch (e.source) {
+            case "api" : return 1 ;
+            case "code.navigation" : return 4 ;
+            case "code.jump" : return 5 ;
+            default: return 2 ;
+        }
+    }
+    _cellAtBottom(cell) {
+        const visibleRanges = this._notebookWidget.value?.visibleRanges || [];
+        const cellIndex = this._notebookWidget.value?.getCellIndex(cell);
+        if (cellIndex === Math.max(...( visibleRanges.map(range => range.end - 1)))) {
+            return true;
+        }
+        return false;
+    }
+    _scrollIfNecessary(cvm) {
+        const index = this._notebookWidget.value.getCellIndex(cvm);
+        if (index === this._notebookWidget.value.getLength() - 1) {
+            if (this._configurationService.getValue(InteractiveWindowSetting.interactiveWindowAlwaysScrollOnNewCell) || this._cellAtBottom(cvm)) {
+                this._notebookWidget.value.scrollToBottom();
+            }
+        }
+    }
+    _syncWithKernel() {
+        const notebook = this._notebookWidget.value?.textModel;
+        const textModel = this._codeEditorWidget.getModel();
+        if (notebook && textModel) {
+            const info = this._notebookKernelService.getMatchingKernel(notebook);
+            const selectedOrSuggested = info.selected
+                ?? (info.suggestions.length === 1 ? info.suggestions[0] : undefined)
+                ?? (info.all.length === 1 ? info.all[0] : undefined);
+            if (selectedOrSuggested) {
+                const language = selectedOrSuggested.supportedLanguages[0];
+                if (language && language !== 'plaintext') {
+                    const newMode = this._languageService.createById(language).languageId;
+                    textModel.setLanguage(newMode);
+                }
+                NOTEBOOK_KERNEL.bindTo(this._contextKeyService).set(selectedOrSuggested.id);
+            }
+        }
+        this._updateInputDecoration();
+    }
+    layout(dimension, position) {
+        this._rootElement.classList.toggle('mid-width', dimension.width < 1000 && dimension.width >= 600);
+        this._rootElement.classList.toggle('narrow-width', dimension.width < 600);
+        const editorHeightChanged = dimension.height !== this._lastLayoutDimensions?.dimension.height;
+        this._lastLayoutDimensions = { dimension, position };
+        if (!this._notebookWidget.value) {
+            return;
+        }
+        if (editorHeightChanged && this._codeEditorWidget) {
+            SuggestController.get(this._codeEditorWidget)?.cancelSuggestWidget();
+        }
+        this._notebookEditorContainer.style.height = `${this._lastLayoutDimensions.dimension.height - this.inputCellContainerHeight}px`;
+        this._layoutWidgets(dimension, position);
+    }
+    _layoutWidgets(dimension, position) {
+        const contentHeight = this._codeEditorWidget.hasModel() ? this._codeEditorWidget.getContentHeight() : this.inputCellEditorHeight;
+        const maxHeight = Math.min(dimension.height / 2, contentHeight);
+        const leftMargin = this._notebookOptions.getCellEditorContainerLeftMargin();
+        const inputCellContainerHeight = maxHeight + INPUT_CELL_VERTICAL_PADDING * 2;
+        this._notebookEditorContainer.style.height = `${dimension.height - inputCellContainerHeight}px`;
+        this._notebookWidget.value.layout(dimension.with(dimension.width, dimension.height - inputCellContainerHeight), this._notebookEditorContainer, position);
+        this._codeEditorWidget.layout(this._validateDimension(dimension.width - leftMargin - INPUT_CELL_HORIZONTAL_PADDING_RIGHT, maxHeight));
+        this._inputFocusIndicator.style.height = `${contentHeight}px`;
+        this._inputCellContainer.style.top = `${dimension.height - inputCellContainerHeight}px`;
+        this._inputCellContainer.style.width = `${dimension.width}px`;
+    }
+    _validateDimension(width, height) {
+        return new Dimension(Math.max(0, width), Math.max(0, height));
+    }
+    _updateInputDecoration() {
+        if (!this._codeEditorWidget) {
+            return;
+        }
+        if (!this._codeEditorWidget.hasModel()) {
+            return;
+        }
+        const model = this._codeEditorWidget.getModel();
+        const decorations = [];
+        if (model?.getValueLength() === 0) {
+            const transparentForeground = resolveColorValue(editorForeground, this.themeService.getColorTheme())?.transparent(0.4);
+            const languageId = model.getLanguageId();
+            const keybinding = this._keybindingService.lookupKeybinding('interactive.execute', this._contextKeyService)?.getLabel();
+            const text = ( localizeWithPath(
+                'vs/workbench/contrib/interactive/browser/interactiveEditor',
+                'interactiveInputPlaceHolder',
+                "Type '{0}' code here and press {1} to run",
+                languageId,
+                keybinding ?? 'ctrl+enter'
+            ));
+            decorations.push({
+                range: {
+                    startLineNumber: 0,
+                    endLineNumber: 0,
+                    startColumn: 0,
+                    endColumn: 1
+                },
+                renderOptions: {
+                    after: {
+                        contentText: text,
+                        color: transparentForeground ? ( transparentForeground.toString()) : undefined
+                    }
+                }
+            });
+        }
+        this._codeEditorWidget.setDecorationsByType('interactive-decoration', DECORATION_KEY, decorations);
+    }
+    getScrollPosition() {
+        return {
+            scrollTop: this._notebookWidget.value?.scrollTop ?? 0,
+            scrollLeft: 0
+        };
+    }
+    setScrollPosition(position) {
+        this._notebookWidget.value?.setScrollTop(position.scrollTop);
+    }
+    focus() {
+        super.focus();
+        this._notebookWidget.value?.onShow();
+        this._codeEditorWidget.focus();
+    }
+    focusHistory() {
+        this._notebookWidget.value.focus();
+    }
+    setEditorVisible(visible) {
+        super.setEditorVisible(visible);
+        this._groupListener.value = this.group.onWillCloseEditor(e => this._saveEditorViewState(e.editor));
+        if (!visible) {
+            this._saveEditorViewState(this.input);
+            if (this.input && this._notebookWidget.value) {
+                this._notebookWidget.value.onWillHide();
+            }
+        }
+    }
+    clearInput() {
+        if (this._notebookWidget.value) {
+            this._saveEditorViewState(this.input);
+            this._notebookWidget.value.onWillHide();
+        }
+        this._codeEditorWidget?.dispose();
+        this._notebookWidget = { value: undefined };
+        this._widgetDisposableStore.clear();
+        super.clearInput();
+    }
+    getControl() {
+        return {
+            notebookEditor: this._notebookWidget.value,
+            codeEditor: this._codeEditorWidget
+        };
+    }
+};
+InteractiveEditor = ( __decorate([
+    ( __param(1, ITelemetryService)),
+    ( __param(2, IThemeService)),
+    ( __param(3, IStorageService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, INotebookEditorService)),
+    ( __param(6, IContextKeyService)),
+    ( __param(7, ICodeEditorService)),
+    ( __param(8, INotebookKernelService)),
+    ( __param(9, ILanguageService)),
+    ( __param(10, IKeybindingService)),
+    ( __param(11, IConfigurationService)),
+    ( __param(12, IMenuService)),
+    ( __param(13, IContextMenuService)),
+    ( __param(14, IEditorGroupsService)),
+    ( __param(15, ITextResourceConfigurationService)),
+    ( __param(16, INotebookExecutionStateService)),
+    ( __param(17, IExtensionService))
+], InteractiveEditor));
+export { InteractiveEditor };

package/vscode/src/vs/workbench/contrib/interactive/browser/media/interactive.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".interactive-editor .input-cell-container{box-sizing:border-box}.interactive-editor .input-cell-container .input-focus-indicator{height:19px;left:0;position:absolute}.interactive-editor .input-cell-container .input-focus-indicator:before{border-left:3px solid transparent;border-radius:2px;content:\"\";height:100%;left:0;margin-left:4px;position:absolute;top:0;width:0;z-index:10}.interactive-editor .input-cell-container .run-button-container{position:absolute}.interactive-editor .input-cell-container .run-button-container .monaco-toolbar .actions-container{justify-content:center}";
+n(css,{});
+export { css, css as default };

package/vscode/src/vs/workbench/contrib/issue/browser/issue.contribution.js

@@ -0,0 +1,27 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { CommandsRegistry } from '../../../../platform/commands/common/commands.js';
+import { IProductService } from '../../../../platform/product/common/productService.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { Extensions } from '../../../common/contributions.js';
+import '../../../services/issue/browser/issueService.js';
+import '../../../../platform/instantiation/common/instantiation.js';
+import { BaseIssueContribution } from '../common/issue.contribution.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+let WebIssueContribution = class WebIssueContribution extends BaseIssueContribution {
+    constructor(productService, configurationService) {
+        super(productService, configurationService);
+    }
+};
+WebIssueContribution = ( __decorate([
+    ( __param(0, IProductService)),
+    ( __param(1, IConfigurationService))
+], WebIssueContribution));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(WebIssueContribution, 3 );
+CommandsRegistry.registerCommand('_issues.getSystemStatus', (accessor) => {
+    return ( localizeWithPath(
+        'vs/workbench/contrib/issue/browser/issue.contribution',
+        'statusUnsupported',
+        "The --status argument is not yet supported in browsers."
+    ));
+});