@codingame/monaco-vscode-extensions-service-override 1.83.7 → 1.83.9

package/vscode/src/vs/workbench/api/browser/mainThreadUriOpeners.js

@@ -0,0 +1,110 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { INotificationService, Severity } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { defaultExternalUriOpenerId } from 'vscode/vscode/vs/workbench/contrib/externalUriOpener/common/configuration';
+import { ContributedExternalUriOpenersStore } from '../../contrib/externalUriOpener/common/contributedOpeners.js';
+import { IExternalUriOpenerService } from 'vscode/vscode/vs/workbench/contrib/externalUriOpener/common/externalUriOpenerService';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+let MainThreadUriOpeners = class MainThreadUriOpeners extends Disposable {
+    constructor(context, storageService, externalUriOpenerService, extensionService, openerService, notificationService) {
+        super();
+        this.extensionService = extensionService;
+        this.openerService = openerService;
+        this.notificationService = notificationService;
+        this._registeredOpeners = ( new Map());
+        this.proxy = ( context.getProxy(ExtHostContext.ExtHostUriOpeners));
+        this._register(externalUriOpenerService.registerExternalOpenerProvider(this));
+        this._contributedExternalUriOpenersStore = this._register(( new ContributedExternalUriOpenersStore(storageService, extensionService)));
+    }
+    async *getOpeners(targetUri) {
+        if (targetUri.scheme !== Schemas.http && targetUri.scheme !== Schemas.https) {
+            return;
+        }
+        await this.extensionService.activateByEvent(`onOpenExternalUri:${targetUri.scheme}`);
+        for (const [id, openerMetadata] of this._registeredOpeners) {
+            if (( openerMetadata.schemes.has(targetUri.scheme))) {
+                yield this.createOpener(id, openerMetadata);
+            }
+        }
+    }
+    createOpener(id, metadata) {
+        return {
+            id: id,
+            label: metadata.label,
+            canOpen: (uri, token) => {
+                return this.proxy.$canOpenUri(id, uri, token);
+            },
+            openExternalUri: async (uri, ctx, token) => {
+                try {
+                    await this.proxy.$openUri(id, { resolvedUri: uri, sourceUri: ctx.sourceUri }, token);
+                }
+                catch (e) {
+                    if (!isCancellationError(e)) {
+                        const openDefaultAction = ( new Action('default', ( localizeWithPath(
+                            'vs/workbench/api/browser/mainThreadUriOpeners',
+                            'openerFailedUseDefault',
+                            "Open using default opener"
+                        )), undefined, undefined, async () => {
+                            await this.openerService.open(uri, {
+                                allowTunneling: false,
+                                allowContributedOpeners: defaultExternalUriOpenerId,
+                            });
+                        }));
+                        openDefaultAction.tooltip = ( uri.toString());
+                        this.notificationService.notify({
+                            severity: Severity.Error,
+                            message: ( localizeWithPath('vs/workbench/api/browser/mainThreadUriOpeners', {
+                                key: 'openerFailedMessage',
+                                comment: ['{0} is the id of the opener. {1} is the url being opened.'],
+                            }, 'Could not open uri with \'{0}\': {1}', id, ( e.toString()))),
+                            actions: {
+                                primary: [
+                                    openDefaultAction
+                                ]
+                            }
+                        });
+                    }
+                }
+                return true;
+            },
+        };
+    }
+    async $registerUriOpener(id, schemes, extensionId, label) {
+        if (( this._registeredOpeners.has(id))) {
+            throw new Error(`Opener with id '${id}' already registered`);
+        }
+        this._registeredOpeners.set(id, {
+            schemes: ( new Set(schemes)),
+            label,
+            extensionId,
+        });
+        this._contributedExternalUriOpenersStore.didRegisterOpener(id, extensionId.value);
+    }
+    async $unregisterUriOpener(id) {
+        this._registeredOpeners.delete(id);
+        this._contributedExternalUriOpenersStore.delete(id);
+    }
+    dispose() {
+        super.dispose();
+        this._registeredOpeners.clear();
+    }
+};
+MainThreadUriOpeners = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadUriOpeners),
+    ( __param(1, IStorageService)),
+    ( __param(2, IExternalUriOpenerService)),
+    ( __param(3, IExtensionService)),
+    ( __param(4, IOpenerService)),
+    ( __param(5, INotificationService))
+], MainThreadUriOpeners);
+
+export { MainThreadUriOpeners };

