@codingame/monaco-vscode-api 37.1.0 → 37.2.0

package/vscode/src/vs/workbench/contrib/notebook/browser/viewModel/viewContext.d.ts

@@ -1,9 +0,0 @@
-import { IBaseCellEditorOptions } from "../notebookBrowser.js";
-import { NotebookEventDispatcher } from "./eventDispatcher.js";
-import { NotebookOptions } from "../notebookOptions.js";
-export declare class ViewContext {
-    readonly notebookOptions: NotebookOptions;
-    readonly eventDispatcher: NotebookEventDispatcher;
-    readonly getBaseCellEditorOptions: (language: string) => IBaseCellEditorOptions;
-    constructor(notebookOptions: NotebookOptions, eventDispatcher: NotebookEventDispatcher, getBaseCellEditorOptions: (language: string) => IBaseCellEditorOptions);
-}

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

@@ -1,11 +0,0 @@
-
-
-class ViewContext {
-    constructor(notebookOptions, eventDispatcher, getBaseCellEditorOptions) {
-        this.notebookOptions = notebookOptions;
-        this.eventDispatcher = eventDispatcher;
-        this.getBaseCellEditorOptions = getBaseCellEditorOptions;
-    }
-}
-
-export { ViewContext };

package/vscode/src/vs/workbench/contrib/notebook/browser/viewParts/notebookCellOverlays.d.ts

@@ -1,20 +0,0 @@
-import { FastDomNode } from "../../../../../base/browser/fastDomNode.js";
-import { Disposable } from "../../../../../base/common/lifecycle.js";
-import { INotebookCellOverlayChangeAccessor, INotebookViewCellsUpdateEvent } from "../notebookBrowser.js";
-import { NotebookCellListView } from "../view/notebookCellListView.js";
-import { CellViewModel } from "../viewModel/notebookViewModelImpl.js";
-export declare class NotebookCellOverlays extends Disposable {
-    private readonly listView;
-    private _lastOverlayId;
-    domNode: FastDomNode<HTMLElement>;
-    private _overlays;
-    constructor(listView: NotebookCellListView<CellViewModel>);
-    changeCellOverlays(callback: (changeAccessor: INotebookCellOverlayChangeAccessor) => void): boolean;
-    onCellsChanged(e: INotebookViewCellsUpdateEvent): void;
-    onHiddenRangesChange(): void;
-    layout(): void;
-    private _addOverlay;
-    private _removeOverlay;
-    private _layoutOverlay;
-    private _isInHiddenRanges;
-}

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

