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

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

@@ -0,0 +1,227 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { illegalArgument } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { DisposableStore, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { equals } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { EditorActivation, EditorResolution } from 'monaco-editor/esm/vs/platform/editor/common/editor.js';
+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 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService';
+import { getCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+
+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

@@ -0,0 +1,24 @@
+import { __decorate } from '../../../../../../external/tslib/tslib.es6.js';
+import { ErrorNoTelemetry, onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+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

@@ -0,0 +1,317 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { FileAccess } from 'monaco-editor/esm/vs/base/common/network.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { areSameExtensions } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+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.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.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.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.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.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.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 };