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

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

@@ -1,130 +0,0 @@
-import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
-import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { escape } from 'monaco-editor/esm/vs/base/common/strings.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
-import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
-import { ExtHostContext } from '../common/extHost.protocol.js';
-import { deserializeWebviewMessage, serializeWebviewMessage } from '../common/extHostWebviewMessaging.js';
-import { SerializableObjectWithBuffers } from '../../services/extensions/common/proxyIdentifier.js';
-let MainThreadWebviews = class MainThreadWebviews extends Disposable {
-    constructor(context, _openerService, _productService) {
-        super();
-        this._openerService = _openerService;
-        this._productService = _productService;
-        this._webviews = ( (new Map()));
-        this._proxy = ( (context.getProxy(ExtHostContext.ExtHostWebviews)));
-    }
-    addWebview(handle, webview, options) {
-        if (( (this._webviews.has(handle)))) {
-            throw new Error('Webview already registered');
-        }
-        this._webviews.set(handle, webview);
-        this.hookupWebviewEventDelegate(handle, webview, options);
-    }
-    $setHtml(handle, value) {
-        this.tryGetWebview(handle)?.setHtml(value);
-    }
-    $setOptions(handle, options) {
-        const webview = this.tryGetWebview(handle);
-        if (webview) {
-            webview.contentOptions = reviveWebviewContentOptions(options);
-        }
-    }
-    async $postMessage(handle, jsonMessage, ...buffers) {
-        const webview = this.tryGetWebview(handle);
-        if (!webview) {
-            return false;
-        }
-        const { message, arrayBuffers } = deserializeWebviewMessage(jsonMessage, buffers);
-        return webview.postMessage(message, arrayBuffers);
-    }
-    hookupWebviewEventDelegate(handle, webview, options) {
-        const disposables = ( (new DisposableStore()));
-        disposables.add(webview.onDidClickLink((uri) => this.onDidClickLink(handle, uri)));
-        disposables.add(webview.onMessage((message) => {
-            const serialized = serializeWebviewMessage(message.message, options);
-            this._proxy.$onMessage(handle, serialized.message, ( (new SerializableObjectWithBuffers(serialized.buffers))));
-        }));
-        disposables.add(webview.onMissingCsp((extension) => this._proxy.$onMissingCsp(handle, extension.value)));
-        disposables.add(webview.onDidDispose(() => {
-            disposables.dispose();
-            this._webviews.delete(handle);
-        }));
-    }
-    onDidClickLink(handle, link) {
-        const webview = this.getWebview(handle);
-        if (this.isSupportedLink(webview, ( (URI.parse(link))))) {
-            this._openerService.open(link, { fromUserGesture: true, allowContributedOpeners: true, allowCommands: Array.isArray(webview.contentOptions.enableCommandUris) || webview.contentOptions.enableCommandUris === true, fromWorkspace: true });
-        }
-    }
-    isSupportedLink(webview, link) {
-        if (( (MainThreadWebviews.standardSupportedLinkSchemes.has(link.scheme)))) {
-            return true;
-        }
-        if (!isWeb && this._productService.urlProtocol === link.scheme) {
-            return true;
-        }
-        if (link.scheme === Schemas.command) {
-            if (Array.isArray(webview.contentOptions.enableCommandUris)) {
-                return webview.contentOptions.enableCommandUris.includes(link.path);
-            }
-            return webview.contentOptions.enableCommandUris === true;
-        }
-        return false;
-    }
-    tryGetWebview(handle) {
-        return this._webviews.get(handle);
-    }
-    getWebview(handle) {
-        const webview = this.tryGetWebview(handle);
-        if (!webview) {
-            throw new Error(`Unknown webview handle:${handle}`);
-        }
-        return webview;
-    }
-    getWebviewResolvedFailedContent(viewType) {
-        return `<!DOCTYPE html>
-		<html>
-			<head>
-				<meta http-equiv="Content-type" content="text/html;charset=UTF-8">
-				<meta http-equiv="Content-Security-Policy" content="default-src 'none';">
-			</head>
-			<body>${( ( localize(
-            'errorMessage',
-            "An error occurred while loading view: {0}",
-            escape(viewType)
-        )))}</body>
-		</html>`;
-    }
-};
-MainThreadWebviews.standardSupportedLinkSchemes = ( (new Set([
-    Schemas.http,
-    Schemas.https,
-    Schemas.mailto,
-    Schemas.vscode,
-    'vscode-insider',
-])));
-MainThreadWebviews = ( (__decorate([
-    ( (__param(1, IOpenerService))),
-    ( (__param(2, IProductService)))
-], MainThreadWebviews)));
-function reviveWebviewExtension(extensionData) {
-    return {
-        id: extensionData.id,
-        location: URI.revive(extensionData.location),
-    };
-}
-function reviveWebviewContentOptions(webviewOptions) {
-    return {
-        allowScripts: webviewOptions.enableScripts,
-        allowForms: webviewOptions.enableForms,
-        enableCommandUris: webviewOptions.enableCommandUris,
-        localResourceRoots: Array.isArray(webviewOptions.localResourceRoots) ? ( (webviewOptions.localResourceRoots.map(r => URI.revive(r)))) : undefined,
-        portMapping: webviewOptions.portMapping,
-    };
-}
-export { MainThreadWebviews, reviveWebviewContentOptions, reviveWebviewExtension };

