@codingame/monaco-vscode-api 4.1.0 → 4.1.1

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/debug/notebookCellPausing.js

@@ -1,66 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
-import { RunOnceScheduler } from '../../../../../../base/common/async.js';
-import { Disposable } from '../../../../../../base/common/lifecycle.js';
-import { URI } from '../../../../../../base/common/uri.js';
-import { Registry } from '../../../../../../platform/registry/common/platform.js';
-import { Extensions } from '../../../../../common/contributions.js';
-import { IDebugService } from '../../../../debug/common/debug.js';
-import { CellUri } from '../../../common/notebookCommon.js';
-import { CellExecutionUpdateType } from '../../../common/notebookExecutionService.js';
-import { INotebookExecutionStateService } from '../../../common/notebookExecutionStateService.js';
-let NotebookCellPausing = class NotebookCellPausing extends Disposable {
-    constructor(_debugService, _notebookExecutionStateService) {
-        super();
-        this._debugService = _debugService;
-        this._notebookExecutionStateService = _notebookExecutionStateService;
-        this._pausedCells = ( new Set());
-        this._register(_debugService.getModel().onDidChangeCallStack(() => {
-            this.onDidChangeCallStack(true);
-            this._scheduler.schedule();
-        }));
-        this._scheduler = this._register(( new RunOnceScheduler(() => this.onDidChangeCallStack(false), 2000)));
-    }
-    async onDidChangeCallStack(fallBackOnStaleCallstack) {
-        const newPausedCells = ( new Set());
-        for (const session of this._debugService.getModel().getSessions()) {
-            for (const thread of session.getAllThreads()) {
-                let callStack = thread.getCallStack();
-                if (fallBackOnStaleCallstack && !callStack.length) {
-                    callStack = thread.getStaleCallStack();
-                }
-                callStack.forEach(sf => {
-                    const parsed = CellUri.parse(sf.source.uri);
-                    if (parsed) {
-                        newPausedCells.add(( sf.source.uri.toString()));
-                        this.editIsPaused(sf.source.uri, true);
-                    }
-                });
-            }
-        }
-        for (const uri of this._pausedCells) {
-            if (!( newPausedCells.has(uri))) {
-                this.editIsPaused(( URI.parse(uri)), false);
-                this._pausedCells.delete(uri);
-            }
-        }
-        newPausedCells.forEach(cell => this._pausedCells.add(cell));
-    }
-    editIsPaused(cellUri, isPaused) {
-        const parsed = CellUri.parse(cellUri);
-        if (parsed) {
-            const exeState = this._notebookExecutionStateService.getCellExecution(cellUri);
-            if (exeState && (exeState.isPaused !== isPaused || !exeState.didPause)) {
-                exeState.update([{
-                        editType: CellExecutionUpdateType.ExecutionState,
-                        didPause: true,
-                        isPaused
-                    }]);
-            }
-        }
-    }
-};
-NotebookCellPausing = ( __decorate([
-    ( __param(0, IDebugService)),
-    ( __param(1, INotebookExecutionStateService))
-], NotebookCellPausing));
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(NotebookCellPausing, 3 );

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/debug/notebookDebugDecorations.js

