@codingame/monaco-vscode-api 1.79.7-next.1 → 1.79.7-next.2

package/dist/vscode/vs/workbench/contrib/webview/browser/webviewElement.js

@@ -0,0 +1,643 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { isFirefox } from 'monaco-editor/esm/vs/base/browser/browser.js';
+import { addDisposableListener, EventType } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { ThrottledDelayer } from 'monaco-editor/esm/vs/base/common/async.js';
+import { streamToBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { COI } from 'monaco-editor/esm/vs/base/common/network.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
+import { MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IRemoteAuthorityResolverService } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { ITunnelService } from '../../../../platform/tunnel/common/tunnel.js';
+import { WebviewPortMappingManager } from '../../../../platform/webview/common/webviewPortMapping.js';
+import { parentOriginHash } from '../../../browser/iframe.js';
+import { loadLocalResource, WebviewResourceResponse } from './resourceLoading.js';
+import { areWebviewContentOptionsEqual } from './webview.js';
+import { WebviewFindWidget } from './webviewFindWidget.js';
+import { decodeAuthority, webviewGenericCspSource, webviewRootResourceAuthority } from '../common/webview.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
+var WebviewState;
+( (function(WebviewState) {
+    ( (function(Type) {
+        Type[Type["Initializing"] = 0] = "Initializing";
+        Type[Type["Ready"] = 1] = "Ready";
+    })(WebviewState.Type || (WebviewState.Type = {})));
+    class Initializing {
+        constructor(pendingMessages) {
+            this.pendingMessages = pendingMessages;
+            this.type = 0 ;
+        }
+    }
+    WebviewState.Initializing = Initializing;
+    WebviewState.Ready = { type: 1  };
+})(WebviewState || (WebviewState = {})));
+const webviewIdContext = 'webviewId';
+let WebviewElement = class WebviewElement extends Disposable {
+    get platform() { return 'browser'; }
+    get element() { return this._element; }
+    get isFocused() {
+        if (!this._focused) {
+            return false;
+        }
+        if (document.activeElement && document.activeElement !== this.element) {
+            return false;
+        }
+        return true;
+    }
+    constructor(initInfo, webviewThemeDataProvider, configurationService, contextMenuService, notificationService, _environmentService, _fileService, _logService, _remoteAuthorityResolverService, _telemetryService, _tunnelService, instantiationService, _accessibilityService) {
+        super();
+        this.webviewThemeDataProvider = webviewThemeDataProvider;
+        this._environmentService = _environmentService;
+        this._fileService = _fileService;
+        this._logService = _logService;
+        this._remoteAuthorityResolverService = _remoteAuthorityResolverService;
+        this._telemetryService = _telemetryService;
+        this._tunnelService = _tunnelService;
+        this._accessibilityService = _accessibilityService;
+        this.id = generateUuid();
+        this._expectedServiceWorkerVersion = 4;
+        this._state = new WebviewState.Initializing([]);
+        this._resourceLoadingCts = this._register(( new CancellationTokenSource()));
+        this._focusDelayer = this._register(( new ThrottledDelayer(50)));
+        this._onDidHtmlChange = this._register(( new Emitter()));
+        this.onDidHtmlChange = this._onDidHtmlChange.event;
+        this._messageHandlers = ( new Map());
+        this.checkImeCompletionState = true;
+        this._disposed = false;
+        this._onMissingCsp = this._register(( new Emitter()));
+        this.onMissingCsp = this._onMissingCsp.event;
+        this._onDidClickLink = this._register(( new Emitter()));
+        this.onDidClickLink = this._onDidClickLink.event;
+        this._onDidReload = this._register(( new Emitter()));
+        this.onDidReload = this._onDidReload.event;
+        this._onMessage = this._register(( new Emitter()));
+        this.onMessage = this._onMessage.event;
+        this._onDidScroll = this._register(( new Emitter()));
+        this.onDidScroll = this._onDidScroll.event;
+        this._onDidWheel = this._register(( new Emitter()));
+        this.onDidWheel = this._onDidWheel.event;
+        this._onDidUpdateState = this._register(( new Emitter()));
+        this.onDidUpdateState = this._onDidUpdateState.event;
+        this._onDidFocus = this._register(( new Emitter()));
+        this.onDidFocus = this._onDidFocus.event;
+        this._onDidBlur = this._register(( new Emitter()));
+        this.onDidBlur = this._onDidBlur.event;
+        this._onFatalError = this._register(( new Emitter()));
+        this.onFatalError = this._onFatalError.event;
+        this._onDidDispose = this._register(( new Emitter()));
+        this.onDidDispose = this._onDidDispose.event;
+        this._hasAlertedAboutMissingCsp = false;
+        this._hasFindResult = this._register(( new Emitter()));
+        this.hasFindResult = this._hasFindResult.event;
+        this._onDidStopFind = this._register(( new Emitter()));
+        this.onDidStopFind = this._onDidStopFind.event;
+        this.providedViewType = initInfo.providedViewType;
+        this.origin = initInfo.origin ?? this.id;
+        this._encodedWebviewOriginPromise = parentOriginHash(window.origin, this.origin).then(id => this._encodedWebviewOrigin = id);
+        this._options = initInfo.options;
+        this.extension = initInfo.extension;
+        this._content = {
+            html: '',
+            title: initInfo.title,
+            options: initInfo.contentOptions,
+            state: undefined
+        };
+        this._portMappingManager = this._register(( new WebviewPortMappingManager(
+            () => this.extension?.location,
+            () => this._content.options.portMapping || [],
+            this._tunnelService
+        )));
+        this._element = this._createElement(initInfo.options, initInfo.contentOptions);
+        const subscription = this._register(addDisposableListener(window, 'message', (e) => {
+            if (!this._encodedWebviewOrigin || e?.data?.target !== this.id) {
+                return;
+            }
+            if (e.origin !== this._webviewContentOrigin(this._encodedWebviewOrigin)) {
+                console.log(`Skipped renderer receiving message due to mismatched origins: ${e.origin} ${this._webviewContentOrigin}`);
+                return;
+            }
+            if (e.data.channel === 'webview-ready') {
+                if (this._messagePort) {
+                    return;
+                }
+                this._logService.debug(`Webview(${this.id}): webview ready`);
+                this._messagePort = e.ports[0];
+                this._messagePort.onmessage = (e) => {
+                    const handlers = this._messageHandlers.get(e.data.channel);
+                    if (!handlers) {
+                        console.log(`No handlers found for '${e.data.channel}'`);
+                        return;
+                    }
+                    handlers?.forEach(handler => handler(e.data.data, e));
+                };
+                this.element?.classList.add('ready');
+                if (this._state.type === 0 ) {
+                    this._state.pendingMessages.forEach(({ channel, data }) => this.doPostMessage(channel, data));
+                }
+                this._state = WebviewState.Ready;
+                subscription.dispose();
+            }
+        }));
+        this._register(this.on('no-csp-found', () => {
+            this.handleNoCspFound();
+        }));
+        this._register(this.on('did-click-link', ({ uri }) => {
+            this._onDidClickLink.fire(uri);
+        }));
+        this._register(this.on('onmessage', ({ message, transfer }) => {
+            this._onMessage.fire({ message, transfer });
+        }));
+        this._register(this.on('did-scroll', ({ scrollYPercentage }) => {
+            this._onDidScroll.fire({ scrollYPercentage });
+        }));
+        this._register(this.on('do-reload', () => {
+            this.reload();
+        }));
+        this._register(this.on('do-update-state', (state) => {
+            this.state = state;
+            this._onDidUpdateState.fire(state);
+        }));
+        this._register(this.on('did-focus', () => {
+            this.handleFocusChange(true);
+        }));
+        this._register(this.on('did-blur', () => {
+            this.handleFocusChange(false);
+        }));
+        this._register(this.on('did-scroll-wheel', (event) => {
+            this._onDidWheel.fire(event);
+        }));
+        this._register(this.on('did-find', ({ didFind }) => {
+            this._hasFindResult.fire(didFind);
+        }));
+        this._register(this.on('fatal-error', (e) => {
+            notificationService.error(( localize('fatalErrorMessage', "Error loading webview: {0}", e.message)));
+            this._onFatalError.fire({ message: e.message });
+        }));
+        this._register(this.on('did-keydown', (data) => {
+            this.handleKeyEvent('keydown', data);
+        }));
+        this._register(this.on('did-keyup', (data) => {
+            this.handleKeyEvent('keyup', data);
+        }));
+        this._register(this.on('did-context-menu', (data) => {
+            if (!this.element) {
+                return;
+            }
+            if (!this._contextKeyService) {
+                return;
+            }
+            const elementBox = this.element.getBoundingClientRect();
+            const contextKeyService = this._contextKeyService.createOverlay([
+                ...Object.entries(data.context),
+                [webviewIdContext, this.providedViewType],
+            ]);
+            contextMenuService.showContextMenu({
+                menuId: MenuId.WebviewContext,
+                menuActionOptions: { shouldForwardArgs: true },
+                contextKeyService,
+                getActionsContext: () => ({ ...data.context, webview: this.providedViewType }),
+                getAnchor: () => ({
+                    x: elementBox.x + data.clientX,
+                    y: elementBox.y + data.clientY
+                })
+            });
+        }));
+        this._register(this.on('load-resource', async (entry) => {
+            try {
+                const authority = decodeAuthority(entry.authority);
+                const uri = ( URI.from({
+                    scheme: entry.scheme,
+                    authority: authority,
+                    path: decodeURIComponent(entry.path),
+                    query: entry.query ? decodeURIComponent(entry.query) : entry.query,
+                }));
+                this.loadResource(entry.id, uri, entry.ifNoneMatch);
+            }
+            catch (e) {
+                this._send('did-load-resource', {
+                    id: entry.id,
+                    status: 404,
+                    path: entry.path,
+                });
+            }
+        }));
+        this._register(this.on('load-localhost', (entry) => {
+            this.localLocalhost(entry.id, entry.origin);
+        }));
+        this._register(Event.runAndSubscribe(webviewThemeDataProvider.onThemeDataChanged, () => this.style()));
+        this._register(_accessibilityService.onDidChangeReducedMotion(() => this.style()));
+        this._register(_accessibilityService.onDidChangeScreenReaderOptimized(() => this.style()));
+        this._confirmBeforeClose = configurationService.getValue('window.confirmBeforeClose');
+        this._register(configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('window.confirmBeforeClose')) {
+                this._confirmBeforeClose = configurationService.getValue('window.confirmBeforeClose');
+                this._send('set-confirm-before-close', this._confirmBeforeClose);
+            }
+        }));
+        this._register(this.on('drag-start', () => {
+            this._startBlockingIframeDragEvents();
+        }));
+        if (initInfo.options.enableFindWidget) {
+            this._webviewFindWidget = this._register(instantiationService.createInstance(WebviewFindWidget, this));
+        }
+        this._encodedWebviewOriginPromise.then(encodedWebviewOrigin => {
+            if (!this._disposed) {
+                this._initElement(encodedWebviewOrigin, this.extension, this._options);
+            }
+        });
+    }
+    dispose() {
+        this._disposed = true;
+        this.element?.remove();
+        this._element = undefined;
+        this._messagePort = undefined;
+        if (this._state.type === 0 ) {
+            for (const message of this._state.pendingMessages) {
+                message.resolve(false);
+            }
+            this._state.pendingMessages = [];
+        }
+        this._onDidDispose.fire();
+        this._resourceLoadingCts.dispose(true);
+        super.dispose();
+    }
+    setContextKeyService(contextKeyService) {
+        this._contextKeyService = contextKeyService;
+    }
+    postMessage(message, transfer) {
+        return this._send('message', { message, transfer });
+    }
+    async _send(channel, data, _createElement = []) {
+        if (this._state.type === 0 ) {
+            let resolve;
+            const promise = ( new Promise(r => resolve = r));
+            this._state.pendingMessages.push({ channel, data, transferable: _createElement, resolve: resolve });
+            return promise;
+        }
+        else {
+            return this.doPostMessage(channel, data, _createElement);
+        }
+    }
+    _createElement(options, _contentOptions) {
+        const element = document.createElement('iframe');
+        element.name = this.id;
+        element.className = `webview ${options.customClasses || ''}`;
+        element.sandbox.add('allow-scripts', 'allow-same-origin', 'allow-forms', 'allow-pointer-lock', 'allow-downloads');
+        const allowRules = ['cross-origin-isolated', 'autoplay'];
+        if (!isFirefox) {
+            allowRules.push('clipboard-read', 'clipboard-write');
+        }
+        element.setAttribute('allow', allowRules.join('; '));
+        element.style.border = 'none';
+        element.style.width = '100%';
+        element.style.height = '100%';
+        element.focus = () => {
+            this._doFocus();
+        };
+        return element;
+    }
+    _initElement(encodedWebviewOrigin, extension, options) {
+        const params = {
+            id: this.id,
+            origin: this.origin,
+            swVersion: String(this._expectedServiceWorkerVersion),
+            extensionId: extension?.id.value ?? '',
+            platform: this.platform,
+            'vscode-resource-base-authority': webviewRootResourceAuthority,
+            parentOrigin: window.origin,
+        };
+        if (this._options.disableServiceWorker) {
+            params.disableServiceWorker = 'true';
+        }
+        if (this._environmentService.remoteAuthority) {
+            params.remoteAuthority = this._environmentService.remoteAuthority;
+        }
+        if (options.purpose) {
+            params.purpose = options.purpose;
+        }
+        COI.addSearchParam(params, true, true);
+        const queryString = ( ( new URLSearchParams(params)).toString());
+        const fileName = isFirefox ? 'index-no-csp.html' : 'index.html';
+        this.element.setAttribute('src', `${this.webviewContentEndpoint(encodedWebviewOrigin)}/${fileName}?${queryString}`);
+    }
+    mountTo(element) {
+        if (!this.element) {
+            return;
+        }
+        if (this._webviewFindWidget) {
+            element.appendChild(this._webviewFindWidget.getDomNode());
+        }
+        for (const eventName of [EventType.MOUSE_DOWN, EventType.MOUSE_MOVE, EventType.DROP]) {
+            this._register(addDisposableListener(element, eventName, () => {
+                this._stopBlockingIframeDragEvents();
+            }));
+        }
+        for (const node of [element, window]) {
+            this._register(addDisposableListener(node, EventType.DRAG_END, () => {
+                this._stopBlockingIframeDragEvents();
+            }));
+        }
+        element.id = this.id;
+        element.appendChild(this.element);
+    }
+    _startBlockingIframeDragEvents() {
+        if (this.element) {
+            this.element.style.pointerEvents = 'none';
+        }
+    }
+    _stopBlockingIframeDragEvents() {
+        if (this.element) {
+            this.element.style.pointerEvents = 'auto';
+        }
+    }
+    webviewContentEndpoint(encodedWebviewOrigin) {
+        const webviewExternalEndpoint = this._environmentService.webviewExternalEndpoint;
+        if (!webviewExternalEndpoint) {
+            throw new Error(`'webviewExternalEndpoint' has not been configured. Webviews will not work!`);
+        }
+        const endpoint = webviewExternalEndpoint.replace('{{uuid}}', encodedWebviewOrigin);
+        if (endpoint[endpoint.length - 1] === '/') {
+            return endpoint.slice(0, endpoint.length - 1);
+        }
+        return endpoint;
+    }
+    _webviewContentOrigin(encodedWebviewOrigin) {
+        const uri = ( URI.parse(this.webviewContentEndpoint(encodedWebviewOrigin)));
+        return uri.scheme + '://' + uri.authority.toLowerCase();
+    }
+    doPostMessage(channel, data, transferable = []) {
+        if (this.element && this._messagePort) {
+            this._messagePort.postMessage({ channel, args: data }, transferable);
+            return true;
+        }
+        return false;
+    }
+    on(channel, handler) {
+        let handlers = this._messageHandlers.get(channel);
+        if (!handlers) {
+            handlers = ( new Set());
+            this._messageHandlers.set(channel, handlers);
+        }
+        handlers.add(handler);
+        return toDisposable(() => {
+            this._messageHandlers.get(channel)?.delete(handler);
+        });
+    }
+    handleNoCspFound() {
+        if (this._hasAlertedAboutMissingCsp) {
+            return;
+        }
+        this._hasAlertedAboutMissingCsp = true;
+        if (this.extension?.id) {
+            if (this._environmentService.isExtensionDevelopment) {
+                this._onMissingCsp.fire(this.extension.id);
+            }
+            const payload = {
+                extension: this.extension.id.value
+            };
+            this._telemetryService.publicLog2('webviewMissingCsp', payload);
+        }
+    }
+    reload() {
+        this.doUpdateContent(this._content);
+        const subscription = this._register(this.on('did-load', () => {
+            this._onDidReload.fire();
+            subscription.dispose();
+        }));
+    }
+    setHtml(html) {
+        this.doUpdateContent({ ...this._content, html });
+        this._onDidHtmlChange.fire(html);
+    }
+    setTitle(title) {
+        this._content = { ...this._content, title };
+        this._send('set-title', title);
+    }
+    set contentOptions(options) {
+        this._logService.debug(`Webview(${this.id}): will update content options`);
+        if (areWebviewContentOptionsEqual(options, this._content.options)) {
+            this._logService.debug(`Webview(${this.id}): skipping content options update`);
+            return;
+        }
+        this.doUpdateContent({ ...this._content, options });
+    }
+    set localResourcesRoot(resources) {
+        this._content = {
+            ...this._content,
+            options: { ...this._content.options, localResourceRoots: resources }
+        };
+    }
+    set state(state) {
+        this._content = { ...this._content, state };
+    }
+    set initialScrollProgress(value) {
+        this._send('initial-scroll-position', value);
+    }
+    doUpdateContent(newContent) {
+        this._logService.debug(`Webview(${this.id}): will update content`);
+        this._content = newContent;
+        const allowScripts = !!this._content.options.allowScripts;
+        this._send('content', {
+            contents: this._content.html,
+            title: this._content.title,
+            options: {
+                allowMultipleAPIAcquire: !!this._content.options.allowMultipleAPIAcquire,
+                allowScripts: allowScripts,
+                allowForms: this._content.options.allowForms ?? allowScripts,
+            },
+            state: this._content.state,
+            cspSource: webviewGenericCspSource,
+            confirmBeforeClose: this._confirmBeforeClose,
+        });
+    }
+    style() {
+        let { styles, activeTheme, themeLabel, themeId } = this.webviewThemeDataProvider.getWebviewThemeData();
+        if (this._options.transformCssVariables) {
+            styles = this._options.transformCssVariables(styles);
+        }
+        const reduceMotion = this._accessibilityService.isMotionReduced();
+        const screenReader = this._accessibilityService.isScreenReaderOptimized();
+        this._send('styles', { styles, activeTheme, themeId, themeLabel, reduceMotion, screenReader });
+    }
+    handleFocusChange(isFocused) {
+        this._focused = isFocused;
+        if (isFocused) {
+            this._onDidFocus.fire();
+        }
+        else {
+            this._onDidBlur.fire();
+        }
+    }
+    handleKeyEvent(type, event) {
+        const emulatedKeyboardEvent = ( new KeyboardEvent(type, event));
+        Object.defineProperty(emulatedKeyboardEvent, 'target', {
+            get: () => this.element,
+        });
+        window.dispatchEvent(emulatedKeyboardEvent);
+    }
+    windowDidDragStart() {
+        this._startBlockingIframeDragEvents();
+    }
+    windowDidDragEnd() {
+        this._stopBlockingIframeDragEvents();
+    }
+    selectAll() {
+        this.execCommand('selectAll');
+    }
+    copy() {
+        this.execCommand('copy');
+    }
+    paste() {
+        this.execCommand('paste');
+    }
+    cut() {
+        this.execCommand('cut');
+    }
+    undo() {
+        this.execCommand('undo');
+    }
+    redo() {
+        this.execCommand('redo');
+    }
+    execCommand(command) {
+        if (this.element) {
+            this._send('execCommand', command);
+        }
+    }
+    async loadResource(id, uri, ifNoneMatch) {
+        try {
+            const result = await loadLocalResource(uri, {
+                ifNoneMatch,
+                roots: this._content.options.localResourceRoots || [],
+            }, this._fileService, this._logService, this._resourceLoadingCts.token);
+            switch (result.type) {
+                case WebviewResourceResponse.Type.Success: {
+                    const buffer = await this.streamToBuffer(result.stream);
+                    return this._send('did-load-resource', {
+                        id,
+                        status: 200,
+                        path: uri.path,
+                        mime: result.mimeType,
+                        data: buffer,
+                        etag: result.etag,
+                        mtime: result.mtime
+                    }, [buffer]);
+                }
+                case WebviewResourceResponse.Type.NotModified: {
+                    return this._send('did-load-resource', {
+                        id,
+                        status: 304,
+                        path: uri.path,
+                        mime: result.mimeType,
+                        mtime: result.mtime
+                    });
+                }
+                case WebviewResourceResponse.Type.AccessDenied: {
+                    return this._send('did-load-resource', {
+                        id,
+                        status: 401,
+                        path: uri.path,
+                    });
+                }
+            }
+        }
+        catch {
+        }
+        return this._send('did-load-resource', {
+            id,
+            status: 404,
+            path: uri.path,
+        });
+    }
+    async streamToBuffer(stream) {
+        const vsBuffer = await streamToBuffer(stream);
+        return vsBuffer.buffer.buffer;
+    }
+    async localLocalhost(id, origin) {
+        const authority = this._environmentService.remoteAuthority;
+        const resolveAuthority = authority ? await this._remoteAuthorityResolverService.resolveAuthority(authority) : undefined;
+        const redirect = resolveAuthority ? await this._portMappingManager.getRedirect(resolveAuthority.authority, origin) : undefined;
+        return this._send('did-load-localhost', {
+            id,
+            origin,
+            location: redirect
+        });
+    }
+    focus() {
+        this._doFocus();
+        this.handleFocusChange(true);
+    }
+    _doFocus() {
+        if (!this.element) {
+            return;
+        }
+        try {
+            this.element.contentWindow?.focus();
+        }
+        catch {
+        }
+        this._focusDelayer.trigger(async () => {
+            if (!this.isFocused || !this.element) {
+                return;
+            }
+            if (document.activeElement && document.activeElement !== this.element && document.activeElement?.tagName !== 'BODY') {
+                return;
+            }
+            this._send('focus', undefined);
+        });
+    }
+    find(value, previous) {
+        if (!this.element) {
+            return;
+        }
+        this._send('find', { value, previous });
+    }
+    updateFind(value) {
+        if (!value || !this.element) {
+            return;
+        }
+        this._send('find', { value });
+    }
+    stopFind(keepSelection) {
+        if (!this.element) {
+            return;
+        }
+        this._send('find-stop', { clearSelection: !keepSelection });
+        this._onDidStopFind.fire();
+    }
+    showFind(animated = true) {
+        this._webviewFindWidget?.reveal(undefined, animated);
+    }
+    hideFind(animated = true) {
+        this._webviewFindWidget?.hide(animated);
+    }
+    runFindAction(previous) {
+        this._webviewFindWidget?.find(previous);
+    }
+};
+WebviewElement = ( __decorate([
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IContextMenuService)),
+    ( __param(4, INotificationService)),
+    ( __param(5, IWorkbenchEnvironmentService)),
+    ( __param(6, IFileService)),
+    ( __param(7, ILogService)),
+    ( __param(8, IRemoteAuthorityResolverService)),
+    ( __param(9, ITelemetryService)),
+    ( __param(10, ITunnelService)),
+    ( __param(11, IInstantiationService)),
+    ( __param(12, IAccessibilityService))
+], WebviewElement));
+export { WebviewElement };