package/dist/vscode/vs/workbench/api/common/extHostCustomEditors.js

@@ -1,282 +0,0 @@
-import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
-import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
-import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { ViewColumn } from './extHostTypeConverters.js';
-import { toExtensionData, shouldSerializeBuffersForPostMessage } from './extHostWebview.js';
-import { Cache } from './cache.js';
-import { MainContext } from './extHost.protocol.js';
-import { Disposable } from './extHostTypes.js';
-class CustomDocumentStoreEntry {
-    constructor(document, _storagePath) {
-        this.document = document;
-        this._storagePath = _storagePath;
-        this._backupCounter = 1;
-        this._edits = ( new Cache('custom documents'));
-    }
-    addEdit(item) {
-        return this._edits.add([item]);
-    }
-    async undo(editId, isDirty) {
-        await this.getEdit(editId).undo();
-        if (!isDirty) {
-            this.disposeBackup();
-        }
-    }
-    async redo(editId, isDirty) {
-        await this.getEdit(editId).redo();
-        if (!isDirty) {
-            this.disposeBackup();
-        }
-    }
-    disposeEdits(editIds) {
-        for (const id of editIds) {
-            this._edits.delete(id);
-        }
-    }
-    getNewBackupUri() {
-        if (!this._storagePath) {
-            throw new Error('Backup requires a valid storage path');
-        }
-        const fileName = hashPath(this.document.uri) + (this._backupCounter++);
-        return joinPath(this._storagePath, fileName);
-    }
-    updateBackup(backup) {
-        this._backup?.delete();
-        this._backup = backup;
-    }
-    disposeBackup() {
-        this._backup?.delete();
-        this._backup = undefined;
-    }
-    getEdit(editId) {
-        const edit = this._edits.get(editId, 0);
-        if (!edit) {
-            throw new Error('No edit found');
-        }
-        return edit;
-    }
-}
-class CustomDocumentStore {
-    constructor() {
-        this._documents = ( new Map());
-    }
-    get(viewType, resource) {
-        return this._documents.get(this.key(viewType, resource));
-    }
-    add(viewType, document, storagePath) {
-        const key = this.key(viewType, document.uri);
-        if (( this._documents.has(key))) {
-            throw new Error(`Document already exists for viewType:${viewType} resource:${document.uri}`);
-        }
-        const entry = ( new CustomDocumentStoreEntry(document, storagePath));
-        this._documents.set(key, entry);
-        return entry;
-    }
-    delete(viewType, document) {
-        const key = this.key(viewType, document.uri);
-        this._documents.delete(key);
-    }
-    key(viewType, resource) {
-        return `${viewType}@@@${resource}`;
-    }
-}
-class EditorProviderStore {
-    constructor() {
-        this._providers = ( new Map());
-    }
-    addTextProvider(viewType, extension, provider) {
-        return this.add(0 , viewType, extension, provider);
-    }
-    addCustomProvider(viewType, extension, provider) {
-        return this.add(1 , viewType, extension, provider);
-    }
-    get(viewType) {
-        return this._providers.get(viewType);
-    }
-    add(type, viewType, extension, provider) {
-        if (( this._providers.has(viewType))) {
-            throw new Error(`Provider for viewType:${viewType} already registered`);
-        }
-        this._providers.set(viewType, { type, extension, provider });
-        return new Disposable(() => this._providers.delete(viewType));
-    }
-}
-class ExtHostCustomEditors {
-    constructor(mainContext, _extHostDocuments, _extensionStoragePaths, _extHostWebview, _extHostWebviewPanels) {
-        this._extHostDocuments = _extHostDocuments;
-        this._extensionStoragePaths = _extensionStoragePaths;
-        this._extHostWebview = _extHostWebview;
-        this._extHostWebviewPanels = _extHostWebviewPanels;
-        this._editorProviders = ( new EditorProviderStore());
-        this._documents = ( new CustomDocumentStore());
-        this._proxy = ( mainContext.getProxy(MainContext.MainThreadCustomEditors));
-    }
-    registerCustomEditorProvider(extension, viewType, provider, options) {
-        const disposables = ( new DisposableStore());
-        if (isCustomTextEditorProvider(provider)) {
-            disposables.add(this._editorProviders.addTextProvider(viewType, extension, provider));
-            this._proxy.$registerTextEditorProvider(toExtensionData(extension), viewType, options.webviewOptions || {}, {
-                supportsMove: !!provider.moveCustomTextEditor,
-            }, shouldSerializeBuffersForPostMessage(extension));
-        }
-        else {
-            disposables.add(this._editorProviders.addCustomProvider(viewType, extension, provider));
-            if (isCustomEditorProviderWithEditingCapability(provider)) {
-                disposables.add(provider.onDidChangeCustomDocument(e => {
-                    const entry = this.getCustomDocumentEntry(viewType, e.document.uri);
-                    if (isEditEvent(e)) {
-                        const editId = entry.addEdit(e);
-                        this._proxy.$onDidEdit(e.document.uri, viewType, editId, e.label);
-                    }
-                    else {
-                        this._proxy.$onContentChange(e.document.uri, viewType);
-                    }
-                }));
-            }
-            this._proxy.$registerCustomEditorProvider(toExtensionData(extension), viewType, options.webviewOptions || {}, !!options.supportsMultipleEditorsPerDocument, shouldSerializeBuffersForPostMessage(extension));
-        }
-        return Disposable.from(disposables, new Disposable(() => {
-            this._proxy.$unregisterEditorProvider(viewType);
-        }));
-    }
-    async $createCustomDocument(resource, viewType, backupId, untitledDocumentData, cancellation) {
-        const entry = this._editorProviders.get(viewType);
-        if (!entry) {
-            throw new Error(`No provider found for '${viewType}'`);
-        }
-        if (entry.type !== 1 ) {
-            throw new Error(`Invalid provide type for '${viewType}'`);
-        }
-        const revivedResource = URI.revive(resource);
-        const document = await entry.provider.openCustomDocument(revivedResource, { backupId, untitledDocumentData: untitledDocumentData?.buffer }, cancellation);
-        let storageRoot;
-        if (isCustomEditorProviderWithEditingCapability(entry.provider) && this._extensionStoragePaths) {
-            storageRoot = this._extensionStoragePaths.workspaceValue(entry.extension) ?? this._extensionStoragePaths.globalValue(entry.extension);
-        }
-        this._documents.add(viewType, document, storageRoot);
-        return { editable: isCustomEditorProviderWithEditingCapability(entry.provider) };
-    }
-    async $disposeCustomDocument(resource, viewType) {
-        const entry = this._editorProviders.get(viewType);
-        if (!entry) {
-            throw new Error(`No provider found for '${viewType}'`);
-        }
-        if (entry.type !== 1 ) {
-            throw new Error(`Invalid provider type for '${viewType}'`);
-        }
-        const revivedResource = URI.revive(resource);
-        const { document } = this.getCustomDocumentEntry(viewType, revivedResource);
-        this._documents.delete(viewType, document);
-        document.dispose();
-    }
-    async $resolveCustomEditor(resource, handle, viewType, initData, position, cancellation) {
-        const entry = this._editorProviders.get(viewType);
-        if (!entry) {
-            throw new Error(`No provider found for '${viewType}'`);
-        }
-        const viewColumn = ViewColumn.to(position);
-        const webview = this._extHostWebview.createNewWebview(handle, initData.contentOptions, entry.extension);
-        const panel = this._extHostWebviewPanels.createNewWebviewPanel(handle, viewType, initData.title, viewColumn, initData.options, webview, initData.active);
-        const revivedResource = URI.revive(resource);
-        switch (entry.type) {
-            case 1 : {
-                const { document } = this.getCustomDocumentEntry(viewType, revivedResource);
-                return entry.provider.resolveCustomEditor(document, panel, cancellation);
-            }
-            case 0 : {
-                const document = this._extHostDocuments.getDocument(revivedResource);
-                return entry.provider.resolveCustomTextEditor(document, panel, cancellation);
-            }
-            default: {
-                throw new Error('Unknown webview provider type');
-            }
-        }
-    }
-    $disposeEdits(resourceComponents, viewType, editIds) {
-        const document = this.getCustomDocumentEntry(viewType, resourceComponents);
-        document.disposeEdits(editIds);
-    }
-    async $onMoveCustomEditor(handle, newResourceComponents, viewType) {
-        const entry = this._editorProviders.get(viewType);
-        if (!entry) {
-            throw new Error(`No provider found for '${viewType}'`);
-        }
-        if (!entry.provider.moveCustomTextEditor) {
-            throw new Error(`Provider does not implement move '${viewType}'`);
-        }
-        const webview = this._extHostWebviewPanels.getWebviewPanel(handle);
-        if (!webview) {
-            throw new Error(`No webview found`);
-        }
-        const resource = URI.revive(newResourceComponents);
-        const document = this._extHostDocuments.getDocument(resource);
-        await entry.provider.moveCustomTextEditor(document, webview, CancellationToken.None);
-    }
-    async $undo(resourceComponents, viewType, editId, isDirty) {
-        const entry = this.getCustomDocumentEntry(viewType, resourceComponents);
-        return entry.undo(editId, isDirty);
-    }
-    async $redo(resourceComponents, viewType, editId, isDirty) {
-        const entry = this.getCustomDocumentEntry(viewType, resourceComponents);
-        return entry.redo(editId, isDirty);
-    }
-    async $revert(resourceComponents, viewType, cancellation) {
-        const entry = this.getCustomDocumentEntry(viewType, resourceComponents);
-        const provider = this.getCustomEditorProvider(viewType);
-        await provider.revertCustomDocument(entry.document, cancellation);
-        entry.disposeBackup();
-    }
-    async $onSave(resourceComponents, viewType, cancellation) {
-        const entry = this.getCustomDocumentEntry(viewType, resourceComponents);
-        const provider = this.getCustomEditorProvider(viewType);
-        await provider.saveCustomDocument(entry.document, cancellation);
-        entry.disposeBackup();
-    }
-    async $onSaveAs(resourceComponents, viewType, targetResource, cancellation) {
-        const entry = this.getCustomDocumentEntry(viewType, resourceComponents);
-        const provider = this.getCustomEditorProvider(viewType);
-        return provider.saveCustomDocumentAs(entry.document, URI.revive(targetResource), cancellation);
-    }
-    async $backup(resourceComponents, viewType, cancellation) {
-        const entry = this.getCustomDocumentEntry(viewType, resourceComponents);
-        const provider = this.getCustomEditorProvider(viewType);
-        const backup = await provider.backupCustomDocument(entry.document, {
-            destination: entry.getNewBackupUri(),
-        }, cancellation);
-        entry.updateBackup(backup);
-        return backup.id;
-    }
-    getCustomDocumentEntry(viewType, resource) {
-        const entry = this._documents.get(viewType, URI.revive(resource));
-        if (!entry) {
-            throw new Error('No custom document found');
-        }
-        return entry;
-    }
-    getCustomEditorProvider(viewType) {
-        const entry = this._editorProviders.get(viewType);
-        const provider = entry?.provider;
-        if (!provider || !isCustomEditorProviderWithEditingCapability(provider)) {
-            throw new Error('Custom document is not editable');
-        }
-        return provider;
-    }
-}
-function isCustomEditorProviderWithEditingCapability(provider) {
-    return !!provider.onDidChangeCustomDocument;
-}
-function isCustomTextEditorProvider(provider) {
-    return typeof provider.resolveCustomTextEditor === 'function';
-}
-function isEditEvent(e) {
-    return typeof e.undo === 'function'
-        && typeof e.redo === 'function';
-}
-function hashPath(resource) {
-    const str = resource.scheme === Schemas.file || resource.scheme === Schemas.untitled ? resource.fsPath : ( resource.toString());
-    return hash(str) + '';
-}
-export { ExtHostCustomEditors };

