@codingame/monaco-vscode-api 1.83.8 → 1.83.10-next.0

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

@@ -1,53 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { ITimelineService } from '../../contrib/timeline/common/timeline.js';
-import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
-let MainThreadTimeline = class MainThreadTimeline {
-    constructor(context, logService, _timelineService) {
-        this.logService = logService;
-        this._timelineService = _timelineService;
-        this._providerEmitters = ( new Map());
-        this._proxy = ( context.getProxy(ExtHostContext.ExtHostTimeline));
-    }
-    $registerTimelineProvider(provider) {
-        this.logService.trace(`MainThreadTimeline#registerTimelineProvider: id=${provider.id}`);
-        const proxy = this._proxy;
-        const emitters = this._providerEmitters;
-        let onDidChange = emitters.get(provider.id);
-        if (onDidChange === undefined) {
-            onDidChange = ( new Emitter());
-            emitters.set(provider.id, onDidChange);
-        }
-        this._timelineService.registerTimelineProvider({
-            ...provider,
-            onDidChange: onDidChange.event,
-            async provideTimeline(uri, options, token) {
-                return revive(await proxy.$getTimeline(provider.id, uri, options, token));
-            },
-            dispose() {
-                emitters.delete(provider.id);
-                onDidChange?.dispose();
-            }
-        });
-    }
-    $unregisterTimelineProvider(id) {
-        this.logService.trace(`MainThreadTimeline#unregisterTimelineProvider: id=${id}`);
-        this._timelineService.unregisterTimelineProvider(id);
-    }
-    $emitTimelineChangeEvent(e) {
-        this.logService.trace(`MainThreadTimeline#emitChangeEvent: id=${e.id}, uri=${e.uri?.toString(true)}`);
-        const emitter = this._providerEmitters.get(e.id);
-        emitter?.fire(e);
-    }
-    dispose() {
-    }
-};
-MainThreadTimeline = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadTimeline),
-    ( __param(1, ILogService)),
-    ( __param(2, ITimelineService))
-], MainThreadTimeline);
-export { MainThreadTimeline };

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

