@codingame/monaco-vscode-extensions-service-override 4.0.0 → 4.1.0

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

@@ -1,227 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { illegalArgument } from 'vscode/vscode/vs/base/common/errors';
-import { DisposableStore, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
-import { equals } from 'vscode/vscode/vs/base/common/objects';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
-import { CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
-import { EditorActivation, EditorResolution } from 'vscode/vscode/vs/platform/editor/common/editor';
-import { ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { editorGroupToColumn, columnToEditorGroup } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupColumn';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
-import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment';
-import { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService';
-import { getCodeEditor } from 'vscode/vscode/vs/editor/browser/editorBrowser';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-
-var MainThreadTextEditors_1;
-let MainThreadTextEditors = class MainThreadTextEditors {
-    static { MainThreadTextEditors_1 = this; }
-    static { this.INSTANCE_COUNT = 0; }
-    constructor(_editorLocator, extHostContext, _codeEditorService, _editorService, _editorGroupService, _configurationService) {
-        this._editorLocator = _editorLocator;
-        this._codeEditorService = _codeEditorService;
-        this._editorService = _editorService;
-        this._editorGroupService = _editorGroupService;
-        this._configurationService = _configurationService;
-        this._toDispose = ( new DisposableStore());
-        this._instanceId = String(++MainThreadTextEditors_1.INSTANCE_COUNT);
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostEditors));
-        this._textEditorsListenersMap = Object.create(null);
-        this._editorPositionData = null;
-        this._toDispose.add(this._editorService.onDidVisibleEditorsChange(() => this._updateActiveAndVisibleTextEditors()));
-        this._toDispose.add(this._editorGroupService.onDidRemoveGroup(() => this._updateActiveAndVisibleTextEditors()));
-        this._toDispose.add(this._editorGroupService.onDidMoveGroup(() => this._updateActiveAndVisibleTextEditors()));
-        this._registeredDecorationTypes = Object.create(null);
-    }
-    dispose() {
-        ( Object.keys(this._textEditorsListenersMap)).forEach((editorId) => {
-            dispose(this._textEditorsListenersMap[editorId]);
-        });
-        this._textEditorsListenersMap = Object.create(null);
-        this._toDispose.dispose();
-        for (const decorationType in this._registeredDecorationTypes) {
-            this._codeEditorService.removeDecorationType(decorationType);
-        }
-        this._registeredDecorationTypes = Object.create(null);
-    }
-    handleTextEditorAdded(textEditor) {
-        const id = textEditor.getId();
-        const toDispose = [];
-        toDispose.push(textEditor.onPropertiesChanged((data) => {
-            this._proxy.$acceptEditorPropertiesChanged(id, data);
-        }));
-        this._textEditorsListenersMap[id] = toDispose;
-    }
-    handleTextEditorRemoved(id) {
-        dispose(this._textEditorsListenersMap[id]);
-        delete this._textEditorsListenersMap[id];
-    }
-    _updateActiveAndVisibleTextEditors() {
-        const editorPositionData = this._getTextEditorPositionData();
-        if (!equals(this._editorPositionData, editorPositionData)) {
-            this._editorPositionData = editorPositionData;
-            this._proxy.$acceptEditorPositionData(this._editorPositionData);
-        }
-    }
-    _getTextEditorPositionData() {
-        const result = Object.create(null);
-        for (const editorPane of this._editorService.visibleEditorPanes) {
-            const id = this._editorLocator.findTextEditorIdFor(editorPane);
-            if (id) {
-                result[id] = editorGroupToColumn(this._editorGroupService, editorPane.group);
-            }
-        }
-        return result;
-    }
-    async $tryShowTextDocument(resource, options) {
-        const uri = URI.revive(resource);
-        const editorOptions = {
-            preserveFocus: options.preserveFocus,
-            pinned: options.pinned,
-            selection: options.selection,
-            activation: options.preserveFocus ? EditorActivation.RESTORE : undefined,
-            override: EditorResolution.EXCLUSIVE_ONLY
-        };
-        const input = {
-            resource: uri,
-            options: editorOptions
-        };
-        const editor = await this._editorService.openEditor(input, columnToEditorGroup(this._editorGroupService, this._configurationService, options.position));
-        if (!editor) {
-            return undefined;
-        }
-        const editorControl = editor.getControl();
-        const codeEditor = getCodeEditor(editorControl);
-        return codeEditor ? this._editorLocator.getIdOfCodeEditor(codeEditor) : undefined;
-    }
-    async $tryShowEditor(id, position) {
-        const mainThreadEditor = this._editorLocator.getEditor(id);
-        if (mainThreadEditor) {
-            const model = mainThreadEditor.getModel();
-            await this._editorService.openEditor({
-                resource: model.uri,
-                options: { preserveFocus: false }
-            }, columnToEditorGroup(this._editorGroupService, this._configurationService, position));
-            return;
-        }
-    }
-    async $tryHideEditor(id) {
-        const mainThreadEditor = this._editorLocator.getEditor(id);
-        if (mainThreadEditor) {
-            const editorPanes = this._editorService.visibleEditorPanes;
-            for (const editorPane of editorPanes) {
-                if (mainThreadEditor.matches(editorPane)) {
-                    await editorPane.group.closeEditor(editorPane.input);
-                    return;
-                }
-            }
-        }
-    }
-    $trySetSelections(id, selections) {
-        const editor = this._editorLocator.getEditor(id);
-        if (!editor) {
-            return Promise.reject(illegalArgument(`TextEditor(${id})`));
-        }
-        editor.setSelections(selections);
-        return Promise.resolve(undefined);
-    }
-    $trySetDecorations(id, key, ranges) {
-        key = `${this._instanceId}-${key}`;
-        const editor = this._editorLocator.getEditor(id);
-        if (!editor) {
-            return Promise.reject(illegalArgument(`TextEditor(${id})`));
-        }
-        editor.setDecorations(key, ranges);
-        return Promise.resolve(undefined);
-    }
-    $trySetDecorationsFast(id, key, ranges) {
-        key = `${this._instanceId}-${key}`;
-        const editor = this._editorLocator.getEditor(id);
-        if (!editor) {
-            return Promise.reject(illegalArgument(`TextEditor(${id})`));
-        }
-        editor.setDecorationsFast(key, ranges);
-        return Promise.resolve(undefined);
-    }
-    $tryRevealRange(id, range, revealType) {
-        const editor = this._editorLocator.getEditor(id);
-        if (!editor) {
-            return Promise.reject(illegalArgument(`TextEditor(${id})`));
-        }
-        editor.revealRange(range, revealType);
-        return Promise.resolve();
-    }
-    $trySetOptions(id, options) {
-        const editor = this._editorLocator.getEditor(id);
-        if (!editor) {
-            return Promise.reject(illegalArgument(`TextEditor(${id})`));
-        }
-        editor.setConfiguration(options);
-        return Promise.resolve(undefined);
-    }
-    $tryApplyEdits(id, modelVersionId, edits, opts) {
-        const editor = this._editorLocator.getEditor(id);
-        if (!editor) {
-            return Promise.reject(illegalArgument(`TextEditor(${id})`));
-        }
-        return Promise.resolve(editor.applyEdits(modelVersionId, edits, opts));
-    }
-    $tryInsertSnippet(id, modelVersionId, template, ranges, opts) {
-        const editor = this._editorLocator.getEditor(id);
-        if (!editor) {
-            return Promise.reject(illegalArgument(`TextEditor(${id})`));
-        }
-        return Promise.resolve(editor.insertSnippet(modelVersionId, template, ranges, opts));
-    }
-    $registerTextEditorDecorationType(extensionId, key, options) {
-        key = `${this._instanceId}-${key}`;
-        this._registeredDecorationTypes[key] = true;
-        this._codeEditorService.registerDecorationType(`exthost-api-${extensionId}`, key, options);
-    }
-    $removeTextEditorDecorationType(key) {
-        key = `${this._instanceId}-${key}`;
-        delete this._registeredDecorationTypes[key];
-        this._codeEditorService.removeDecorationType(key);
-    }
-    $getDiffInformation(id) {
-        const editor = this._editorLocator.getEditor(id);
-        if (!editor) {
-            return Promise.reject(( new Error('No such TextEditor')));
-        }
-        const codeEditor = editor.getCodeEditor();
-        if (!codeEditor) {
-            return Promise.reject(( new Error('No such CodeEditor')));
-        }
-        const codeEditorId = codeEditor.getId();
-        const diffEditors = this._codeEditorService.listDiffEditors();
-        const [diffEditor] = diffEditors.filter(d => d.getOriginalEditor().getId() === codeEditorId || d.getModifiedEditor().getId() === codeEditorId);
-        if (diffEditor) {
-            return Promise.resolve(diffEditor.getLineChanges() || []);
-        }
-        const dirtyDiffContribution = codeEditor.getContribution('editor.contrib.dirtydiff');
-        if (dirtyDiffContribution) {
-            return Promise.resolve(dirtyDiffContribution.getChanges());
-        }
-        return Promise.resolve([]);
-    }
-};
-MainThreadTextEditors = MainThreadTextEditors_1 = ( __decorate([
-    ( __param(2, ICodeEditorService)),
-    ( __param(3, IEditorService)),
-    ( __param(4, IEditorGroupsService)),
-    ( __param(5, IConfigurationService))
-], MainThreadTextEditors));
-CommandsRegistry.registerCommand('_workbench.revertAllDirty', async function (accessor) {
-    const environmentService = accessor.get(IEnvironmentService);
-    if (!environmentService.extensionTestsLocationURI) {
-        throw new Error('Command is only available when running extension tests.');
-    }
-    const workingCopyService = accessor.get(IWorkingCopyService);
-    for (const workingCopy of workingCopyService.dirtyWorkingCopies) {
-        await workingCopy.revert({ soft: true });
-    }
-});
-
-export { MainThreadTextEditors };

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

@@ -1,24 +0,0 @@
-import { __decorate } from '../../../../../../external/tslib/tslib.es6.js';
-import { ErrorNoTelemetry, onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-
-let MainThreadErrors = class MainThreadErrors {
-    dispose() {
-    }
-    $onUnexpectedError(err) {
-        if (err && err.$isError) {
-            const { name, message, stack } = err;
-            err = err.noTelemetry ? ( new ErrorNoTelemetry()) : ( new Error());
-            err.message = message;
-            err.name = name;
-            err.stack = stack;
-        }
-        onUnexpectedError(err);
-    }
-};
-MainThreadErrors = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadErrors)
-], MainThreadErrors);
-
-export { MainThreadErrors };

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

