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

package/dist/vscode/vs/workbench/api/browser/mainThreadLogService.js

@@ -1,76 +0,0 @@
-import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { ILoggerService, parseLogLevel, ILogService, LogLevelToString, isLogLevel, log } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { MainContext, ExtHostContext } from '../common/extHost.protocol.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
-let MainThreadLoggerService = class MainThreadLoggerService {
-    constructor(extHostContext, loggerService) {
-        this.loggerService = loggerService;
-        this.disposables = ( new DisposableStore());
-        const proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostLogLevelServiceShape));
-        this.disposables.add(loggerService.onDidChangeLogLevel(arg => {
-            if (isLogLevel(arg)) {
-                proxy.$setLogLevel(arg);
-            }
-            else {
-                proxy.$setLogLevel(arg[1], arg[0]);
-            }
-        }));
-    }
-    $log(file, messages) {
-        const logger = this.loggerService.getLogger(URI.revive(file));
-        if (!logger) {
-            throw new Error('Create the logger before logging');
-        }
-        for (const [level, message] of messages) {
-            log(logger, level, message);
-        }
-    }
-    async $createLogger(file, options) {
-        this.loggerService.createLogger(URI.revive(file), options);
-    }
-    async $registerLogger(logResource) {
-        this.loggerService.registerLogger({
-            ...logResource,
-            resource: URI.revive(logResource.resource)
-        });
-    }
-    async $deregisterLogger(resource) {
-        this.loggerService.deregisterLogger(URI.revive(resource));
-    }
-    async $setVisibility(resource, visible) {
-        this.loggerService.setVisibility(URI.revive(resource), visible);
-    }
-    $flush(file) {
-        const logger = this.loggerService.getLogger(URI.revive(file));
-        if (!logger) {
-            throw new Error('Create the logger before flushing');
-        }
-        logger.flush();
-    }
-    dispose() {
-        this.disposables.dispose();
-    }
-};
-MainThreadLoggerService = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadLogger),
-    ( __param(1, ILoggerService))
-], MainThreadLoggerService);
-CommandsRegistry.registerCommand('_extensionTests.setLogLevel', function (accessor, level) {
-    const loggerService = accessor.get(ILoggerService);
-    const environmentService = accessor.get(IEnvironmentService);
-    if (environmentService.isExtensionDevelopment && !!environmentService.extensionTestsLocationURI) {
-        const logLevel = parseLogLevel(level);
-        if (logLevel !== undefined) {
-            loggerService.setLogLevel(logLevel);
-        }
-    }
-});
-CommandsRegistry.registerCommand('_extensionTests.getLogLevel', function (accessor) {
-    const logService = accessor.get(ILogService);
-    return LogLevelToString(logService.getLevel());
-});
-export { MainThreadLoggerService };

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

@@ -1,104 +0,0 @@
-import { __decorate, __param } from '../../../../../node_modules/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 { localize } from 'monaco-editor/esm/vs/nls.js';
-import { Severity, INotificationService } 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 { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-import { defaultExternalUriOpenerId } from '../../contrib/externalUriOpener/common/configuration.js';
-import { ContributedExternalUriOpenersStore } from '../../contrib/externalUriOpener/common/contributedOpeners.js';
-import { IExternalUriOpenerService } from '../../contrib/externalUriOpener/common/externalUriOpenerService.js';
-import { IExtensionService } from '../../services/extensions/common/extensions.js';
-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', ( localize('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: ( localize({
-                                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/dist/vscode/vs/workbench/api/browser/mainThreadWebviewManager.js

@@ -1,27 +0,0 @@
-import { __decorate, __param } from '../../../../../node_modules/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 '../common/extHost.protocol.js';
-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/dist/vscode/vs/workbench/api/browser/mainThreadWebviewPanels.js

@@ -1,281 +0,0 @@
-import { __decorate, __param } from '../../../../../node_modules/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 '../common/extHost.protocol.js';
-import { DiffEditorInput } from '../../common/editor/diffEditorInput.js';
-import { ExtensionKeyedWebviewOriginStore } from '../../contrib/webview/browser/webview.js';
-import { WebviewInput } from '../../contrib/webviewPanel/browser/webviewEditorInput.js';
-import { IWebviewWorkbenchService } from '../../contrib/webviewPanel/browser/webviewWorkbenchService.js';
-import { editorGroupToColumn } from '../../services/editor/common/editorGroupColumn.js';
-import { preferredSideBySideGroupDirection, IEditorGroupsService } from '../../services/editor/common/editorGroupsService.js';
-import { ACTIVE_GROUP, SIDE_GROUP, IEditorService } from '../../services/editor/common/editorService.js';
-import { IExtensionService } from '../../services/extensions/common/extensions.js';
-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/dist/vscode/vs/workbench/api/browser/mainThreadWebviewViews.js

@@ -1,98 +0,0 @@
-import { __decorate, __param } from '../../../../../node_modules/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 '../common/extHost.protocol.js';
-import { IWebviewViewService } from '../../contrib/webviewView/browser/webviewViewService.js';
-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 };