@@ -1,311 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-import { Extensions, IViewsService, NoTreeViewError, ResolvableTreeItem } from '../../common/views.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-import { isUndefinedOrNull, isNumber } from 'monaco-editor/esm/vs/base/common/types.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { IExtensionService } from '../../services/extensions/common/extensions.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { createStringDataTransferItem, VSDataTransfer } from 'monaco-editor/esm/vs/base/common/dataTransfer.js';
-import { DataTransferFileCache } from '../common/shared/dataTransferCache.js';
-import { DataTransfer } from '../common/extHostTypeConverters.js';
-let MainThreadTreeViews = class MainThreadTreeViews extends Disposable {
-    constructor(extHostContext, viewsService, notificationService, extensionService, logService) {
-        super();
-        this.viewsService = viewsService;
-        this.notificationService = notificationService;
-        this.extensionService = extensionService;
-        this.logService = logService;
-        this._dataProviders = ( new Map());
-        this._dndControllers = ( new Map());
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostTreeViews));
-    }
-    async $registerTreeViewDataProvider(treeViewId, options) {
-        this.logService.trace('MainThreadTreeViews#$registerTreeViewDataProvider', treeViewId, options);
-        this.extensionService.whenInstalledExtensionsRegistered().then(() => {
-            const dataProvider = ( new TreeViewDataProvider(treeViewId, this._proxy, this.notificationService));
-            const disposables = ( new DisposableStore());
-            this._register(disposables);
-            this._dataProviders.set(treeViewId, { dataProvider, disposables });
-            const dndController = (options.hasHandleDrag || options.hasHandleDrop)
-                ? ( new TreeViewDragAndDropController(
-                treeViewId,
-                options.dropMimeTypes,
-                options.dragMimeTypes,
-                options.hasHandleDrag,
-                this._proxy
-            )) : undefined;
-            const viewer = this.getTreeView(treeViewId);
-            if (viewer) {
-                viewer.showCollapseAllAction = options.showCollapseAll;
-                viewer.canSelectMany = options.canSelectMany;
-                viewer.manuallyManageCheckboxes = options.manuallyManageCheckboxes;
-                viewer.dragAndDropController = dndController;
-                if (dndController) {
-                    this._dndControllers.set(treeViewId, dndController);
-                }
-                viewer.dataProvider = dataProvider;
-                this.registerListeners(treeViewId, viewer, disposables);
-                this._proxy.$setVisible(treeViewId, viewer.visible);
-            }
-            else {
-                this.notificationService.error('No view is registered with id: ' + treeViewId);
-            }
-        });
-    }
-    $reveal(treeViewId, itemInfo, options) {
-        this.logService.trace('MainThreadTreeViews#$reveal', treeViewId, itemInfo?.item, itemInfo?.parentChain, options);
-        return this.viewsService.openView(treeViewId, options.focus)
-            .then(() => {
-            const viewer = this.getTreeView(treeViewId);
-            if (viewer && itemInfo) {
-                return this.reveal(viewer, this._dataProviders.get(treeViewId).dataProvider, itemInfo.item, itemInfo.parentChain, options);
-            }
-            return undefined;
-        });
-    }
-    $refresh(treeViewId, itemsToRefreshByHandle) {
-        this.logService.trace('MainThreadTreeViews#$refresh', treeViewId, itemsToRefreshByHandle);
-        const viewer = this.getTreeView(treeViewId);
-        const dataProvider = this._dataProviders.get(treeViewId);
-        if (viewer && dataProvider) {
-            const itemsToRefresh = dataProvider.dataProvider.getItemsToRefresh(itemsToRefreshByHandle);
-            return viewer.refresh(itemsToRefresh.length ? itemsToRefresh : undefined);
-        }
-        return Promise.resolve();
-    }
-    $setMessage(treeViewId, message) {
-        this.logService.trace('MainThreadTreeViews#$setMessage', treeViewId, ( message.toString()));
-        const viewer = this.getTreeView(treeViewId);
-        if (viewer) {
-            viewer.message = message;
-        }
-    }
-    $setTitle(treeViewId, title, description) {
-        this.logService.trace('MainThreadTreeViews#$setTitle', treeViewId, title, description);
-        const viewer = this.getTreeView(treeViewId);
-        if (viewer) {
-            viewer.title = title;
-            viewer.description = description;
-        }
-    }
-    $setBadge(treeViewId, badge) {
-        this.logService.trace('MainThreadTreeViews#$setBadge', treeViewId, badge?.value, badge?.tooltip);
-        const viewer = this.getTreeView(treeViewId);
-        if (viewer) {
-            viewer.badge = badge;
-        }
-    }
-    $resolveDropFileData(destinationViewId, requestId, dataItemId) {
-        const controller = this._dndControllers.get(destinationViewId);
-        if (!controller) {
-            throw new Error('Unknown tree');
-        }
-        return controller.resolveDropFileData(requestId, dataItemId);
-    }
-    async $disposeTree(treeViewId) {
-        const viewer = this.getTreeView(treeViewId);
-        if (viewer) {
-            viewer.dataProvider = undefined;
-        }
-        const dataProvider = this._dataProviders.get(treeViewId);
-        if (dataProvider) {
-            dataProvider.disposables.dispose();
-            this._dataProviders.delete(treeViewId);
-        }
-    }
-    async reveal(treeView, dataProvider, itemIn, parentChain, options) {
-        options = options ? options : { select: false, focus: false };
-        const select = isUndefinedOrNull(options.select) ? false : options.select;
-        const focus = isUndefinedOrNull(options.focus) ? false : options.focus;
-        let expand = Math.min(isNumber(options.expand) ? options.expand : options.expand === true ? 1 : 0, 3);
-        if (dataProvider.isEmpty()) {
-            await treeView.refresh();
-        }
-        for (const parent of parentChain) {
-            const parentItem = dataProvider.getItem(parent.handle);
-            if (parentItem) {
-                await treeView.expand(parentItem);
-            }
-        }
-        const item = dataProvider.getItem(itemIn.handle);
-        if (item) {
-            await treeView.reveal(item);
-            if (select) {
-                treeView.setSelection([item]);
-            }
-            if (focus === false) {
-                treeView.setFocus();
-            }
-            else if (focus) {
-                treeView.setFocus(item);
-            }
-            let itemsToExpand = [item];
-            for (; itemsToExpand.length > 0 && expand > 0; expand--) {
-                await treeView.expand(itemsToExpand);
-                itemsToExpand = itemsToExpand.reduce((result, itemValue) => {
-                    const item = dataProvider.getItem(itemValue.handle);
-                    if (item && item.children && item.children.length) {
-                        result.push(...item.children);
-                    }
-                    return result;
-                }, []);
-            }
-        }
-    }
-    registerListeners(treeViewId, treeView, disposables) {
-        disposables.add(treeView.onDidExpandItem(item => this._proxy.$setExpanded(treeViewId, item.handle, true)));
-        disposables.add(treeView.onDidCollapseItem(item => this._proxy.$setExpanded(treeViewId, item.handle, false)));
-        disposables.add(treeView.onDidChangeSelectionAndFocus(items => this._proxy.$setSelectionAndFocus(treeViewId, ( items.selection.map(({ handle }) => handle)), items.focus.handle)));
-        disposables.add(treeView.onDidChangeVisibility(isVisible => this._proxy.$setVisible(treeViewId, isVisible)));
-        disposables.add(treeView.onDidChangeCheckboxState(items => {
-            this._proxy.$changeCheckboxState(treeViewId, ( items.map(item => {
-                return { treeItemHandle: item.handle, newState: item.checkbox?.isChecked ?? false };
-            })));
-        }));
-    }
-    getTreeView(treeViewId) {
-        const viewDescriptor = ( Registry.as(Extensions.ViewsRegistry)).getView(treeViewId);
-        return viewDescriptor ? viewDescriptor.treeView : null;
-    }
-    dispose() {
-        this._dataProviders.forEach((dataProvider, treeViewId) => {
-            const treeView = this.getTreeView(treeViewId);
-            if (treeView) {
-                treeView.dataProvider = undefined;
-            }
-        });
-        this._dataProviders.clear();
-        this._dndControllers.clear();
-        super.dispose();
-    }
-};
-MainThreadTreeViews = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadTreeViews),
-    ( __param(1, IViewsService)),
-    ( __param(2, INotificationService)),
-    ( __param(3, IExtensionService)),
-    ( __param(4, ILogService))
-], MainThreadTreeViews);
-class TreeViewDragAndDropController {
-    constructor(treeViewId, dropMimeTypes, dragMimeTypes, hasWillDrop, _proxy) {
-        this.treeViewId = treeViewId;
-        this.dropMimeTypes = dropMimeTypes;
-        this.dragMimeTypes = dragMimeTypes;
-        this.hasWillDrop = hasWillDrop;
-        this._proxy = _proxy;
-        this.dataTransfersCache = ( new DataTransferFileCache());
-    }
-    async handleDrop(dataTransfer, targetTreeItem, token, operationUuid, sourceTreeId, sourceTreeItemHandles) {
-        const request = this.dataTransfersCache.add(dataTransfer);
-        try {
-            const dataTransferDto = await DataTransfer.from(dataTransfer);
-            if (token.isCancellationRequested) {
-                return;
-            }
-            return await this._proxy.$handleDrop(this.treeViewId, request.id, dataTransferDto, targetTreeItem?.handle, token, operationUuid, sourceTreeId, sourceTreeItemHandles);
-        }
-        finally {
-            request.dispose();
-        }
-    }
-    async handleDrag(sourceTreeItemHandles, operationUuid, token) {
-        if (!this.hasWillDrop) {
-            return;
-        }
-        const additionalDataTransferDTO = await this._proxy.$handleDrag(this.treeViewId, sourceTreeItemHandles, operationUuid, token);
-        if (!additionalDataTransferDTO) {
-            return;
-        }
-        const additionalDataTransfer = ( new VSDataTransfer());
-        additionalDataTransferDTO.items.forEach(([type, item]) => {
-            additionalDataTransfer.replace(type, createStringDataTransferItem(item.asString));
-        });
-        return additionalDataTransfer;
-    }
-    resolveDropFileData(requestId, dataItemId) {
-        return this.dataTransfersCache.resolveFileData(requestId, dataItemId);
-    }
-}
-class TreeViewDataProvider {
-    constructor(treeViewId, _proxy, notificationService) {
-        this.treeViewId = treeViewId;
-        this._proxy = _proxy;
-        this.notificationService = notificationService;
-        this.itemsMap = ( new Map());
-        this.hasResolve = this._proxy.$hasResolve(this.treeViewId);
-    }
-    getChildren(treeItem) {
-        return this._proxy.$getChildren(this.treeViewId, treeItem ? treeItem.handle : undefined)
-            .then(children => this.postGetChildren(children), err => {
-            if (!NoTreeViewError.is(err)) {
-                this.notificationService.error(err);
-            }
-            return [];
-        });
-    }
-    getItemsToRefresh(itemsToRefreshByHandle) {
-        const itemsToRefresh = [];
-        if (itemsToRefreshByHandle) {
-            for (const treeItemHandle of ( Object.keys(itemsToRefreshByHandle))) {
-                const currentTreeItem = this.getItem(treeItemHandle);
-                if (currentTreeItem) {
-                    const treeItem = itemsToRefreshByHandle[treeItemHandle];
-                    this.updateTreeItem(currentTreeItem, treeItem);
-                    if (treeItemHandle === treeItem.handle) {
-                        itemsToRefresh.push(currentTreeItem);
-                    }
-                    else {
-                        this.itemsMap.delete(treeItemHandle);
-                        this.itemsMap.set(currentTreeItem.handle, currentTreeItem);
-                        const parent = treeItem.parentHandle ? this.itemsMap.get(treeItem.parentHandle) : null;
-                        if (parent) {
-                            itemsToRefresh.push(parent);
-                        }
-                    }
-                }
-            }
-        }
-        return itemsToRefresh;
-    }
-    getItem(treeItemHandle) {
-        return this.itemsMap.get(treeItemHandle);
-    }
-    isEmpty() {
-        return this.itemsMap.size === 0;
-    }
-    async postGetChildren(elements) {
-        if (elements === undefined) {
-            return undefined;
-        }
-        const result = [];
-        const hasResolve = await this.hasResolve;
-        if (elements) {
-            for (const element of elements) {
-                const resolvable = ( new ResolvableTreeItem(element, hasResolve ? (token) => {
-                    return this._proxy.$resolve(this.treeViewId, element.handle, token);
-                } : undefined));
-                this.itemsMap.set(element.handle, resolvable);
-                result.push(resolvable);
-            }
-        }
-        return result;
-    }
-    updateTreeItem(current, treeItem) {
-        treeItem.children = treeItem.children ? treeItem.children : undefined;
-        if (current) {
-            const properties = distinct([...( Object.keys(current instanceof ResolvableTreeItem ? current.asTreeItem() : current)),
-                ...( Object.keys(treeItem))]);
-            for (const property of properties) {
-                current[property] = treeItem[property];
-            }
-            if (current instanceof ResolvableTreeItem) {
-                current.resetResolve();
-            }
-        }
-    }
-}
-export { MainThreadTreeViews };

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