@@ -1,101 +0,0 @@
-
-import { createElement } from '../../../../../base/browser/dom.js';
-import { createFastDomNode } from '../../../../../base/browser/fastDomNode.js';
-import { Disposable } from '../../../../../base/common/lifecycle.js';
-
-class NotebookCellOverlays extends Disposable {
-    constructor(listView) {
-        super();
-        this.listView = listView;
-        this._lastOverlayId = 0;
-        this._overlays = Object.create(null);
-        this.domNode = createFastDomNode(createElement('div'));
-        this.domNode.setClassName('cell-overlays');
-        this.domNode.setPosition('absolute');
-        this.domNode.setAttribute('role', 'presentation');
-        this.domNode.setAttribute('aria-hidden', 'true');
-        this.domNode.setWidth('100%');
-        this.listView.containerDomNode.appendChild(this.domNode.domNode);
-    }
-    changeCellOverlays(callback) {
-        let overlaysHaveChanged = false;
-        const changeAccessor = {
-            addOverlay: (overlay) => {
-                overlaysHaveChanged = true;
-                return this._addOverlay(overlay);
-            },
-            removeOverlay: (id) => {
-                overlaysHaveChanged = true;
-                this._removeOverlay(id);
-            },
-            layoutOverlay: (id) => {
-                overlaysHaveChanged = true;
-                this._layoutOverlay(id);
-            }
-        };
-        callback(changeAccessor);
-        return overlaysHaveChanged;
-    }
-    onCellsChanged(e) {
-        this.layout();
-    }
-    onHiddenRangesChange() {
-        this.layout();
-    }
-    layout() {
-        for (const id in this._overlays) {
-            this._layoutOverlay(id);
-        }
-    }
-    _addOverlay(overlay) {
-        const overlayId = `${++this._lastOverlayId}`;
-        const overlayWidget = {
-            overlayId,
-            overlay,
-            domNode: createFastDomNode(overlay.domNode)
-        };
-        this._overlays[overlayId] = overlayWidget;
-        overlayWidget.domNode.setClassName('cell-overlay');
-        overlayWidget.domNode.setPosition('absolute');
-        this.domNode.appendChild(overlayWidget.domNode);
-        return overlayId;
-    }
-    _removeOverlay(id) {
-        const overlay = this._overlays[id];
-        if (overlay) {
-            try {
-                this.domNode.removeChild(overlay.domNode);
-            }
-            catch {
-            }
-            delete this._overlays[id];
-        }
-    }
-    _layoutOverlay(id) {
-        const overlay = this._overlays[id];
-        if (!overlay) {
-            return;
-        }
-        const isInHiddenRanges = this._isInHiddenRanges(overlay);
-        if (isInHiddenRanges) {
-            overlay.domNode.setDisplay('none');
-            return;
-        }
-        overlay.domNode.setDisplay('block');
-        const index = this.listView.indexOf(overlay.overlay.cell);
-        if (index === -1) {
-            return;
-        }
-        const top = this.listView.elementTop(index);
-        overlay.domNode.setTop(top);
-    }
-    _isInHiddenRanges(zone) {
-        const index = this.listView.indexOf(zone.overlay.cell);
-        if (index === -1) {
-            return true;
-        }
-        return false;
-    }
-}
-
-export { NotebookCellOverlays };

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

@@ -1,65 +0,0 @@
-import { Event } from "../../../../../base/common/event.js";
-import { Disposable } from "../../../../../base/common/lifecycle.js";
-import { IContextMenuService } from "../../../../../platform/contextview/browser/contextView.service.js";
-import { INotebookEditor } from "../notebookBrowser.js";
-import { INotebookCellList } from "../view/notebookRenderingCommon.js";
-import { OutlineEntry } from "@codingame/monaco-vscode-notebook-service-override/vscode/vs/workbench/contrib/notebook/browser/viewModel/OutlineEntry";
-import { IInstantiationService } from "../../../../../platform/instantiation/common/instantiation.js";
-export declare class NotebookStickyLine extends Disposable {
-    readonly element: HTMLElement;
-    readonly foldingIcon: StickyFoldingIcon;
-    readonly header: HTMLElement;
-    readonly entry: OutlineEntry;
-    readonly notebookEditor: INotebookEditor;
-    constructor(element: HTMLElement, foldingIcon: StickyFoldingIcon, header: HTMLElement, entry: OutlineEntry, notebookEditor: INotebookEditor);
-    private toggleFoldRange;
-    private focusCell;
-    static getParentCount(entry: OutlineEntry): number;
-}
-declare class StickyFoldingIcon {
-    isCollapsed: boolean;
-    dimension: number;
-    domNode: HTMLElement;
-    constructor(isCollapsed: boolean, dimension: number);
-    setVisible(visible: boolean): void;
-}
-export declare class NotebookStickyScroll extends Disposable {
-    private readonly domNode;
-    private readonly notebookEditor;
-    private readonly notebookCellList;
-    private readonly layoutFn;
-    private readonly _contextMenuService;
-    private readonly instantiationService;
-    private readonly _disposables;
-    private currentStickyLines;
-    private readonly _onDidChangeNotebookStickyScroll;
-    readonly onDidChangeNotebookStickyScroll: Event<number>;
-    private notebookCellOutlineReference?;
-    private readonly _layoutDisposableStore;
-    getDomNode(): HTMLElement;
-    getCurrentStickyHeight(): number;
-    private setCurrentStickyLines;
-    private compareStickyLineMaps;
-    constructor(domNode: HTMLElement, notebookEditor: INotebookEditor, notebookCellList: INotebookCellList, layoutFn: (delta: number) => void, _contextMenuService: IContextMenuService, instantiationService: IInstantiationService);
-    private onContextMenu;
-    private updateConfig;
-    private init;
-    private disposeStickyLineMap;
-    static getVisibleOutlineEntry(visibleIndex: number, notebookOutlineEntries: OutlineEntry[]): OutlineEntry | undefined;
-    private updateContent;
-    private updateDisplay;
-    static computeStickyHeight(entry: OutlineEntry): number;
-    static checkCollapsedStickyLines(entry: OutlineEntry | undefined, numLinesToRender: number, notebookEditor: INotebookEditor): Map<OutlineEntry, {
-        line: NotebookStickyLine;
-        rendered: boolean;
-    }>;
-    private renderStickyLines;
-    static createStickyElement(entry: OutlineEntry, notebookEditor: INotebookEditor): NotebookStickyLine;
-    private disposeCurrentStickyLines;
-    dispose(): void;
-}
-export declare function computeContent(notebookEditor: INotebookEditor, notebookCellList: INotebookCellList, notebookOutlineEntries: OutlineEntry[], renderedStickyHeight: number): Map<OutlineEntry, {
-    line: NotebookStickyLine;
-    rendered: boolean;
-}>;
-export {};

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