@@ -1,163 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable } from '../../../../../../base/common/lifecycle.js';
-import { Range } from '../../../../../../editor/common/core/range.js';
-import { IConfigurationService } from '../../../../../../platform/configuration/common/configuration.js';
-import { debugIconBreakpointForeground } from '../../../../debug/browser/breakpointEditorContribution.js';
-import { topStackFrameColor, focusedStackFrameColor } from '../../../../debug/browser/callStackEditorContribution.js';
-import { IDebugService } from '../../../../debug/common/debug.js';
-import { NotebookOverviewRulerLane } from '../../notebookBrowser.js';
-import { registerNotebookContribution } from '../../notebookEditorExtensions.js';
-import { runningCellRulerDecorationColor } from '../../notebookEditorWidget.js';
-import { CellUri, NotebookCellExecutionState } from '../../../common/notebookCommon.js';
-import { NotebookExecutionType, INotebookExecutionStateService } from '../../../common/notebookExecutionStateService.js';
-let PausedCellDecorationContribution = class PausedCellDecorationContribution extends Disposable {
-    static { this.id = 'workbench.notebook.debug.pausedCellDecorations'; }
-    constructor(_notebookEditor, _debugService, _notebookExecutionStateService) {
-        super();
-        this._notebookEditor = _notebookEditor;
-        this._debugService = _debugService;
-        this._notebookExecutionStateService = _notebookExecutionStateService;
-        this._currentTopDecorations = [];
-        this._currentOtherDecorations = [];
-        this._executingCellDecorations = [];
-        this._register(_debugService.getModel().onDidChangeCallStack(() => this.updateExecutionDecorations()));
-        this._register(_debugService.getViewModel().onDidFocusStackFrame(() => this.updateExecutionDecorations()));
-        this._register(_notebookExecutionStateService.onDidChangeExecution(e => {
-            if (e.type === NotebookExecutionType.cell && this._notebookEditor.textModel && e.affectsNotebook(this._notebookEditor.textModel.uri)) {
-                this.updateExecutionDecorations();
-            }
-        }));
-    }
-    updateExecutionDecorations() {
-        const exes = this._notebookEditor.textModel ?
-            this._notebookExecutionStateService.getCellExecutionsByHandleForNotebook(this._notebookEditor.textModel.uri)
-            : undefined;
-        const topFrameCellsAndRanges = [];
-        let focusedFrameCellAndRange = undefined;
-        const getNotebookCellAndRange = (sf) => {
-            const parsed = CellUri.parse(sf.source.uri);
-            if (parsed && ( parsed.notebook.toString()) === this._notebookEditor.textModel?.uri.toString()) {
-                return { handle: parsed.handle, range: sf.range };
-            }
-            return undefined;
-        };
-        for (const session of this._debugService.getModel().getSessions()) {
-            for (const thread of session.getAllThreads()) {
-                const topFrame = thread.getTopStackFrame();
-                if (topFrame) {
-                    const notebookCellAndRange = getNotebookCellAndRange(topFrame);
-                    if (notebookCellAndRange) {
-                        topFrameCellsAndRanges.push(notebookCellAndRange);
-                        exes?.delete(notebookCellAndRange.handle);
-                    }
-                }
-            }
-        }
-        const focusedFrame = this._debugService.getViewModel().focusedStackFrame;
-        if (focusedFrame && focusedFrame.thread.stopped) {
-            const thisFocusedFrameCellAndRange = getNotebookCellAndRange(focusedFrame);
-            if (thisFocusedFrameCellAndRange &&
-                !( topFrameCellsAndRanges.some(
-                    topFrame => topFrame.handle === thisFocusedFrameCellAndRange?.handle && Range.equalsRange(topFrame.range, thisFocusedFrameCellAndRange?.range)
-                ))) {
-                focusedFrameCellAndRange = thisFocusedFrameCellAndRange;
-                exes?.delete(focusedFrameCellAndRange.handle);
-            }
-        }
-        this.setTopFrameDecoration(topFrameCellsAndRanges);
-        this.setFocusedFrameDecoration(focusedFrameCellAndRange);
-        const exeHandles = exes ?
-            ( Array.from(exes.entries())
-                .filter(([_, exe]) => exe.state === NotebookCellExecutionState.Executing)
-                .map(([handle]) => handle))
-            : [];
-        this.setExecutingCellDecorations(exeHandles);
-    }
-    setTopFrameDecoration(handlesAndRanges) {
-        const newDecorations = ( handlesAndRanges.map(({ handle, range }) => {
-            const options = {
-                overviewRuler: {
-                    color: topStackFrameColor,
-                    includeOutput: false,
-                    modelRanges: [range],
-                    position: NotebookOverviewRulerLane.Full
-                }
-            };
-            return { handle, options };
-        }));
-        this._currentTopDecorations = this._notebookEditor.deltaCellDecorations(this._currentTopDecorations, newDecorations);
-    }
-    setFocusedFrameDecoration(focusedFrameCellAndRange) {
-        let newDecorations = [];
-        if (focusedFrameCellAndRange) {
-            const options = {
-                overviewRuler: {
-                    color: focusedStackFrameColor,
-                    includeOutput: false,
-                    modelRanges: [focusedFrameCellAndRange.range],
-                    position: NotebookOverviewRulerLane.Full
-                }
-            };
-            newDecorations = [{ handle: focusedFrameCellAndRange.handle, options }];
-        }
-        this._currentOtherDecorations = this._notebookEditor.deltaCellDecorations(this._currentOtherDecorations, newDecorations);
-    }
-    setExecutingCellDecorations(handles) {
-        const newDecorations = ( handles.map(handle => {
-            const options = {
-                overviewRuler: {
-                    color: runningCellRulerDecorationColor,
-                    includeOutput: false,
-                    modelRanges: [( new Range(0, 0, 0, 0))],
-                    position: NotebookOverviewRulerLane.Left
-                }
-            };
-            return { handle, options };
-        }));
-        this._executingCellDecorations = this._notebookEditor.deltaCellDecorations(this._executingCellDecorations, newDecorations);
-    }
-};
-PausedCellDecorationContribution = ( __decorate([
-    ( __param(1, IDebugService)),
-    ( __param(2, INotebookExecutionStateService))
-], PausedCellDecorationContribution));
-registerNotebookContribution(PausedCellDecorationContribution.id, PausedCellDecorationContribution);
-let NotebookBreakpointDecorations = class NotebookBreakpointDecorations extends Disposable {
-    static { this.id = 'workbench.notebook.debug.notebookBreakpointDecorations'; }
-    constructor(_notebookEditor, _debugService, _configService) {
-        super();
-        this._notebookEditor = _notebookEditor;
-        this._debugService = _debugService;
-        this._configService = _configService;
-        this._currentDecorations = [];
-        this._register(_debugService.getModel().onDidChangeBreakpoints(() => this.updateDecorations()));
-        this._register(_configService.onDidChangeConfiguration(e => e.affectsConfiguration('debug.showBreakpointsInOverviewRuler') && this.updateDecorations()));
-    }
-    updateDecorations() {
-        const enabled = this._configService.getValue('debug.showBreakpointsInOverviewRuler');
-        const newDecorations = enabled ?
-            ( this._debugService.getModel().getBreakpoints().map(breakpoint => {
-                const parsed = CellUri.parse(breakpoint.uri);
-                if (!parsed || ( parsed.notebook.toString()) !== ( this._notebookEditor.textModel.uri.toString())) {
-                    return null;
-                }
-                const options = {
-                    overviewRuler: {
-                        color: debugIconBreakpointForeground,
-                        includeOutput: false,
-                        modelRanges: [( new Range(breakpoint.lineNumber, 0, breakpoint.lineNumber, 0))],
-                        position: NotebookOverviewRulerLane.Left
-                    }
-                };
-                return { handle: parsed.handle, options };
-            })).filter(x => !!x)
-            : [];
-        this._currentDecorations = this._notebookEditor.deltaCellDecorations(this._currentDecorations, newDecorations);
-    }
-};
-NotebookBreakpointDecorations = ( __decorate([
-    ( __param(1, IDebugService)),
-    ( __param(2, IConfigurationService))
-], NotebookBreakpointDecorations));
-registerNotebookContribution(NotebookBreakpointDecorations.id, NotebookBreakpointDecorations);
-export { NotebookBreakpointDecorations, PausedCellDecorationContribution };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/editorHint/emptyCellEditorHint.js

