@theia/plugin-ext 1.67.0-next.13 → 1.67.0-next.56

package/lib/main/browser/notebooks/renderers/output-webview-internal.js

@@ -1,660 +0,0 @@
-"use strict";
-// *****************************************************************************
-// Copyright (C) 2023 TypeFox and others.
-//
-// This program and the accompanying materials are made available under the
-// terms of the Eclipse Public License v. 2.0 which is available at
-// http://www.eclipse.org/legal/epl-2.0.
-//
-// This Source Code may also be made available under the following Secondary
-// Licenses when the conditions for such availability set forth in the Eclipse
-// Public License v. 2.0 are satisfied: GNU General Public License, version 2
-// with the GNU Classpath Exception which is available at
-// https://www.gnu.org/software/classpath/license.html.
-//
-// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
-// *****************************************************************************
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.outputWebviewPreload = void 0;
-;
-;
-async function outputWebviewPreload(ctx) {
-    // workaround to allow rendering of links in outputs for non chromium browsers
-    // see https://developer.mozilla.org/en-US/docs/Web/API/Trusted_Types_API#cross-browser_support_for_trusted_types
-    if (!window.trustedTypes) {
-        window.trustedTypes = {
-            createPolicy: (name, rules) => rules
-        };
-    }
-    const theia = acquireVsCodeApi();
-    const renderFallbackErrorName = 'vscode.fallbackToNextRenderer';
-    document.body.style.overflow = 'hidden';
-    const container = document.createElement('div');
-    container.id = 'container';
-    container.classList.add('widgetarea');
-    document.body.appendChild(container);
-    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) {
-                    if ('push' in disposables) {
-                        disposables.push(disposable);
-                    }
-                    else {
-                        disposables.add(disposable);
-                    }
-                }
-                return disposable;
-            }
-        };
-    }
-    ;
-    const settingChange = createEmitter();
-    const onDidReceiveKernelMessage = createEmitter();
-    function createKernelContext() {
-        return Object.freeze({
-            onDidReceiveKernelMessage: onDidReceiveKernelMessage.event,
-            postKernelMessage: (data) => {
-                theia.postMessage({ type: 'customKernelMessage', message: data });
-            }
-        });
-    }
-    async function runKernelPreload(url) {
-        try {
-            return activateModuleKernelPreload(url);
-        }
-        catch (e) {
-            console.error(e);
-            throw e;
-        }
-    }
-    async function activateModuleKernelPreload(url) {
-        const baseUri = window.location.href.replace(/\/webview\/index\.html.*/, '');
-        const module = (await __import(`${baseUri}/${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());
-    }
-    class OutputCell {
-        constructor(cellHandle, cellIndex) {
-            this.cellHandle = cellHandle;
-            this.outputElements = [];
-            this.cellHeight = 0;
-            this.element = document.createElement('div');
-            this.element.style.outline = '0';
-            this.element.id = `cellHandle${cellHandle}`;
-            this.element.classList.add('cell_container');
-            this.element.addEventListener('focusin', e => {
-                theia.postMessage({ type: 'cellFocusChanged', cellHandle: cellHandle });
-            });
-            if (cellIndex !== undefined && cellIndex < container.children.length) {
-                container.insertBefore(this.element, container.children[cellIndex]);
-            }
-            else {
-                container.appendChild(this.element);
-            }
-            this.element = this.element;
-            theia.postMessage({ type: 'cellHeightRequest', cellHandle: cellHandle });
-        }
-        dispose() {
-            this.element.remove();
-        }
-        calcTotalOutputHeight() {
-            return this.outputElements.reduce((acc, output) => acc + output.element.getBoundingClientRect().height, 0) + 5;
-        }
-        createOutputElement(index, output, items) {
-            let outputContainer = this.outputElements.find(o => o.outputId === output.id);
-            if (!outputContainer) {
-                outputContainer = new OutputContainer(output, items, this);
-                this.element.appendChild(outputContainer.containerElement);
-                this.outputElements.splice(index, 0, outputContainer);
-                this.updateCellHeight(this.cellHeight);
-            }
-            return outputContainer;
-        }
-        clearOutputs(start, deleteCount) {
-            for (const output of this.outputElements.splice(start, deleteCount)) {
-                output === null || output === void 0 ? void 0 : output.clear();
-                output.containerElement.remove();
-            }
-        }
-        show(outputId, top) {
-            const outputContainer = this.outputElements.find(o => o.outputId === outputId);
-            if (!outputContainer) {
-                return;
-            }
-        }
-        hide() {
-            this.element.style.visibility = 'hidden';
-        }
-        updateCellHeight(height) {
-            this.cellHeight = height;
-            let additionalHeight = 54.5;
-            additionalHeight -= cells[0] === this ? 2.5 : 0; // first cell
-            additionalHeight -= this.outputElements.length ? 0 : 5.5; // no outputs
-            this.element.style.paddingTop = `${height + additionalHeight}px`;
-        }
-        outputVisibilityChanged(visible) {
-            var _a;
-            this.outputElements.forEach(output => {
-                output.element.style.display = visible ? 'initial' : 'none';
-                output.containerElement.style.minHeight = visible ? '20px' : '0px';
-            });
-            if (visible) {
-                (_a = this.element.getElementsByClassName('output-hidden')) === null || _a === void 0 ? void 0 : _a[0].remove();
-                window.requestAnimationFrame(() => this.outputElements.forEach(output => sendDidRenderMessage(this, output)));
-            }
-            else {
-                const outputHiddenElement = document.createElement('div');
-                outputHiddenElement.classList.add('output-hidden');
-                outputHiddenElement.style.height = '16px';
-                this.element.appendChild(outputHiddenElement);
-            }
-        }
-    }
-    const cells = [];
-    class OutputContainer {
-        constructor(output, items, cell) {
-            this.cell = cell;
-            this.outputId = output.id;
-            this.createHtmlElement();
-            this.allItems = items;
-        }
-        findItemToRender(preferredMimetype) {
-            var _a;
-            if (preferredMimetype) {
-                const itemToRender = this.allItems.find(item => item.mime === preferredMimetype);
-                if (itemToRender) {
-                    return itemToRender;
-                }
-            }
-            return (_a = this.renderedItem) !== null && _a !== void 0 ? _a : this.allItems[0];
-        }
-        clear() {
-            var _a, _b, _c;
-            (_b = (_a = this.renderer) === null || _a === void 0 ? void 0 : _a.disposeOutputItem) === null || _b === void 0 ? void 0 : _b.call(_a, (_c = this.renderedItem) === null || _c === void 0 ? void 0 : _c.id);
-            this.element.innerHTML = '';
-        }
-        preferredMimeTypeChange(mimeType) {
-            this.containerElement.remove();
-            this.createHtmlElement();
-            this.cell.element.appendChild(this.containerElement);
-            renderers.render(this.cell, this, mimeType, undefined, new AbortController().signal);
-        }
-        createHtmlElement() {
-            this.containerElement = document.createElement('div');
-            this.containerElement.classList.add('output-container');
-            this.containerElement.style.minHeight = '20px';
-            this.element = document.createElement('div');
-            this.element.id = this.outputId;
-            this.element.classList.add('output');
-            this.containerElement.appendChild(this.element);
-        }
-    }
-    class Renderer {
-        constructor(data) {
-            this.data = data;
-            this.onMessageEvent = createEmitter();
-        }
-        receiveMessage(message) {
-            this.onMessageEvent.fire(message);
-        }
-        disposeOutputItem(id) {
-            var _a, _b;
-            (_b = (_a = this.rendererApi) === null || _a === void 0 ? void 0 : _a.disposeOutputItem) === null || _b === void 0 ? void 0 : _b.call(_a, id);
-        }
-        async getOrLoad() {
-            if (this.rendererApi) {
-                return this.rendererApi;
-            }
-            // Preloads need to be loaded before loading renderers.
-            await kernelPreloads.waitForAllCurrent();
-            const baseUri = window.location.href.replace(/\/webview\/index\.html.*/, '');
-            const rendererModule = await __import(`${baseUri}/${this.data.entrypoint.uri}`);
-            this.rendererApi = await rendererModule.activate(this.createRendererContext());
-            return this.rendererApi;
-        }
-        createRendererContext() {
-            const context = {
-                setState: newState => theia.setState({ ...theia.getState(), [this.data.id]: newState }),
-                getState: () => {
-                    const state = theia.getState();
-                    return typeof state === 'object' && state ? state[this.data.id] : undefined;
-                },
-                getRenderer: async (id) => {
-                    const renderer = renderers.getRenderer(id);
-                    if (!renderer) {
-                        return undefined;
-                    }
-                    if (renderer.rendererApi) {
-                        return renderer.rendererApi;
-                    }
-                    return renderer.getOrLoad();
-                },
-                workspace: {
-                    get isTrusted() { return true; } // TODO use Workspace trust service
-                },
-                settings: {
-                    get lineLimit() { return ctx.renderOptions.lineLimit; },
-                    get outputScrolling() { return ctx.renderOptions.outputScrolling; },
-                    get outputWordWrap() { return ctx.renderOptions.outputWordWrap; },
-                },
-                get onDidChangeSettings() { return settingChange.event; },
-            };
-            if (this.data.requiresMessaging) {
-                context.onDidReceiveMessage = this.onMessageEvent.event;
-                context.postMessage = message => {
-                    theia.postMessage({ type: 'customRendererMessage', rendererId: this.data.id, message });
-                };
-            }
-            return Object.freeze(context);
-        }
-    }
-    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.uri !== b.entrypoint.uri || a.entrypoint.extends !== b.entrypoint.extends || a.requiresMessaging !== b.requiresMessaging) {
-                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() {
-            for (const renderer of this.renderers.values()) {
-                renderer.disposeOutputItem();
-            }
-        }
-        clearOutput(rendererId, outputId) {
-            var _a;
-            // outputRunner.cancelOutput(outputId);
-            (_a = this.renderers.get(rendererId)) === null || _a === void 0 ? void 0 : _a.disposeOutputItem(outputId);
-        }
-        async render(cell, output, preferredMimeType, preferredRendererId, signal) {
-            const item = output.findItemToRender(preferredMimeType);
-            const primaryRenderer = this.findRenderer(preferredRendererId, item);
-            if (!primaryRenderer) {
-                this.showRenderError(item, output.element, 'No renderer found for output type.');
-                return;
-            }
-            // Try primary renderer first
-            if (!(await this.doRender(item, output.element, primaryRenderer, signal)).continue) {
-                output.renderer = primaryRenderer;
-                this.onRenderCompleted(cell, output);
-                return;
-            }
-            // Primary renderer failed in an expected way. Fallback to render the next mime types
-            for (const additionalItem of output.allItems) {
-                if (additionalItem.mime === item.mime) {
-                    continue;
-                }
-                if (signal.aborted) {
-                    return;
-                }
-                if (additionalItem) {
-                    const renderer = this.findRenderer(undefined, additionalItem);
-                    if (renderer) {
-                        if (!(await this.doRender(additionalItem, output.element, renderer, signal)).continue) {
-                            output.renderer = renderer;
-                            this.onRenderCompleted(cell, output);
-                            return; // We rendered successfully
-                        }
-                    }
-                }
-            }
-            // All renderers have failed and there is nothing left to fallback to
-            this.showRenderError(item, output.element, 'No fallback renderers found or all fallback renderers failed.');
-        }
-        onRenderCompleted(cell, output) {
-            // we need to check for all images are loaded. Otherwise we can't determine the correct height of the output
-            const images = Array.from(document.images);
-            if (images.length > 0) {
-                Promise.all(images
-                    .filter(img => !img.complete && !img.dataset.waiting)
-                    .map(img => {
-                    img.dataset.waiting = 'true'; // mark to avoid overriding onload a second time
-                    return new Promise(resolve => { img.onload = img.onerror = resolve; });
-                })).then(() => {
-                    sendDidRenderMessage(cell, output);
-                    new ResizeObserver(() => sendDidRenderMessage(cell, output)).observe(cell.element);
-                });
-            }
-            else {
-                sendDidRenderMessage(cell, output);
-                new ResizeObserver(() => sendDidRenderMessage(cell, output)).observe(cell.element);
-            }
-        }
-        async doRender(item, element, renderer, signal) {
-            var _a;
-            try {
-                await ((_a = (await renderer.getOrLoad())) === null || _a === void 0 ? void 0 : _a.renderOutputItem(item, element, signal));
-                return { continue: false }; // We rendered successfully
-            }
-            catch (e) {
-                if (signal.aborted) {
-                    return { continue: false };
-                }
-                if (e instanceof Error && e.name === renderFallbackErrorName) {
-                    return { continue: true };
-                }
-                else {
-                    throw e; // Bail and let callers handle unknown errors
-                }
-            }
-        }
-        findRenderer(preferredRendererId, info) {
-            let foundRenderer;
-            if (typeof preferredRendererId === 'string') {
-                foundRenderer = Array.from(this.renderers.values())
-                    .find(renderer => renderer.data.id === preferredRendererId);
-            }
-            else {
-                const rendererList = Array.from(this.renderers.values())
-                    .filter(renderer => renderer.data.mimeTypes.includes(info.mime) && !renderer.data.entrypoint.extends);
-                if (rendererList.length) {
-                    // De-prioritize built-in renderers
-                    // rendererList.sort((a, b) => +a.data.isBuiltin - +b.data.isBuiltin);
-                    // Use first renderer we find in sorted list
-                    foundRenderer = rendererList[0];
-                }
-            }
-            return foundRenderer;
-        }
-        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);
-        }
-    }();
-    function sendDidRenderMessage(cell, output) {
-        theia.postMessage({
-            type: 'didRenderOutput',
-            cellHandle: cell.cellHandle,
-            outputId: output.outputId,
-            outputHeight: cell.calcTotalOutputHeight(),
-            bodyHeight: document.body.clientHeight
-        });
-    }
-    const kernelPreloads = new class {
-        constructor() {
-            this.preloads = new Map();
-        }
-        /**
-         * Returns a promise that resolves when the given preload is activated.
-         */
-        waitFor(uri) {
-            return this.preloads.get(uri) || Promise.resolve(new Error(`Preload not ready: ${uri}`));
-        }
-        /**
-         * Loads a preload.
-         * @param uri URI to load from
-         * @param originalUri URI to show in an error message if the preload is invalid.
-         */
-        load(uri) {
-            const promise = Promise.all([
-                runKernelPreload(uri),
-                this.waitForAllCurrent(),
-            ]);
-            this.preloads.set(uri, promise);
-            return promise;
-        }
-        /**
-         * Returns a promise that waits for all currently-registered preloads to
-         * activate before resolving.
-         */
-        waitForAllCurrent() {
-            return Promise.all([...this.preloads.values()].map(p => p.catch(err => err)));
-        }
-    };
-    await Promise.all(ctx.staticPreloadsData.map(preload => kernelPreloads.load(preload)));
-    async function outputsChanged(changedEvent) {
-        var _a, _b, _c;
-        for (const cellChange of changedEvent.changes) {
-            let cell = cells.find(c => c.cellHandle === cellChange.cellHandle);
-            if (!cell) {
-                cell = new OutputCell(cellChange.cellHandle);
-                cells.push(cell);
-            }
-            cell.clearOutputs(cellChange.start, cellChange.deleteCount);
-            for (const outputData of (_a = cellChange.newOutputs) !== null && _a !== void 0 ? _a : []) {
-                const apiItems = outputData.items.map((item, index) => ({
-                    id: `${outputData.id}-${index}`,
-                    mime: item.mime,
-                    metadata: outputData.metadata,
-                    data() {
-                        return item.data;
-                    },
-                    text() {
-                        return new TextDecoder().decode(this.data());
-                    },
-                    json() {
-                        return JSON.parse(this.text());
-                    },
-                    blob() {
-                        return new Blob([this.data()], { type: this.mime });
-                    },
-                }));
-                const output = cell.createOutputElement(cellChange.start, outputData, apiItems);
-                await renderers.render(cell, output, undefined, undefined, new AbortController().signal);
-                theia.postMessage({
-                    type: 'didRenderOutput',
-                    cellHandle: cell.cellHandle,
-                    outputId: outputData.id,
-                    outputHeight: (_c = (_b = document.getElementById(output.outputId)) === null || _b === void 0 ? void 0 : _b.clientHeight) !== null && _c !== void 0 ? _c : 0,
-                    bodyHeight: document.body.clientHeight
-                });
-            }
-        }
-    }
-    function cellsChanged(changes) {
-        for (const change of changes) {
-            if (change.type === 'cellMoved') {
-                const currentIndex = cells.findIndex(c => c.cellHandle === change.cellHandle);
-                const cell = cells[currentIndex];
-                cells.splice(change.toIndex, 0, cells.splice(currentIndex, 1)[0]);
-                if (change.toIndex < cells.length - 1) {
-                    container.insertBefore(cell.element, container.children[change.toIndex + (change.toIndex > currentIndex ? 1 : 0)]);
-                }
-                else {
-                    container.appendChild(cell.element);
-                }
-            }
-            else if (change.type === 'cellsSpliced') {
-                // if startCellHandle is negative, it means we should add a trailing new cell
-                const startCellIndex = change.startCellHandle < 0 ? cells.length : cells.findIndex(c => c.cellHandle === change.startCellHandle);
-                if (startCellIndex === -1) {
-                    console.error(`Can't find cell output to splice. Cells: ${cells.length}, startCellHandle: ${change.startCellHandle}`);
-                }
-                else {
-                    const deletedCells = cells.splice(startCellIndex, change.deleteCount, ...change.newCells.map((cellHandle, i) => new OutputCell(cellHandle, startCellIndex + i)));
-                    deletedCells.forEach(cell => cell.dispose());
-                }
-            }
-        }
-    }
-    function shouldHandleScroll(event) {
-        for (let node = event.target; node; node = node.parentNode) {
-            if (!(node instanceof Element)) {
-                return false;
-            }
-            // scroll up
-            if (event.deltaY < 0 && node.scrollTop > 0) {
-                // there is still some content to scroll
-                return true;
-            }
-            // scroll down
-            if (event.deltaY > 0 && node.scrollTop + node.clientHeight < node.scrollHeight) {
-                // per https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollHeight
-                // scrollTop is not rounded but scrollHeight and clientHeight are
-                // so we need to check if the difference is less than some threshold
-                if (node.scrollHeight - node.scrollTop - node.clientHeight < 2) {
-                    continue;
-                }
-                // if the node is not scrollable, we can continue. We don't check the computed style always as it's expensive
-                if (window.getComputedStyle(node).overflowY === 'hidden' || window.getComputedStyle(node).overflowY === 'visible') {
-                    continue;
-                }
-                return true;
-            }
-        }
-        return false;
-    }
-    const handleWheel = (event) => {
-        if (event.defaultPrevented || shouldHandleScroll(event)) {
-            return;
-        }
-        theia.postMessage({
-            type: 'did-scroll-wheel',
-            deltaY: event.deltaY,
-            deltaX: event.deltaX,
-        });
-    };
-    window.addEventListener('message', async (rawEvent) => {
-        var _a, _b, _c;
-        const event = rawEvent;
-        let cellHandle;
-        switch (event.data.type) {
-            case 'updateRenderers':
-                renderers.updateRendererData(event.data.rendererData);
-                break;
-            case 'outputChanged':
-                outputsChanged(event.data);
-                break;
-            case 'cellsChanged':
-                cellsChanged(event.data.changes);
-                break;
-            case 'customRendererMessage':
-                (_a = renderers.getRenderer(event.data.rendererId)) === null || _a === void 0 ? void 0 : _a.receiveMessage(event.data.message);
-                break;
-            case 'changePreferredMimetype':
-                cellHandle = event.data.cellHandle;
-                const mimeType = event.data.mimeType;
-                (_b = cells.find(c => c.cellHandle === cellHandle)) === null || _b === void 0 ? void 0 : _b.outputElements.forEach(o => o.preferredMimeTypeChange(mimeType));
-                break;
-            case 'customKernelMessage':
-                onDidReceiveKernelMessage.fire(event.data.message);
-                break;
-            case 'preload':
-                const resources = event.data.resources;
-                for (const uri of resources) {
-                    kernelPreloads.load(uri);
-                }
-                break;
-            case 'notebookStyles':
-                const documentStyle = window.document.documentElement.style;
-                for (let i = documentStyle.length - 1; i >= 0; i--) {
-                    const property = documentStyle[i];
-                    // Don't remove properties that the webview might have added separately
-                    if (property && property.startsWith('--notebook-')) {
-                        documentStyle.removeProperty(property);
-                    }
-                }
-                // Re-add new properties
-                for (const [name, value] of Object.entries(event.data.styles)) {
-                    documentStyle.setProperty(`--${name}`, value);
-                }
-                break;
-            case 'cellHeightUpdate':
-                cellHandle = event.data.cellHandle;
-                const cell = cells.find(c => c.cellHandle === cellHandle);
-                if (cell) {
-                    cell.updateCellHeight(event.data.height);
-                }
-                break;
-            case 'outputVisibilityChanged':
-                cellHandle = event.data.cellHandle;
-                (_c = cells.find(c => c.cellHandle === cellHandle)) === null || _c === void 0 ? void 0 : _c.outputVisibilityChanged(event.data.visible);
-                break;
-        }
-    });
-    window.addEventListener('wheel', handleWheel);
-    document.head.originalAppendChild = document.head.appendChild;
-    document.head.appendChild = function appendChild(node) {
-        if (node instanceof HTMLScriptElement && node.src.includes('webviewuuid')) {
-            node.src = node.src.replace('webviewuuid', location.hostname.split('.')[0]);
-        }
-        return this.originalAppendChild(node);
-    };
-    const focusChange = (event, focus) => {
-        if (event.target instanceof HTMLInputElement) {
-            theia.postMessage({ type: 'inputFocusChanged', focused: focus });
-        }
-    };
-    window.addEventListener('focusin', (event) => focusChange(event, true));
-    window.addEventListener('focusout', (event) => focusChange(event, false));
-    const webviewFocuseChange = (focus) => {
-        theia.postMessage({ type: 'webviewFocusChanged', focused: focus });
-    };
-    window.addEventListener('focus', () => webviewFocuseChange(true));
-    window.addEventListener('blur', () => webviewFocuseChange(false));
-    new ResizeObserver(() => {
-        theia.postMessage({
-            type: 'bodyHeightChange',
-            height: document.body.clientHeight
-        });
-    }).observe(document.body);
-    theia.postMessage({ type: 'initialized' });
-}
-exports.outputWebviewPreload = outputWebviewPreload;
-//# sourceMappingURL=output-webview-internal.js.map