package/vscode/src/vs/workbench/api/browser/mainThreadUrls.js

@@ -0,0 +1,61 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { IURLService } from 'vscode/vscode/vs/platform/url/common/url';
+import { IExtensionUrlHandler } from 'vscode/vscode/vs/workbench/services/extensions/browser/extensionUrlHandler';
+import { ExtensionIdentifier } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
+
+class ExtensionUrlHandler {
+    constructor(proxy, handle, extensionId, extensionDisplayName) {
+        this.proxy = proxy;
+        this.handle = handle;
+        this.extensionId = extensionId;
+        this.extensionDisplayName = extensionDisplayName;
+    }
+    handleURL(uri, options) {
+        if (!ExtensionIdentifier.equals(this.extensionId, uri.authority)) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(this.proxy.$handleExternalUri(this.handle, uri)).then(() => true);
+    }
+}
+let MainThreadUrls = class MainThreadUrls {
+    constructor(context, urlService, extensionUrlHandler) {
+        this.urlService = urlService;
+        this.extensionUrlHandler = extensionUrlHandler;
+        this.handlers = ( new Map());
+        this.proxy = ( context.getProxy(ExtHostContext.ExtHostUrls));
+    }
+    $registerUriHandler(handle, extensionId, extensionDisplayName) {
+        const handler = ( new ExtensionUrlHandler(this.proxy, handle, extensionId, extensionDisplayName));
+        const disposable = this.urlService.registerHandler(handler);
+        this.handlers.set(handle, { extensionId, disposable });
+        this.extensionUrlHandler.registerExtensionHandler(extensionId, handler);
+        return Promise.resolve(undefined);
+    }
+    $unregisterUriHandler(handle) {
+        const tuple = this.handlers.get(handle);
+        if (!tuple) {
+            return Promise.resolve(undefined);
+        }
+        const { extensionId, disposable } = tuple;
+        this.extensionUrlHandler.unregisterExtensionHandler(extensionId);
+        this.handlers.delete(handle);
+        disposable.dispose();
+        return Promise.resolve(undefined);
+    }
+    async $createAppUri(uri) {
+        return this.urlService.create(uri);
+    }
+    dispose() {
+        this.handlers.forEach(({ disposable }) => disposable.dispose());
+        this.handlers.clear();
+    }
+};
+MainThreadUrls = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadUrls),
+    ( __param(1, IURLService)),
+    ( __param(2, IExtensionUrlHandler))
+], MainThreadUrls);
+
+export { MainThreadUrls };

package/vscode/src/vs/workbench/api/browser/mainThreadWebviewManager.js

