@codingame/monaco-vscode-api 1.83.1 → 1.83.3-next.0

package/vscode/src/vs/workbench/api/common/extHostTreeViews.js

@@ -1,4 +1,4 @@
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { basename } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
@@ -35,8 +35,8 @@ class ExtHostTreeViews extends Disposable {
         this._proxy = _proxy;
         this.commands = commands;
         this.logService = logService;
-        this.treeViews = ( (new Map()));
-        this.treeDragAndDropService = ( (new TreeViewsDnDService()));
+        this.treeViews = ( new Map());
+        this.treeDragAndDropService = ( new TreeViewsDnDService());
         function isTreeViewConvertableItem(arg) {
             return arg && arg.$treeViewId && (arg.$treeItemHandle || arg.$selectedTreeItems || arg.$focusedTreeItem);
         }
@@ -46,14 +46,12 @@ class ExtHostTreeViews extends Disposable {
                     return this.convertArgument(arg);
                 }
                 else if (Array.isArray(arg) && (arg.length > 0)) {
-                    return (
-                         (arg.map(item => {
-                            if (isTreeViewConvertableItem(item)) {
-                                return this.convertArgument(item);
-                            }
-                            return item;
-                        }))
-                    );
+                    return ( arg.map(item => {
+                        if (isTreeViewConvertableItem(item)) {
+                            return this.convertArgument(item);
+                        }
+                        return item;
+                    }));
                 }
                 return arg;
             }