package/dist/vscode/vs/workbench/api/common/extHostDialogs.js

@@ -1,22 +0,0 @@
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { MainContext } from './extHost.protocol.js';
-import { checkProposedApiEnabled } from '../../services/extensions/common/extensions.js';
-class ExtHostDialogs {
-    constructor(mainContext) {
-        this._proxy = ( mainContext.getProxy(MainContext.MainThreadDialogs));
-    }
-    showOpenDialog(extension, options) {
-        if (options?.allowUIResources) {
-            checkProposedApiEnabled(extension, 'showLocal');
-        }
-        return this._proxy.$showOpenDialog(options).then(filepaths => {
-            return filepaths ? ( filepaths.map(p => URI.revive(p))) : undefined;
-        });
-    }
-    showSaveDialog(options) {
-        return this._proxy.$showSaveDialog(options).then(filepath => {
-            return filepath ? URI.revive(filepath) : undefined;
-        });
-    }
-}
-export { ExtHostDialogs };

package/dist/vscode/vs/workbench/api/common/extHostLogService.js

@@ -1,17 +0,0 @@
-import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { ILoggerService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { LogService } from 'monaco-editor/esm/vs/platform/log/common/logService.js';
-import { IExtHostInitDataService } from './extHostInitDataService.js';
-let ExtHostLogService = class ExtHostLogService extends LogService {
-    constructor(isWorker, loggerService, initData) {
-        const id = initData.remote.isRemote ? 'remoteexthost' : isWorker ? 'workerexthost' : 'exthost';
-        const name = initData.remote.isRemote ? ( localize('remote', "Extension Host (Remote)")) : isWorker ? ( localize('worker', "Extension Host (Worker)")) : ( localize('local', "Extension Host"));
-        super(loggerService.createLogger(id, { name }));
-    }
-};
-ExtHostLogService = ( __decorate([
-    ( __param(1, ILoggerService)),
-    ( __param(2, IExtHostInitDataService))
-], ExtHostLogService));
-export { ExtHostLogService };

package/dist/vscode/vs/workbench/api/common/extHostLoggerService.js

@@ -1,63 +0,0 @@
-import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
-import { AbstractLoggerService, AbstractMessageLogger } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { MainContext } from './extHost.protocol.js';
-import { IExtHostInitDataService } from './extHostInitDataService.js';
-import { IExtHostRpcService } from './extHostRpcService.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
-let ExtHostLoggerService = class ExtHostLoggerService extends AbstractLoggerService {
-    constructor(rpc, initData) {
-        super(initData.logLevel, initData.logsLocation, ( initData.loggers.map(logger => revive(logger))));
-        this._proxy = ( rpc.getProxy(MainContext.MainThreadLogger));
-    }
-    $setLogLevel(logLevel, resource) {
-        if (resource) {
-            this.setLogLevel(URI.revive(resource), logLevel);
-        }
-        else {
-            this.setLogLevel(logLevel);
-        }
-    }
-    setVisibility(resource, visibility) {
-        super.setVisibility(resource, visibility);
-        this._proxy.$setVisibility(resource, visibility);
-    }
-    doCreateLogger(resource, logLevel, options) {
-        return ( new Logger(this._proxy, resource, logLevel, options));
-    }
-};
-ExtHostLoggerService = ( __decorate([
-    ( __param(0, IExtHostRpcService)),
-    ( __param(1, IExtHostInitDataService))
-], ExtHostLoggerService));
-class Logger extends AbstractMessageLogger {
-    constructor(proxy, file, logLevel, loggerOptions) {
-        super(loggerOptions?.logLevel === 'always');
-        this.proxy = proxy;
-        this.file = file;
-        this.isLoggerCreated = false;
-        this.buffer = [];
-        this.setLevel(logLevel);
-        this.proxy.$createLogger(file, loggerOptions)
-            .then(() => {
-            this.doLog(this.buffer);
-            this.isLoggerCreated = true;
-        });
-    }
-    log(level, message) {
-        const messages = [[level, message]];
-        if (this.isLoggerCreated) {
-            this.doLog(messages);
-        }
-        else {
-            this.buffer.push(...messages);
-        }
-    }
-    doLog(messages) {
-        this.proxy.$log(this.file, messages);
-    }
-    flush() {
-        this.proxy.$flush(this.file);
-    }
-}
-export { ExtHostLoggerService };

package/dist/vscode/vs/workbench/api/common/extHostUriOpener.js

@@ -1,44 +0,0 @@
-import { toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { MainContext } from './extHost.protocol.js';
-class ExtHostUriOpeners {
-    constructor(mainContext) {
-        this._openers = ( new Map());
-        this._proxy = ( mainContext.getProxy(MainContext.MainThreadUriOpeners));
-    }
-    registerExternalUriOpener(extensionId, id, opener, metadata) {
-        if (( this._openers.has(id))) {
-            throw new Error(`Opener with id '${id}' already registered`);
-        }
-        const invalidScheme = metadata.schemes.find(scheme => !( ExtHostUriOpeners.supportedSchemes.has(scheme)));
-        if (invalidScheme) {
-            throw new Error(`Scheme '${invalidScheme}' is not supported. Only http and https are currently supported.`);
-        }
-        this._openers.set(id, opener);
-        this._proxy.$registerUriOpener(id, metadata.schemes, extensionId, metadata.label);
-        return toDisposable(() => {
-            this._openers.delete(id);
-            this._proxy.$unregisterUriOpener(id);
-        });
-    }
-    async $canOpenUri(id, uriComponents, token) {
-        const opener = this._openers.get(id);
-        if (!opener) {
-            throw new Error(`Unknown opener with id: ${id}`);
-        }
-        const uri = URI.revive(uriComponents);
-        return opener.canOpenExternalUri(uri, token);
-    }
-    async $openUri(id, context, token) {
-        const opener = this._openers.get(id);
-        if (!opener) {
-            throw new Error(`Unknown opener id: '${id}'`);
-        }
-        return opener.openExternalUri(URI.revive(context.resolvedUri), {
-            sourceUri: URI.revive(context.sourceUri)
-        }, token);
-    }
-}
-ExtHostUriOpeners.supportedSchemes = ( new Set([Schemas.http, Schemas.https]));
-export { ExtHostUriOpeners };