@codingame/monaco-vscode-notebook-service-override 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline.js

@@ -1,656 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { clearNode, WindowIdleValue } from 'vscode/vscode/vs/base/browser/dom';
-import { ToolBar } from 'vscode/vscode/vs/base/browser/ui/toolbar/toolbar';
-import { IconLabel } from 'vscode/vscode/vs/base/browser/ui/iconLabel/iconLabel';
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import { createMatches } from 'vscode/vscode/vs/base/common/filters';
-import { DisposableStore, Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
-import { getIconClassesForLanguageId } from 'vscode/vscode/vs/editor/common/services/getIconClasses';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { Extensions as Extensions$1 } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { MarkerSeverity } from 'vscode/vscode/vs/platform/markers/common/markers';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import 'vscode/vscode/vs/platform/theme/common/colorUtils';
-import 'vscode/vscode/vs/platform/theme/common/colors/baseColors';
-import 'vscode/vscode/vs/platform/theme/common/colors/chartsColors';
-import 'vscode/vscode/vs/platform/theme/common/colors/editorColors';
-import 'vscode/vscode/vs/platform/theme/common/colors/inputColors';
-import { listErrorForeground, listWarningForeground } from 'vscode/vscode/vs/platform/theme/common/colors/listColors';
-import 'vscode/vscode/vs/platform/theme/common/colors/menuColors';
-import 'vscode/vscode/vs/platform/theme/common/colors/minimapColors';
-import 'vscode/vscode/vs/platform/theme/common/colors/miscColors';
-import 'vscode/vscode/vs/platform/theme/common/colors/quickpickColors';
-import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
-import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
-import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
-import { NotebookEditor } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditor';
-import { NotebookCellOutlineProvider } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/viewModel/notebookOutlineProvider';
-import { NotebookSetting, CellKind } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { SIDE_GROUP, IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { IOutlineService } from 'vscode/vscode/vs/workbench/services/outline/browser/outline';
-import { Range } from 'vscode/vscode/vs/editor/common/core/range';
-import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
-import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView';
-import { MenuRegistry, MenuId, registerAction2, Action2, MenuItemAction, IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { RawContextKey, ContextKeyExpr, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { MenuEntryActionViewItem, createAndFillInActionBarActions } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
-import { disposableTimeout } from 'vscode/vscode/vs/base/common/async';
-import { IOutlinePane } from 'vscode/vscode/vs/workbench/contrib/outline/browser/outline';
-import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
-import { NOTEBOOK_IS_ACTIVE_EDITOR } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
-
-var NotebookCellOutline_1;
-class NotebookOutlineTemplate {
-    static { this.templateId = 'NotebookOutlineRenderer'; }
-    constructor(container, iconClass, iconLabel, decoration, actionMenu, elementDisposables) {
-        this.container = container;
-        this.iconClass = iconClass;
-        this.iconLabel = iconLabel;
-        this.decoration = decoration;
-        this.actionMenu = actionMenu;
-        this.elementDisposables = elementDisposables;
-    }
-}
-let NotebookOutlineRenderer = class NotebookOutlineRenderer {
-    constructor(_editor, _target, _themeService, _configurationService, _contextMenuService, _contextKeyService, _menuService, _instantiationService) {
-        this._editor = _editor;
-        this._target = _target;
-        this._themeService = _themeService;
-        this._configurationService = _configurationService;
-        this._contextMenuService = _contextMenuService;
-        this._contextKeyService = _contextKeyService;
-        this._menuService = _menuService;
-        this._instantiationService = _instantiationService;
-        this.templateId = NotebookOutlineTemplate.templateId;
-    }
-    renderTemplate(container) {
-        const elementDisposables = ( new DisposableStore());
-        container.classList.add('notebook-outline-element', 'show-file-icons');
-        const iconClass = document.createElement('div');
-        container.append(iconClass);
-        const iconLabel = ( new IconLabel(container, { supportHighlights: true }));
-        const decoration = document.createElement('div');
-        decoration.className = 'element-decoration';
-        container.append(decoration);
-        const actionMenu = document.createElement('div');
-        actionMenu.className = 'action-menu';
-        container.append(actionMenu);
-        return ( new NotebookOutlineTemplate(
-            container,
-            iconClass,
-            iconLabel,
-            decoration,
-            actionMenu,
-            elementDisposables
-        ));
-    }
-    renderElement(node, _index, template, _height) {
-        const extraClasses = [];
-        const options = {
-            matches: createMatches(node.filterData),
-            labelEscapeNewLines: true,
-            extraClasses,
-        };
-        const isCodeCell = node.element.cell.cellKind === CellKind.Code;
-        if (node.element.level >= 8) {
-            template.iconClass.className = 'element-icon ' + ThemeIcon.asClassNameArray(node.element.icon).join(' ');
-        }
-        else if (isCodeCell && this._themeService.getFileIconTheme().hasFileIcons && !node.element.isExecuting) {
-            template.iconClass.className = '';
-            extraClasses.push(...getIconClassesForLanguageId(node.element.cell.language ?? ''));
-        }
-        else {
-            template.iconClass.className = 'element-icon ' + ThemeIcon.asClassNameArray(node.element.icon).join(' ');
-        }
-        template.iconLabel.setLabel(' ' + node.element.label, undefined, options);
-        const { markerInfo } = node.element;
-        template.container.style.removeProperty('--outline-element-color');
-        template.decoration.innerText = '';
-        if (markerInfo) {
-            const problem = this._configurationService.getValue('problems.visibility');
-            const useBadges = this._configurationService.getValue("outline.problems.badges" );
-            if (!useBadges || !problem) {
-                template.decoration.classList.remove('bubble');
-                template.decoration.innerText = '';
-            }
-            else if (markerInfo.count === 0) {
-                template.decoration.classList.add('bubble');
-                template.decoration.innerText = '\uea71';
-            }
-            else {
-                template.decoration.classList.remove('bubble');
-                template.decoration.innerText = markerInfo.count > 9 ? '9+' : String(markerInfo.count);
-            }
-            const color = this._themeService.getColorTheme().getColor(markerInfo.topSev === MarkerSeverity.Error ? listErrorForeground : listWarningForeground);
-            if (problem === undefined) {
-                return;
-            }
-            const useColors = this._configurationService.getValue("outline.problems.colors" );
-            if (!useColors || !problem) {
-                template.container.style.removeProperty('--outline-element-color');
-                template.decoration.style.setProperty('--outline-element-color', color?.toString() ?? 'inherit');
-            }
-            else {
-                template.container.style.setProperty('--outline-element-color', color?.toString() ?? 'inherit');
-            }
-        }
-        if (this._target === 1 ) {
-            const nbCell = node.element.cell;
-            const nbViewModel = this._editor?.getViewModel();
-            if (!nbViewModel) {
-                return;
-            }
-            const idx = nbViewModel.getCellIndex(nbCell);
-            const length = isCodeCell ? 0 : nbViewModel.getFoldedLength(idx);
-            const scopedContextKeyService = template.elementDisposables.add(this._contextKeyService.createScoped(template.container));
-            NotebookOutlineContext.CellKind.bindTo(scopedContextKeyService).set(isCodeCell ? CellKind.Code : CellKind.Markup);
-            NotebookOutlineContext.CellHasChildren.bindTo(scopedContextKeyService).set(length > 0);
-            NotebookOutlineContext.CellHasHeader.bindTo(scopedContextKeyService).set(node.element.level !== 7);
-            NotebookOutlineContext.OutlineElementTarget.bindTo(scopedContextKeyService).set(this._target);
-            this.setupFolding(isCodeCell, nbViewModel, scopedContextKeyService, template, nbCell);
-            const outlineEntryToolbar = template.elementDisposables.add(( new ToolBar(template.actionMenu, this._contextMenuService, {
-                actionViewItemProvider: action => {
-                    if (action instanceof MenuItemAction) {
-                        return this._instantiationService.createInstance(MenuEntryActionViewItem, action, undefined);
-                    }
-                    return undefined;
-                },
-            })));
-            const menu = template.elementDisposables.add(this._menuService.createMenu(MenuId.NotebookOutlineActionMenu, scopedContextKeyService));
-            const actions = getOutlineToolbarActions(menu, { notebookEditor: this._editor, outlineEntry: node.element });
-            outlineEntryToolbar.setActions(actions.primary, actions.secondary);
-            this.setupToolbarListeners(outlineEntryToolbar, menu, actions, node.element, template);
-            template.actionMenu.style.padding = '0 0.8em 0 0.4em';
-        }
-    }
-    disposeTemplate(templateData) {
-        templateData.iconLabel.dispose();
-        templateData.elementDisposables.clear();
-    }
-    disposeElement(element, index, templateData, height) {
-        templateData.elementDisposables.clear();
-        clearNode(templateData.actionMenu);
-    }
-    setupFolding(isCodeCell, nbViewModel, scopedContextKeyService, template, nbCell) {
-        const foldingState = isCodeCell ? 0  : (nbCell.foldingState);
-        const foldingStateCtx = NotebookOutlineContext.CellFoldingState.bindTo(scopedContextKeyService);
-        foldingStateCtx.set(foldingState);
-        if (!isCodeCell) {
-            template.elementDisposables.add(nbViewModel.onDidFoldingStateChanged(() => {
-                const foldingState = nbCell.foldingState;
-                NotebookOutlineContext.CellFoldingState.bindTo(scopedContextKeyService).set(foldingState);
-                foldingStateCtx.set(foldingState);
-            }));
-        }
-    }
-    setupToolbarListeners(toolbar, menu, initActions, entry, templateData) {
-        let dropdownIsVisible = false;
-        let deferredUpdate;
-        toolbar.setActions(initActions.primary, initActions.secondary);
-        templateData.elementDisposables.add(menu.onDidChange(() => {
-            if (dropdownIsVisible) {
-                const actions = getOutlineToolbarActions(menu, { notebookEditor: this._editor, outlineEntry: entry });
-                deferredUpdate = () => toolbar.setActions(actions.primary, actions.secondary);
-                return;
-            }
-            const actions = getOutlineToolbarActions(menu, { notebookEditor: this._editor, outlineEntry: entry });
-            toolbar.setActions(actions.primary, actions.secondary);
-        }));
-        templateData.container.classList.remove('notebook-outline-toolbar-dropdown-active');
-        templateData.elementDisposables.add(toolbar.onDidChangeDropdownVisibility(visible => {
-            dropdownIsVisible = visible;
-            if (visible) {
-                templateData.container.classList.add('notebook-outline-toolbar-dropdown-active');
-            }
-            else {
-                templateData.container.classList.remove('notebook-outline-toolbar-dropdown-active');
-            }
-            if (deferredUpdate && !visible) {
-                disposableTimeout(() => {
-                    deferredUpdate?.();
-                }, 0, templateData.elementDisposables);
-                deferredUpdate = undefined;
-            }
-        }));
-    }
-};
-NotebookOutlineRenderer = ( __decorate([
-    ( __param(2, IThemeService)),
-    ( __param(3, IConfigurationService)),
-    ( __param(4, IContextMenuService)),
-    ( __param(5, IContextKeyService)),
-    ( __param(6, IMenuService)),
-    ( __param(7, IInstantiationService))
-], NotebookOutlineRenderer));
-function getOutlineToolbarActions(menu, args) {
-    const primary = [];
-    const secondary = [];
-    const result = { primary, secondary };
-    createAndFillInActionBarActions(menu, { shouldForwardArgs: true, arg: args }, result);
-    return result;
-}
-class NotebookOutlineAccessibility {
-    getAriaLabel(element) {
-        return element.label;
-    }
-    getWidgetAriaLabel() {
-        return '';
-    }
-}
-class NotebookNavigationLabelProvider {
-    getKeyboardNavigationLabel(element) {
-        return element.label;
-    }
-}
-class NotebookOutlineVirtualDelegate {
-    getHeight(_element) {
-        return 22;
-    }
-    getTemplateId(_element) {
-        return NotebookOutlineTemplate.templateId;
-    }
-}
-let NotebookQuickPickProvider = class NotebookQuickPickProvider {
-    constructor(_getEntries, _themeService) {
-        this._getEntries = _getEntries;
-        this._themeService = _themeService;
-    }
-    getQuickPickElements() {
-        const bucket = [];
-        for (const entry of this._getEntries()) {
-            entry.asFlatList(bucket);
-        }
-        const result = [];
-        const { hasFileIcons } = this._themeService.getFileIconTheme();
-        for (const element of bucket) {
-            const useFileIcon = hasFileIcons && !element.symbolKind;
-            result.push({
-                element,
-                label: useFileIcon ? element.label : `$(${element.icon.id}) ${element.label}`,
-                ariaLabel: element.label,
-                iconClasses: useFileIcon ? getIconClassesForLanguageId(element.cell.language ?? '') : undefined,
-            });
-        }
-        return result;
-    }
-};
-NotebookQuickPickProvider = ( __decorate([
-    ( __param(1, IThemeService))
-], NotebookQuickPickProvider));
-class NotebookComparator {
-    constructor() {
-        this._collator = new WindowIdleValue(mainWindow, () => new Intl.Collator(undefined, { numeric: true }));
-    }
-    compareByPosition(a, b) {
-        return a.index - b.index;
-    }
-    compareByType(a, b) {
-        return a.cell.cellKind - b.cell.cellKind || this._collator.value.compare(a.label, b.label);
-    }
-    compareByName(a, b) {
-        return this._collator.value.compare(a.label, b.label);
-    }
-}
-let NotebookCellOutline = NotebookCellOutline_1 = class NotebookCellOutline {
-    get entries() {
-        return this._outlineProvider?.entries ?? [];
-    }
-    get activeElement() {
-        return this._outlineProvider?.activeElement;
-    }
-    constructor(_editor, _target, instantiationService, _editorService, _configurationService) {
-        this._editor = _editor;
-        this._editorService = _editorService;
-        this._dispoables = ( new DisposableStore());
-        this._onDidChange = ( new Emitter());
-        this.onDidChange = this._onDidChange.event;
-        this._entriesDisposables = ( new DisposableStore());
-        this.outlineKind = 'notebookCells';
-        this._localDisposables = ( new DisposableStore());
-        const installSelectionListener = () => {
-            const notebookEditor = _editor.getControl();
-            if (!notebookEditor?.hasModel()) {
-                this._outlineProvider?.dispose();
-                this._outlineProvider = undefined;
-                this._localDisposables.clear();
-            }
-            else {
-                this._outlineProvider?.dispose();
-                this._localDisposables.clear();
-                this._outlineProvider = instantiationService.createInstance(NotebookCellOutlineProvider, notebookEditor, _target);
-                this._localDisposables.add(this._outlineProvider.onDidChange(e => {
-                    this._onDidChange.fire(e);
-                }));
-            }
-        };
-        this._dispoables.add(_editor.onDidChangeModel(() => {
-            installSelectionListener();
-        }));
-        installSelectionListener();
-        const treeDataSource = {
-            getChildren: parent => {
-                return this.getChildren(parent, _configurationService);
-            }
-        };
-        const delegate = ( new NotebookOutlineVirtualDelegate());
-        const renderers = [instantiationService.createInstance(NotebookOutlineRenderer, this._editor.getControl(), _target)];
-        const comparator = ( new NotebookComparator());
-        const options = {
-            collapseByDefault: _target === 2  || ((_target === 1  && _configurationService.getValue("outline.collapseItems" ) === "alwaysCollapse") ),
-            expandOnlyOnTwistieClick: true,
-            multipleSelectionSupport: false,
-            accessibilityProvider: ( new NotebookOutlineAccessibility()),
-            identityProvider: { getId: element => ( element.cell.uri.toString()) },
-            keyboardNavigationLabelProvider: ( new NotebookNavigationLabelProvider())
-        };
-        this.config = {
-            breadcrumbsDataSource: {
-                getBreadcrumbElements: () => {
-                    const result = [];
-                    let candidate = this.activeElement;
-                    while (candidate) {
-                        result.unshift(candidate);
-                        candidate = candidate.parent;
-                    }
-                    return result;
-                }
-            },
-            quickPickDataSource: instantiationService.createInstance(NotebookQuickPickProvider, () => (this._outlineProvider?.entries ?? [])),
-            treeDataSource,
-            delegate,
-            renderers,
-            comparator,
-            options
-        };
-    }
-    *getChildren(parent, configurationService) {
-        const showCodeCells = configurationService.getValue(NotebookSetting.outlineShowCodeCells);
-        const showCodeCellSymbols = configurationService.getValue(NotebookSetting.outlineShowCodeCellSymbols);
-        const showMarkdownHeadersOnly = configurationService.getValue(NotebookSetting.outlineShowMarkdownHeadersOnly);
-        for (const entry of parent instanceof NotebookCellOutline_1 ? (this._outlineProvider?.entries ?? []) : parent.children) {
-            if (entry.cell.cellKind === CellKind.Markup) {
-                if (!showMarkdownHeadersOnly) {
-                    yield entry;
-                }
-                else if (entry.level < 7) {
-                    yield entry;
-                }
-            }
-            else if (showCodeCells && entry.cell.cellKind === CellKind.Code) {
-                if (showCodeCellSymbols) {
-                    yield entry;
-                }
-                else if (entry.level === 7) {
-                    yield entry;
-                }
-            }
-        }
-    }
-    async setFullSymbols(cancelToken) {
-        await this._outlineProvider?.setFullSymbols(cancelToken);
-    }
-    get uri() {
-        return this._outlineProvider?.uri;
-    }
-    get isEmpty() {
-        return this._outlineProvider?.isEmpty ?? true;
-    }
-    async reveal(entry, options, sideBySide) {
-        await this._editorService.openEditor({
-            resource: entry.cell.uri,
-            options: {
-                ...options,
-                override: this._editor.input?.editorId,
-                cellRevealType: 5 ,
-                selection: entry.position
-            },
-        }, sideBySide ? SIDE_GROUP : undefined);
-    }
-    preview(entry) {
-        const widget = this._editor.getControl();
-        if (!widget) {
-            return Disposable.None;
-        }
-        if (entry.range) {
-            const range = Range.lift(entry.range);
-            widget.revealRangeInCenterIfOutsideViewportAsync(entry.cell, range);
-        }
-        else {
-            widget.revealInCenterIfOutsideViewport(entry.cell);
-        }
-        const ids = widget.deltaCellDecorations([], [{
-                handle: entry.cell.handle,
-                options: { className: 'nb-symbolHighlight', outputClassName: 'nb-symbolHighlight' }
-            }]);
-        let editorDecorations;
-        widget.changeModelDecorations(accessor => {
-            if (entry.range) {
-                const decorations = [
-                    {
-                        range: entry.range, options: {
-                            description: 'document-symbols-outline-range-highlight',
-                            className: 'rangeHighlight',
-                            isWholeLine: true
-                        }
-                    }
-                ];
-                const deltaDecoration = {
-                    ownerId: entry.cell.handle,
-                    decorations: decorations
-                };
-                editorDecorations = accessor.deltaDecorations([], [deltaDecoration]);
-            }
-        });
-        return toDisposable(() => {
-            widget.deltaCellDecorations(ids, []);
-            if (editorDecorations?.length) {
-                widget.changeModelDecorations(accessor => {
-                    accessor.deltaDecorations(editorDecorations, []);
-                });
-            }
-        });
-    }
-    captureViewState() {
-        const widget = this._editor.getControl();
-        const viewState = widget?.getEditorViewState();
-        return toDisposable(() => {
-            if (viewState) {
-                widget?.restoreListViewState(viewState);
-            }
-        });
-    }
-    dispose() {
-        this._onDidChange.dispose();
-        this._dispoables.dispose();
-        this._entriesDisposables.dispose();
-        this._outlineProvider?.dispose();
-        this._localDisposables.dispose();
-    }
-};
-NotebookCellOutline = NotebookCellOutline_1 = ( __decorate([
-    ( __param(2, IInstantiationService)),
-    ( __param(3, IEditorService)),
-    ( __param(4, IConfigurationService))
-], NotebookCellOutline));
-let NotebookOutlineCreator = class NotebookOutlineCreator {
-    constructor(outlineService, _instantiationService, _configurationService) {
-        this._instantiationService = _instantiationService;
-        this._configurationService = _configurationService;
-        const reg = outlineService.registerOutlineCreator(this);
-        this.dispose = () => reg.dispose();
-    }
-    matches(candidate) {
-        return candidate.getId() === NotebookEditor.ID;
-    }
-    async createOutline(editor, target, cancelToken) {
-        const outline = this._instantiationService.createInstance(NotebookCellOutline, editor, target);
-        const showAllGotoSymbols = this._configurationService.getValue(NotebookSetting.gotoSymbolsAllSymbols);
-        const showAllOutlineSymbols = this._configurationService.getValue(NotebookSetting.outlineShowCodeCellSymbols);
-        if (target === 4  && showAllGotoSymbols) {
-            await outline.setFullSymbols(cancelToken);
-        }
-        else if (target === 1  && showAllOutlineSymbols) {
-            await outline.setFullSymbols(cancelToken);
-        }
-        return outline;
-    }
-};
-NotebookOutlineCreator = ( __decorate([
-    ( __param(0, IOutlineService)),
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IConfigurationService))
-], NotebookOutlineCreator));
-const NotebookOutlineContext = {
-    CellKind: ( new RawContextKey('notebookCellKind', undefined)),
-    CellHasChildren: ( new RawContextKey('notebookCellHasChildren', false)),
-    CellHasHeader: ( new RawContextKey('notebookCellHasHeader', false)),
-    CellFoldingState: ( new RawContextKey('notebookCellFoldingState', 0 )),
-    OutlineElementTarget: ( new RawContextKey('notebookOutlineElementTarget', undefined)),
-};
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(NotebookOutlineCreator, 4 );
-( Registry.as(Extensions$1.Configuration)).registerConfiguration({
-    id: 'notebook',
-    order: 100,
-    type: 'object',
-    'properties': {
-        [NotebookSetting.outlineShowMarkdownHeadersOnly]: {
-            type: 'boolean',
-            default: true,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
-                'outline.showMarkdownHeadersOnly',
-                "When enabled, notebook outline will show only markdown cells containing a header."
-            ))
-        },
-        [NotebookSetting.outlineShowCodeCells]: {
-            type: 'boolean',
-            default: false,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
-                'outline.showCodeCells',
-                "When enabled, notebook outline shows code cells."
-            ))
-        },
-        [NotebookSetting.outlineShowCodeCellSymbols]: {
-            type: 'boolean',
-            default: true,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
-                'outline.showCodeCellSymbols',
-                "When enabled, notebook outline shows code cell symbols. Relies on `notebook.outline.showCodeCells` being enabled."
-            ))
-        },
-        [NotebookSetting.breadcrumbsShowCodeCells]: {
-            type: 'boolean',
-            default: true,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
-                'breadcrumbs.showCodeCells',
-                "When enabled, notebook breadcrumbs contain code cells."
-            ))
-        },
-        [NotebookSetting.gotoSymbolsAllSymbols]: {
-            type: 'boolean',
-            default: true,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
-                'notebook.gotoSymbols.showAllSymbols',
-                "When enabled, the Go to Symbol Quick Pick will display full code symbols from the notebook, as well as Markdown headers."
-            ))
-        },
-    }
-});
-MenuRegistry.appendMenuItem(MenuId.ViewTitle, {
-    submenu: MenuId.NotebookOutlineFilter,
-    title: ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
-        'filter',
-        "Filter Entries"
-    )),
-    icon: Codicon.filter,
-    group: 'navigation',
-    order: -1,
-    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', IOutlinePane.Id)), NOTEBOOK_IS_ACTIVE_EDITOR)),
-});
-registerAction2(class ToggleShowMarkdownHeadersOnly extends Action2 {
-    constructor() {
-        super({
-            id: 'notebook.outline.toggleShowMarkdownHeadersOnly',
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
-                'toggleShowMarkdownHeadersOnly',
-                "Markdown Headers Only"
-            )),
-            f1: false,
-            toggled: {
-                condition: ( ContextKeyExpr.equals('config.notebook.outline.showMarkdownHeadersOnly', true))
-            },
-            menu: {
-                id: MenuId.NotebookOutlineFilter,
-                group: '0_markdown_cells',
-            }
-        });
-    }
-    run(accessor, ...args) {
-        const configurationService = accessor.get(IConfigurationService);
-        const showMarkdownHeadersOnly = configurationService.getValue(NotebookSetting.outlineShowMarkdownHeadersOnly);
-        configurationService.updateValue(NotebookSetting.outlineShowMarkdownHeadersOnly, !showMarkdownHeadersOnly);
-    }
-});
-registerAction2(class ToggleCodeCellEntries extends Action2 {
-    constructor() {
-        super({
-            id: 'notebook.outline.toggleCodeCells',
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
-                'toggleCodeCells',
-                "Code Cells"
-            )),
-            f1: false,
-            toggled: {
-                condition: ( ContextKeyExpr.equals('config.notebook.outline.showCodeCells', true))
-            },
-            menu: {
-                id: MenuId.NotebookOutlineFilter,
-                order: 1,
-                group: '1_code_cells',
-            }
-        });
-    }
-    run(accessor, ...args) {
-        const configurationService = accessor.get(IConfigurationService);
-        const showCodeCells = configurationService.getValue(NotebookSetting.outlineShowCodeCells);
-        configurationService.updateValue(NotebookSetting.outlineShowCodeCells, !showCodeCells);
-    }
-});
-registerAction2(class ToggleCodeCellSymbolEntries extends Action2 {
-    constructor() {
-        super({
-            id: 'notebook.outline.toggleCodeCellSymbols',
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
-                'toggleCodeCellSymbols',
-                "Code Cell Symbols"
-            )),
-            f1: false,
-            toggled: {
-                condition: ( ContextKeyExpr.equals('config.notebook.outline.showCodeCellSymbols', true))
-            },
-            menu: {
-                id: MenuId.NotebookOutlineFilter,
-                order: 2,
-                group: '1_code_cells',
-            }
-        });
-    }
-    run(accessor, ...args) {
-        const configurationService = accessor.get(IConfigurationService);
-        const showCodeCellSymbols = configurationService.getValue(NotebookSetting.outlineShowCodeCellSymbols);
-        configurationService.updateValue(NotebookSetting.outlineShowCodeCellSymbols, !showCodeCellSymbols);
-    }
-});
-
-export { NotebookCellOutline, NotebookOutlineContext, NotebookOutlineCreator };