@@ -1,458 +0,0 @@
-
-import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { addDisposableListener, EventType, createElement, getWindow, clearNode, scheduleAtNextAnimationFrame } from '../../../../../base/browser/dom.js';
-import '../../../../../base/browser/touch.js';
-import { CancellationToken } from '../../../../../base/common/cancellation.js';
-import { StandardMouseEvent } from '../../../../../base/browser/mouseEvent.js';
-import { Emitter } from '../../../../../base/common/event.js';
-import { Disposable, DisposableStore } from '../../../../../base/common/lifecycle.js';
-import { MenuId } from '../../../../../platform/actions/common/actions.js';
-import { IContextMenuService } from '../../../../../platform/contextview/browser/contextView.service.js';
-import { CellFoldingState } from '../notebookBrowser.js';
-import { CellKind } from '../../common/notebookCommon.js';
-import { Delayer } from '../../../../../base/common/async.js';
-import { ThemeIcon } from '../../../../../base/common/themables.js';
-import { foldingCollapsedIcon, foldingExpandedIcon } from '../../../../../editor/contrib/folding/browser/foldingDecorations.js';
-import { FoldingController } from '../controller/foldingController.js';
-import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
-import { INotebookCellOutlineDataSourceFactory } from '../viewModel/notebookOutlineDataSourceFactory.service.js';
-
-var NotebookStickyScroll_1;
-class NotebookStickyLine extends Disposable {
-    constructor(element, foldingIcon, header, entry, notebookEditor) {
-        super();
-        this.element = element;
-        this.foldingIcon = foldingIcon;
-        this.header = header;
-        this.entry = entry;
-        this.notebookEditor = notebookEditor;
-        this._register(
-            addDisposableListener(this.header, EventType.CLICK, () => {
-                this.focusCell();
-            })
-        );
-        this._register(addDisposableListener(
-            this.foldingIcon.domNode,
-            EventType.CLICK,
-            () => {
-                if (this.entry.cell.cellKind === CellKind.Markup) {
-                    const currentFoldingState = this.entry.cell.foldingState;
-                    this.toggleFoldRange(currentFoldingState);
-                }
-            }
-        ));
-    }
-    toggleFoldRange(currentState) {
-        const foldingController = this.notebookEditor.getContribution(FoldingController.id);
-        const index = this.entry.index;
-        const headerLevel = this.entry.level;
-        const newFoldingState = (currentState === CellFoldingState.Collapsed) ? CellFoldingState.Expanded : CellFoldingState.Collapsed;
-        foldingController.setFoldingStateDown(index, newFoldingState, headerLevel);
-        this.focusCell();
-    }
-    focusCell() {
-        this.notebookEditor.focusNotebookCell(this.entry.cell, "container");
-        const cellScrollTop = this.notebookEditor.getAbsoluteTopOfElement(this.entry.cell);
-        const parentCount = NotebookStickyLine.getParentCount(this.entry);
-        this.notebookEditor.setScrollTop(cellScrollTop - (parentCount + 1.1) * 22);
-    }
-    static getParentCount(entry) {
-        let count = 0;
-        while (entry.parent) {
-            count++;
-            entry = entry.parent;
-        }
-        return count;
-    }
-}
-class StickyFoldingIcon {
-    constructor(isCollapsed, dimension) {
-        this.isCollapsed = isCollapsed;
-        this.dimension = dimension;
-        this.domNode = createElement("div");
-        this.domNode.style.width = `${dimension}px`;
-        this.domNode.style.height = `${dimension}px`;
-        this.domNode.className = ThemeIcon.asClassName(isCollapsed ? foldingCollapsedIcon : foldingExpandedIcon);
-    }
-    setVisible(visible) {
-        this.domNode.style.cursor = visible ? "pointer" : "default";
-        this.domNode.style.opacity = visible ? "1" : "0";
-    }
-}
-let NotebookStickyScroll = NotebookStickyScroll_1 = class NotebookStickyScroll extends Disposable {
-    getDomNode() {
-        return this.domNode;
-    }
-    getCurrentStickyHeight() {
-        let height = 0;
-        this.currentStickyLines.forEach(value => {
-            if (value.rendered) {
-                height += 22;
-            }
-        });
-        return height;
-    }
-    setCurrentStickyLines(newStickyLines) {
-        this.currentStickyLines = newStickyLines;
-    }
-    compareStickyLineMaps(mapA, mapB) {
-        if (mapA.size !== mapB.size) {
-            return false;
-        }
-        for (const [key, value] of mapA) {
-            const otherValue = mapB.get(key);
-            if (!otherValue || value.rendered !== otherValue.rendered) {
-                return false;
-            }
-        }
-        return true;
-    }
-    constructor(
-        domNode,
-        notebookEditor,
-        notebookCellList,
-        layoutFn,
-        _contextMenuService,
-        instantiationService
-    ) {
-        super();
-        this.domNode = domNode;
-        this.notebookEditor = notebookEditor;
-        this.notebookCellList = notebookCellList;
-        this.layoutFn = layoutFn;
-        this._contextMenuService = _contextMenuService;
-        this.instantiationService = instantiationService;
-        this._disposables = ( new DisposableStore());
-        this.currentStickyLines = ( new Map());
-        this._onDidChangeNotebookStickyScroll = this._register(( new Emitter()));
-        this.onDidChangeNotebookStickyScroll = this._onDidChangeNotebookStickyScroll.event;
-        this._layoutDisposableStore = this._register(( new DisposableStore()));
-        if (this.notebookEditor.notebookOptions.getDisplayOptions().stickyScrollEnabled) {
-            this.init().catch(console.error);
-        }
-        this._register(this.notebookEditor.notebookOptions.onDidChangeOptions(e => {
-            if (e.stickyScrollEnabled || e.stickyScrollMode) {
-                this.updateConfig(e);
-            }
-        }));
-        this._register(
-            addDisposableListener(this.domNode, EventType.CONTEXT_MENU, async event => {
-                this.onContextMenu(event);
-            })
-        );
-        this._register(addDisposableListener(this.domNode, EventType.WHEEL, event => {
-            this.notebookCellList.triggerScrollFromMouseWheelEvent(event);
-        }));
-    }
-    onContextMenu(e) {
-        const event = ( new StandardMouseEvent(getWindow(this.domNode), e));
-        const selectedElement = event.target.parentElement;
-        const selectedOutlineEntry = Array.from(( this.currentStickyLines.values())).find(entry => entry.line.element.contains(selectedElement))?.line.entry;
-        if (!selectedOutlineEntry) {
-            return;
-        }
-        const args = {
-            outlineEntry: selectedOutlineEntry,
-            notebookEditor: this.notebookEditor
-        };
-        this._contextMenuService.showContextMenu({
-            menuId: MenuId.NotebookStickyScrollContext,
-            getAnchor: () => event,
-            menuActionOptions: {
-                shouldForwardArgs: true,
-                arg: args,
-                renderShortTitle: true
-            }
-        });
-    }
-    updateConfig(e) {
-        if (e.stickyScrollEnabled) {
-            if (this.notebookEditor.notebookOptions.getDisplayOptions().stickyScrollEnabled) {
-                this.init().catch(console.error);
-            } else {
-                this._disposables.clear();
-                this.notebookCellOutlineReference?.dispose();
-                this.disposeCurrentStickyLines();
-                clearNode(this.domNode);
-                this.updateDisplay();
-            }
-        } else if (e.stickyScrollMode && this.notebookEditor.notebookOptions.getDisplayOptions().stickyScrollEnabled && this.notebookCellOutlineReference?.object) {
-            this.updateContent(computeContent(
-                this.notebookEditor,
-                this.notebookCellList,
-                this.notebookCellOutlineReference?.object?.entries,
-                this.getCurrentStickyHeight()
-            ));
-        }
-    }
-    async init() {
-        const {
-            object: notebookCellOutline
-        } = this.notebookCellOutlineReference = this.instantiationService.invokeFunction(
-            accessor => accessor.get(INotebookCellOutlineDataSourceFactory).getOrCreate(this.notebookEditor)
-        );
-        this._register(this.notebookCellOutlineReference);
-        await notebookCellOutline.computeFullSymbols(CancellationToken.None);
-        const computed = computeContent(
-            this.notebookEditor,
-            this.notebookCellList,
-            notebookCellOutline.entries,
-            this.getCurrentStickyHeight()
-        );
-        this.updateContent(computed);
-        this._disposables.add(notebookCellOutline.onDidChange(() => {
-            const computed = computeContent(
-                this.notebookEditor,
-                this.notebookCellList,
-                notebookCellOutline.entries,
-                this.getCurrentStickyHeight()
-            );
-            if (!this.compareStickyLineMaps(computed, this.currentStickyLines)) {
-                this.updateContent(computed);
-            } else {
-                this.disposeStickyLineMap(computed);
-            }
-        }));
-        this._disposables.add(this.notebookEditor.onDidAttachViewModel(async () => {
-            await notebookCellOutline.computeFullSymbols(CancellationToken.None);
-            const computed = computeContent(
-                this.notebookEditor,
-                this.notebookCellList,
-                notebookCellOutline.entries,
-                this.getCurrentStickyHeight()
-            );
-            this.updateContent(computed);
-        }));
-        this._disposables.add(this.notebookEditor.onDidScroll(() => {
-            const d = ( new Delayer(100));
-            d.trigger(() => {
-                d.dispose();
-                const computed = computeContent(
-                    this.notebookEditor,
-                    this.notebookCellList,
-                    notebookCellOutline.entries,
-                    this.getCurrentStickyHeight()
-                );
-                if (!this.compareStickyLineMaps(computed, this.currentStickyLines)) {
-                    this.updateContent(computed);
-                } else {
-                    this.disposeStickyLineMap(computed);
-                }
-            });
-        }));
-    }
-    disposeStickyLineMap(map) {
-        map.forEach(value => {
-            if (value.line) {
-                value.line.dispose();
-            }
-        });
-    }
-    static getVisibleOutlineEntry(visibleIndex, notebookOutlineEntries) {
-        let left = 0;
-        let right = notebookOutlineEntries.length - 1;
-        while (left <= right) {
-            const mid = Math.floor((left + right) / 2);
-            if (notebookOutlineEntries[mid].index === visibleIndex) {
-                const rootEntry = notebookOutlineEntries[mid];
-                const flatList = [];
-                rootEntry.asFlatList(flatList);
-                return flatList.find(entry => entry.index === visibleIndex);
-            } else if (notebookOutlineEntries[mid].index < visibleIndex) {
-                left = mid + 1;
-            } else {
-                right = mid - 1;
-            }
-        }
-        if (right >= 0) {
-            const rootEntry = notebookOutlineEntries[right];
-            const flatList = [];
-            rootEntry.asFlatList(flatList);
-            return flatList.find(entry => entry.index === visibleIndex);
-        }
-        return undefined;
-    }
-    updateContent(newMap) {
-        clearNode(this.domNode);
-        this.disposeCurrentStickyLines();
-        this.renderStickyLines(newMap, this.domNode);
-        const oldStickyHeight = this.getCurrentStickyHeight();
-        this.setCurrentStickyLines(newMap);
-        const sizeDelta = this.getCurrentStickyHeight() - oldStickyHeight;
-        if (sizeDelta !== 0) {
-            this._onDidChangeNotebookStickyScroll.fire(sizeDelta);
-            const d = this._layoutDisposableStore.add(scheduleAtNextAnimationFrame(getWindow(this.getDomNode()), () => {
-                this.layoutFn(sizeDelta);
-                this.updateDisplay();
-                this._layoutDisposableStore.delete(d);
-            }));
-        } else {
-            this.updateDisplay();
-        }
-    }
-    updateDisplay() {
-        const hasSticky = this.getCurrentStickyHeight() > 0;
-        if (!hasSticky) {
-            this.domNode.style.display = "none";
-        } else {
-            this.domNode.style.display = "block";
-        }
-    }
-    static computeStickyHeight(entry) {
-        let height = 0;
-        if (entry.cell.cellKind === CellKind.Markup && entry.level < 7) {
-            height += 22;
-        }
-        while (entry.parent) {
-            height += 22;
-            entry = entry.parent;
-        }
-        return height;
-    }
-    static checkCollapsedStickyLines(entry, numLinesToRender, notebookEditor) {
-        let currentEntry = entry;
-        const newMap = ( new Map());
-        const elementsToRender = [];
-        while (currentEntry) {
-            if (currentEntry.level >= 7) {
-                currentEntry = currentEntry.parent;
-                continue;
-            }
-            const lineToRender = NotebookStickyScroll_1.createStickyElement(currentEntry, notebookEditor);
-            newMap.set(currentEntry, {
-                line: lineToRender,
-                rendered: false
-            });
-            elementsToRender.unshift(lineToRender);
-            currentEntry = currentEntry.parent;
-        }
-        for (let i = 0; i < elementsToRender.length; i++) {
-            if (i >= numLinesToRender) {
-                break;
-            }
-            newMap.set(elementsToRender[i].entry, {
-                line: elementsToRender[i],
-                rendered: true
-            });
-        }
-        return newMap;
-    }
-    renderStickyLines(stickyMap, containerElement) {
-        const reversedEntries = Array.from(stickyMap.entries()).reverse();
-        for (const [, value] of reversedEntries) {
-            if (!value.rendered) {
-                continue;
-            }
-            containerElement.append(value.line.element);
-        }
-    }
-    static createStickyElement(entry, notebookEditor) {
-        const stickyElement = createElement("div");
-        stickyElement.classList.add("notebook-sticky-scroll-element");
-        const indentMode = notebookEditor.notebookOptions.getLayoutConfiguration().stickyScrollMode;
-        if (indentMode === "indented") {
-            stickyElement.style.paddingLeft = NotebookStickyLine.getParentCount(entry) * 10 + "px";
-        }
-        let isCollapsed = false;
-        if (entry.cell.cellKind === CellKind.Markup) {
-            isCollapsed = entry.cell.foldingState === CellFoldingState.Collapsed;
-        }
-        const stickyFoldingIcon = ( new StickyFoldingIcon(isCollapsed, 16));
-        stickyFoldingIcon.domNode.classList.add("notebook-sticky-scroll-folding-icon");
-        stickyFoldingIcon.setVisible(true);
-        const stickyHeader = createElement("div");
-        stickyHeader.classList.add("notebook-sticky-scroll-header");
-        stickyHeader.innerText = entry.label;
-        stickyElement.append(stickyFoldingIcon.domNode, stickyHeader);
-        return ( new NotebookStickyLine(stickyElement, stickyFoldingIcon, stickyHeader, entry, notebookEditor));
-    }
-    disposeCurrentStickyLines() {
-        this.currentStickyLines.forEach(value => {
-            value.line.dispose();
-        });
-    }
-    dispose() {
-        this._disposables.dispose();
-        this.disposeCurrentStickyLines();
-        this.notebookCellOutlineReference?.dispose();
-        super.dispose();
-    }
-};
-NotebookStickyScroll = NotebookStickyScroll_1 = ( __decorate([( __param(4, IContextMenuService)), ( __param(5, IInstantiationService))], NotebookStickyScroll));
-function computeContent(
-    notebookEditor,
-    notebookCellList,
-    notebookOutlineEntries,
-    renderedStickyHeight
-) {
-    const editorScrollTop = notebookEditor.scrollTop - renderedStickyHeight;
-    const visibleRange = notebookEditor.visibleRanges[0];
-    if (!visibleRange) {
-        return ( new Map());
-    }
-    if (visibleRange.start === 0) {
-        const firstCell = notebookEditor.cellAt(0);
-        const firstCellEntry = NotebookStickyScroll.getVisibleOutlineEntry(0, notebookOutlineEntries);
-        if (firstCell && firstCellEntry && firstCell.cellKind === CellKind.Markup && firstCellEntry.level < 7) {
-            if (notebookEditor.scrollTop > 22) {
-                const newMap = NotebookStickyScroll.checkCollapsedStickyLines(firstCellEntry, 100, notebookEditor);
-                return newMap;
-            }
-        }
-    }
-    let cell;
-    let cellEntry;
-    const startIndex = visibleRange.start - 1;
-    for (let currentIndex = startIndex; currentIndex < visibleRange.end; currentIndex++) {
-        cell = notebookEditor.cellAt(currentIndex);
-        if (!cell) {
-            return ( new Map());
-        }
-        cellEntry = NotebookStickyScroll.getVisibleOutlineEntry(currentIndex, notebookOutlineEntries);
-        if (!cellEntry) {
-            continue;
-        }
-        const nextCell = notebookEditor.cellAt(currentIndex + 1);
-        if (!nextCell) {
-            const sectionBottom = notebookEditor.getLayoutInfo().scrollHeight;
-            const linesToRender = Math.floor(sectionBottom / 22);
-            const newMap = NotebookStickyScroll.checkCollapsedStickyLines(cellEntry, linesToRender, notebookEditor);
-            return newMap;
-        }
-        const nextCellEntry = NotebookStickyScroll.getVisibleOutlineEntry(currentIndex + 1, notebookOutlineEntries);
-        if (!nextCellEntry) {
-            continue;
-        }
-        if (nextCell.cellKind === CellKind.Markup && nextCellEntry.level < 7) {
-            const sectionBottom = notebookCellList.getCellViewScrollTop(nextCell);
-            const currentSectionStickyHeight = NotebookStickyScroll.computeStickyHeight(cellEntry);
-            const nextSectionStickyHeight = NotebookStickyScroll.computeStickyHeight(nextCellEntry);
-            if (editorScrollTop + currentSectionStickyHeight < sectionBottom) {
-                const linesToRender = Math.floor((sectionBottom - editorScrollTop) / 22);
-                const newMap = NotebookStickyScroll.checkCollapsedStickyLines(cellEntry, linesToRender, notebookEditor);
-                return newMap;
-            }
-            else if (nextSectionStickyHeight >= currentSectionStickyHeight) {
-                const newMap = NotebookStickyScroll.checkCollapsedStickyLines(nextCellEntry, 100, notebookEditor);
-                return newMap;
-            }
-            else if (nextSectionStickyHeight < currentSectionStickyHeight) {
-                const availableSpace = sectionBottom - editorScrollTop;
-                if (availableSpace >= nextSectionStickyHeight) {
-                    const linesToRender = Math.floor(availableSpace / 22);
-                    const newMap = NotebookStickyScroll.checkCollapsedStickyLines(cellEntry, linesToRender, notebookEditor);
-                    return newMap;
-                } else {
-                    const newMap = NotebookStickyScroll.checkCollapsedStickyLines(nextCellEntry, 100, notebookEditor);
-                    return newMap;
-                }
-            }
-        }
-    }
-    const sectionBottom = notebookEditor.getLayoutInfo().scrollHeight;
-    const linesToRender = Math.floor((sectionBottom - editorScrollTop) / 22);
-    const newMap = NotebookStickyScroll.checkCollapsedStickyLines(cellEntry, linesToRender, notebookEditor);
-    return newMap;
-}
-
-export { NotebookStickyLine, NotebookStickyScroll, computeContent };