@codingame/monaco-vscode-api 37.0.0 → 37.2.0

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

@@ -1,2546 +0,0 @@
-
-
-async function webviewPreloads(ctx) {
-    const userAgent = navigator.userAgent;
-    const isChrome = (userAgent.indexOf("Chrome") >= 0);
-    const textEncoder = ( new TextEncoder());
-    const textDecoder = ( new TextDecoder());
-    function promiseWithResolvers() {
-        let resolve;
-        let reject;
-        const promise = ( new Promise((res, rej) => {
-            resolve = res;
-            reject = rej;
-        }));
-        return {
-            promise,
-            resolve: resolve,
-            reject: reject
-        };
-    }
-    let currentOptions = ctx.options;
-    const isWorkspaceTrusted = ctx.isWorkspaceTrusted;
-    let currentRenderOptions = ctx.renderOptions;
-    const settingChange = createEmitter();
-    const acquireVsCodeApi = globalThis.acquireVsCodeApi;
-    const vscode = acquireVsCodeApi();
-    delete globalThis.acquireVsCodeApi;
-    const tokenizationStyle = ( new CSSStyleSheet());
-    tokenizationStyle.replaceSync(ctx.style.tokenizationCss);
-    const runWhenIdle = (typeof requestIdleCallback !== "function" || typeof cancelIdleCallback !== "function") ? runner => {
-        setTimeout(() => {
-            if (disposed) {
-                return;
-            }
-            const end = Date.now() + 15;
-            runner(( Object.freeze({
-                didTimeout: true,
-                timeRemaining() {
-                    return Math.max(0, end - Date.now());
-                }
-            })));
-        });
-        let disposed = false;
-        return {
-            dispose() {
-                if (disposed) {
-                    return;
-                }
-                disposed = true;
-            }
-        };
-    } : (runner, timeout) => {
-        const handle = requestIdleCallback(runner, typeof timeout === "number" ? {
-            timeout
-        } : undefined);
-        let disposed = false;
-        return {
-            dispose() {
-                if (disposed) {
-                    return;
-                }
-                disposed = true;
-                cancelIdleCallback(handle);
-            }
-        };
-    };
-    function getOutputContainer(event) {
-        for (const node of event.composedPath()) {
-            if (node instanceof HTMLElement && node.classList.contains("output")) {
-                return {
-                    id: node.id
-                };
-            }
-        }
-        return;
-    }
-    let lastFocusedOutput = undefined;
-    const handleOutputFocusOut = event => {
-        const outputFocus = event && getOutputContainer(event);
-        if (!outputFocus) {
-            return;
-        }
-        lastFocusedOutput = undefined;
-        setTimeout(() => {
-            if (lastFocusedOutput?.id === outputFocus.id) {
-                return;
-            }
-            postNotebookMessage("outputBlur", outputFocus);
-        }, 0);
-    };
-    const hasActiveEditableElement = (parent, root = document) => {
-        const element = root.activeElement;
-        return !!(element && parent.contains(element) && (element.matches(":read-write") || element.tagName.toLowerCase() === "select" || (element.shadowRoot && hasActiveEditableElement(element.shadowRoot, element.shadowRoot))));
-    };
-    const checkOutputInputFocus = e => {
-        lastFocusedOutput = getOutputContainer(e);
-        const activeElement = window.document.activeElement;
-        if (!activeElement) {
-            return;
-        }
-        const id = lastFocusedOutput?.id;
-        if (id && (hasActiveEditableElement(activeElement, window.document))) {
-            postNotebookMessage("outputInputFocus", {
-                inputFocused: true,
-                id
-            });
-            activeElement.addEventListener("blur", () => {
-                postNotebookMessage("outputInputFocus", {
-                    inputFocused: false,
-                    id
-                });
-            }, {
-                once: true
-            });
-        }
-    };
-    const handleInnerClick = event => {
-        if (!event || !event.view || !event.view.document) {
-            return;
-        }
-        const outputFocus = lastFocusedOutput = getOutputContainer(event);
-        for (const node of event.composedPath()) {
-            if (node instanceof HTMLAnchorElement && node.href) {
-                if (node.href.startsWith("blob:")) {
-                    if (outputFocus) {
-                        postNotebookMessage("outputFocus", outputFocus);
-                    }
-                    handleBlobUrlClick(node.href, node.download);
-                } else if (node.href.startsWith("data:")) {
-                    if (outputFocus) {
-                        postNotebookMessage("outputFocus", outputFocus);
-                    }
-                    handleDataUrl(node.href, node.download);
-                } else if (node.getAttribute("href")?.trim().startsWith("#")) {
-                    if (!node.hash) {
-                        postNotebookMessage("scroll-to-reveal", {
-                            scrollTop: 0
-                        });
-                        return;
-                    }
-                    const targetId = node.hash.substring(1);
-                    let scrollTarget = event.view.document.getElementById(targetId);
-                    if (!scrollTarget) {
-                        for (const preview of event.view.document.querySelectorAll(".preview")) {
-                            scrollTarget = preview.shadowRoot?.getElementById(targetId);
-                            if (scrollTarget) {
-                                break;
-                            }
-                        }
-                    }
-                    if (scrollTarget) {
-                        const scrollTop = scrollTarget.getBoundingClientRect().top + event.view.scrollY;
-                        postNotebookMessage("scroll-to-reveal", {
-                            scrollTop
-                        });
-                        return;
-                    }
-                } else {
-                    const href = node.getAttribute("href");
-                    if (href) {
-                        if (href.startsWith("command:") && outputFocus) {
-                            postNotebookMessage("outputFocus", outputFocus);
-                        }
-                        postNotebookMessage("clicked-link", {
-                            href
-                        });
-                    }
-                }
-                event.preventDefault();
-                event.stopPropagation();
-                return;
-            }
-        }
-        if (outputFocus) {
-            postNotebookMessage("outputFocus", outputFocus);
-        }
-    };
-    const blurOutput = () => {
-        const selection = window.getSelection();
-        if (!selection) {
-            return;
-        }
-        selection.removeAllRanges();
-    };
-    const selectOutputContents = cellOrOutputId => {
-        const selection = window.getSelection();
-        if (!selection) {
-            return;
-        }
-        const cellOutputContainer = window.document.getElementById(cellOrOutputId);
-        if (!cellOutputContainer) {
-            return;
-        }
-        selection.removeAllRanges();
-        const range = document.createRange();
-        range.selectNode(cellOutputContainer);
-        selection.addRange(range);
-    };
-    const selectInputContents = cellOrOutputId => {
-        const cellOutputContainer = window.document.getElementById(cellOrOutputId);
-        if (!cellOutputContainer) {
-            return;
-        }
-        const activeElement = window.document.activeElement;
-        if (activeElement && hasActiveEditableElement(activeElement, window.document)) {
-            activeElement.select();
-        }
-    };
-    const onPageUpDownSelectionHandler = e => {
-        if (!lastFocusedOutput?.id || !e.shiftKey) {
-            return;
-        }
-        if (e.shiftKey && (e.code === "ArrowUp" || e.code === "ArrowDown")) {
-            e.stopPropagation();
-            return;
-        }
-        if (!(e.code === "PageUp" || e.code === "PageDown") && !(e.metaKey && (e.code === "ArrowDown" || e.code === "ArrowUp"))) {
-            return;
-        }
-        const outputContainer = window.document.getElementById(lastFocusedOutput.id);
-        const selection = window.getSelection();
-        if (!outputContainer || !selection?.anchorNode) {
-            return;
-        }
-        const activeElement = window.document.activeElement;
-        if (activeElement && hasActiveEditableElement(activeElement, window.document)) {
-            return;
-        }
-        e.stopPropagation();
-        e.preventDefault();
-        const {
-            anchorNode,
-            anchorOffset
-        } = selection;
-        const range = document.createRange();
-        if (e.code === "PageDown" || e.code === "ArrowDown") {
-            range.setStart(anchorNode, anchorOffset);
-            range.setEnd(outputContainer, 1);
-        } else {
-            range.setStart(outputContainer, 0);
-            range.setEnd(anchorNode, anchorOffset);
-        }
-        selection.removeAllRanges();
-        selection.addRange(range);
-    };
-    const disableNativeSelectAll = e => {
-        if (!lastFocusedOutput?.id) {
-            return;
-        }
-        const activeElement = window.document.activeElement;
-        if (activeElement && hasActiveEditableElement(activeElement, window.document)) {
-            return;
-        }
-        if ((e.key === "a" && e.ctrlKey) || (e.metaKey && e.key === "a")) {
-            e.preventDefault();
-            return;
-        }
-    };
-    const handleDataUrl = async (data, downloadName) => {
-        postNotebookMessage("clicked-data-url", {
-            data,
-            downloadName
-        });
-    };
-    const handleBlobUrlClick = async (url, downloadName) => {
-        try {
-            const response = await fetch(url);
-            const blob = await response.blob();
-            const reader = ( new FileReader());
-            reader.addEventListener("load", () => {
-                handleDataUrl(reader.result, downloadName);
-            });
-            reader.readAsDataURL(blob);
-        } catch (e) {
-            console.error(e.message);
-        }
-    };
-    window.document.body.addEventListener("click", handleInnerClick);
-    window.document.body.addEventListener("focusin", checkOutputInputFocus);
-    window.document.body.addEventListener("focusout", handleOutputFocusOut);
-    window.document.body.addEventListener("keydown", onPageUpDownSelectionHandler);
-    window.document.body.addEventListener("keydown", disableNativeSelectAll);
-    function createKernelContext() {
-        return ( Object.freeze({
-            onDidReceiveKernelMessage: onDidReceiveKernelMessage.event,
-            postKernelMessage: data => postNotebookMessage("customKernelMessage", {
-                message: data
-            })
-        }));
-    }
-    async function runKernelPreload(url) {
-        try {
-            return await activateModuleKernelPreload(url);
-        } catch (e) {
-            console.error(e);
-            throw e;
-        }
-    }
-    async function activateModuleKernelPreload(url) {
-        const module = await __import(url);
-        if (!module.activate) {
-            console.error(
-                `Notebook preload '${url}' was expected to be a module but it does not export an 'activate' function`
-            );
-            return;
-        }
-        return module.activate(createKernelContext());
-    }
-    const dimensionUpdater = new (class {
-        constructor() {
-            this.pending = ( new Map());
-        }
-        updateHeight(id, height, options) {
-            if (!this.pending.size) {
-                setTimeout(() => {
-                    this.updateImmediately();
-                }, 0);
-            }
-            const update = this.pending.get(id);
-            if (update && update.isOutput) {
-                this.pending.set(id, {
-                    id,
-                    height,
-                    init: update.init,
-                    isOutput: update.isOutput
-                });
-            } else {
-                this.pending.set(id, {
-                    id,
-                    height,
-                    ...options
-                });
-            }
-        }
-        updateImmediately() {
-            if (!this.pending.size) {
-                return;
-            }
-            postNotebookMessage("dimension", {
-                updates: Array.from(( this.pending.values()))
-            });
-            this.pending.clear();
-        }
-    })();
-    function elementHasContent(height) {
-        return height > 2.1;
-    }
-    const resizeObserver = new (class {
-        constructor() {
-            this._observedElements = ( new WeakMap());
-            this._observer = ( new ResizeObserver(entries => {
-                for (const entry of entries) {
-                    if (!window.document.body.contains(entry.target)) {
-                        continue;
-                    }
-                    const observedElementInfo = this._observedElements.get(entry.target);
-                    if (!observedElementInfo) {
-                        continue;
-                    }
-                    this.postResizeMessage(observedElementInfo.cellId);
-                    if (entry.target.id !== observedElementInfo.id) {
-                        continue;
-                    }
-                    if (!entry.contentRect) {
-                        continue;
-                    }
-                    if (!observedElementInfo.output) {
-                        this.updateHeight(observedElementInfo, entry.target.offsetHeight);
-                        continue;
-                    }
-                    const hasContent = elementHasContent(entry.contentRect.height);
-                    const shouldUpdatePadding = (hasContent && observedElementInfo.lastKnownPadding === 0) || (!hasContent && observedElementInfo.lastKnownPadding !== 0);
-                    if (shouldUpdatePadding) {
-                        window.requestAnimationFrame(() => {
-                            if (hasContent) {
-                                entry.target.style.padding = `${ctx.style.outputNodePadding}px ${ctx.style.outputNodePadding}px ${ctx.style.outputNodePadding}px ${ctx.style.outputNodeLeftPadding}px`;
-                            } else {
-                                entry.target.style.padding = `0px`;
-                            }
-                            this.updateHeight(observedElementInfo, hasContent ? entry.target.offsetHeight : 0);
-                        });
-                    } else {
-                        this.updateHeight(observedElementInfo, hasContent ? entry.target.offsetHeight : 0);
-                    }
-                }
-            }));
-        }
-        updateHeight(observedElementInfo, offsetHeight) {
-            if (observedElementInfo.lastKnownHeight !== offsetHeight) {
-                observedElementInfo.lastKnownHeight = offsetHeight;
-                dimensionUpdater.updateHeight(observedElementInfo.id, offsetHeight, {
-                    isOutput: observedElementInfo.output
-                });
-            }
-        }
-        observe(container, id, output, cellId) {
-            if (( this._observedElements.has(container))) {
-                return;
-            }
-            this._observedElements.set(container, {
-                id,
-                output,
-                lastKnownPadding: ctx.style.outputNodePadding,
-                lastKnownHeight: -1,
-                cellId
-            });
-            this._observer.observe(container);
-        }
-        postResizeMessage(cellId) {
-            clearTimeout(this._outputResizeTimer);
-            this._outputResizeTimer = setTimeout(() => {
-                postNotebookMessage("outputResized", {
-                    cellId
-                });
-            }, 250);
-        }
-    })();
-    let previousDelta;
-    let scrollTimeout;
-    let scrolledElement;
-    let lastTimeScrolled;
-    function flagRecentlyScrolled(node, deltaY) {
-        scrolledElement = node;
-        if (deltaY === undefined) {
-            lastTimeScrolled = Date.now();
-            previousDelta = undefined;
-            node.setAttribute("recentlyScrolled", "true");
-            clearTimeout(scrollTimeout);
-            scrollTimeout = setTimeout(() => {
-                scrolledElement?.removeAttribute("recentlyScrolled");
-            }, 300);
-            return true;
-        }
-        if (node.hasAttribute("recentlyScrolled")) {
-            if (lastTimeScrolled && Date.now() - lastTimeScrolled > 400) {
-                if (!!previousDelta && deltaY < 0 && deltaY < previousDelta - 8) {
-                    clearTimeout(scrollTimeout);
-                    scrolledElement?.removeAttribute("recentlyScrolled");
-                    return false;
-                } else if (!!previousDelta && deltaY > 0 && deltaY > previousDelta + 8) {
-                    clearTimeout(scrollTimeout);
-                    scrolledElement?.removeAttribute("recentlyScrolled");
-                    return false;
-                }
-                clearTimeout(scrollTimeout);
-                scrollTimeout = setTimeout(() => {
-                    scrolledElement?.removeAttribute("recentlyScrolled");
-                }, 50);
-            } else {
-                clearTimeout(scrollTimeout);
-                scrollTimeout = setTimeout(() => {
-                    scrolledElement?.removeAttribute("recentlyScrolled");
-                }, 300);
-            }
-            previousDelta = deltaY;
-            return true;
-        }
-        return false;
-    }
-    function eventTargetShouldHandleScroll(event) {
-        for (let node = event.target; node; node = node.parentNode) {
-            if (!(node instanceof Element) || node.id === "container" || node.classList.contains("cell_container") || node.classList.contains("markup") || node.classList.contains("output_container")) {
-                return false;
-            }
-            if (event.deltaY < 0 && node.scrollTop > 0) {
-                flagRecentlyScrolled(node);
-                return true;
-            }
-            if (event.deltaY > 0 && node.scrollTop + node.clientHeight < node.scrollHeight) {
-                if (node.scrollHeight - node.scrollTop - node.clientHeight < 2) {
-                    continue;
-                }
-                const overflowY = window.getComputedStyle(node).overflowY;
-                if (overflowY === "hidden" || overflowY === "visible") {
-                    continue;
-                }
-                flagRecentlyScrolled(node);
-                return true;
-            }
-            if (flagRecentlyScrolled(node, event.deltaY)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    const handleWheel = event => {
-        if (event.defaultPrevented || eventTargetShouldHandleScroll(event)) {
-            return;
-        }
-        postNotebookMessage("did-scroll-wheel", {
-            payload: {
-                deltaMode: event.deltaMode,
-                deltaX: event.deltaX,
-                deltaY: event.deltaY,
-                deltaZ: event.deltaZ,
-                wheelDelta: event.wheelDelta && isChrome ? (event.wheelDelta / window.devicePixelRatio) : event.wheelDelta,
-                wheelDeltaX: event.wheelDeltaX && isChrome ? (event.wheelDeltaX / window.devicePixelRatio) : event.wheelDeltaX,
-                wheelDeltaY: event.wheelDeltaY && isChrome ? (event.wheelDeltaY / window.devicePixelRatio) : event.wheelDeltaY,
-                detail: event.detail,
-                shiftKey: event.shiftKey,
-                type: event.type
-            }
-        });
-    };
-    function focusFirstFocusableOrContainerInOutput(cellOrOutputId, alternateId) {
-        const cellOutputContainer = window.document.getElementById(cellOrOutputId) ?? (!!alternateId ? window.document.getElementById(alternateId) : undefined);
-        if (!!cellOutputContainer) {
-            if (cellOutputContainer.contains(window.document.activeElement)) {
-                return;
-            }
-            let focusableElement = cellOutputContainer.querySelector("[tabindex=\"0\"], [href], button, input, option, select, textarea");
-            if (!focusableElement) {
-                focusableElement = cellOutputContainer;
-                focusableElement.tabIndex = -1;
-            }
-            if (lastFocusedOutput?.id !== cellOutputContainer.id) {
-                lastFocusedOutput = cellOutputContainer;
-                postNotebookMessage("outputFocus", {
-                    id: cellOutputContainer.id
-                });
-            }
-            focusableElement.focus();
-        }
-    }
-    function createFocusSink(cellId, focusNext) {
-        const element = document.createElement("div");
-        element.id = `focus-sink-${cellId}`;
-        element.tabIndex = 0;
-        element.addEventListener("focus", () => {
-            postNotebookMessage("focus-editor", {
-                cellId: cellId,
-                focusNext
-            });
-        });
-        return element;
-    }
-    function _internalHighlightRange(range, tagName = "mark", attributes = {}) {
-        function _textNodesInRange(range) {
-            if (!range.startContainer.ownerDocument) {
-                return [];
-            }
-            if (range.startContainer.nodeType === Node.TEXT_NODE && range.startOffset > 0) {
-                const startContainer = range.startContainer;
-                const endOffset = range.endOffset;
-                const createdNode = startContainer.splitText(range.startOffset);
-                if (range.endContainer === startContainer) {
-                    range.setEnd(createdNode, endOffset - range.startOffset);
-                }
-                range.setStart(createdNode, 0);
-            }
-            if (range.endContainer.nodeType === Node.TEXT_NODE && range.endOffset < range.endContainer.length) {
-                range.endContainer.splitText(range.endOffset);
-            }
-            const walker = range.startContainer.ownerDocument.createTreeWalker(
-                range.commonAncestorContainer,
-                NodeFilter.SHOW_TEXT,
-                node => range.intersectsNode(node) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT
-            );
-            walker.currentNode = range.startContainer;
-            const nodes = [];
-            if (walker.currentNode.nodeType === Node.TEXT_NODE) {
-                nodes.push(walker.currentNode);
-            }
-            while (walker.nextNode() && range.comparePoint(walker.currentNode, 0) !== 1) {
-                if (walker.currentNode.nodeType === Node.TEXT_NODE) {
-                    nodes.push(walker.currentNode);
-                }
-            }
-            return nodes;
-        }
-        function wrapNodeInHighlight(node, tagName, attributes) {
-            const highlightElement = node.ownerDocument.createElement(tagName);
-            ( Object.keys(attributes)).forEach(key => {
-                highlightElement.setAttribute(key, attributes[key]);
-            });
-            const tempRange = node.ownerDocument.createRange();
-            tempRange.selectNode(node);
-            tempRange.surroundContents(highlightElement);
-            return highlightElement;
-        }
-        if (range.collapsed) {
-            return {
-                remove: () => {},
-                update: () => {}
-            };
-        }
-        const nodes = _textNodesInRange(range);
-        const highlightElements = [];
-        for (const nodeIdx in nodes) {
-            const highlightElement = wrapNodeInHighlight(nodes[nodeIdx], tagName, attributes);
-            highlightElements.push(highlightElement);
-        }
-        function _removeHighlight(highlightElement) {
-            if (highlightElement.childNodes.length === 1) {
-                highlightElement.replaceWith(highlightElement.firstChild);
-            } else {
-                while (highlightElement.firstChild) {
-                    highlightElement.parentNode?.insertBefore(highlightElement.firstChild, highlightElement);
-                }
-                highlightElement.remove();
-            }
-        }
-        function _removeHighlights() {
-            for (const highlightIdx in highlightElements) {
-                _removeHighlight(highlightElements[highlightIdx]);
-            }
-        }
-        function _updateHighlight(highlightElement, attributes = {}) {
-            ( Object.keys(attributes)).forEach(key => {
-                highlightElement.setAttribute(key, attributes[key]);
-            });
-        }
-        function updateHighlights(attributes) {
-            for (const highlightIdx in highlightElements) {
-                _updateHighlight(highlightElements[highlightIdx], attributes);
-            }
-        }
-        return {
-            remove: _removeHighlights,
-            update: updateHighlights
-        };
-    }
-    function highlightRange(range, useCustom, tagName = "mark", attributes = {}) {
-        {
-            const ret = _internalHighlightRange(range, tagName, attributes);
-            return {
-                range: range,
-                dispose: ret.remove,
-                update: (color, className) => {
-                    if (className === undefined) {
-                        ret.update({
-                            "style": `background-color: ${color}`
-                        });
-                    } else {
-                        ret.update({
-                            "class": className
-                        });
-                    }
-                }
-            };
-        }
-    }
-    function createEmitter(listenerChange = () => undefined) {
-        const listeners = ( new Set());
-        return {
-            fire(data) {
-                for (const listener of [...listeners]) {
-                    listener.fn.call(listener.thisArg, data);
-                }
-            },
-            event(fn, thisArg, disposables) {
-                const listenerObj = {
-                    fn,
-                    thisArg
-                };
-                const disposable = {
-                    dispose: () => {
-                        listeners.delete(listenerObj);
-                        listenerChange(listeners);
-                    }
-                };
-                listeners.add(listenerObj);
-                listenerChange(listeners);
-                if (disposables instanceof Array) {
-                    disposables.push(disposable);
-                } else if (disposables) {
-                    disposables.add(disposable);
-                }
-                return disposable;
-            }
-        };
-    }
-    function showRenderError(errorText, outputNode, errors) {
-        outputNode.innerText = errorText;
-        const errList = document.createElement("ul");
-        for (const result of errors) {
-            console.error(result);
-            const item = document.createElement("li");
-            item.innerText = result.message;
-            errList.appendChild(item);
-        }
-        outputNode.appendChild(errList);
-    }
-    const outputItemRequests = new (class {
-        constructor() {
-            this._requestPool = 0;
-            this._requests = ( new Map());
-        }
-        getOutputItem(outputId, mime) {
-            const requestId = this._requestPool++;
-            const {
-                promise,
-                resolve
-            } = promiseWithResolvers();
-            this._requests.set(requestId, {
-                resolve
-            });
-            postNotebookMessage("getOutputItem", {
-                requestId,
-                outputId,
-                mime
-            });
-            return promise;
-        }
-        resolveOutputItem(requestId, output) {
-            const request = this._requests.get(requestId);
-            if (!request) {
-                return;
-            }
-            this._requests.delete(requestId);
-            request.resolve(output);
-        }
-    })();
-    let hasWarnedAboutAllOutputItemsProposal = false;
-    function createOutputItem(id, mime, metadata, valueBytes, allOutputItemData, appended) {
-        function create(id, mime, metadata, valueBytes, appended) {
-            return ( Object.freeze({
-                id,
-                mime,
-                metadata,
-                appendedText() {
-                    if (appended) {
-                        return textDecoder.decode(appended.valueBytes);
-                    }
-                    return undefined;
-                },
-                data() {
-                    return valueBytes;
-                },
-                text() {
-                    return textDecoder.decode(valueBytes);
-                },
-                json() {
-                    return JSON.parse(this.text());
-                },
-                blob() {
-                    return ( new Blob([valueBytes], {
-                        type: this.mime
-                    }));
-                },
-                get _allOutputItems() {
-                    if (!hasWarnedAboutAllOutputItemsProposal) {
-                        hasWarnedAboutAllOutputItemsProposal = true;
-                        console.warn(
-                            `'_allOutputItems' is proposed API. DO NOT ship an extension that depends on it!`
-                        );
-                    }
-                    return allOutputItemList;
-                }
-            }));
-        }
-        const allOutputItemCache = ( new Map());
-        const allOutputItemList = ( Object.freeze(( allOutputItemData.map(outputItem => {
-            const mime = outputItem.mime;
-            return ( Object.freeze({
-                mime,
-                getItem() {
-                    const existingTask = allOutputItemCache.get(mime);
-                    if (existingTask) {
-                        return existingTask;
-                    }
-                    const task = outputItemRequests.getOutputItem(id, mime).then(item => {
-                        return item ? create(id, item.mime, metadata, item.valueBytes) : undefined;
-                    });
-                    allOutputItemCache.set(mime, task);
-                    return task;
-                }
-            }));
-        }))));
-        const item = create(id, mime, metadata, valueBytes, appended);
-        allOutputItemCache.set(mime, Promise.resolve(item));
-        return item;
-    }
-    const onDidReceiveKernelMessage = createEmitter();
-    const ttPolicy = window.trustedTypes?.createPolicy("notebookRenderer", {
-        createHTML: value => value,
-        createScript: value => value
-    });
-    window.addEventListener("wheel", handleWheel);
-    const matchColor = window.getComputedStyle(window.document.getElementById("_defaultColorPalatte")).color;
-    const currentMatchColor = window.getComputedStyle(window.document.getElementById("_defaultColorPalatte")).backgroundColor;
-    class JSHighlighter {
-        constructor() {
-            this._activeHighlightInfo = ( new Map());
-        }
-        addHighlights(matches, ownerID) {
-            for (let i = matches.length - 1; i >= 0; i--) {
-                const match = matches[i];
-                const ret = highlightRange(match.originalRange, true, "mark", match.isShadow ? {
-                    "style": "background-color: " + matchColor + ";"
-                } : {
-                    "class": "find-match"
-                });
-                match.highlightResult = ret;
-            }
-            const highlightInfo = {
-                matches,
-                currentMatchIndex: -1
-            };
-            this._activeHighlightInfo.set(ownerID, highlightInfo);
-        }
-        removeHighlights(ownerID) {
-            this._activeHighlightInfo.get(ownerID)?.matches.forEach(match => {
-                match.highlightResult?.dispose();
-            });
-            this._activeHighlightInfo.delete(ownerID);
-        }
-        highlightCurrentMatch(index, ownerID) {
-            const highlightInfo = this._activeHighlightInfo.get(ownerID);
-            if (!highlightInfo) {
-                console.error("Modified current highlight match before adding highlight list.");
-                return;
-            }
-            const oldMatch = highlightInfo.matches[highlightInfo.currentMatchIndex];
-            oldMatch?.highlightResult?.update(matchColor, oldMatch.isShadow ? undefined : "find-match");
-            const match = highlightInfo.matches[index];
-            highlightInfo.currentMatchIndex = index;
-            const sel = window.getSelection();
-            if (!!match && !!sel && match.highlightResult) {
-                let offset = 0;
-                try {
-                    const outputOffset = window.document.getElementById(match.id).getBoundingClientRect().top;
-                    const tempRange = document.createRange();
-                    tempRange.selectNode(match.highlightResult.range.startContainer);
-                    match.highlightResult.range.startContainer.parentElement?.scrollIntoView({
-                        behavior: "auto",
-                        block: "end",
-                        inline: "nearest"
-                    });
-                    const rangeOffset = tempRange.getBoundingClientRect().top;
-                    tempRange.detach();
-                    offset = rangeOffset - outputOffset;
-                } catch (e) {
-                    console.error(e);
-                }
-                match.highlightResult?.update(currentMatchColor, match.isShadow ? undefined : "current-find-match");
-                window.document.getSelection()?.removeAllRanges();
-                postNotebookMessage("didFindHighlightCurrent", {
-                    offset
-                });
-            }
-        }
-        unHighlightCurrentMatch(index, ownerID) {
-            const highlightInfo = this._activeHighlightInfo.get(ownerID);
-            if (!highlightInfo) {
-                return;
-            }
-            const oldMatch = highlightInfo.matches[index];
-            if (oldMatch && oldMatch.highlightResult) {
-                oldMatch.highlightResult.update(matchColor, oldMatch.isShadow ? undefined : "find-match");
-            }
-        }
-        dispose() {
-            window.document.getSelection()?.removeAllRanges();
-            this._activeHighlightInfo.forEach(highlightInfo => {
-                highlightInfo.matches.forEach(match => {
-                    match.highlightResult?.dispose();
-                });
-            });
-        }
-    }
-    class CSSHighlighter {
-        constructor() {
-            this._activeHighlightInfo = ( new Map());
-            this._matchesHighlight = ( new Highlight());
-            this._matchesHighlight.priority = 1;
-            this._currentMatchesHighlight = ( new Highlight());
-            this._currentMatchesHighlight.priority = 2;
-            CSS.highlights?.set(`find-highlight`, this._matchesHighlight);
-            CSS.highlights?.set(`current-find-highlight`, this._currentMatchesHighlight);
-        }
-        _refreshRegistry(updateMatchesHighlight = true) {
-            if (updateMatchesHighlight) {
-                this._matchesHighlight.clear();
-            }
-            this._currentMatchesHighlight.clear();
-            this._activeHighlightInfo.forEach(highlightInfo => {
-                if (updateMatchesHighlight) {
-                    for (let i = 0; i < highlightInfo.matches.length; i++) {
-                        this._matchesHighlight.add(highlightInfo.matches[i].originalRange);
-                    }
-                }
-                if (highlightInfo.currentMatchIndex < highlightInfo.matches.length && highlightInfo.currentMatchIndex >= 0) {
-                    this._currentMatchesHighlight.add(highlightInfo.matches[highlightInfo.currentMatchIndex].originalRange);
-                }
-            });
-        }
-        addHighlights(matches, ownerID) {
-            for (let i = 0; i < matches.length; i++) {
-                this._matchesHighlight.add(matches[i].originalRange);
-            }
-            const newEntry = {
-                matches,
-                currentMatchIndex: -1
-            };
-            this._activeHighlightInfo.set(ownerID, newEntry);
-        }
-        highlightCurrentMatch(index, ownerID) {
-            const highlightInfo = this._activeHighlightInfo.get(ownerID);
-            if (!highlightInfo) {
-                console.error("Modified current highlight match before adding highlight list.");
-                return;
-            }
-            highlightInfo.currentMatchIndex = index;
-            const match = highlightInfo.matches[index];
-            if (match) {
-                let offset = 0;
-                try {
-                    const outputOffset = window.document.getElementById(match.id).getBoundingClientRect().top;
-                    match.originalRange.startContainer.parentElement?.scrollIntoView({
-                        behavior: "auto",
-                        block: "end",
-                        inline: "nearest"
-                    });
-                    const rangeOffset = match.originalRange.getBoundingClientRect().top;
-                    offset = rangeOffset - outputOffset;
-                    postNotebookMessage("didFindHighlightCurrent", {
-                        offset
-                    });
-                } catch (e) {
-                    console.error(e);
-                }
-            }
-            this._refreshRegistry(false);
-        }
-        unHighlightCurrentMatch(index, ownerID) {
-            const highlightInfo = this._activeHighlightInfo.get(ownerID);
-            if (!highlightInfo) {
-                return;
-            }
-            highlightInfo.currentMatchIndex = -1;
-        }
-        removeHighlights(ownerID) {
-            this._activeHighlightInfo.delete(ownerID);
-            this._refreshRegistry();
-        }
-        dispose() {
-            window.document.getSelection()?.removeAllRanges();
-            this._currentMatchesHighlight.clear();
-            this._matchesHighlight.clear();
-        }
-    }
-    const _highlighter = (CSS.highlights) ? ( new CSSHighlighter()) : ( new JSHighlighter());
-    function extractSelectionLine(selection) {
-        const range = selection.getRangeAt(0);
-        const oldRange = range.cloneRange();
-        const captureLength = ( selection.toString()).length;
-        selection.collapseToStart();
-        selection.modify("move", "backward", "lineboundary");
-        selection.modify("extend", "forward", "lineboundary");
-        const line = ( selection.toString());
-        const rangeStart = getStartOffset(selection.getRangeAt(0), oldRange);
-        const lineRange = {
-            start: rangeStart,
-            end: rangeStart + captureLength
-        };
-        selection.removeAllRanges();
-        selection.addRange(oldRange);
-        return {
-            line,
-            range: lineRange
-        };
-    }
-    function getStartOffset(lineRange, originalRange) {
-        const firstCommonAncestor = findFirstCommonAncestor(lineRange.startContainer, originalRange.startContainer);
-        const selectionOffset = getSelectionOffsetRelativeTo(firstCommonAncestor, lineRange.startContainer) + lineRange.startOffset;
-        const textOffset = getSelectionOffsetRelativeTo(firstCommonAncestor, originalRange.startContainer) + originalRange.startOffset;
-        return textOffset - selectionOffset;
-    }
-    function findFirstCommonAncestor(nodeA, nodeB) {
-        const range = ( new Range());
-        range.setStart(nodeA, 0);
-        range.setEnd(nodeB, 0);
-        return range.commonAncestorContainer;
-    }
-    function getTextContentLength(node) {
-        let length = 0;
-        if (node.nodeType === Node.TEXT_NODE) {
-            length += node.textContent?.length || 0;
-        } else {
-            for (const childNode of node.childNodes) {
-                length += getTextContentLength(childNode);
-            }
-        }
-        return length;
-    }
-    function getSelectionOffsetRelativeTo(parentElement, currentNode) {
-        if (!currentNode) {
-            return 0;
-        }
-        let offset = 0;
-        if (currentNode === parentElement || !parentElement.contains(currentNode)) {
-            return offset;
-        }
-        let prevSibling = currentNode.previousSibling;
-        while (prevSibling) {
-            offset += getTextContentLength(prevSibling);
-            prevSibling = prevSibling.previousSibling;
-        }
-        return offset + getSelectionOffsetRelativeTo(parentElement, currentNode.parentNode);
-    }
-    const find = (query, options) => {
-        let find = true;
-        let matches = [];
-        const range = document.createRange();
-        range.selectNodeContents(window.document.getElementById("findStart"));
-        const sel = window.getSelection();
-        sel?.removeAllRanges();
-        sel?.addRange(range);
-        viewModel.toggleDragDropEnabled(false);
-        try {
-            document.designMode = "On";
-            while (find && matches.length < 500) {
-                find = window.find(
-                    query,
-                     !!options.caseSensitive,
-                     false,
-                     false,
-                     !!options.wholeWord,
-                     true,
-                    false
-                );
-                if (find) {
-                    const selection = window.getSelection();
-                    if (!selection) {
-                        console.log("no selection");
-                        break;
-                    }
-                    if (options.includeMarkup && selection.rangeCount > 0 && selection.getRangeAt(0).startContainer.nodeType === 1 && selection.getRangeAt(0).startContainer.classList.contains("markup")) {
-                        const preview = selection.anchorNode?.firstChild;
-                        const root = preview.shadowRoot;
-                        const shadowSelection = root?.getSelection ? root?.getSelection() : null;
-                        if (shadowSelection && shadowSelection.anchorNode) {
-                            matches.push({
-                                type: "preview",
-                                id: preview.id,
-                                cellId: preview.id,
-                                container: preview,
-                                isShadow: true,
-                                originalRange: shadowSelection.getRangeAt(0),
-                                searchPreviewInfo: options.shouldGetSearchPreviewInfo ? extractSelectionLine(shadowSelection) : undefined
-                            });
-                        }
-                    }
-                    if (options.includeOutput && selection.rangeCount > 0 && selection.getRangeAt(0).startContainer.nodeType === 1 && selection.getRangeAt(0).startContainer.classList.contains("output_container")) {
-                        const cellId = selection.getRangeAt(0).startContainer.parentElement.id;
-                        const outputNode = selection.anchorNode?.firstChild;
-                        const root = outputNode.shadowRoot;
-                        const shadowSelection = root?.getSelection ? root?.getSelection() : null;
-                        if (shadowSelection && shadowSelection.anchorNode) {
-                            matches.push({
-                                type: "output",
-                                id: outputNode.id,
-                                cellId: cellId,
-                                container: outputNode,
-                                isShadow: true,
-                                originalRange: shadowSelection.getRangeAt(0),
-                                searchPreviewInfo: options.shouldGetSearchPreviewInfo ? extractSelectionLine(shadowSelection) : undefined
-                            });
-                        }
-                    }
-                    const anchorNode = selection.anchorNode?.parentElement;
-                    if (anchorNode) {
-                        const lastEl = matches.length ? matches[matches.length - 1] : null;
-                        if (lastEl && lastEl.container.contains(anchorNode) && options.includeOutput) {
-                            matches.push({
-                                type: lastEl.type,
-                                id: lastEl.id,
-                                cellId: lastEl.cellId,
-                                container: lastEl.container,
-                                isShadow: false,
-                                originalRange: selection.getRangeAt(0),
-                                searchPreviewInfo: options.shouldGetSearchPreviewInfo ? extractSelectionLine(selection) : undefined
-                            });
-                        } else {
-                            for (let node = anchorNode; node; node = node.parentElement) {
-                                if (!(node instanceof Element)) {
-                                    break;
-                                }
-                                if (node.classList.contains("output") && options.includeOutput) {
-                                    const cellId = node.parentElement?.parentElement?.id;
-                                    if (cellId) {
-                                        matches.push({
-                                            type: "output",
-                                            id: node.id,
-                                            cellId: cellId,
-                                            container: node,
-                                            isShadow: false,
-                                            originalRange: selection.getRangeAt(0),
-                                            searchPreviewInfo: options.shouldGetSearchPreviewInfo ? extractSelectionLine(selection) : undefined
-                                        });
-                                    }
-                                    break;
-                                }
-                                if (node.id === "container" || node === window.document.body) {
-                                    break;
-                                }
-                            }
-                        }
-                    } else {
-                        break;
-                    }
-                }
-            }
-        } catch (e) {
-            console.log(e);
-        }
-        matches = matches.filter(
-            match => options.findIds.length ? options.findIds.includes(match.cellId) : true
-        );
-        _highlighter.addHighlights(matches, options.ownerID);
-        window.document.getSelection()?.removeAllRanges();
-        viewModel.toggleDragDropEnabled(currentOptions.dragAndDropEnabled);
-        document.designMode = "Off";
-        postNotebookMessage("didFind", {
-            matches: ( matches.map((match, index) => ({
-                type: match.type,
-                id: match.id,
-                cellId: match.cellId,
-                index,
-                searchPreviewInfo: match.searchPreviewInfo
-            })))
-        });
-    };
-    const copyOutputImage = async (outputId, altOutputId, textAlternates, retries = 5) => {
-        if (!window.document.hasFocus() && retries > 0) {
-            setTimeout(() => {
-                copyOutputImage(outputId, altOutputId, textAlternates, retries - 1);
-            }, 50);
-            return;
-        }
-        try {
-            const outputElement = window.document.getElementById(outputId) ?? window.document.getElementById(altOutputId);
-            let image = outputElement?.querySelector("img");
-            if (!image) {
-                const svgImage = outputElement?.querySelector("svg.output-image") ?? outputElement?.querySelector("div.svgContainerStyle > svg");
-                if (svgImage) {
-                    image = ( new Image());
-                    image.src = "data:image/svg+xml," + encodeURIComponent(svgImage.outerHTML);
-                }
-            }
-            if (image) {
-                const ensureImageLoaded = img => {
-                    return ( new Promise((resolve, reject) => {
-                        if (img.complete && img.naturalWidth > 0) {
-                            resolve(img);
-                        } else {
-                            img.onload = () => resolve(img);
-                            img.onerror = () => reject(( new Error("Failed to load image")));
-                            setTimeout(() => reject(( new Error("Image load timeout"))), 5000);
-                        }
-                    }));
-                };
-                const imageToCopy = await ensureImageLoaded(image);
-                const clipboardData = {
-                    "image/png": ( new Promise(resolve => {
-                        const canvas = document.createElement("canvas");
-                        canvas.width = imageToCopy.naturalWidth;
-                        canvas.height = imageToCopy.naturalHeight;
-                        const context = canvas.getContext("2d");
-                        context.drawImage(imageToCopy, 0, 0);
-                        canvas.toBlob(blob => {
-                            if (blob) {
-                                resolve(blob);
-                            } else {
-                                console.error("No blob data to write to clipboard");
-                            }
-                            canvas.remove();
-                        }, "image/png");
-                    }))
-                };
-                if (textAlternates) {
-                    for (const alternate of textAlternates) {
-                        clipboardData[alternate.mimeType] = alternate.content;
-                    }
-                }
-                await navigator.clipboard.write([( new ClipboardItem(clipboardData))]);
-            } else {
-                console.error("Could not find image element to copy for output with id", outputId);
-            }
-        } catch (e) {
-            console.error("Could not copy image:", e);
-        }
-    };
-    window.addEventListener("message", async rawEvent => {
-        const event = rawEvent;
-        switch (event.data.type) {
-        case "initializeMarkup":
-            {
-                try {
-                    await Promise.all(( event.data.cells.map(info => viewModel.ensureMarkupCell(info))));
-                } finally {
-                    dimensionUpdater.updateImmediately();
-                    postNotebookMessage("initializedMarkup", {
-                        requestId: event.data.requestId
-                    });
-                }
-                break;
-            }
-        case "createMarkupCell":
-            viewModel.ensureMarkupCell(event.data.cell);
-            break;
-        case "showMarkupCell":
-            viewModel.showMarkupCell(event.data.id, event.data.top, event.data.content, event.data.metadata);
-            break;
-        case "hideMarkupCells":
-            for (const id of event.data.ids) {
-                viewModel.hideMarkupCell(id);
-            }
-            break;
-        case "unhideMarkupCells":
-            for (const id of event.data.ids) {
-                viewModel.unhideMarkupCell(id);
-            }
-            break;
-        case "deleteMarkupCell":
-            for (const id of event.data.ids) {
-                viewModel.deleteMarkupCell(id);
-            }
-            break;
-        case "updateSelectedMarkupCells":
-            viewModel.updateSelectedCells(event.data.selectedCellIds);
-            break;
-        case "html":
-            {
-                const data = event.data;
-                if (data.createOnIdle) {
-                    outputRunner.enqueueIdle(data.outputId, signal => {
-                        return viewModel.renderOutputCell(data, signal);
-                    });
-                } else {
-                    outputRunner.enqueue(data.outputId, signal => {
-                        return viewModel.renderOutputCell(data, signal);
-                    });
-                }
-                break;
-            }
-        case "view-scroll":
-            {
-                event.data.widgets.forEach(widget => {
-                    outputRunner.enqueue(widget.outputId, () => {
-                        viewModel.updateOutputsScroll([widget]);
-                    });
-                });
-                viewModel.updateMarkupScrolls(event.data.markupCells);
-                break;
-            }
-        case "clear":
-            renderers.clearAll();
-            viewModel.clearAll();
-            window.document.getElementById("container").innerText = "";
-            break;
-        case "clearOutput":
-            {
-                const {
-                    cellId,
-                    rendererId,
-                    outputId
-                } = event.data;
-                outputRunner.cancelOutput(outputId);
-                viewModel.clearOutput(cellId, outputId, rendererId);
-                break;
-            }
-        case "hideOutput":
-            {
-                const {
-                    cellId,
-                    outputId
-                } = event.data;
-                outputRunner.enqueue(outputId, () => {
-                    viewModel.hideOutput(cellId);
-                });
-                break;
-            }
-        case "showOutput":
-            {
-                const {
-                    outputId,
-                    cellTop,
-                    cellId,
-                    content
-                } = event.data;
-                outputRunner.enqueue(outputId, () => {
-                    viewModel.showOutput(cellId, outputId, cellTop);
-                    if (content) {
-                        viewModel.updateAndRerender(cellId, outputId, content);
-                    }
-                });
-                break;
-            }
-        case "copyImage":
-            {
-                await copyOutputImage(event.data.outputId, event.data.altOutputId, event.data.textAlternates);
-                break;
-            }
-        case "ack-dimension":
-            {
-                for (const {
-                    cellId,
-                    outputId,
-                    height
-                } of event.data.updates) {
-                    viewModel.updateOutputHeight(cellId, outputId, height);
-                }
-                break;
-            }
-        case "preload":
-            {
-                const resources = event.data.resources;
-                for (const {
-                    uri
-                } of resources) {
-                    kernelPreloads.load(uri);
-                }
-                break;
-            }
-        case "updateRenderers":
-            {
-                const {
-                    rendererData
-                } = event.data;
-                renderers.updateRendererData(rendererData);
-                break;
-            }
-        case "focus-output":
-            focusFirstFocusableOrContainerInOutput(event.data.cellOrOutputId, event.data.alternateId);
-            break;
-        case "blur-output":
-            blurOutput();
-            break;
-        case "select-output-contents":
-            selectOutputContents(event.data.cellOrOutputId);
-            break;
-        case "select-input-contents":
-            selectInputContents(event.data.cellOrOutputId);
-            break;
-        case "decorations":
-            {
-                let outputContainer = window.document.getElementById(event.data.cellId);
-                if (!outputContainer) {
-                    viewModel.ensureOutputCell(event.data.cellId, -1e5, true);
-                    outputContainer = window.document.getElementById(event.data.cellId);
-                }
-                outputContainer?.classList.add(...event.data.addedClassNames);
-                outputContainer?.classList.remove(...event.data.removedClassNames);
-                break;
-            }
-        case "markupDecorations":
-            {
-                const markupCell = window.document.getElementById(event.data.cellId);
-                if (markupCell) {
-                    markupCell?.classList.add(...event.data.addedClassNames);
-                    markupCell?.classList.remove(...event.data.removedClassNames);
-                }
-                break;
-            }
-        case "customKernelMessage":
-            onDidReceiveKernelMessage.fire(event.data.message);
-            break;
-        case "customRendererMessage":
-            renderers.getRenderer(event.data.rendererId)?.receiveMessage(event.data.message);
-            break;
-        case "notebookStyles":
-            {
-                const documentStyle = window.document.documentElement.style;
-                for (let i = documentStyle.length - 1; i >= 0; i--) {
-                    const property = documentStyle[i];
-                    if (property && property.startsWith("--notebook-")) {
-                        documentStyle.removeProperty(property);
-                    }
-                }
-                for (const [name, value] of Object.entries(event.data.styles)) {
-                    documentStyle.setProperty(`--${name}`, value);
-                }
-                break;
-            }
-        case "notebookOptions":
-            currentOptions = event.data.options;
-            viewModel.toggleDragDropEnabled(currentOptions.dragAndDropEnabled);
-            currentRenderOptions = event.data.renderOptions;
-            settingChange.fire(currentRenderOptions);
-            break;
-        case "tokenizedCodeBlock":
-            {
-                const {
-                    codeBlockId,
-                    html
-                } = event.data;
-                MarkdownCodeBlock.highlightCodeBlock(codeBlockId, html);
-                break;
-            }
-        case "tokenizedStylesChanged":
-            {
-                tokenizationStyle.replaceSync(event.data.css);
-                break;
-            }
-        case "find":
-            {
-                _highlighter.removeHighlights(event.data.options.ownerID);
-                find(event.data.query, event.data.options);
-                break;
-            }
-        case "findHighlightCurrent":
-            {
-                _highlighter?.highlightCurrentMatch(event.data.index, event.data.ownerID);
-                break;
-            }
-        case "findUnHighlightCurrent":
-            {
-                _highlighter?.unHighlightCurrentMatch(event.data.index, event.data.ownerID);
-                break;
-            }
-        case "findStop":
-            {
-                _highlighter.removeHighlights(event.data.ownerID);
-                break;
-            }
-        case "returnOutputItem":
-            {
-                outputItemRequests.resolveOutputItem(event.data.requestId, event.data.output);
-            }
-        }
-    });
-    const renderFallbackErrorName = "vscode.fallbackToNextRenderer";
-    class Renderer {
-        constructor(data) {
-            this.data = data;
-            this._onMessageEvent = createEmitter();
-        }
-        receiveMessage(message) {
-            this._onMessageEvent.fire(message);
-        }
-        async renderOutputItem(item, element, signal) {
-            try {
-                await this.load();
-            } catch (e) {
-                if (!signal.aborted) {
-                    showRenderError(
-                        `Error loading renderer '${this.data.id}'`,
-                        element,
-                        e instanceof Error ? [e] : []
-                    );
-                }
-                return;
-            }
-            if (!this._api) {
-                if (!signal.aborted) {
-                    showRenderError(
-                        `Renderer '${this.data.id}' does not implement renderOutputItem`,
-                        element,
-                        []
-                    );
-                }
-                return;
-            }
-            try {
-                const renderStart = performance.now();
-                await this._api.renderOutputItem(item, element, signal);
-                this.postDebugMessage("Rendered output item", {
-                    id: item.id,
-                    duration: `${performance.now() - renderStart}ms`
-                });
-            } catch (e) {
-                if (signal.aborted) {
-                    return;
-                }
-                if (e instanceof Error && e.name === renderFallbackErrorName) {
-                    throw e;
-                }
-                showRenderError(
-                    `Error rendering output item using '${this.data.id}'`,
-                    element,
-                    e instanceof Error ? [e] : []
-                );
-                this.postDebugMessage("Rendering output item failed", {
-                    id: item.id,
-                    error: e + ""
-                });
-            }
-        }
-        disposeOutputItem(id) {
-            this._api?.disposeOutputItem?.(id);
-        }
-        createRendererContext() {
-            const {
-                id,
-                messaging
-            } = this.data;
-            const context = {
-                setState: newState => vscode.setState({
-                    ...vscode.getState(),
-                    [id]: newState
-                }),
-                getState: () => {
-                    const state = vscode.getState();
-                    return typeof state === "object" && state ? state[id] : undefined;
-                },
-                getRenderer: async id => {
-                    const renderer = renderers.getRenderer(id);
-                    if (!renderer) {
-                        return undefined;
-                    }
-                    if (renderer._api) {
-                        return renderer._api;
-                    }
-                    return renderer.load();
-                },
-                workspace: {
-                    get isTrusted() {
-                        return isWorkspaceTrusted;
-                    }
-                },
-                settings: {
-                    get lineLimit() {
-                        return currentRenderOptions.lineLimit;
-                    },
-                    get outputScrolling() {
-                        return currentRenderOptions.outputScrolling;
-                    },
-                    get outputWordWrap() {
-                        return currentRenderOptions.outputWordWrap;
-                    },
-                    get linkifyFilePaths() {
-                        return currentRenderOptions.linkifyFilePaths;
-                    },
-                    get minimalError() {
-                        return currentRenderOptions.minimalError;
-                    }
-                },
-                get onDidChangeSettings() {
-                    return settingChange.event;
-                }
-            };
-            if (messaging) {
-                context.onDidReceiveMessage = this._onMessageEvent.event;
-                context.postMessage = message => postNotebookMessage("customRendererMessage", {
-                    rendererId: id,
-                    message
-                });
-            }
-            return ( Object.freeze(context));
-        }
-        load() {
-            this._loadPromise ??= this._load();
-            return this._loadPromise;
-        }
-        async _load() {
-            this.postDebugMessage("Start loading renderer");
-            try {
-                await kernelPreloads.waitForAllCurrent();
-                const importStart = performance.now();
-                const module = await __import(this.data.entrypoint.path);
-                this.postDebugMessage("Imported renderer", {
-                    duration: `${performance.now() - importStart}ms`
-                });
-                if (!module) {
-                    return;
-                }
-                this._api = await module.activate(this.createRendererContext());
-                this.postDebugMessage("Activated renderer", {
-                    duration: `${performance.now() - importStart}ms`
-                });
-                const dependantRenderers = ctx.rendererData.filter(d => d.entrypoint.extends === this.data.id);
-                if (dependantRenderers.length) {
-                    this.postDebugMessage("Activating dependant renderers", {
-                        dependents: ( dependantRenderers.map(x => x.id)).join(", ")
-                    });
-                }
-                await Promise.all(( dependantRenderers.map(async d => {
-                    const renderer = renderers.getRenderer(d.id);
-                    if (!renderer) {
-                        throw ( new Error(`Could not find extending renderer: ${d.id}`));
-                    }
-                    try {
-                        return await renderer.load();
-                    } catch (e) {
-                        console.error(e);
-                        this.postDebugMessage("Activating dependant renderer failed", {
-                            dependent: d.id,
-                            error: e + ""
-                        });
-                        return undefined;
-                    }
-                })));
-                return this._api;
-            } catch (e) {
-                this.postDebugMessage("Loading renderer failed");
-                throw e;
-            }
-        }
-        postDebugMessage(msg, data) {
-            postNotebookMessage("logRendererDebugMessage", {
-                message: `[renderer ${this.data.id}] - ${msg}`,
-                data
-            });
-        }
-    }
-    const kernelPreloads = new (class {
-        constructor() {
-            this.preloads = ( new Map());
-        }
-        waitFor(uri) {
-            return this.preloads.get(uri) || Promise.resolve(( new Error(`Preload not ready: ${uri}`)));
-        }
-        load(uri) {
-            const promise = Promise.all([runKernelPreload(uri), this.waitForAllCurrent()]);
-            this.preloads.set(uri, promise);
-            return promise;
-        }
-        waitForAllCurrent() {
-            return Promise.all(( [...( this.preloads.values())].map(p => p.catch(err => err))));
-        }
-    })();
-    const outputRunner = new (class {
-        constructor() {
-            this.outputs = ( new Map());
-            this.pendingOutputCreationRequest = ( new Map());
-        }
-        enqueue(outputId, action) {
-            this.pendingOutputCreationRequest.get(outputId)?.dispose();
-            this.pendingOutputCreationRequest.delete(outputId);
-            const record = this.outputs.get(outputId);
-            if (!record) {
-                const controller = ( new AbortController());
-                this.outputs.set(outputId, {
-                    abort: controller,
-                    queue: ( new Promise(r => r(action(controller.signal))))
-                });
-            } else {
-                record.queue = record.queue.then(async r => {
-                    if (!record.abort.signal.aborted) {
-                        await action(record.abort.signal);
-                    }
-                });
-            }
-        }
-        enqueueIdle(outputId, action) {
-            this.pendingOutputCreationRequest.get(outputId)?.dispose();
-            outputRunner.pendingOutputCreationRequest.set(outputId, runWhenIdle(() => {
-                outputRunner.enqueue(outputId, action);
-                outputRunner.pendingOutputCreationRequest.delete(outputId);
-            }));
-        }
-        cancelAll() {
-            this.pendingOutputCreationRequest.forEach(r => r.dispose());
-            this.pendingOutputCreationRequest.clear();
-            for (const {
-                abort
-            } of ( this.outputs.values())) {
-                abort.abort();
-            }
-            this.outputs.clear();
-        }
-        cancelOutput(outputId) {
-            this.pendingOutputCreationRequest.get(outputId)?.dispose();
-            this.pendingOutputCreationRequest.delete(outputId);
-            const output = this.outputs.get(outputId);
-            if (output) {
-                output.abort.abort();
-                this.outputs.delete(outputId);
-            }
-        }
-    })();
-    const renderers = new (class {
-        constructor() {
-            this._renderers = ( new Map());
-            for (const renderer of ctx.rendererData) {
-                this.addRenderer(renderer);
-            }
-        }
-        getRenderer(id) {
-            return this._renderers.get(id);
-        }
-        rendererEqual(a, b) {
-            if (a.id !== b.id || a.entrypoint.path !== b.entrypoint.path || a.entrypoint.extends !== b.entrypoint.extends || a.messaging !== b.messaging) {
-                return false;
-            }
-            if (a.mimeTypes.length !== b.mimeTypes.length) {
-                return false;
-            }
-            for (let i = 0; i < a.mimeTypes.length; i++) {
-                if (a.mimeTypes[i] !== b.mimeTypes[i]) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        updateRendererData(rendererData) {
-            const oldKeys = ( new Set(( this._renderers.keys())));
-            const newKeys = ( new Set(( rendererData.map(d => d.id))));
-            for (const renderer of rendererData) {
-                const existing = this._renderers.get(renderer.id);
-                if (existing && this.rendererEqual(existing.data, renderer)) {
-                    continue;
-                }
-                this.addRenderer(renderer);
-            }
-            for (const key of oldKeys) {
-                if (!( newKeys.has(key))) {
-                    this._renderers.delete(key);
-                }
-            }
-        }
-        addRenderer(renderer) {
-            this._renderers.set(renderer.id, ( new Renderer(renderer)));
-        }
-        clearAll() {
-            outputRunner.cancelAll();
-            for (const renderer of ( this._renderers.values())) {
-                renderer.disposeOutputItem();
-            }
-        }
-        clearOutput(rendererId, outputId) {
-            outputRunner.cancelOutput(outputId);
-            this._renderers.get(rendererId)?.disposeOutputItem(outputId);
-        }
-        async render(item, preferredRendererId, element, signal) {
-            const primaryRenderer = this.findRenderer(preferredRendererId, item);
-            if (!primaryRenderer) {
-                const errorMessage = (window.document.documentElement.style.getPropertyValue("--notebook-cell-renderer-not-found-error") || "").replace("$0", () => item.mime);
-                this.showRenderError(item, element, errorMessage);
-                return;
-            }
-            if (!(await this._doRender(item, element, primaryRenderer, signal)).continue) {
-                return;
-            }
-            for (const additionalItemData of item._allOutputItems) {
-                if (additionalItemData.mime === item.mime) {
-                    continue;
-                }
-                const additionalItem = await additionalItemData.getItem();
-                if (signal.aborted) {
-                    return;
-                }
-                if (additionalItem) {
-                    const renderer = this.findRenderer(undefined, additionalItem);
-                    if (renderer) {
-                        if (!(await this._doRender(additionalItem, element, renderer, signal)).continue) {
-                            return;
-                        }
-                    }
-                }
-            }
-            const errorMessage = (window.document.documentElement.style.getPropertyValue("--notebook-cell-renderer-fallbacks-exhausted") || "").replace("$0", () => item.mime);
-            this.showRenderError(item, element, errorMessage);
-        }
-        async _doRender(item, element, renderer, signal) {
-            try {
-                await renderer.renderOutputItem(item, element, signal);
-                return {
-                    continue: false
-                };
-            } catch (e) {
-                if (signal.aborted) {
-                    return {
-                        continue: false
-                    };
-                }
-                if (e instanceof Error && e.name === renderFallbackErrorName) {
-                    return {
-                        continue: true
-                    };
-                } else {
-                    throw e;
-                }
-            }
-        }
-        findRenderer(preferredRendererId, info) {
-            let renderer;
-            if (typeof preferredRendererId === "string") {
-                renderer = Array.from(( this._renderers.values())).find(renderer => renderer.data.id === preferredRendererId);
-            } else {
-                const renderers = Array.from(( this._renderers.values())).filter(
-                    renderer => renderer.data.mimeTypes.includes(info.mime) && !renderer.data.entrypoint.extends
-                );
-                if (renderers.length) {
-                    renderers.sort((a, b) => +a.data.isBuiltin - +b.data.isBuiltin);
-                    renderer = renderers[0];
-                }
-            }
-            return renderer;
-        }
-        showRenderError(info, element, errorMessage) {
-            const errorContainer = document.createElement("div");
-            const error = document.createElement("div");
-            error.className = "no-renderer-error";
-            error.innerText = errorMessage;
-            const cellText = document.createElement("div");
-            cellText.innerText = info.text();
-            errorContainer.appendChild(error);
-            errorContainer.appendChild(cellText);
-            element.innerText = "";
-            element.appendChild(errorContainer);
-        }
-    })();
-    const viewModel = new (class ViewModel {
-        constructor() {
-            this._markupCells = ( new Map());
-            this._outputCells = ( new Map());
-        }
-        clearAll() {
-            for (const cell of ( this._markupCells.values())) {
-                cell.dispose();
-            }
-            this._markupCells.clear();
-            for (const output of ( this._outputCells.values())) {
-                output.dispose();
-            }
-            this._outputCells.clear();
-        }
-        async createMarkupCell(init, top, visible) {
-            const existing = this._markupCells.get(init.cellId);
-            if (existing) {
-                console.error(`Trying to create markup that already exists: ${init.cellId}`);
-                return existing;
-            }
-            const cell = ( new MarkupCell(init.cellId, init.mime, init.content, top, init.metadata));
-            cell.element.style.visibility = visible ? "" : "hidden";
-            this._markupCells.set(init.cellId, cell);
-            await cell.ready;
-            return cell;
-        }
-        async ensureMarkupCell(info) {
-            let cell = this._markupCells.get(info.cellId);
-            if (cell) {
-                cell.element.style.visibility = info.visible ? "" : "hidden";
-                await cell.updateContentAndRender(info.content, info.metadata);
-            } else {
-                cell = await this.createMarkupCell(info, info.offset, info.visible);
-            }
-        }
-        deleteMarkupCell(id) {
-            const cell = this.getExpectedMarkupCell(id);
-            if (cell) {
-                cell.remove();
-                cell.dispose();
-                this._markupCells.delete(id);
-            }
-        }
-        async updateMarkupContent(id, newContent, metadata) {
-            const cell = this.getExpectedMarkupCell(id);
-            await cell?.updateContentAndRender(newContent, metadata);
-        }
-        showMarkupCell(id, top, newContent, metadata) {
-            const cell = this.getExpectedMarkupCell(id);
-            cell?.show(top, newContent, metadata);
-        }
-        hideMarkupCell(id) {
-            const cell = this.getExpectedMarkupCell(id);
-            cell?.hide();
-        }
-        unhideMarkupCell(id) {
-            const cell = this.getExpectedMarkupCell(id);
-            cell?.unhide();
-        }
-        getExpectedMarkupCell(id) {
-            const cell = this._markupCells.get(id);
-            if (!cell) {
-                console.log(`Could not find markup cell '${id}'`);
-                return undefined;
-            }
-            return cell;
-        }
-        updateSelectedCells(selectedCellIds) {
-            const selectedCellSet = ( new Set(selectedCellIds));
-            for (const cell of ( this._markupCells.values())) {
-                cell.setSelected(( selectedCellSet.has(cell.id)));
-            }
-        }
-        toggleDragDropEnabled(dragAndDropEnabled) {
-            for (const cell of ( this._markupCells.values())) {
-                cell.toggleDragDropEnabled(dragAndDropEnabled);
-            }
-        }
-        updateMarkupScrolls(markupCells) {
-            for (const {
-                id,
-                top
-            } of markupCells) {
-                const cell = this._markupCells.get(id);
-                if (cell) {
-                    cell.element.style.top = `${top}px`;
-                }
-            }
-        }
-        async renderOutputCell(data, signal) {
-            const preloadErrors = await Promise.all(( data.requiredPreloads.map(p => kernelPreloads.waitFor(p.uri).then(() => undefined, err => err))));
-            if (signal.aborted) {
-                return;
-            }
-            const cellOutput = this.ensureOutputCell(data.cellId, data.cellTop, false);
-            return cellOutput.renderOutputElement(data, preloadErrors, signal);
-        }
-        ensureOutputCell(cellId, cellTop, skipCellTopUpdateIfExist) {
-            let cell = this._outputCells.get(cellId);
-            const existed = !!cell;
-            if (!cell) {
-                cell = ( new OutputCell(cellId));
-                this._outputCells.set(cellId, cell);
-            }
-            if (existed && skipCellTopUpdateIfExist) {
-                return cell;
-            }
-            cell.element.style.top = cellTop + "px";
-            return cell;
-        }
-        clearOutput(cellId, outputId, rendererId) {
-            const cell = this._outputCells.get(cellId);
-            cell?.clearOutput(outputId, rendererId);
-        }
-        showOutput(cellId, outputId, top) {
-            const cell = this._outputCells.get(cellId);
-            cell?.show(outputId, top);
-        }
-        updateAndRerender(cellId, outputId, content) {
-            const cell = this._outputCells.get(cellId);
-            cell?.updateContentAndRerender(outputId, content);
-        }
-        hideOutput(cellId) {
-            const cell = this._outputCells.get(cellId);
-            cell?.hide();
-        }
-        updateOutputHeight(cellId, outputId, height) {
-            const cell = this._outputCells.get(cellId);
-            cell?.updateOutputHeight(outputId, height);
-        }
-        updateOutputsScroll(updates) {
-            for (const request of updates) {
-                const cell = this._outputCells.get(request.cellId);
-                cell?.updateScroll(request);
-            }
-        }
-    })();
-    class MarkdownCodeBlock {
-        static {
-            this.pendingCodeBlocksToHighlight = ( new Map());
-        }
-        static highlightCodeBlock(id, html) {
-            const el = MarkdownCodeBlock.pendingCodeBlocksToHighlight.get(id);
-            if (!el) {
-                return;
-            }
-            const trustedHtml = ttPolicy?.createHTML(html) ?? html;
-            el.innerHTML = trustedHtml;
-            const root = el.getRootNode();
-            if (root instanceof ShadowRoot) {
-                if (!root.adoptedStyleSheets.includes(tokenizationStyle)) {
-                    root.adoptedStyleSheets.push(tokenizationStyle);
-                }
-            }
-        }
-        static requestHighlightCodeBlock(root) {
-            const codeBlocks = [];
-            let i = 0;
-            for (const el of root.querySelectorAll(".vscode-code-block")) {
-                const lang = el.getAttribute("data-vscode-code-block-lang");
-                if (el.textContent && lang) {
-                    const id = `${Date.now()}-${i++}`;
-                    codeBlocks.push({
-                        value: el.textContent,
-                        lang: lang,
-                        id
-                    });
-                    MarkdownCodeBlock.pendingCodeBlocksToHighlight.set(id, el);
-                }
-            }
-            return codeBlocks;
-        }
-    }
-    class MarkupCell {
-        constructor(id, mime, content, top, metadata) {
-            this._isDisposed = false;
-            const self = this;
-            this.id = id;
-            this._content = {
-                value: content,
-                version: 0,
-                metadata: metadata
-            };
-            const {
-                promise,
-                resolve,
-                reject
-            } = promiseWithResolvers();
-            this.ready = promise;
-            let cachedData;
-            this.outputItem = ( Object.freeze({
-                id,
-                mime,
-                get metadata() {
-                    return self._content.metadata;
-                },
-                text: () => {
-                    return this._content.value;
-                },
-                json: () => {
-                    return undefined;
-                },
-                data: () => {
-                    if (cachedData?.version === this._content.version) {
-                        return cachedData.value;
-                    }
-                    const data = textEncoder.encode(this._content.value);
-                    cachedData = {
-                        version: this._content.version,
-                        value: data
-                    };
-                    return data;
-                },
-                blob() {
-                    return ( new Blob([this.data()], {
-                        type: this.mime
-                    }));
-                },
-                _allOutputItems: [{
-                    mime,
-                    getItem: async () => this.outputItem
-                }]
-            }));
-            const root = window.document.getElementById("container");
-            const markupCell = document.createElement("div");
-            markupCell.className = "markup";
-            markupCell.style.position = "absolute";
-            markupCell.style.width = "100%";
-            this.element = document.createElement("div");
-            this.element.id = this.id;
-            this.element.classList.add("preview");
-            this.element.style.position = "absolute";
-            this.element.style.top = top + "px";
-            this.toggleDragDropEnabled(currentOptions.dragAndDropEnabled);
-            markupCell.appendChild(this.element);
-            root.appendChild(markupCell);
-            this.addEventListeners();
-            this.updateContentAndRender(this._content.value, this._content.metadata).then(() => {
-                if (!this._isDisposed) {
-                    resizeObserver.observe(this.element, this.id, false, this.id);
-                }
-                resolve();
-            }, () => reject());
-        }
-        dispose() {
-            this._isDisposed = true;
-            this.renderTaskAbort?.abort();
-            this.renderTaskAbort = undefined;
-        }
-        addEventListeners() {
-            this.element.addEventListener("dblclick", () => {
-                postNotebookMessage("toggleMarkupPreview", {
-                    cellId: this.id
-                });
-            });
-            this.element.addEventListener("click", e => {
-                postNotebookMessage("clickMarkupCell", {
-                    cellId: this.id,
-                    altKey: e.altKey,
-                    ctrlKey: e.ctrlKey,
-                    metaKey: e.metaKey,
-                    shiftKey: e.shiftKey
-                });
-            });
-            this.element.addEventListener("contextmenu", e => {
-                postNotebookMessage("contextMenuMarkupCell", {
-                    cellId: this.id,
-                    clientX: e.clientX,
-                    clientY: e.clientY
-                });
-            });
-            this.element.addEventListener("mouseenter", () => {
-                postNotebookMessage("mouseEnterMarkupCell", {
-                    cellId: this.id
-                });
-            });
-            this.element.addEventListener("mouseleave", () => {
-                postNotebookMessage("mouseLeaveMarkupCell", {
-                    cellId: this.id
-                });
-            });
-            this.element.addEventListener("dragstart", e => {
-                markupCellDragManager.startDrag(e, this.id);
-            });
-            this.element.addEventListener("drag", e => {
-                markupCellDragManager.updateDrag(e, this.id);
-            });
-            this.element.addEventListener("dragend", e => {
-                markupCellDragManager.endDrag(e, this.id);
-            });
-        }
-        async updateContentAndRender(newContent, metadata) {
-            this._content = {
-                value: newContent,
-                version: this._content.version + 1,
-                metadata
-            };
-            this.renderTaskAbort?.abort();
-            const controller = ( new AbortController());
-            this.renderTaskAbort = controller;
-            try {
-                await renderers.render(this.outputItem, undefined, this.element, this.renderTaskAbort.signal);
-            } finally {
-                if (this.renderTaskAbort === controller) {
-                    this.renderTaskAbort = undefined;
-                }
-            }
-            const root = (this.element.shadowRoot ?? this.element);
-            const html = [];
-            for (const child of root.children) {
-                switch (child.tagName) {
-                case "LINK":
-                case "SCRIPT":
-                case "STYLE":
-                    break;
-                default:
-                    html.push(child.outerHTML);
-                    break;
-                }
-            }
-            const codeBlocks = MarkdownCodeBlock.requestHighlightCodeBlock(root);
-            postNotebookMessage("renderedMarkup", {
-                cellId: this.id,
-                html: html.join(""),
-                codeBlocks
-            });
-            dimensionUpdater.updateHeight(this.id, this.element.offsetHeight, {
-                isOutput: false
-            });
-        }
-        show(top, newContent, metadata) {
-            this.element.style.visibility = "";
-            this.element.style.top = `${top}px`;
-            if (typeof newContent === "string" || metadata) {
-                this.updateContentAndRender(newContent ?? this._content.value, metadata ?? this._content.metadata);
-            } else {
-                this.updateMarkupDimensions();
-            }
-        }
-        hide() {
-            this.element.style.visibility = "hidden";
-        }
-        unhide() {
-            this.element.style.visibility = "";
-            this.updateMarkupDimensions();
-        }
-        remove() {
-            this.element.remove();
-        }
-        async updateMarkupDimensions() {
-            dimensionUpdater.updateHeight(this.id, this.element.offsetHeight, {
-                isOutput: false
-            });
-        }
-        setSelected(selected) {
-            this.element.classList.toggle("selected", selected);
-        }
-        toggleDragDropEnabled(enabled) {
-            if (enabled) {
-                this.element.classList.add("draggable");
-                this.element.setAttribute("draggable", "true");
-            } else {
-                this.element.classList.remove("draggable");
-                this.element.removeAttribute("draggable");
-            }
-        }
-    }
-    class OutputCell {
-        constructor(cellId) {
-            this.outputElements = ( new Map());
-            const container = window.document.getElementById("container");
-            const upperWrapperElement = createFocusSink(cellId);
-            container.appendChild(upperWrapperElement);
-            this.element = document.createElement("div");
-            this.element.style.position = "absolute";
-            this.element.style.outline = "0";
-            this.element.id = cellId;
-            this.element.classList.add("cell_container");
-            container.appendChild(this.element);
-            this.element = this.element;
-            const lowerWrapperElement = createFocusSink(cellId, true);
-            container.appendChild(lowerWrapperElement);
-        }
-        dispose() {
-            for (const output of ( this.outputElements.values())) {
-                output.dispose();
-            }
-            this.outputElements.clear();
-        }
-        createOutputElement(data) {
-            let outputContainer = this.outputElements.get(data.outputId);
-            if (!outputContainer) {
-                outputContainer = ( new OutputContainer(data.outputId));
-                this.element.appendChild(outputContainer.element);
-                this.outputElements.set(data.outputId, outputContainer);
-            }
-            return outputContainer.createOutputElement(data.outputId, data.outputOffset, data.left, data.cellId);
-        }
-        async renderOutputElement(data, preloadErrors, signal) {
-            const startTime = Date.now();
-            const outputElement  = this.createOutputElement(data);
-            await outputElement.render(data.content, data.rendererId, preloadErrors, signal);
-            outputElement .element.style.visibility = data.initiallyHidden ? "hidden" : "";
-            if (!!data.executionId && !!data.rendererId) {
-                let outputSize = undefined;
-                if (data.content.type === 1 ) {
-                    outputSize = data.content.output.valueBytes.length;
-                }
-                if (outputSize !== undefined && outputSize > 0 && outputSize < 100 * 1024) {
-                    postNotebookMessage("notebookPerformanceMessage", {
-                        cellId: data.cellId,
-                        executionId: data.executionId,
-                        duration: Date.now() - startTime,
-                        rendererId: data.rendererId,
-                        outputSize
-                    });
-                }
-            }
-        }
-        clearOutput(outputId, rendererId) {
-            const output = this.outputElements.get(outputId);
-            output?.clear(rendererId);
-            output?.dispose();
-            this.outputElements.delete(outputId);
-        }
-        show(outputId, top) {
-            const outputContainer = this.outputElements.get(outputId);
-            if (!outputContainer) {
-                return;
-            }
-            this.element.style.visibility = "";
-            this.element.style.top = `${top}px`;
-        }
-        hide() {
-            this.element.style.visibility = "hidden";
-        }
-        updateContentAndRerender(outputId, content) {
-            this.outputElements.get(outputId)?.updateContentAndRender(content);
-        }
-        updateOutputHeight(outputId, height) {
-            this.outputElements.get(outputId)?.updateHeight(height);
-        }
-        updateScroll(request) {
-            this.element.style.top = `${request.cellTop}px`;
-            const outputElement = this.outputElements.get(request.outputId);
-            if (outputElement) {
-                outputElement.updateScroll(request.outputOffset);
-                if (request.forceDisplay && outputElement.outputNode) {
-                    outputElement.outputNode.element.style.visibility = "";
-                }
-            }
-            if (request.forceDisplay) {
-                this.element.style.visibility = "";
-            }
-        }
-    }
-    class OutputContainer {
-        get outputNode() {
-            return this._outputNode;
-        }
-        constructor(outputId) {
-            this.outputId = outputId;
-            this.element = document.createElement("div");
-            this.element.classList.add("output_container");
-            this.element.setAttribute("data-vscode-context", JSON.stringify({
-                "preventDefaultContextMenuItems": true
-            }));
-            this.element.style.position = "absolute";
-            this.element.style.overflow = "hidden";
-        }
-        dispose() {
-            this._outputNode?.dispose();
-        }
-        clear(rendererId) {
-            if (rendererId) {
-                renderers.clearOutput(rendererId, this.outputId);
-            }
-            this.element.remove();
-        }
-        updateHeight(height) {
-            this.element.style.maxHeight = `${height}px`;
-            this.element.style.height = `${height}px`;
-        }
-        updateScroll(outputOffset) {
-            this.element.style.top = `${outputOffset}px`;
-        }
-        createOutputElement(outputId, outputOffset, left, cellId) {
-            this.element.innerText = "";
-            this.element.style.maxHeight = "0px";
-            this.element.style.top = `${outputOffset}px`;
-            this._outputNode?.dispose();
-            this._outputNode = ( new OutputElement(outputId, left, cellId));
-            this.element.appendChild(this._outputNode.element);
-            return this._outputNode;
-        }
-        updateContentAndRender(content) {
-            this._outputNode?.updateAndRerender(content);
-        }
-    }
-    vscode.postMessage({
-        __vscode_notebook_message: true,
-        type: "initialized"
-    });
-    for (const preload of ctx.staticPreloadsData) {
-        kernelPreloads.load(preload.entrypoint);
-    }
-    function postNotebookMessage(type, properties) {
-        vscode.postMessage({
-            __vscode_notebook_message: true,
-            type,
-            ...properties
-        });
-    }
-    class OutputElement {
-        constructor(outputId, left, cellId) {
-            this.outputId = outputId;
-            this.cellId = cellId;
-            this.hasResizeObserver = false;
-            this.isImageOutput = false;
-            this.element = document.createElement("div");
-            this.element.id = outputId;
-            this.element.classList.add("output");
-            this.element.style.position = "absolute";
-            this.element.style.top = `0px`;
-            this.element.style.left = left + "px";
-            this.element.style.padding = `${ctx.style.outputNodePadding}px ${ctx.style.outputNodePadding}px ${ctx.style.outputNodePadding}px ${ctx.style.outputNodeLeftPadding}`;
-            this.element.addEventListener("mouseenter", () => {
-                postNotebookMessage("mouseenter", {
-                    id: outputId
-                });
-            });
-            this.element.addEventListener("mouseleave", () => {
-                postNotebookMessage("mouseleave", {
-                    id: outputId
-                });
-            });
-            this.element.addEventListener("dragstart", e => {
-                if (!e.dataTransfer) {
-                    return;
-                }
-                const outputData = {
-                    outputId: this.outputId
-                };
-                e.dataTransfer.setData("notebook-cell-output", JSON.stringify(outputData));
-            });
-            window.addEventListener("keydown", e => {
-                if (e.altKey) {
-                    this.element.draggable = true;
-                }
-            });
-            window.addEventListener("keyup", e => {
-                if (!e.altKey) {
-                    this.element.draggable = this.isImageOutput;
-                }
-            });
-            window.addEventListener("blur", () => {
-                this.element.draggable = this.isImageOutput;
-            });
-        }
-        dispose() {
-            this.renderTaskAbort?.abort();
-            this.renderTaskAbort = undefined;
-        }
-        async render(content, preferredRendererId, preloadErrors, signal) {
-            this.renderTaskAbort?.abort();
-            this.renderTaskAbort = undefined;
-            this._content = {
-                preferredRendererId,
-                preloadErrors
-            };
-            if (content.type === 0 ) {
-                const trustedHtml = ttPolicy?.createHTML(content.htmlContent) ?? content.htmlContent;
-                this.element.innerHTML = trustedHtml;
-            } else if (( preloadErrors.some(e => e instanceof Error))) {
-                const errors = preloadErrors.filter(e => e instanceof Error);
-                showRenderError(`Error loading preloads`, this.element, errors);
-            } else {
-                const imageMimeTypes = ["image/png", "image/jpeg", "image/svg"];
-                this.isImageOutput = imageMimeTypes.includes(content.output.mime);
-                this.element.draggable = this.isImageOutput;
-                const item = createOutputItem(
-                    this.outputId,
-                    content.output.mime,
-                    content.metadata,
-                    content.output.valueBytes,
-                    content.allOutputs,
-                    content.output.appended
-                );
-                const controller = ( new AbortController());
-                this.renderTaskAbort = controller;
-                signal?.addEventListener("abort", () => controller.abort());
-                try {
-                    await renderers.render(item, preferredRendererId, this.element, controller.signal);
-                } finally {
-                    if (this.renderTaskAbort === controller) {
-                        this.renderTaskAbort = undefined;
-                    }
-                }
-            }
-            if (!this.hasResizeObserver) {
-                this.hasResizeObserver = true;
-                resizeObserver.observe(this.element, this.outputId, true, this.cellId);
-            }
-            const offsetHeight = this.element.offsetHeight;
-            const cps = document.defaultView.getComputedStyle(this.element);
-            const verticalPadding = parseFloat(cps.paddingTop) + parseFloat(cps.paddingBottom);
-            const contentHeight = offsetHeight - verticalPadding;
-            if (elementHasContent(contentHeight) && cps.padding === "0px") {
-                dimensionUpdater.updateHeight(this.outputId, offsetHeight + ctx.style.outputNodePadding * 2, {
-                    isOutput: true,
-                    init: true
-                });
-                this.element.style.padding = `${ctx.style.outputNodePadding}px ${ctx.style.outputNodePadding}px ${ctx.style.outputNodePadding}px ${ctx.style.outputNodeLeftPadding}`;
-            } else if (elementHasContent(contentHeight)) {
-                dimensionUpdater.updateHeight(this.outputId, this.element.offsetHeight, {
-                    isOutput: true,
-                    init: true
-                });
-                this.element.style.padding = `0 ${ctx.style.outputNodePadding}px 0 ${ctx.style.outputNodeLeftPadding}`;
-            } else {
-                dimensionUpdater.updateHeight(this.outputId, 0, {
-                    isOutput: true,
-                    init: true
-                });
-            }
-            const root = this.element.shadowRoot ?? this.element;
-            const codeBlocks = MarkdownCodeBlock.requestHighlightCodeBlock(root);
-            if (codeBlocks.length > 0) {
-                postNotebookMessage("renderedCellOutput", {
-                    codeBlocks
-                });
-            }
-        }
-        updateAndRerender(content) {
-            if (this._content) {
-                this.render(content, this._content.preferredRendererId, this._content.preloadErrors);
-            }
-        }
-    }
-    const markupCellDragManager = new (class MarkupCellDragManager {
-        constructor() {
-            window.document.addEventListener("dragover", e => {
-                e.preventDefault();
-            });
-            window.document.addEventListener("drop", e => {
-                e.preventDefault();
-                const drag = this.currentDrag;
-                if (!drag) {
-                    return;
-                }
-                this.currentDrag = undefined;
-                postNotebookMessage("cell-drop", {
-                    cellId: drag.cellId,
-                    ctrlKey: e.ctrlKey,
-                    altKey: e.altKey,
-                    dragOffsetY: e.clientY
-                });
-            });
-        }
-        startDrag(e, cellId) {
-            if (!e.dataTransfer) {
-                return;
-            }
-            if (!currentOptions.dragAndDropEnabled) {
-                return;
-            }
-            this.currentDrag = {
-                cellId,
-                clientY: e.clientY
-            };
-            const overlayZIndex = 9999;
-            if (!this.dragOverlay) {
-                this.dragOverlay = document.createElement("div");
-                this.dragOverlay.style.position = "absolute";
-                this.dragOverlay.style.top = "0";
-                this.dragOverlay.style.left = "0";
-                this.dragOverlay.style.zIndex = `${overlayZIndex}`;
-                this.dragOverlay.style.width = "100%";
-                this.dragOverlay.style.height = "100%";
-                this.dragOverlay.style.background = "transparent";
-                window.document.body.appendChild(this.dragOverlay);
-            }
-            e.target.style.zIndex = `${overlayZIndex + 1}`;
-            e.target.classList.add("dragging");
-            postNotebookMessage("cell-drag-start", {
-                cellId: cellId,
-                dragOffsetY: e.clientY
-            });
-            const trySendDragUpdate = () => {
-                if (this.currentDrag?.cellId !== cellId) {
-                    return;
-                }
-                postNotebookMessage("cell-drag", {
-                    cellId: cellId,
-                    dragOffsetY: this.currentDrag.clientY
-                });
-                window.requestAnimationFrame(trySendDragUpdate);
-            };
-            window.requestAnimationFrame(trySendDragUpdate);
-        }
-        updateDrag(e, cellId) {
-            if (cellId !== this.currentDrag?.cellId) {
-                this.currentDrag = undefined;
-            } else {
-                this.currentDrag = {
-                    cellId,
-                    clientY: e.clientY
-                };
-            }
-        }
-        endDrag(e, cellId) {
-            this.currentDrag = undefined;
-            e.target.classList.remove("dragging");
-            postNotebookMessage("cell-drag-end", {
-                cellId: cellId
-            });
-            if (this.dragOverlay) {
-                this.dragOverlay.remove();
-                this.dragOverlay = undefined;
-            }
-            e.target.style.zIndex = "";
-        }
-    })();
-}
-function preloadsScriptStr(
-    styleValues,
-    options,
-    renderOptions,
-    renderers,
-    preloads,
-    isWorkspaceTrusted,
-    nonce
-) {
-    const ctx = {
-        style: styleValues,
-        options,
-        renderOptions,
-        rendererData: renderers,
-        staticPreloadsData: preloads,
-        isWorkspaceTrusted,
-        nonce
-    };
-    return `
-        const __import = (x) => import(x);
-        (${webviewPreloads})(
-            JSON.parse(decodeURIComponent("${encodeURIComponent(JSON.stringify(ctx))}"))
-        )\n//# sourceURL=notebookWebviewPreloads.js\n`;
-}
-
-export { preloadsScriptStr };