@@ -138,14 +136,14 @@ class ExtHostTreeViews extends Disposable {
     $getChildren(treeViewId, treeItemHandle) {
         const treeView = this.treeViews.get(treeViewId);
         if (!treeView) {
-            return Promise.reject(( (new NoTreeViewError(treeViewId))));
+            return Promise.reject(( new NoTreeViewError(treeViewId)));
         }
         return treeView.getChildren(treeItemHandle);
     }
     async $handleDrop(destinationViewId, requestId, treeDataTransferDTO, targetItemHandle, token, operationUuid, sourceViewId, sourceTreeItemHandles) {
         const treeView = this.treeViews.get(destinationViewId);
         if (!treeView) {
-            return Promise.reject(( (new NoTreeViewError(destinationViewId))));
+            return Promise.reject(( new NoTreeViewError(destinationViewId)));
         }
         const treeDataTransfer = DataTransfer.toDataTransfer(treeDataTransferDTO, async (dataItemIndex) => {
             return (await this._proxy.$resolveDropFileData(destinationViewId, requestId, dataItemIndex)).buffer;
@@ -174,7 +172,7 @@ class ExtHostTreeViews extends Disposable {
     async $handleDrag(sourceViewId, sourceTreeItemHandles, operationUuid, token) {
         const treeView = this.treeViews.get(sourceViewId);
         if (!treeView) {
-            return Promise.reject(( (new NoTreeViewError(sourceViewId))));
+            return Promise.reject(( new NoTreeViewError(sourceViewId)));
         }
         const treeDataTransfer = await this.addAdditionalTransferItems(new DataTransfer$1(), treeView, sourceTreeItemHandles, token, operationUuid);
         if (!treeDataTransfer || token.isCancellationRequested) {
@@ -228,14 +226,14 @@ class ExtHostTreeViews extends Disposable {
         treeView.setCheckboxState(checkboxUpdate);
     }
     createExtHostTreeView(id, options, extension) {
-        const treeView = this._register(( (new ExtHostTreeView(
+        const treeView = this._register(( new ExtHostTreeView(
             id,
             options,
             this._proxy,
             this.commands.converter,
             this.logService,
             extension
-        ))));
+        )));
         this.treeViews.set(id, treeView);
         return treeView;
     }
@@ -254,7 +252,7 @@ class ExtHostTreeView extends Disposable {
     static { this.LABEL_HANDLE_PREFIX = '0'; }
     static { this.ID_HANDLE_PREFIX = '1'; }
     get visible() { return this._visible; }
-    get selectedElements() { return ( (this._selectedHandles.map(handle => this.getExtensionElement(handle)))).filter(element => !isUndefinedOrNull(element)); }
+    get selectedElements() { return ( this._selectedHandles.map(handle => this.getExtensionElement(handle))).filter(element => !isUndefinedOrNull(element)); }
     get focusedElement() { return (this._focusedHandle ? this.getExtensionElement(this._focusedHandle) : undefined); }
     constructor(viewId, options, proxy, commands, logService, extension) {
         super();
@@ -264,29 +262,29 @@ class ExtHostTreeView extends Disposable {
         this.logService = logService;
         this.extension = extension;
         this.roots = undefined;
-        this.elements = ( (new Map()));
-        this.nodes = ( (new Map()));
+        this.elements = ( new Map());
+        this.nodes = ( new Map());
         this._visible = false;
         this._selectedHandles = [];
         this._focusedHandle = undefined;
-        this._onDidExpandElement = this._register(( (new Emitter())));
+        this._onDidExpandElement = this._register(( new Emitter()));
         this.onDidExpandElement = this._onDidExpandElement.event;
-        this._onDidCollapseElement = this._register(( (new Emitter())));
+        this._onDidCollapseElement = this._register(( new Emitter()));
         this.onDidCollapseElement = this._onDidCollapseElement.event;
-        this._onDidChangeSelection = this._register(( (new Emitter())));
+        this._onDidChangeSelection = this._register(( new Emitter()));
         this.onDidChangeSelection = this._onDidChangeSelection.event;
-        this._onDidChangeActiveItem = this._register(( (new Emitter())));
+        this._onDidChangeActiveItem = this._register(( new Emitter()));
         this.onDidChangeActiveItem = this._onDidChangeActiveItem.event;
-        this._onDidChangeVisibility = this._register(( (new Emitter())));
+        this._onDidChangeVisibility = this._register(( new Emitter()));
         this.onDidChangeVisibility = this._onDidChangeVisibility.event;
-        this._onDidChangeCheckboxState = this._register(( (new Emitter())));
+        this._onDidChangeCheckboxState = this._register(( new Emitter()));
         this.onDidChangeCheckboxState = this._onDidChangeCheckboxState.event;
-        this._onDidChangeData = this._register(( (new Emitter())));
+        this._onDidChangeData = this._register(( new Emitter()));
         this.refreshPromise = Promise.resolve();
         this.refreshQueue = Promise.resolve();
         this._message = '';
         this._title = '';
-        this._refreshCancellationSource = ( (new CancellationTokenSource()));
+        this._refreshCancellationSource = ( new CancellationTokenSource());
         if (extension.contributes && extension.contributes.views) {
             for (const location in extension.contributes.views) {
                 for (const view of extension.contributes.views[location]) {
@@ -309,7 +307,7 @@ class ExtHostTreeView extends Disposable {
             }
             if (current.element !== false) {
                 if (!refreshingPromise) {
-                    refreshingPromise = ( (new Promise(c => promiseCallback = c)));
+                    refreshingPromise = ( new Promise(c => promiseCallback = c));
                     this.refreshPromise = this.refreshPromise.then(() => refreshingPromise);
                 }
                 if (Array.isArray(current.element)) {
@@ -347,7 +345,7 @@ class ExtHostTreeView extends Disposable {
         if (!childrenNodes) {
             childrenNodes = await this.fetchChildrenNodes(parentElement);
         }
-        return childrenNodes ? ( (childrenNodes.map(n => n.item))) : undefined;
+        return childrenNodes ? ( childrenNodes.map(n => n.item)) : undefined;
     }
     getExtensionElement(treeItemHandle) {
         return this.elements.get(treeItemHandle);
@@ -358,15 +356,15 @@ class ExtHostTreeView extends Disposable {
         const focus = isUndefinedOrNull(options.focus) ? false : options.focus;
         const expand = isUndefinedOrNull(options.expand) ? false : options.expand;
         if (typeof this.dataProvider.getParent !== 'function') {
-            return Promise.reject(( (new Error(
+            return Promise.reject(( new Error(
                 `Required registered TreeDataProvider to implement 'getParent' method to access 'reveal' method`
-            ))));
+            )));
         }
         if (element) {
             return this.refreshPromise
                 .then(() => this.resolveUnknownParentChain(element))
                 .then(parentChain => this.resolveTreeNode(element, parentChain[parentChain.length - 1])
-                .then(treeNode => this.proxy.$reveal(this.viewId, { item: treeNode.item, parentChain: ( (parentChain.map(p => p.item))) }, { select, focus, expand })), error => this.logService.error(error));
+                .then(treeNode => this.proxy.$reveal(this.viewId, { item: treeNode.item, parentChain: ( parentChain.map(p => p.item)) }, { select, focus, expand })), error => this.logService.error(error));
         }
         else {
             return this.proxy.$reveal(this.viewId, undefined, { select, focus, expand });
@@ -408,10 +406,10 @@ class ExtHostTreeView extends Disposable {
         const element = this.getExtensionElement(treeItemHandle);
         if (element) {
             if (expanded) {
-                this._onDidExpandElement.fire(( (Object.freeze({ element }))));
+                this._onDidExpandElement.fire(( Object.freeze({ element })));
             }
             else {
-                this._onDidCollapseElement.fire(( (Object.freeze({ element }))));
+                this._onDidCollapseElement.fire(( Object.freeze({ element })));
             }
         }
     }
@@ -421,20 +419,20 @@ class ExtHostTreeView extends Disposable {
         const changedFocus = this._focusedHandle !== focusedHandle;
         this._focusedHandle = focusedHandle;
         if (changedSelection) {
-            this._onDidChangeSelection.fire(( (Object.freeze({ selection: this.selectedElements }))));
+            this._onDidChangeSelection.fire(( Object.freeze({ selection: this.selectedElements })));
         }
         if (changedFocus) {
-            this._onDidChangeActiveItem.fire(( (Object.freeze({ activeItem: this.focusedElement }))));
+            this._onDidChangeActiveItem.fire(( Object.freeze({ activeItem: this.focusedElement })));
         }
     }
     setVisible(visible) {
         if (visible !== this._visible) {
             this._visible = visible;
-            this._onDidChangeVisibility.fire(( (Object.freeze({ visible: this._visible }))));
+            this._onDidChangeVisibility.fire(( Object.freeze({ visible: this._visible })));
         }
     }
     async setCheckboxState(checkboxUpdates) {
-        const items = (await Promise.all(( (checkboxUpdates.map(async (checkboxUpdate) => {
+        const items = (await Promise.all(( checkboxUpdates.map(async (checkboxUpdate) => {
             const extensionItem = this.getExtensionElement(checkboxUpdate.treeItemHandle);
             if (extensionItem) {
                 return {
@@ -444,11 +442,11 @@ class ExtHostTreeView extends Disposable {
                 };
             }
             return Promise.resolve(undefined);
-        }))))).filter((item) => item !== undefined);
+        })))).filter((item) => item !== undefined);
         items.forEach(item => {
             item.treeItem.checkboxState = item.newState ? TreeItemCheckboxState.Checked : TreeItemCheckboxState.Unchecked;
         });
-        this._onDidChangeCheckboxState.fire({ items: ( (items.map(item => [item.extensionItem, item.newState]))) });
+        this._onDidChangeCheckboxState.fire({ items: ( items.map(item => [item.extensionItem, item.newState])) });
     }
     async handleDrag(sourceTreeItemHandles, treeDataTransfer, token) {
         const extensionTreeItems = [];
@@ -552,17 +550,17 @@ class ExtHostTreeView extends Disposable {
     }
     async fetchChildrenNodes(parentElement) {
         this.clearChildren(parentElement);
-        const cts = ( (new CancellationTokenSource(this._refreshCancellationSource.token)));
+        const cts = ( new CancellationTokenSource(this._refreshCancellationSource.token));
         try {
             const parentNode = parentElement ? this.nodes.get(parentElement) : undefined;
             const elements = await this.dataProvider.getChildren(parentElement);
             if (cts.token.isCancellationRequested) {
                 return undefined;
             }
-            const items = await Promise.all(( (coalesce(elements || []).map(async (element) => {
+            const items = await Promise.all(( coalesce(elements || []).map(async (element) => {
                 const item = await this.dataProvider.getTreeItem(element);
                 return item && !cts.token.isCancellationRequested ? this.createAndRegisterTreeNode(element, item, parentNode) : null;
-            }))));
+            })));
             if (cts.token.isCancellationRequested) {
                 return undefined;
             }
@@ -573,10 +571,10 @@ class ExtHostTreeView extends Disposable {
         }
     }
     refresh(elements) {
-        const hasRoot = ( (elements.some(element => !element)));
+        const hasRoot = ( elements.some(element => !element));
         if (hasRoot) {
             this._refreshCancellationSource.dispose(true);
-            this._refreshCancellationSource = ( (new CancellationTokenSource()));
+            this._refreshCancellationSource = ( new CancellationTokenSource());
             this.clearAll();
             return this.proxy.$refresh(this.viewId);
         }
@@ -589,10 +587,10 @@ class ExtHostTreeView extends Disposable {
         return Promise.resolve(undefined);
     }
     getHandlesToRefresh(elements) {
-        const elementsToUpdate = ( (new Set()));
-        const elementNodes = ( (elements.map(element => this.nodes.get(element))));
+        const elementsToUpdate = ( new Set());
+        const elementNodes = ( elements.map(element => this.nodes.get(element)));
         for (const elementNode of elementNodes) {
-            if (elementNode && !( (elementsToUpdate.has(elementNode.item.handle)))) {
+            if (elementNode && !( elementsToUpdate.has(elementNode.item.handle))) {
                 let currentNode = elementNode;
                 while (currentNode && currentNode.parent && elementNodes.findIndex(node => currentNode && currentNode.parent && node && node.item.handle === currentNode.parent.item.handle) === -1) {
                     const parentElement = this.elements.get(currentNode.parent.item.handle);
@@ -608,7 +606,7 @@ class ExtHostTreeView extends Disposable {
             const element = this.elements.get(handle);
             if (element) {
                 const node = this.nodes.get(element);
-                if (node && (!node.parent || !( (elementsToUpdate.has(node.parent.item.handle))))) {
+                if (node && (!node.parent || !( elementsToUpdate.has(node.parent.item.handle)))) {
                     handlesToUpdate.push(handle);
                 }
             }
@@ -617,13 +615,13 @@ class ExtHostTreeView extends Disposable {
     }
     refreshHandles(itemHandles) {
         const itemsToRefresh = {};
-        return Promise.all(( (itemHandles.map(treeItemHandle => this.refreshNode(treeItemHandle)
+        return Promise.all(( itemHandles.map(treeItemHandle => this.refreshNode(treeItemHandle)
             .then(node => {
             if (node) {
                 itemsToRefresh[treeItemHandle] = node.item;
             }
-        })))))
-            .then(() => ( (Object.keys(itemsToRefresh))).length ? this.proxy.$refresh(this.viewId, itemsToRefresh) : undefined);
+        }))))
+            .then(() => ( Object.keys(itemsToRefresh)).length ? this.proxy.$refresh(this.viewId, itemsToRefresh) : undefined);
     }
     refreshNode(treeItemHandle) {
         const extElement = this.getExtensionElement(treeItemHandle);
@@ -647,8 +645,8 @@ class ExtHostTreeView extends Disposable {
     }
     createAndRegisterTreeNode(element, extTreeItem, parentNode) {
         const node = this.createTreeNode(element, extTreeItem, parentNode);
-        if (extTreeItem.id && ( (this.elements.has(node.item.handle)))) {
-            throw new Error(localize('treeView.duplicateElement', 'Element with id {0} is already registered', extTreeItem.id));
+        if (extTreeItem.id && ( this.elements.has(node.item.handle))) {
+            throw new Error(localizeWithPath('vs/workbench/api/common/extHostTreeViews', 'treeView.duplicateElement', 'Element with id {0} is already registered', extTreeItem.id));
         }
         this.addNodeToCache(element, node);
         this.addNodeToParentCache(node, parentNode);
@@ -687,7 +685,7 @@ class ExtHostTreeView extends Disposable {
     }
     createTreeNode(element, extensionTreeItem, parent) {
         this.validateTreeItem(extensionTreeItem);
-        const disposableStore = this._register(( (new DisposableStore())));
+        const disposableStore = this._register(( new DisposableStore()));
         const handle = this.createHandle(element, extensionTreeItem, parent);
         const icon = this.getLightIconPath(extensionTreeItem);
         const item = {
@@ -726,13 +724,13 @@ class ExtHostTreeView extends Disposable {
         const prefix = parent ? parent.item.handle : ExtHostTreeView.LABEL_HANDLE_PREFIX;
         let elementId = treeItemLabel ? treeItemLabel.label : resourceUri ? basename(resourceUri) : '';
         elementId = elementId.indexOf('/') !== -1 ? elementId.replace('/', '//') : elementId;
-        const existingHandle = ( (this.nodes.has(element))) ? this.nodes.get(element).item.handle : undefined;
+        const existingHandle = ( this.nodes.has(element)) ? this.nodes.get(element).item.handle : undefined;
         const childrenNodes = (this.getChildrenNodes(parent) || []);
         let handle;
         let counter = 0;
         do {
             handle = `${prefix}/${counter}:${elementId}`;
-            if (returnFirst || !( ( this.elements.has(handle))) || existingHandle === handle) {
+            if (returnFirst || !( this.elements.has(handle)) || existingHandle === handle) {
                 break;
             }
             counter++;

package/vscode/src/vs/workbench/api/common/extHostTunnelService.js

@@ -13,7 +13,7 @@ import { Disposable as Disposable$1 } from './extHostTypes.js';
 class ExtensionTunnel extends DisposableTunnel {
 }
 var TunnelDtoConverter;
-( ((function(TunnelDtoConverter) {
+( (function(TunnelDtoConverter) {
     function fromApiTunnel(tunnel) {
         return {
             remoteAddress: tunnel.remoteAddress,
@@ -37,27 +37,27 @@ var TunnelDtoConverter;
         };
     }
     TunnelDtoConverter.fromServiceTunnel = fromServiceTunnel;
-})(TunnelDtoConverter || (TunnelDtoConverter = {}))));
-const IExtHostTunnelService = ( (createDecorator('IExtHostTunnelService')));
+})(TunnelDtoConverter || (TunnelDtoConverter = {})));
+const IExtHostTunnelService = ( createDecorator('IExtHostTunnelService'));
 let ExtHostTunnelService = class ExtHostTunnelService extends Disposable {
     constructor(extHostRpc, initData, logService) {
         super();
         this.logService = logService;
         this._showCandidatePort = () => { return Promise.resolve(true); };
-        this._extensionTunnels = ( (new Map()));
-        this._onDidChangeTunnels = ( (new Emitter()));
+        this._extensionTunnels = ( new Map());
+        this._onDidChangeTunnels = ( new Emitter());
         this.onDidChangeTunnels = this._onDidChangeTunnels.event;
         this._providerHandleCounter = 0;
-        this._portAttributesProviders = ( (new Map()));
-        this._proxy = ( (extHostRpc.getProxy(MainContext.MainThreadTunnelService)));
+        this._portAttributesProviders = ( new Map());
+        this._proxy = ( extHostRpc.getProxy(MainContext.MainThreadTunnelService));
     }
     async openTunnel(extension, forward) {
         this.logService.trace(`ForwardedPorts: (ExtHostTunnelService) ${extension.identifier.value} called openTunnel API for ${forward.remoteAddress.host}:${forward.remoteAddress.port}.`);
         const tunnel = await this._proxy.$openTunnel(forward, extension.displayName);
         if (tunnel) {
-            const disposableTunnel = ( (new ExtensionTunnel(tunnel.remoteAddress, tunnel.localAddress, () => {
+            const disposableTunnel = ( new ExtensionTunnel(tunnel.remoteAddress, tunnel.localAddress, () => {
                 return this._proxy.$closeTunnel(tunnel.remoteAddress);
-            })));
+            }));
             this._register(disposableTunnel);
             return disposableTunnel;
         }
@@ -85,7 +85,7 @@ let ExtHostTunnelService = class ExtHostTunnelService extends Disposable {
             if (!provider) {
                 return [];
             }
-            providedAttributes.push(...(await Promise.all(( (ports.map(async (port) => {
+            providedAttributes.push(...(await Promise.all(( ports.map(async (port) => {
                 let providedAttributes;
                 try {
                     providedAttributes = await provider.provider.providePortAttributes({ port, pid, commandLine }, cancellationToken);
@@ -94,15 +94,15 @@ let ExtHostTunnelService = class ExtHostTunnelService extends Disposable {
                     providedAttributes = await provider.provider.providePortAttributes(port, pid, commandLine, cancellationToken);
                 }
                 return { providedAttributes, port };
-            }))))));
+            })))));
         }
         const allAttributes = providedAttributes.filter(attribute => !!attribute.providedAttributes);
-        return (allAttributes.length > 0) ? ( (allAttributes.map(attributes => {
+        return (allAttributes.length > 0) ? ( allAttributes.map(attributes => {
             return {
                 autoForwardAction: attributes.providedAttributes.autoForwardAction,
                 port: attributes.port
             };
-        }))) : [];
+        })) : [];
     }
     async $registerCandidateFinder(_enable) { }
     registerTunnelProvider(provider, information) {
@@ -110,7 +110,7 @@ let ExtHostTunnelService = class ExtHostTunnelService extends Disposable {
             throw new Error('A tunnel provider has already been registered. Only the first tunnel provider to be registered will be used.');
         }
         this._forwardPortProvider = async (tunnelOptions, tunnelCreationOptions) => {
-            const result = await provider.provideTunnel(tunnelOptions, tunnelCreationOptions, ( (new CancellationTokenSource())).token);
+            const result = await provider.provideTunnel(tunnelOptions, tunnelCreationOptions, ( new CancellationTokenSource()).token);
             return result ?? undefined;
         };
         const tunnelFeatures = information.tunnelFeatures ? {
@@ -140,12 +140,12 @@ let ExtHostTunnelService = class ExtHostTunnelService extends Disposable {
                     privacyOptions = [
                         {
                             id: 'private',
-                            label: ( (nls.localize('tunnelPrivacy.private', "Private"))),
+                            label: nls.localizeWithPath('vs/workbench/api/common/extHostTunnelService', 'tunnelPrivacy.private', "Private"),
                             themeIcon: 'lock'
                         },
                         {
                             id: 'public',
-                            label: ( (nls.localize('tunnelPrivacy.public', "Public"))),
+                            label: nls.localizeWithPath('vs/workbench/api/common/extHostTunnelService', 'tunnelPrivacy.public', "Public"),
                             themeIcon: 'eye'
                         }
                     ];
@@ -169,9 +169,9 @@ let ExtHostTunnelService = class ExtHostTunnelService extends Disposable {
         return undefined;
     }
     async $closeTunnel(remote, silent) {
-        if (( (this._extensionTunnels.has(remote.host)))) {
+        if (( this._extensionTunnels.has(remote.host))) {
             const hostMap = this._extensionTunnels.get(remote.host);
-            if (( (hostMap.has(remote.port)))) {
+            if (( hostMap.has(remote.port))) {
                 if (silent) {
                     hostMap.get(remote.port).disposeListener.dispose();
                 }
@@ -196,8 +196,8 @@ let ExtHostTunnelService = class ExtHostTunnelService extends Disposable {
                         this.logService.error('ForwardedPorts: (ExtHostTunnelService) Resolved tunnel is undefined');
                         return undefined;
                     }
-                    if (!( (this._extensionTunnels.has(tunnelOptions.remoteAddress.host)))) {
-                        this._extensionTunnels.set(tunnelOptions.remoteAddress.host, ( (new Map())));
+                    if (!( this._extensionTunnels.has(tunnelOptions.remoteAddress.host))) {
+                        this._extensionTunnels.set(tunnelOptions.remoteAddress.host, ( new Map()));
                     }
                     const disposeListener = this._register(tunnel.onDidDispose(() => {
                         this.logService.trace('ForwardedPorts: (ExtHostTunnelService) Extension fired tunnel\'s onDidDispose.');
@@ -220,17 +220,17 @@ let ExtHostTunnelService = class ExtHostTunnelService extends Disposable {
         return undefined;
     }
     async $applyCandidateFilter(candidates) {
-        const filter = await Promise.all(( (candidates.map(
+        const filter = await Promise.all(( candidates.map(
             candidate => this._showCandidatePort(candidate.host, candidate.port, candidate.detail ?? '')
-        ))));
+        )));
         const result = candidates.filter((candidate, index) => filter[index]);
-        this.logService.trace(`ForwardedPorts: (ExtHostTunnelService) filtered from ${( ( candidates.map(port => port.port))).join(', ')} to ${( ( result.map(port => port.port))).join(', ')}`);
+        this.logService.trace(`ForwardedPorts: (ExtHostTunnelService) filtered from ${( candidates.map(port => port.port)).join(', ')} to ${( result.map(port => port.port)).join(', ')}`);
         return result;
     }
 };
-ExtHostTunnelService = ( (__decorate([
-    ( (__param(0, IExtHostRpcService))),
-    ( (__param(1, IExtHostInitDataService))),
-    ( (__param(2, ILogService)))
-], ExtHostTunnelService)));
+ExtHostTunnelService = ( __decorate([
+    ( __param(0, IExtHostRpcService)),
+    ( __param(1, IExtHostInitDataService)),
+    ( __param(2, ILogService))
+], ExtHostTunnelService));
 export { ExtHostTunnelService, IExtHostTunnelService, TunnelDtoConverter };