@@ -1,65 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
-import { Schemas } from '../../../../../../base/common/network.js';
-import { registerEditorContribution } from '../../../../../../editor/browser/editorExtensions.js';
-import { ICommandService } from '../../../../../../platform/commands/common/commands.js';
-import { IConfigurationService } from '../../../../../../platform/configuration/common/configuration.js';
-import { IKeybindingService } from '../../../../../../platform/keybinding/common/keybinding.js';
-import { IProductService } from '../../../../../../platform/product/common/productService.js';
-import { ITelemetryService } from '../../../../../../platform/telemetry/common/telemetry.js';
-import { EmptyTextEditorHintContribution } from '../../../../codeEditor/browser/emptyTextEditorHint/emptyTextEditorHint.js';
-import { IInlineChatSessionService } from '../../../../inlineChat/browser/inlineChatSessionService.js';
-import { IInlineChatService } from '../../../../inlineChat/common/inlineChat.js';
-import { getNotebookEditorFromEditorPane } from '../../notebookBrowser.js';
-import { IEditorGroupsService } from '../../../../../services/editor/common/editorGroupsService.js';
-import { IEditorService } from '../../../../../services/editor/common/editorService.js';
-let EmptyCellEditorHintContribution = class EmptyCellEditorHintContribution extends EmptyTextEditorHintContribution {
-    static { this.CONTRIB_ID = 'notebook.editor.contrib.emptyCellEditorHint'; }
-    constructor(editor, _editorService, editorGroupsService, commandService, configurationService, keybindingService, inlineChatSessionService, inlineChatService, telemetryService, productService) {
-        super(editor, editorGroupsService, commandService, configurationService, keybindingService, inlineChatSessionService, inlineChatService, telemetryService, productService);
-        this._editorService = _editorService;
-        const activeEditor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
-        if (!activeEditor) {
-            return;
-        }
-        this.toDispose.push(activeEditor.onDidChangeActiveCell(() => this.update()));
-    }
-    _getOptions() {
-        return { clickable: false };
-    }
-    _shouldRenderHint() {
-        const shouldRenderHint = super._shouldRenderHint();
-        if (!shouldRenderHint) {
-            return false;
-        }
-        const model = this.editor.getModel();
-        if (!model) {
-            return false;
-        }
-        const isNotebookCell = model?.uri.scheme === Schemas.vscodeNotebookCell;
-        if (!isNotebookCell) {
-            return false;
-        }
-        const activeEditor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
-        if (!activeEditor) {
-            return false;
-        }
-        const activeCell = activeEditor.getActiveCell();
-        if (activeCell?.uri.fragment !== model.uri.fragment) {
-            return false;
-        }
-        return true;
-    }
-};
-EmptyCellEditorHintContribution = ( __decorate([
-    ( __param(1, IEditorService)),
-    ( __param(2, IEditorGroupsService)),
-    ( __param(3, ICommandService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IKeybindingService)),
-    ( __param(6, IInlineChatSessionService)),
-    ( __param(7, IInlineChatService)),
-    ( __param(8, ITelemetryService)),
-    ( __param(9, IProductService))
-], EmptyCellEditorHintContribution));
-registerEditorContribution(EmptyCellEditorHintContribution.CONTRIB_ID, EmptyCellEditorHintContribution, 0 );
-export { EmptyCellEditorHintContribution };

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