@@ -0,0 +1,29 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { MainThreadCustomEditors } from './mainThreadCustomEditors.js';
+import { MainThreadWebviewPanels } from './mainThreadWebviewPanels.js';
+import { MainThreadWebviews } from './mainThreadWebviews.js';
+import { MainThreadWebviewsViews } from './mainThreadWebviewViews.js';
+import { MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { extHostCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+let MainThreadWebviewManager = class MainThreadWebviewManager extends Disposable {
+    constructor(context, instantiationService) {
+        super();
+        const webviews = this._register(instantiationService.createInstance(MainThreadWebviews, context));
+        context.set(MainContext.MainThreadWebviews, webviews);
+        const webviewPanels = this._register(instantiationService.createInstance(MainThreadWebviewPanels, context, webviews));
+        context.set(MainContext.MainThreadWebviewPanels, webviewPanels);
+        const customEditors = this._register(instantiationService.createInstance(MainThreadCustomEditors, context, webviews, webviewPanels));
+        context.set(MainContext.MainThreadCustomEditors, customEditors);
+        const webviewViews = this._register(instantiationService.createInstance(MainThreadWebviewsViews, context, webviews));
+        context.set(MainContext.MainThreadWebviewViews, webviewViews);
+    }
+};
+MainThreadWebviewManager = __decorate([
+    extHostCustomer,
+    ( __param(1, IInstantiationService))
+], MainThreadWebviewManager);
+
+export { MainThreadWebviewManager };

package/vscode/src/vs/workbench/api/browser/mainThreadWebviewPanels.js

@@ -0,0 +1,283 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { reviveWebviewExtension, reviveWebviewContentOptions } from './mainThreadWebviews.js';
+import { ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { DiffEditorInput } from 'vscode/vscode/vs/workbench/common/editor/diffEditorInput';
+import { ExtensionKeyedWebviewOriginStore } from 'vscode/vscode/vs/workbench/contrib/webview/browser/webview';
+import { WebviewInput } from 'vscode/vscode/vs/workbench/contrib/webviewPanel/browser/webviewEditorInput';
+import { IWebviewWorkbenchService } from 'vscode/vscode/vs/workbench/contrib/webviewPanel/browser/webviewWorkbenchService';
+import { editorGroupToColumn } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupColumn';
+import { IEditorGroupsService, preferredSideBySideGroupDirection } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+import { IEditorService, ACTIVE_GROUP, SIDE_GROUP } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+
+class WebviewInputStore {
+    constructor() {
+        this._handlesToInputs = ( new Map());
+        this._inputsToHandles = ( new Map());
+    }
+    add(handle, input) {
+        this._handlesToInputs.set(handle, input);
+        this._inputsToHandles.set(input, handle);
+    }
+    getHandleForInput(input) {
+        return this._inputsToHandles.get(input);
+    }
+    getInputForHandle(handle) {
+        return this._handlesToInputs.get(handle);
+    }
+    delete(handle) {
+        const input = this.getInputForHandle(handle);
+        this._handlesToInputs.delete(handle);
+        if (input) {
+            this._inputsToHandles.delete(input);
+        }
+    }
+    get size() {
+        return this._handlesToInputs.size;
+    }
+    [Symbol.iterator]() {
+        return ( this._handlesToInputs.values());
+    }
+}
+class WebviewViewTypeTransformer {
+    constructor(prefix) {
+        this.prefix = prefix;
+    }
+    fromExternal(viewType) {
+        return this.prefix + viewType;
+    }
+    toExternal(viewType) {
+        return viewType.startsWith(this.prefix)
+            ? viewType.substr(this.prefix.length)
+            : undefined;
+    }
+}
+let MainThreadWebviewPanels = class MainThreadWebviewPanels extends Disposable {
+    constructor(context, _mainThreadWebviews, _configurationService, _editorGroupService, _editorService, extensionService, storageService, _telemetryService, _webviewWorkbenchService) {
+        super();
+        this._mainThreadWebviews = _mainThreadWebviews;
+        this._configurationService = _configurationService;
+        this._editorGroupService = _editorGroupService;
+        this._editorService = _editorService;
+        this._telemetryService = _telemetryService;
+        this._webviewWorkbenchService = _webviewWorkbenchService;
+        this.webviewPanelViewType = ( new WebviewViewTypeTransformer('mainThreadWebview-'));
+        this._webviewInputs = ( new WebviewInputStore());
+        this._revivers = this._register(( new DisposableMap()));
+        this.webviewOriginStore = ( new ExtensionKeyedWebviewOriginStore('mainThreadWebviewPanel.origins', storageService));
+        this._proxy = ( context.getProxy(ExtHostContext.ExtHostWebviewPanels));
+        this._register(Event.any(_editorService.onDidActiveEditorChange, _editorService.onDidVisibleEditorsChange, _editorGroupService.onDidAddGroup, _editorGroupService.onDidRemoveGroup, _editorGroupService.onDidMoveGroup)(() => {
+            this.updateWebviewViewStates(this._editorService.activeEditor);
+        }));
+        this._register(_webviewWorkbenchService.onDidChangeActiveWebviewEditor(input => {
+            this.updateWebviewViewStates(input);
+        }));
+        this._register(_webviewWorkbenchService.registerResolver({
+            canResolve: (webview) => {
+                const viewType = this.webviewPanelViewType.toExternal(webview.viewType);
+                if (typeof viewType === 'string') {
+                    extensionService.activateByEvent(`onWebviewPanel:${viewType}`);
+                }
+                return false;
+            },
+            resolveWebview: () => { throw new Error('not implemented'); }
+        }));
+    }
+    get webviewInputs() { return this._webviewInputs; }
+    addWebviewInput(handle, input, options) {
+        this._webviewInputs.add(handle, input);
+        this._mainThreadWebviews.addWebview(handle, input.webview, options);
+        input.webview.onDidDispose(() => {
+            this._proxy.$onDidDisposeWebviewPanel(handle).finally(() => {
+                this._webviewInputs.delete(handle);
+            });
+        });
+    }
+    $createWebviewPanel(extensionData, handle, viewType, initData, showOptions) {
+        const targetGroup = this.getTargetGroupFromShowOptions(showOptions);
+        const mainThreadShowOptions = showOptions ? {
+            preserveFocus: !!showOptions.preserveFocus,
+            group: targetGroup
+        } : {};
+        const extension = reviveWebviewExtension(extensionData);
+        const origin = this.webviewOriginStore.getOrigin(viewType, extension.id);
+        const webview = this._webviewWorkbenchService.openWebview({
+            origin,
+            providedViewType: viewType,
+            title: initData.title,
+            options: reviveWebviewOptions(initData.panelOptions),
+            contentOptions: reviveWebviewContentOptions(initData.webviewOptions),
+            extension
+        }, this.webviewPanelViewType.fromExternal(viewType), initData.title, mainThreadShowOptions);
+        this.addWebviewInput(handle, webview, { serializeBuffersForPostMessage: initData.serializeBuffersForPostMessage });
+        const payload = {
+            extensionId: extension.id.value,
+            viewType
+        };
+        this._telemetryService.publicLog2('webviews:createWebviewPanel', payload);
+    }
+    $disposeWebview(handle) {
+        const webview = this.tryGetWebviewInput(handle);
+        if (!webview) {
+            return;
+        }
+        webview.dispose();
+    }
+    $setTitle(handle, value) {
+        this.tryGetWebviewInput(handle)?.setName(value);
+    }
+    $setIconPath(handle, value) {
+        const webview = this.tryGetWebviewInput(handle);
+        if (webview) {
+            webview.iconPath = reviveWebviewIcon(value);
+        }
+    }
+    $reveal(handle, showOptions) {
+        const webview = this.tryGetWebviewInput(handle);
+        if (!webview || webview.isDisposed()) {
+            return;
+        }
+        const targetGroup = this.getTargetGroupFromShowOptions(showOptions);
+        this._webviewWorkbenchService.revealWebview(webview, targetGroup, !!showOptions.preserveFocus);
+    }
+    getTargetGroupFromShowOptions(showOptions) {
+        if (typeof showOptions.viewColumn === 'undefined'
+            || showOptions.viewColumn === ACTIVE_GROUP
+            || (this._editorGroupService.count === 1 && this._editorGroupService.activeGroup.isEmpty)) {
+            return ACTIVE_GROUP;
+        }
+        if (showOptions.viewColumn === SIDE_GROUP) {
+            return SIDE_GROUP;
+        }
+        if (showOptions.viewColumn >= 0) {
+            const groupInColumn = this._editorGroupService.getGroups(2 )[showOptions.viewColumn];
+            if (groupInColumn) {
+                return groupInColumn.id;
+            }
+            const newGroup = this._editorGroupService.findGroup({ location: 1  });
+            if (newGroup) {
+                const direction = preferredSideBySideGroupDirection(this._configurationService);
+                return this._editorGroupService.addGroup(newGroup, direction);
+            }
+        }
+        return ACTIVE_GROUP;
+    }
+    $registerSerializer(viewType, options) {
+        if (( this._revivers.has(viewType))) {
+            throw new Error(`Reviver for ${viewType} already registered`);
+        }
+        this._revivers.set(viewType, this._webviewWorkbenchService.registerResolver({
+            canResolve: (webviewInput) => {
+                return webviewInput.viewType === this.webviewPanelViewType.fromExternal(viewType);
+            },
+            resolveWebview: async (webviewInput) => {
+                const viewType = this.webviewPanelViewType.toExternal(webviewInput.viewType);
+                if (!viewType) {
+                    webviewInput.webview.setHtml(this._mainThreadWebviews.getWebviewResolvedFailedContent(webviewInput.viewType));
+                    return;
+                }
+                const handle = generateUuid();
+                this.addWebviewInput(handle, webviewInput, options);
+                let state = undefined;
+                if (webviewInput.webview.state) {
+                    try {
+                        state = JSON.parse(webviewInput.webview.state);
+                    }
+                    catch (e) {
+                        console.error('Could not load webview state', e, webviewInput.webview.state);
+                    }
+                }
+                try {
+                    await this._proxy.$deserializeWebviewPanel(handle, viewType, {
+                        title: webviewInput.getTitle(),
+                        state,
+                        panelOptions: webviewInput.webview.options,
+                        webviewOptions: webviewInput.webview.contentOptions,
+                        active: webviewInput === this._editorService.activeEditor,
+                    }, editorGroupToColumn(this._editorGroupService, webviewInput.group || 0));
+                }
+                catch (error) {
+                    onUnexpectedError(error);
+                    webviewInput.webview.setHtml(this._mainThreadWebviews.getWebviewResolvedFailedContent(viewType));
+                }
+            }
+        }));
+    }
+    $unregisterSerializer(viewType) {
+        if (!( this._revivers.has(viewType))) {
+            throw new Error(`No reviver for ${viewType} registered`);
+        }
+        this._revivers.deleteAndDispose(viewType);
+    }
+    updateWebviewViewStates(activeEditorInput) {
+        if (!this._webviewInputs.size) {
+            return;
+        }
+        const viewStates = {};
+        const updateViewStatesForInput = (group, topLevelInput, editorInput) => {
+            if (!(editorInput instanceof WebviewInput)) {
+                return;
+            }
+            editorInput.updateGroup(group.id);
+            const handle = this._webviewInputs.getHandleForInput(editorInput);
+            if (handle) {
+                viewStates[handle] = {
+                    visible: topLevelInput === group.activeEditor,
+                    active: editorInput === activeEditorInput,
+                    position: editorGroupToColumn(this._editorGroupService, group.id),
+                };
+            }
+        };
+        for (const group of this._editorGroupService.groups) {
+            for (const input of group.editors) {
+                if (input instanceof DiffEditorInput) {
+                    updateViewStatesForInput(group, input, input.primary);
+                    updateViewStatesForInput(group, input, input.secondary);
+                }
+                else {
+                    updateViewStatesForInput(group, input, input);
+                }
+            }
+        }
+        if (( Object.keys(viewStates)).length) {
+            this._proxy.$onDidChangeWebviewPanelViewStates(viewStates);
+        }
+    }
+    tryGetWebviewInput(handle) {
+        return this._webviewInputs.getInputForHandle(handle);
+    }
+};
+MainThreadWebviewPanels = ( __decorate([
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IEditorGroupsService)),
+    ( __param(4, IEditorService)),
+    ( __param(5, IExtensionService)),
+    ( __param(6, IStorageService)),
+    ( __param(7, ITelemetryService)),
+    ( __param(8, IWebviewWorkbenchService))
+], MainThreadWebviewPanels));
+function reviveWebviewIcon(value) {
+    if (!value) {
+        return undefined;
+    }
+    return {
+        light: URI.revive(value.light),
+        dark: URI.revive(value.dark),
+    };
+}
+function reviveWebviewOptions(panelOptions) {
+    return {
+        enableFindWidget: panelOptions.enableFindWidget,
+        retainContextWhenHidden: panelOptions.retainContextWhenHidden,
+    };
+}
+
+export { MainThreadWebviewPanels };

package/vscode/src/vs/workbench/api/browser/mainThreadWebviewViews.js

@@ -0,0 +1,100 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Disposable, DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
+import { reviveWebviewExtension } from './mainThreadWebviews.js';
+import { ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { IWebviewViewService } from 'vscode/vscode/vs/workbench/contrib/webviewView/browser/webviewViewService';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+
+let MainThreadWebviewsViews = class MainThreadWebviewsViews extends Disposable {
+    constructor(context, mainThreadWebviews, _telemetryService, _webviewViewService) {
+        super();
+        this.mainThreadWebviews = mainThreadWebviews;
+        this._telemetryService = _telemetryService;
+        this._webviewViewService = _webviewViewService;
+        this._webviewViews = this._register(( new DisposableMap()));
+        this._webviewViewProviders = this._register(( new DisposableMap()));
+        this._proxy = ( context.getProxy(ExtHostContext.ExtHostWebviewViews));
+    }
+    $setWebviewViewTitle(handle, value) {
+        const webviewView = this.getWebviewView(handle);
+        webviewView.title = value;
+    }
+    $setWebviewViewDescription(handle, value) {
+        const webviewView = this.getWebviewView(handle);
+        webviewView.description = value;
+    }
+    $setWebviewViewBadge(handle, badge) {
+        const webviewView = this.getWebviewView(handle);
+        webviewView.badge = badge;
+    }
+    $show(handle, preserveFocus) {
+        const webviewView = this.getWebviewView(handle);
+        webviewView.show(preserveFocus);
+    }
+    $registerWebviewViewProvider(extensionData, viewType, options) {
+        if (( this._webviewViewProviders.has(viewType))) {
+            throw new Error(`View provider for ${viewType} already registered`);
+        }
+        const extension = reviveWebviewExtension(extensionData);
+        const registration = this._webviewViewService.register(viewType, {
+            resolve: async (webviewView, cancellation) => {
+                const handle = generateUuid();
+                this._webviewViews.set(handle, webviewView);
+                this.mainThreadWebviews.addWebview(handle, webviewView.webview, { serializeBuffersForPostMessage: options.serializeBuffersForPostMessage });
+                let state = undefined;
+                if (webviewView.webview.state) {
+                    try {
+                        state = JSON.parse(webviewView.webview.state);
+                    }
+                    catch (e) {
+                        console.error('Could not load webview state', e, webviewView.webview.state);
+                    }
+                }
+                webviewView.webview.extension = extension;
+                if (options) {
+                    webviewView.webview.options = options;
+                }
+                webviewView.onDidChangeVisibility(visible => {
+                    this._proxy.$onDidChangeWebviewViewVisibility(handle, visible);
+                });
+                webviewView.onDispose(() => {
+                    this._proxy.$disposeWebviewView(handle);
+                    this._webviewViews.deleteAndDispose(handle);
+                });
+                this._telemetryService.publicLog2('webviews:createWebviewView', {
+                    extensionId: extension.id.value,
+                    id: viewType,
+                });
+                try {
+                    await this._proxy.$resolveWebviewView(handle, viewType, webviewView.title, state, cancellation);
+                }
+                catch (error) {
+                    onUnexpectedError(error);
+                    webviewView.webview.setHtml(this.mainThreadWebviews.getWebviewResolvedFailedContent(viewType));
+                }
+            }
+        });
+        this._webviewViewProviders.set(viewType, registration);
+    }
+    $unregisterWebviewViewProvider(viewType) {
+        if (!( this._webviewViewProviders.has(viewType))) {
+            throw new Error(`No view provider for ${viewType} registered`);
+        }
+        this._webviewViewProviders.deleteAndDispose(viewType);
+    }
+    getWebviewView(handle) {
+        const webviewView = this._webviewViews.get(handle);
+        if (!webviewView) {
+            throw new Error('unknown webview view');
+        }
+        return webviewView;
+    }
+};
+MainThreadWebviewsViews = ( __decorate([
+    ( __param(2, ITelemetryService)),
+    ( __param(3, IWebviewViewService))
+], MainThreadWebviewsViews));
+
+export { MainThreadWebviewsViews };