@@ -1,317 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Action } from 'vscode/vscode/vs/base/common/actions';
-import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
-import { FileAccess } from 'vscode/vscode/vs/base/common/network';
-import Severity$1 from 'vscode/vscode/vs/base/common/severity';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
-import { areSameExtensions } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
-import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
-import { WebSocketRemoteConnection, ManagedRemoteConnection } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver';
-import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { IExtensionsWorkbenchService } from 'vscode/vscode/vs/workbench/contrib/extensions/common/extensions';
-import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
-import { IWorkbenchExtensionEnablementService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
-import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
-import { ITimerService } from 'vscode/vscode/vs/workbench/services/timer/browser/timerService';
-
-let MainThreadExtensionService = class MainThreadExtensionService {
-    constructor(extHostContext, _extensionService, _notificationService, _extensionsWorkbenchService, _hostService, _extensionEnablementService, _timerService, _commandService, _environmentService) {
-        this._extensionService = _extensionService;
-        this._notificationService = _notificationService;
-        this._extensionsWorkbenchService = _extensionsWorkbenchService;
-        this._hostService = _hostService;
-        this._extensionEnablementService = _extensionEnablementService;
-        this._timerService = _timerService;
-        this._commandService = _commandService;
-        this._environmentService = _environmentService;
-        this._extensionHostKind = extHostContext.extensionHostKind;
-        const internalExtHostContext = extHostContext;
-        this._internalExtensionService = internalExtHostContext.internalExtensionService;
-        internalExtHostContext._setExtensionHostProxy(( new ExtensionHostProxy(( extHostContext.getProxy(ExtHostContext.ExtHostExtensionService)))));
-        internalExtHostContext._setAllMainProxyIdentifiers(( ( Object.keys(MainContext)).map((key) => MainContext[key])));
-    }
-    dispose() {
-    }
-    $getExtension(extensionId) {
-        return this._extensionService.getExtension(extensionId);
-    }
-    $activateExtension(extensionId, reason) {
-        return this._internalExtensionService._activateById(extensionId, reason);
-    }
-    async $onWillActivateExtension(extensionId) {
-        this._internalExtensionService._onWillActivateExtension(extensionId);
-    }
-    $onDidActivateExtension(extensionId, codeLoadingTime, activateCallTime, activateResolvedTime, activationReason) {
-        this._internalExtensionService._onDidActivateExtension(extensionId, codeLoadingTime, activateCallTime, activateResolvedTime, activationReason);
-    }
-    $onExtensionRuntimeError(extensionId, data) {
-        const error = ( new Error());
-        error.name = data.name;
-        error.message = data.message;
-        error.stack = data.stack;
-        this._internalExtensionService._onExtensionRuntimeError(extensionId, error);
-        console.error(`[${extensionId.value}]${error.message}`);
-        console.error(error.stack);
-    }
-    async $onExtensionActivationError(extensionId, data, missingExtensionDependency) {
-        const error = ( new Error());
-        error.name = data.name;
-        error.message = data.message;
-        error.stack = data.stack;
-        this._internalExtensionService._onDidActivateExtensionError(extensionId, error);
-        if (missingExtensionDependency) {
-            const extension = await this._extensionService.getExtension(extensionId.value);
-            if (extension) {
-                const local = await this._extensionsWorkbenchService.queryLocal();
-                const installedDependency = local.find(i => areSameExtensions(i.identifier, { id: missingExtensionDependency.dependency }));
-                if (installedDependency?.local) {
-                    await this._handleMissingInstalledDependency(extension, installedDependency.local);
-                    return;
-                }
-                else {
-                    await this._handleMissingNotInstalledDependency(extension, missingExtensionDependency.dependency);
-                    return;
-                }
-            }
-        }
-        const isDev = !this._environmentService.isBuilt || this._environmentService.isExtensionDevelopment;
-        if (isDev) {
-            this._notificationService.error(error);
-            return;
-        }
-        console.error(error.message);
-    }
-    async _handleMissingInstalledDependency(extension, missingInstalledDependency) {
-        const extName = extension.displayName || extension.name;
-        if (this._extensionEnablementService.isEnabled(missingInstalledDependency)) {
-            this._notificationService.notify({
-                severity: Severity$1.Error,
-                message: ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadExtensionService',
-                    'reload window',
-                    "Cannot activate the '{0}' extension because it depends on the '{1}' extension, which is not loaded. Would you like to reload the window to load the extension?",
-                    extName,
-                    missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
-                )),
-                actions: {
-                    primary: [( new Action('reload', ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadExtensionService',
-                        'reload',
-                        "Reload Window"
-                    )), '', true, () => this._hostService.reload()))]
-                }
-            });
-        }
-        else {
-            const enablementState = this._extensionEnablementService.getEnablementState(missingInstalledDependency);
-            if (enablementState === 4 ) {
-                this._notificationService.notify({
-                    severity: Severity$1.Error,
-                    message: ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadExtensionService',
-                        'notSupportedInWorkspace',
-                        "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is not supported in the current workspace",
-                        extName,
-                        missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
-                    )),
-                });
-            }
-            else if (enablementState === 0 ) {
-                this._notificationService.notify({
-                    severity: Severity$1.Error,
-                    message: ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadExtensionService',
-                        'restrictedMode',
-                        "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is not supported in Restricted Mode",
-                        extName,
-                        missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
-                    )),
-                    actions: {
-                        primary: [( new Action('manageWorkspaceTrust', ( localizeWithPath(
-                            'vs/workbench/api/browser/mainThreadExtensionService',
-                            'manageWorkspaceTrust',
-                            "Manage Workspace Trust"
-                        )), '', true, () => this._commandService.executeCommand('workbench.trust.manage')))]
-                    }
-                });
-            }
-            else if (this._extensionEnablementService.canChangeEnablement(missingInstalledDependency)) {
-                this._notificationService.notify({
-                    severity: Severity$1.Error,
-                    message: ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadExtensionService',
-                        'disabledDep',
-                        "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is disabled. Would you like to enable the extension and reload the window?",
-                        extName,
-                        missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
-                    )),
-                    actions: {
-                        primary: [( new Action('enable', ( localizeWithPath(
-                            'vs/workbench/api/browser/mainThreadExtensionService',
-                            'enable dep',
-                            "Enable and Reload"
-                        )), '', true, () => this._extensionEnablementService.setEnablement([missingInstalledDependency], enablementState === 6  ? 8  : 9 )
-                                .then(() => this._hostService.reload(), e => this._notificationService.error(e))))]
-                    }
-                });
-            }
-            else {
-                this._notificationService.notify({
-                    severity: Severity$1.Error,
-                    message: ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadExtensionService',
-                        'disabledDepNoAction',
-                        "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is disabled.",
-                        extName,
-                        missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
-                    )),
-                });
-            }
-        }
-    }
-    async _handleMissingNotInstalledDependency(extension, missingDependency) {
-        const extName = extension.displayName || extension.name;
-        let dependencyExtension = null;
-        try {
-            dependencyExtension = (await this._extensionsWorkbenchService.getExtensions([{ id: missingDependency }], CancellationToken.None))[0];
-        }
-        catch (err) {
-        }
-        if (dependencyExtension) {
-            this._notificationService.notify({
-                severity: Severity$1.Error,
-                message: ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadExtensionService',
-                    'uninstalledDep',
-                    "Cannot activate the '{0}' extension because it depends on the '{1}' extension from '{2}', which is not installed. Would you like to install the extension and reload the window?",
-                    extName,
-                    dependencyExtension.displayName,
-                    dependencyExtension.publisherDisplayName
-                )),
-                actions: {
-                    primary: [( new Action('install', ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadExtensionService',
-                        'install missing dep',
-                        "Install and Reload"
-                    )), '', true, () => this._extensionsWorkbenchService.install(dependencyExtension)
-                            .then(() => this._hostService.reload(), e => this._notificationService.error(e))))]
-                }
-            });
-        }
-        else {
-            this._notificationService.error(( localizeWithPath(
-                'vs/workbench/api/browser/mainThreadExtensionService',
-                'unknownDep',
-                "Cannot activate the '{0}' extension because it depends on an unknown '{1}' extension.",
-                extName,
-                missingDependency
-            )));
-        }
-    }
-    async $setPerformanceMarks(marks) {
-        if (this._extensionHostKind === 1 ) {
-            this._timerService.setPerformanceMarks('localExtHost', marks);
-        }
-        else if (this._extensionHostKind === 2 ) {
-            this._timerService.setPerformanceMarks('workerExtHost', marks);
-        }
-        else {
-            this._timerService.setPerformanceMarks('remoteExtHost', marks);
-        }
-    }
-    async $asBrowserUri(uri) {
-        return FileAccess.uriToBrowserUri(URI.revive(uri));
-    }
-    async $getAllStaticBrowserUris() {
-        return Array.from(FileAccess.getRegisteredBrowserUris(), uri => [
-            uri,
-            FileAccess.uriToBrowserUri(uri)
-        ]);
-    }
-};
-MainThreadExtensionService = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadExtensionService),
-    ( __param(1, IExtensionService)),
-    ( __param(2, INotificationService)),
-    ( __param(3, IExtensionsWorkbenchService)),
-    ( __param(4, IHostService)),
-    ( __param(5, IWorkbenchExtensionEnablementService)),
-    ( __param(6, ITimerService)),
-    ( __param(7, ICommandService)),
-    ( __param(8, IWorkbenchEnvironmentService))
-], MainThreadExtensionService);
-class ExtensionHostProxy {
-    constructor(_actual) {
-        this._actual = _actual;
-    }
-    async resolveAuthority(remoteAuthority, resolveAttempt) {
-        const resolved = reviveResolveAuthorityResult(await this._actual.$resolveAuthority(remoteAuthority, resolveAttempt));
-        return resolved;
-    }
-    async getCanonicalURI(remoteAuthority, uri) {
-        const uriComponents = await this._actual.$getCanonicalURI(remoteAuthority, uri);
-        return (uriComponents ? URI.revive(uriComponents) : uriComponents);
-    }
-    startExtensionHost(extensionsDelta) {
-        return this._actual.$startExtensionHost(extensionsDelta);
-    }
-    extensionTestsExecute() {
-        return this._actual.$extensionTestsExecute();
-    }
-    activateByEvent(activationEvent, activationKind) {
-        return this._actual.$activateByEvent(activationEvent, activationKind);
-    }
-    activate(extensionId, reason) {
-        return this._actual.$activate(extensionId, reason);
-    }
-    setRemoteEnvironment(env) {
-        return this._actual.$setRemoteEnvironment(env);
-    }
-    updateRemoteConnectionData(connectionData) {
-        return this._actual.$updateRemoteConnectionData(connectionData);
-    }
-    deltaExtensions(extensionsDelta) {
-        return this._actual.$deltaExtensions(extensionsDelta);
-    }
-    test_latency(n) {
-        return this._actual.$test_latency(n);
-    }
-    test_up(b) {
-        return this._actual.$test_up(b);
-    }
-    test_down(size) {
-        return this._actual.$test_down(size);
-    }
-}
-function reviveResolveAuthorityResult(result) {
-    if (result.type === 'ok') {
-        return {
-            type: 'ok',
-            value: {
-                ...result.value,
-                authority: reviveResolvedAuthority(result.value.authority),
-            }
-        };
-    }
-    else {
-        return result;
-    }
-}
-function reviveResolvedAuthority(resolvedAuthority) {
-    return {
-        ...resolvedAuthority,
-        connectTo: reviveConnection(resolvedAuthority.connectTo),
-    };
-}
-function reviveConnection(connection) {
-    if (connection.type === 0 ) {
-        return ( new WebSocketRemoteConnection(connection.host, connection.port));
-    }
-    return ( new ManagedRemoteConnection(connection.id));
-}
-
-export { MainThreadExtensionService };