@@ -1,318 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from '../../../../../../nls.js';
-import { Disposable, DisposableStore, MutableDisposable } from '../../../../../../base/common/lifecycle.js';
-import { Schemas } from '../../../../../../base/common/network.js';
-import { ILanguageFeaturesService } from '../../../../../../editor/common/services/languageFeatures.js';
-import { IConfigurationService } from '../../../../../../platform/configuration/common/configuration.js';
-import { IInstantiationService } from '../../../../../../platform/instantiation/common/instantiation.js';
-import { ILogService } from '../../../../../../platform/log/common/log.js';
-import { Registry } from '../../../../../../platform/registry/common/platform.js';
-import { Extensions, registerWorkbenchContribution2 } from '../../../../../common/contributions.js';
-import { CENTER_ACTIVE_CELL } from '../navigation/arrow.js';
-import { SELECT_KERNEL_ID } from '../../controller/coreActions.js';
-import { SELECT_NOTEBOOK_INDENTATION_ID } from '../../controller/editActions.js';
-import { getNotebookEditorFromEditorPane } from '../../notebookBrowser.js';
-import { NotebookCellsChangeType } from '../../../common/notebookCommon.js';
-import { INotebookKernelService } from '../../../common/notebookKernelService.js';
-import { IEditorService } from '../../../../../services/editor/common/editorService.js';
-import { IStatusbarService } from '../../../../../services/statusbar/browser/statusbar.js';
-let ImplictKernelSelector = class ImplictKernelSelector {
-    constructor(notebook, suggested, notebookKernelService, languageFeaturesService, logService) {
-        const disposables = ( new DisposableStore());
-        this.dispose = disposables.dispose.bind(disposables);
-        const selectKernel = () => {
-            disposables.clear();
-            notebookKernelService.selectKernelForNotebook(suggested, notebook);
-        };
-        disposables.add(notebook.onDidChangeContent(e => {
-            for (const event of e.rawEvents) {
-                switch (event.kind) {
-                    case NotebookCellsChangeType.ChangeCellContent:
-                    case NotebookCellsChangeType.ModelChange:
-                    case NotebookCellsChangeType.Move:
-                    case NotebookCellsChangeType.ChangeCellLanguage:
-                        logService.trace('IMPLICIT kernel selection because of change event', event.kind);
-                        selectKernel();
-                        break;
-                }
-            }
-        }));
-        disposables.add(languageFeaturesService.hoverProvider.register({ scheme: Schemas.vscodeNotebookCell, pattern: notebook.uri.path }, {
-            provideHover() {
-                logService.trace('IMPLICIT kernel selection because of hover');
-                selectKernel();
-                return undefined;
-            }
-        }));
-    }
-};
-ImplictKernelSelector = ( __decorate([
-    ( __param(2, INotebookKernelService)),
-    ( __param(3, ILanguageFeaturesService)),
-    ( __param(4, ILogService))
-], ImplictKernelSelector));
-let KernelStatus = class KernelStatus extends Disposable {
-    constructor(_editorService, _statusbarService, _notebookKernelService, _instantiationService) {
-        super();
-        this._editorService = _editorService;
-        this._statusbarService = _statusbarService;
-        this._notebookKernelService = _notebookKernelService;
-        this._instantiationService = _instantiationService;
-        this._editorDisposables = this._register(( new DisposableStore()));
-        this._kernelInfoElement = this._register(( new DisposableStore()));
-        this._register(this._editorService.onDidActiveEditorChange(() => this._updateStatusbar()));
-    }
-    _updateStatusbar() {
-        this._editorDisposables.clear();
-        const activeEditor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
-        if (!activeEditor) {
-            this._kernelInfoElement.clear();
-            return;
-        }
-        const updateStatus = () => {
-            if (activeEditor.notebookOptions.getDisplayOptions().globalToolbar) {
-                this._kernelInfoElement.clear();
-                return;
-            }
-            const notebook = activeEditor.textModel;
-            if (notebook) {
-                this._showKernelStatus(notebook);
-            }
-            else {
-                this._kernelInfoElement.clear();
-            }
-        };
-        this._editorDisposables.add(this._notebookKernelService.onDidAddKernel(updateStatus));
-        this._editorDisposables.add(this._notebookKernelService.onDidChangeSelectedNotebooks(updateStatus));
-        this._editorDisposables.add(this._notebookKernelService.onDidChangeNotebookAffinity(updateStatus));
-        this._editorDisposables.add(activeEditor.onDidChangeModel(updateStatus));
-        this._editorDisposables.add(activeEditor.notebookOptions.onDidChangeOptions(updateStatus));
-        updateStatus();
-    }
-    _showKernelStatus(notebook) {
-        this._kernelInfoElement.clear();
-        const { selected, suggestions, all } = this._notebookKernelService.getMatchingKernel(notebook);
-        const suggested = (suggestions.length === 1 ? suggestions[0] : undefined)
-            ?? (all.length === 1) ? all[0] : undefined;
-        let isSuggested = false;
-        if (all.length === 0) {
-            return;
-        }
-        else if (selected || suggested) {
-            let kernel = selected;
-            if (!kernel) {
-                kernel = suggested;
-                isSuggested = true;
-                this._kernelInfoElement.add(this._instantiationService.createInstance(ImplictKernelSelector, notebook, kernel));
-            }
-            const tooltip = kernel.description ?? kernel.detail ?? kernel.label;
-            this._kernelInfoElement.add(this._statusbarService.addEntry({
-                name: ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/contrib/editorStatusBar/editorStatusBar',
-                    'notebook.info',
-                    "Notebook Kernel Info"
-                )),
-                text: `$(notebook-kernel-select) ${kernel.label}`,
-                ariaLabel: kernel.label,
-                tooltip: isSuggested ? ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/contrib/editorStatusBar/editorStatusBar',
-                    'tooltop',
-                    "{0} (suggestion)",
-                    tooltip
-                )) : tooltip,
-                command: SELECT_KERNEL_ID,
-            }, SELECT_KERNEL_ID, 1 , 10));
-            this._kernelInfoElement.add(kernel.onDidChange(() => this._showKernelStatus(notebook)));
-        }
-        else {
-            this._kernelInfoElement.add(this._statusbarService.addEntry({
-                name: ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/contrib/editorStatusBar/editorStatusBar',
-                    'notebook.select',
-                    "Notebook Kernel Selection"
-                )),
-                text: ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/contrib/editorStatusBar/editorStatusBar',
-                    'kernel.select.label',
-                    "Select Kernel"
-                )),
-                ariaLabel: ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/contrib/editorStatusBar/editorStatusBar',
-                    'kernel.select.label',
-                    "Select Kernel"
-                )),
-                command: SELECT_KERNEL_ID,
-                kind: 'prominent'
-            }, SELECT_KERNEL_ID, 1 , 10));
-        }
-    }
-};
-KernelStatus = ( __decorate([
-    ( __param(0, IEditorService)),
-    ( __param(1, IStatusbarService)),
-    ( __param(2, INotebookKernelService)),
-    ( __param(3, IInstantiationService))
-], KernelStatus));
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(KernelStatus, 3 );
-let ActiveCellStatus = class ActiveCellStatus extends Disposable {
-    constructor(_editorService, _statusbarService) {
-        super();
-        this._editorService = _editorService;
-        this._statusbarService = _statusbarService;
-        this._itemDisposables = this._register(( new DisposableStore()));
-        this._accessor = this._register(( new MutableDisposable()));
-        this._register(this._editorService.onDidActiveEditorChange(() => this._update()));
-    }
-    _update() {
-        this._itemDisposables.clear();
-        const activeEditor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
-        if (activeEditor) {
-            this._itemDisposables.add(activeEditor.onDidChangeSelection(() => this._show(activeEditor)));
-            this._itemDisposables.add(activeEditor.onDidChangeActiveCell(() => this._show(activeEditor)));
-            this._show(activeEditor);
-        }
-        else {
-            this._accessor.clear();
-        }
-    }
-    _show(editor) {
-        if (!editor.hasModel()) {
-            this._accessor.clear();
-            return;
-        }
-        const newText = this._getSelectionsText(editor);
-        if (!newText) {
-            this._accessor.clear();
-            return;
-        }
-        const entry = {
-            name: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/editorStatusBar/editorStatusBar',
-                'notebook.activeCellStatusName',
-                "Notebook Editor Selections"
-            )),
-            text: newText,
-            ariaLabel: newText,
-            command: CENTER_ACTIVE_CELL
-        };
-        if (!this._accessor.value) {
-            this._accessor.value = this._statusbarService.addEntry(entry, 'notebook.activeCellStatus', 1 , 100);
-        }
-        else {
-            this._accessor.value.update(entry);
-        }
-    }
-    _getSelectionsText(editor) {
-        if (!editor.hasModel()) {
-            return undefined;
-        }
-        const activeCell = editor.getActiveCell();
-        if (!activeCell) {
-            return undefined;
-        }
-        const idxFocused = editor.getCellIndex(activeCell) + 1;
-        const numSelected = editor.getSelections().reduce((prev, range) => prev + (range.end - range.start), 0);
-        const totalCells = editor.getLength();
-        return numSelected > 1 ?
-            ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/editorStatusBar/editorStatusBar',
-                'notebook.multiActiveCellIndicator',
-                "Cell {0} ({1} selected)",
-                idxFocused,
-                numSelected
-            )) :
-            ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/editorStatusBar/editorStatusBar',
-                'notebook.singleActiveCellIndicator',
-                "Cell {0} of {1}",
-                idxFocused,
-                totalCells
-            ));
-    }
-};
-ActiveCellStatus = ( __decorate([
-    ( __param(0, IEditorService)),
-    ( __param(1, IStatusbarService))
-], ActiveCellStatus));
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(ActiveCellStatus, 3 );
-let NotebookIndentationStatus = class NotebookIndentationStatus extends Disposable {
-    static { this.ID = 'selectNotebookIndentation'; }
-    constructor(_editorService, _statusbarService, _configurationService) {
-        super();
-        this._editorService = _editorService;
-        this._statusbarService = _statusbarService;
-        this._configurationService = _configurationService;
-        this._itemDisposables = this._register(( new DisposableStore()));
-        this._accessor = this._register(( new MutableDisposable()));
-        this._register(this._editorService.onDidActiveEditorChange(() => this._update()));
-        this._register(this._configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration('editor') || e.affectsConfiguration('notebook')) {
-                this._update();
-            }
-        }));
-    }
-    _update() {
-        this._itemDisposables.clear();
-        const activeEditor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
-        if (activeEditor) {
-            this._show(activeEditor);
-            this._itemDisposables.add(activeEditor.onDidChangeSelection(() => {
-                this._accessor.clear();
-                this._show(activeEditor);
-            }));
-        }
-        else {
-            this._accessor.clear();
-        }
-    }
-    _show(editor) {
-        if (!editor.hasModel()) {
-            this._accessor.clear();
-            return;
-        }
-        const cellOptions = editor.getActiveCell()?.textModel?.getOptions();
-        if (!cellOptions) {
-            this._accessor.clear();
-            return;
-        }
-        const cellEditorOverridesRaw = editor.notebookOptions.getDisplayOptions().editorOptionsCustomizations;
-        const indentSize = cellEditorOverridesRaw['editor.indentSize'] ?? cellOptions?.indentSize;
-        const insertSpaces = cellEditorOverridesRaw['editor.insertSpaces'] ?? cellOptions?.tabSize;
-        const tabSize = cellEditorOverridesRaw['editor.tabSize'] ?? cellOptions?.insertSpaces;
-        const width = typeof indentSize === 'number' ? indentSize : tabSize;
-        const message = insertSpaces ? `Spaces: ${width}` : `Tab Size: ${width}`;
-        const newText = message;
-        if (!newText) {
-            this._accessor.clear();
-            return;
-        }
-        const entry = {
-            name: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/editorStatusBar/editorStatusBar',
-                'notebook.indentation',
-                "Notebook Indentation"
-            )),
-            text: newText,
-            ariaLabel: newText,
-            tooltip: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/editorStatusBar/editorStatusBar',
-                'selectNotebookIndentation',
-                "Select Indentation"
-            )),
-            command: SELECT_NOTEBOOK_INDENTATION_ID
-        };
-        if (!this._accessor.value) {
-            this._accessor.value = this._statusbarService.addEntry(entry, 'notebook.status.indentation', 1 , 100.4);
-        }
-        else {
-            this._accessor.value.update(entry);
-        }
-    }
-};
-NotebookIndentationStatus = ( __decorate([
-    ( __param(0, IEditorService)),
-    ( __param(1, IStatusbarService)),
-    ( __param(2, IConfigurationService))
-], NotebookIndentationStatus));
-registerWorkbenchContribution2(NotebookIndentationStatus.ID, NotebookIndentationStatus, 3 );
-export { ActiveCellStatus, KernelStatus, NotebookIndentationStatus };