@@ -1,221 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { ExtHostContext, CandidatePortSource, MainContext } from '../common/extHost.protocol.js';
-import { TunnelDtoConverter } from '../common/extHostTunnelService.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { PORT_AUTO_FORWARD_SETTING, PORT_AUTO_SOURCE_SETTING, PORT_AUTO_SOURCE_SETTING_OUTPUT, IRemoteExplorerService } from '../../services/remote/common/remoteExplorerService.js';
-import { ITunnelService, TunnelProtocol } from '../../../platform/tunnel/common/tunnel.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { Severity, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { IRemoteAgentService } from '../../services/remote/common/remoteAgentService.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
-import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { TunnelSource, TunnelCloseReason, forwardedPortsViewEnabled, makeAddress } from '../../services/remote/common/tunnelModel.js';
-let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
-    constructor(extHostContext, remoteExplorerService, tunnelService, notificationService, configurationService, logService, remoteAgentService, contextKeyService) {
-        super();
-        this.remoteExplorerService = remoteExplorerService;
-        this.tunnelService = tunnelService;
-        this.notificationService = notificationService;
-        this.configurationService = configurationService;
-        this.logService = logService;
-        this.remoteAgentService = remoteAgentService;
-        this.contextKeyService = contextKeyService;
-        this.elevateionRetry = false;
-        this.portsAttributesProviders = ( new Map());
-        this._alreadyRegistered = false;
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostTunnelService));
-        this._register(tunnelService.onTunnelOpened(() => this._proxy.$onDidTunnelsChange()));
-        this._register(tunnelService.onTunnelClosed(() => this._proxy.$onDidTunnelsChange()));
-    }
-    processFindingEnabled() {
-        return (!!this.configurationService.getValue(PORT_AUTO_FORWARD_SETTING) || this.tunnelService.hasTunnelProvider)
-            && (this.configurationService.getValue(PORT_AUTO_SOURCE_SETTING) !== PORT_AUTO_SOURCE_SETTING_OUTPUT);
-    }
-    async $setRemoteTunnelService(processId) {
-        this.remoteExplorerService.namedProcesses.set(processId, 'Code Extension Host');
-        if (this.remoteExplorerService.portsFeaturesEnabled) {
-            this._proxy.$registerCandidateFinder(this.processFindingEnabled());
-        }
-        else {
-            this._register(this.remoteExplorerService.onEnabledPortsFeatures(() => this._proxy.$registerCandidateFinder(this.configurationService.getValue(PORT_AUTO_FORWARD_SETTING))));
-        }
-        this._register(this.configurationService.onDidChangeConfiguration(async (e) => {
-            if (e.affectsConfiguration(PORT_AUTO_FORWARD_SETTING) || e.affectsConfiguration(PORT_AUTO_SOURCE_SETTING)) {
-                return this._proxy.$registerCandidateFinder(this.processFindingEnabled());
-            }
-        }));
-        this._register(this.tunnelService.onAddedTunnelProvider(() => {
-            return this._proxy.$registerCandidateFinder(this.processFindingEnabled());
-        }));
-    }
-    async $registerPortsAttributesProvider(selector, providerHandle) {
-        this.portsAttributesProviders.set(providerHandle, selector);
-        if (!this._alreadyRegistered) {
-            this.remoteExplorerService.tunnelModel.addAttributesProvider(this);
-            this._alreadyRegistered = true;
-        }
-    }
-    async $unregisterPortsAttributesProvider(providerHandle) {
-        this.portsAttributesProviders.delete(providerHandle);
-    }
-    async providePortAttributes(ports, pid, commandLine, token) {
-        if (this.portsAttributesProviders.size === 0) {
-            return [];
-        }
-        const appropriateHandles = ( Array.from(this.portsAttributesProviders.entries()).filter(entry => {
-            const selector = entry[1];
-            const portRange = (typeof selector.portRange === 'number') ? [selector.portRange, selector.portRange + 1] : selector.portRange;
-            const portInRange = portRange ? ( ports.some(port => portRange[0] <= port && port < portRange[1])) : true;
-            const commandMatches = !selector.commandPattern || (commandLine && (commandLine.match(selector.commandPattern)));
-            return portInRange && commandMatches;
-        }).map(entry => entry[0]));
-        if (appropriateHandles.length === 0) {
-            return [];
-        }
-        return this._proxy.$providePortAttributes(appropriateHandles, ports, pid, commandLine, token);
-    }
-    async $openTunnel(tunnelOptions, source) {
-        const tunnel = await this.remoteExplorerService.forward({
-            remote: tunnelOptions.remoteAddress,
-            local: tunnelOptions.localAddressPort,
-            name: tunnelOptions.label,
-            source: {
-                source: TunnelSource.Extension,
-                description: source
-            },
-            elevateIfNeeded: false
-        });
-        if (!tunnel || (typeof tunnel === 'string')) {
-            return undefined;
-        }
-        if (!this.elevateionRetry
-            && (tunnelOptions.localAddressPort !== undefined)
-            && (tunnel.tunnelLocalPort !== undefined)
-            && this.tunnelService.isPortPrivileged(tunnelOptions.localAddressPort)
-            && (tunnel.tunnelLocalPort !== tunnelOptions.localAddressPort)
-            && this.tunnelService.canElevate) {
-            this.elevationPrompt(tunnelOptions, tunnel, source);
-        }
-        return TunnelDtoConverter.fromServiceTunnel(tunnel);
-    }
-    async elevationPrompt(tunnelOptions, tunnel, source) {
-        return this.notificationService.prompt(Severity.Info, ( nls.localizeWithPath(
-            'vs/workbench/api/browser/mainThreadTunnelService',
-            'remote.tunnel.openTunnel',
-            "The extension {0} has forwarded port {1}. You'll need to run as superuser to use port {2} locally.",
-            source,
-            tunnelOptions.remoteAddress.port,
-            tunnelOptions.localAddressPort
-        )), [{
-                label: ( nls.localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadTunnelService',
-                    'remote.tunnelsView.elevationButton',
-                    "Use Port {0} as Sudo...",
-                    tunnel.tunnelRemotePort
-                )),
-                run: async () => {
-                    this.elevateionRetry = true;
-                    await this.remoteExplorerService.close({ host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort }, TunnelCloseReason.Other);
-                    await this.remoteExplorerService.forward({
-                        remote: tunnelOptions.remoteAddress,
-                        local: tunnelOptions.localAddressPort,
-                        name: tunnelOptions.label,
-                        source: {
-                            source: TunnelSource.Extension,
-                            description: source
-                        },
-                        elevateIfNeeded: true
-                    });
-                    this.elevateionRetry = false;
-                }
-            }]);
-    }
-    async $closeTunnel(remote) {
-        return this.remoteExplorerService.close(remote, TunnelCloseReason.Other);
-    }
-    async $getTunnels() {
-        return ( (await this.tunnelService.tunnels).map(tunnel => {
-            return {
-                remoteAddress: { port: tunnel.tunnelRemotePort, host: tunnel.tunnelRemoteHost },
-                localAddress: tunnel.localAddress,
-                privacy: tunnel.privacy,
-                protocol: tunnel.protocol
-            };
-        }));
-    }
-    async $onFoundNewCandidates(candidates) {
-        this.remoteExplorerService.onFoundNewCandidates(candidates);
-    }
-    async $setTunnelProvider(features) {
-        const tunnelProvider = {
-            forwardPort: (tunnelOptions, tunnelCreationOptions) => {
-                const forward = this._proxy.$forwardPort(tunnelOptions, tunnelCreationOptions);
-                return forward.then(tunnelOrError => {
-                    if (!tunnelOrError) {
-                        return undefined;
-                    }
-                    else if (typeof tunnelOrError === 'string') {
-                        return tunnelOrError;
-                    }
-                    const tunnel = tunnelOrError;
-                    this.logService.trace(`ForwardedPorts: (MainThreadTunnelService) New tunnel established by tunnel provider: ${tunnel?.remoteAddress.host}:${tunnel?.remoteAddress.port}`);
-                    return {
-                        tunnelRemotePort: tunnel.remoteAddress.port,
-                        tunnelRemoteHost: tunnel.remoteAddress.host,
-                        localAddress: typeof tunnel.localAddress === 'string' ? tunnel.localAddress : makeAddress(tunnel.localAddress.host, tunnel.localAddress.port),
-                        tunnelLocalPort: typeof tunnel.localAddress !== 'string' ? tunnel.localAddress.port : undefined,
-                        public: tunnel.public,
-                        privacy: tunnel.privacy,
-                        protocol: tunnel.protocol ?? TunnelProtocol.Http,
-                        dispose: async (silent) => {
-                            this.logService.trace(`ForwardedPorts: (MainThreadTunnelService) Closing tunnel from tunnel provider: ${tunnel?.remoteAddress.host}:${tunnel?.remoteAddress.port}`);
-                            return this._proxy.$closeTunnel({ host: tunnel.remoteAddress.host, port: tunnel.remoteAddress.port }, silent);
-                        }
-                    };
-                });
-            }
-        };
-        if (features) {
-            this.tunnelService.setTunnelFeatures(features);
-        }
-        this.tunnelService.setTunnelProvider(tunnelProvider);
-        this.contextKeyService.createKey(forwardedPortsViewEnabled.key, true);
-    }
-    async $setCandidateFilter() {
-        this.remoteExplorerService.setCandidateFilter((candidates) => {
-            return this._proxy.$applyCandidateFilter(candidates);
-        });
-    }
-    async $setCandidatePortSource(source) {
-        this.remoteAgentService.getEnvironment().then(() => {
-            switch (source) {
-                case CandidatePortSource.None: {
-                    ( Registry.as(Extensions.Configuration))
-                        .registerDefaultConfigurations([{ overrides: { 'remote.autoForwardPorts': false } }]);
-                    break;
-                }
-                case CandidatePortSource.Output: {
-                    ( Registry.as(Extensions.Configuration))
-                        .registerDefaultConfigurations([{ overrides: { 'remote.autoForwardPortsSource': PORT_AUTO_SOURCE_SETTING_OUTPUT } }]);
-                    break;
-                }
-            }
-        }).catch(() => {
-        });
-    }
-};
-MainThreadTunnelService = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadTunnelService),
-    ( __param(1, IRemoteExplorerService)),
-    ( __param(2, ITunnelService)),
-    ( __param(3, INotificationService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, ILogService)),
-    ( __param(6, IRemoteAgentService)),
-    ( __param(7, IContextKeyService))
-], MainThreadTunnelService);
-export { MainThreadTunnelService };