@codingame/monaco-vscode-api 4.5.1 → 5.0.0

package/vscode/src/vs/workbench/contrib/remote/browser/remoteExplorer.js

@@ -34,6 +34,7 @@ import { IWorkbenchConfigurationService } from '../../../services/configuration/
 import { Action } from '../../../../base/common/actions.js';
 import { IPreferencesService } from '../../../services/preferences/common/preferences.service.js';
 import { IStorageService } from '../../../../platform/storage/common/storage.service.js';
+const _moduleId = "vs/workbench/contrib/remote/browser/remoteExplorer";
 const VIEWLET_ID = 'workbench.view.remote';
 let ForwardedPortsView = class ForwardedPortsView extends Disposable {
     constructor(contextKeyService, environmentService, remoteExplorerService, tunnelService, activityService, statusbarService) {
@@ -44,18 +45,18 @@ let ForwardedPortsView = class ForwardedPortsView extends Disposable {
         this.tunnelService = tunnelService;
         this.activityService = activityService;
         this.statusbarService = statusbarService;
-        this.contextKeyListener = this._register(( new MutableDisposable()));
-        this.activityBadge = this._register(( new MutableDisposable()));
-        this._register(( Registry.as(Extensions.ViewsRegistry)).registerViewWelcomeContent(TUNNEL_VIEW_ID, {
+        this.contextKeyListener = this._register(( (new MutableDisposable())));
+        this.activityBadge = this._register(( (new MutableDisposable())));
+        this._register(( (Registry.as(Extensions.ViewsRegistry))).registerViewWelcomeContent(TUNNEL_VIEW_ID, {
             content: this.environmentService.remoteAuthority ? ( localizeWithPath(
-                'vs/workbench/contrib/remote/browser/remoteExplorer',
-                'remoteNoPorts',
+                _moduleId,
+                0,
                 "No forwarded ports. Forward a port to access your running services locally.\n[Forward a Port]({0})",
                 `command:${ForwardPortAction.INLINE_ID}`
             ))
                 : ( localizeWithPath(
-                'vs/workbench/contrib/remote/browser/remoteExplorer',
-                'noRemoteNoPorts',
+                _moduleId,
+                1,
                 "No forwarded ports. Forward a port to access your locally running services over the internet.\n[Forward a Port]({0})",
                 `command:${ForwardPortAction.INLINE_ID}`
             )),
@@ -64,14 +65,14 @@ let ForwardedPortsView = class ForwardedPortsView extends Disposable {
         this.enableForwardedPortsView();
     }
     async getViewContainer() {
-        return ( Registry.as(Extensions.ViewContainersRegistry)).registerViewContainer({
+        return ( (Registry.as(Extensions.ViewContainersRegistry))).registerViewContainer({
             id: TUNNEL_VIEW_CONTAINER_ID,
-            title: ( localize2WithPath('vs/workbench/contrib/remote/browser/remoteExplorer', 'ports', "Ports")),
+            title: ( localize2WithPath(_moduleId, 2, "Ports")),
             icon: portsViewIcon,
-            ctorDescriptor: ( new SyncDescriptor(
+            ctorDescriptor: ( (new SyncDescriptor(
                 ViewPaneContainer,
                 [TUNNEL_VIEW_CONTAINER_ID, { mergeViewWithContainerWhenSingleView: true }]
-            )),
+            ))),
             storageId: TUNNEL_VIEW_CONTAINER_ID,
             hideIfEmpty: true,
             order: 5
@@ -82,8 +83,11 @@ let ForwardedPortsView = class ForwardedPortsView extends Disposable {
         const viewEnabled = !!forwardedPortsViewEnabled.getValue(this.contextKeyService);
         if (viewEnabled) {
             const viewContainer = await this.getViewContainer();
-            const tunnelPanelDescriptor = ( new TunnelPanelDescriptor(( new TunnelViewModel(this.remoteExplorerService, this.tunnelService)), this.environmentService));
-            const viewsRegistry = ( Registry.as(Extensions.ViewsRegistry));
+            const tunnelPanelDescriptor = ( (new TunnelPanelDescriptor(
+                 (new TunnelViewModel(this.remoteExplorerService, this.tunnelService)),
+                this.environmentService
+            )));
+            const viewsRegistry = ( (Registry.as(Extensions.ViewsRegistry)));
             if (viewContainer) {
                 this.remoteExplorerService.enablePortsFeatures();
                 viewsRegistry.registerViews([tunnelPanelDescriptor], viewContainer);
@@ -91,14 +95,14 @@ let ForwardedPortsView = class ForwardedPortsView extends Disposable {
         }
         else {
             this.contextKeyListener.value = this.contextKeyService.onDidChangeContext(e => {
-                if (e.affectsSome(( new Set(( forwardedPortsViewEnabled.keys()))))) {
+                if (e.affectsSome(( (new Set( (forwardedPortsViewEnabled.keys())))))) {
                     this.enableForwardedPortsView();
                 }
             });
         }
     }
     enableBadgeAndStatusBar() {
-        const disposable = ( Registry.as(Extensions.ViewsRegistry)).onViewsRegistered(e => {
+        const disposable = ( (Registry.as(Extensions.ViewsRegistry))).onViewsRegistered(e => {
             if (e.find(view => view.views.find(viewDescriptor => viewDescriptor.id === TUNNEL_VIEW_ID))) {
                 this._register(Event.debounce(this.remoteExplorerService.tunnelModel.onForwardPort, (_last, e) => e, 50)(() => {
                     this.updateActivityBadge();
@@ -117,19 +121,10 @@ let ForwardedPortsView = class ForwardedPortsView extends Disposable {
     async updateActivityBadge() {
         if (this.remoteExplorerService.tunnelModel.forwarded.size > 0) {
             this.activityBadge.value = this.activityService.showViewActivity(TUNNEL_VIEW_ID, {
-                badge: ( new NumberBadge(
+                badge: ( (new NumberBadge(
                     this.remoteExplorerService.tunnelModel.forwarded.size,
-                    n => n === 1 ? ( localizeWithPath(
-                        'vs/workbench/contrib/remote/browser/remoteExplorer',
-                        '1forwardedPort',
-                        "1 forwarded port"
-                    )) : ( localizeWithPath(
-                        'vs/workbench/contrib/remote/browser/remoteExplorer',
-                        'nForwardedPorts',
-                        "{0} forwarded ports",
-                        n
-                    ))
-                ))
+                    n => n === 1 ? ( localizeWithPath(_moduleId, 3, "1 forwarded port")) : ( localizeWithPath(_moduleId, 4, "{0} forwarded ports", n))
+                )))
             });
         }
     }
@@ -146,28 +141,20 @@ let ForwardedPortsView = class ForwardedPortsView extends Disposable {
         const count = this.remoteExplorerService.tunnelModel.forwarded.size + this.remoteExplorerService.tunnelModel.detected.size;
         const text = `${count}`;
         if (count === 0) {
-            tooltip = ( localizeWithPath(
-                'vs/workbench/contrib/remote/browser/remoteExplorer',
-                'remote.forwardedPorts.statusbarTextNone',
-                "No Ports Forwarded"
-            ));
+            tooltip = ( localizeWithPath(_moduleId, 5, "No Ports Forwarded"));
         }
         else {
-            const allTunnels = Array.from(( this.remoteExplorerService.tunnelModel.forwarded.values()));
-            allTunnels.push(...Array.from(( this.remoteExplorerService.tunnelModel.detected.values())));
+            const allTunnels = Array.from(( (this.remoteExplorerService.tunnelModel.forwarded.values())));
+            allTunnels.push(...Array.from(( (this.remoteExplorerService.tunnelModel.detected.values()))));
             tooltip = ( localizeWithPath(
-                'vs/workbench/contrib/remote/browser/remoteExplorer',
-                'remote.forwardedPorts.statusbarTooltip',
+                _moduleId,
+                6,
                 "Forwarded Ports: {0}",
-                ( allTunnels.map(forwarded => forwarded.remotePort)).join(', ')
+                ( (allTunnels.map(forwarded => forwarded.remotePort))).join(', ')
             ));
         }
         return {
-            name: ( localizeWithPath(
-                'vs/workbench/contrib/remote/browser/remoteExplorer',
-                'status.forwardedPorts',
-                "Forwarded Ports"
-            )),
+            name: ( localizeWithPath(_moduleId, 7, "Forwarded Ports")),
             text: `$(radio-tower) ${text}`,
             ariaLabel: tooltip,
             tooltip,
@@ -175,14 +162,14 @@ let ForwardedPortsView = class ForwardedPortsView extends Disposable {
         };
     }
 };
-ForwardedPortsView = ( __decorate([
-    ( __param(0, IContextKeyService)),
-    ( __param(1, IWorkbenchEnvironmentService)),
-    ( __param(2, IRemoteExplorerService)),
-    ( __param(3, ITunnelService)),
-    ( __param(4, IActivityService)),
-    ( __param(5, IStatusbarService))
-], ForwardedPortsView));
+ForwardedPortsView = ( (__decorate([
+    ( (__param(0, IContextKeyService))),
+    ( (__param(1, IWorkbenchEnvironmentService))),
+    ( (__param(2, IRemoteExplorerService))),
+    ( (__param(3, ITunnelService))),
+    ( (__param(4, IActivityService))),
+    ( (__param(5, IStatusbarService)))
+], ForwardedPortsView)));
 let PortRestore = class PortRestore {
     constructor(remoteExplorerService, logService) {
         this.remoteExplorerService = remoteExplorerService;
@@ -201,10 +188,10 @@ let PortRestore = class PortRestore {
         return this.remoteExplorerService.restore();
     }
 };
-PortRestore = ( __decorate([
-    ( __param(0, IRemoteExplorerService)),
-    ( __param(1, ILogService))
-], PortRestore));
+PortRestore = ( (__decorate([
+    ( (__param(0, IRemoteExplorerService))),
+    ( (__param(1, ILogService)))
+], PortRestore)));
 let AutomaticPortForwarding = class AutomaticPortForwarding extends Disposable {
     constructor(terminalService, notificationService, openerService, externalOpenerService, remoteExplorerService, environmentService, contextKeyService, configurationService, debugService, remoteAgentService, tunnelService, hostService, logService, storageService, preferencesService) {
         super();
@@ -213,11 +200,9 @@ let AutomaticPortForwarding = class AutomaticPortForwarding extends Disposable {
         this.openerService = openerService;
         this.externalOpenerService = externalOpenerService;
         this.remoteExplorerService = remoteExplorerService;
-        this.environmentService = environmentService;
         this.contextKeyService = contextKeyService;
         this.configurationService = configurationService;
         this.debugService = debugService;
-        this.remoteAgentService = remoteAgentService;
         this.tunnelService = tunnelService;
         this.hostService = hostService;
         this.logService = logService;
@@ -270,36 +255,28 @@ let AutomaticPortForwarding = class AutomaticPortForwarding extends Disposable {
                     this.portListener?.dispose();
                     return;
                 }
-                if (Array.from(( this.remoteExplorerService.tunnelModel.forwarded.values())).filter(tunnel => tunnel.source.source === TunnelSource.Auto).length > fallbackAt) {
+                if (Array.from(( (this.remoteExplorerService.tunnelModel.forwarded.values()))).filter(tunnel => tunnel.source.source === TunnelSource.Auto).length > fallbackAt) {
                     await this.configurationService.updateValue(PORT_AUTO_SOURCE_SETTING, PORT_AUTO_SOURCE_SETTING_HYBRID);
                     this.notificationService.notify({
                         message: ( localizeWithPath(
-                            'vs/workbench/contrib/remote/browser/remoteExplorer',
-                            'remote.autoForwardPortsSource.fallback',
+                            _moduleId,
+                            8,
                             "Over 20 ports have been automatically forwarded. The `process` based automatic port forwarding has been switched to `hybrid` in settings. Some ports may no longer be detected."
                         )),
                         severity: Severity$1.Warning,
                         actions: {
                             primary: [
-                                ( new Action('switchBack', ( localizeWithPath(
-                                    'vs/workbench/contrib/remote/browser/remoteExplorer',
-                                    'remote.autoForwardPortsSource.fallback.switchBack',
-                                    "Undo"
-                                )), undefined, true, async () => {
-                                    await this.configurationService.updateValue(PORT_AUTO_SOURCE_SETTING, PORT_AUTO_SOURCE_SETTING_PROCESS);
-                                    await this.configurationService.updateValue(PORT_AUTO_FALLBACK_SETTING, 0, 5 );
-                                    this.portListener?.dispose();
-                                    this.portListener = undefined;
-                                })),
-                                ( new Action('showPortSourceSetting', ( localizeWithPath(
-                                    'vs/workbench/contrib/remote/browser/remoteExplorer',
-                                    'remote.autoForwardPortsSource.fallback.showPortSourceSetting',
-                                    "Show Setting"
-                                )), undefined, true, async () => {
-                                    await this.preferencesService.openSettings({
-                                        query: 'remote.autoForwardPortsSource'
-                                    });
-                                }))
+                                ( (new Action('switchBack', ( localizeWithPath(_moduleId, 9, "Undo")), undefined, true, async () => {
+                                await this.configurationService.updateValue(PORT_AUTO_SOURCE_SETTING, PORT_AUTO_SOURCE_SETTING_PROCESS);
+                                await this.configurationService.updateValue(PORT_AUTO_FALLBACK_SETTING, 0, 5 );
+                                this.portListener?.dispose();
+                                this.portListener = undefined;
+                            }))),
+                                ( (new Action('showPortSourceSetting', ( localizeWithPath(_moduleId, 10, "Show Setting")), undefined, true, async () => {
+                                await this.preferencesService.openSettings({
+                                    query: 'remote.autoForwardPortsSource'
+                                });
+                            })))
                             ]
                         }
                     });
@@ -320,10 +297,10 @@ let AutomaticPortForwarding = class AutomaticPortForwarding extends Disposable {
         this.outputForwarder = undefined;
         if (environment?.os !== 3 ) {
             if (this.configurationService.inspect(PORT_AUTO_SOURCE_SETTING).default?.value !== PORT_AUTO_SOURCE_SETTING_OUTPUT) {
-                ( Registry.as(Extensions$1.Configuration))
+                ( (Registry.as(Extensions$1.Configuration)))
                     .registerDefaultConfigurations([{ overrides: { 'remote.autoForwardPortsSource': PORT_AUTO_SOURCE_SETTING_OUTPUT } }]);
             }
-            this.outputForwarder = this._register(( new OutputAutomaticPortForwarding(
+            this.outputForwarder = this._register(( (new OutputAutomaticPortForwarding(
                 this.terminalService,
                 this.notificationService,
                 this.openerService,
@@ -336,12 +313,12 @@ let AutomaticPortForwarding = class AutomaticPortForwarding extends Disposable {
                 this.logService,
                 this.contextKeyService,
                 () => false
-            )));
+            ))));
         }
         else {
             const useProc = () => (this.configurationService.getValue(PORT_AUTO_SOURCE_SETTING) === PORT_AUTO_SOURCE_SETTING_PROCESS);
             if (useProc()) {
-                this.procForwarder = this._register(( new ProcAutomaticPortForwarding(
+                this.procForwarder = this._register(( (new ProcAutomaticPortForwarding(
                     false,
                     alreadyForwarded,
                     !isSwitch,
@@ -354,10 +331,10 @@ let AutomaticPortForwarding = class AutomaticPortForwarding extends Disposable {
                     this.hostService,
                     this.logService,
                     this.contextKeyService
-                )));
+                ))));
             }
             else if (this.configurationService.getValue(PORT_AUTO_SOURCE_SETTING) === PORT_AUTO_SOURCE_SETTING_HYBRID) {
-                this.procForwarder = this._register(( new ProcAutomaticPortForwarding(
+                this.procForwarder = this._register(( (new ProcAutomaticPortForwarding(
                     true,
                     alreadyForwarded,
                     !isSwitch,
@@ -370,9 +347,9 @@ let AutomaticPortForwarding = class AutomaticPortForwarding extends Disposable {
                     this.hostService,
                     this.logService,
                     this.contextKeyService
-                )));
+                ))));
             }
-            this.outputForwarder = this._register(( new OutputAutomaticPortForwarding(
+            this.outputForwarder = this._register(( (new OutputAutomaticPortForwarding(
                 this.terminalService,
                 this.notificationService,
                 this.openerService,
@@ -385,28 +362,28 @@ let AutomaticPortForwarding = class AutomaticPortForwarding extends Disposable {
                 this.logService,
                 this.contextKeyService,
                 useProc
-            )));
+            ))));
         }
         this.listenForPorts();
     }
 };
-AutomaticPortForwarding = ( __decorate([
-    ( __param(0, ITerminalService)),
-    ( __param(1, INotificationService)),
-    ( __param(2, IOpenerService)),
-    ( __param(3, IExternalUriOpenerService)),
-    ( __param(4, IRemoteExplorerService)),
-    ( __param(5, IWorkbenchEnvironmentService)),
-    ( __param(6, IContextKeyService)),
-    ( __param(7, IWorkbenchConfigurationService)),
-    ( __param(8, IDebugService)),
-    ( __param(9, IRemoteAgentService)),
-    ( __param(10, ITunnelService)),
-    ( __param(11, IHostService)),
-    ( __param(12, ILogService)),
-    ( __param(13, IStorageService)),
-    ( __param(14, IPreferencesService))
-], AutomaticPortForwarding));
+AutomaticPortForwarding = ( (__decorate([
+    ( (__param(0, ITerminalService))),
+    ( (__param(1, INotificationService))),
+    ( (__param(2, IOpenerService))),
+    ( (__param(3, IExternalUriOpenerService))),
+    ( (__param(4, IRemoteExplorerService))),
+    ( (__param(5, IWorkbenchEnvironmentService))),
+    ( (__param(6, IContextKeyService))),
+    ( (__param(7, IWorkbenchConfigurationService))),
+    ( (__param(8, IDebugService))),
+    ( (__param(9, IRemoteAgentService))),
+    ( (__param(10, ITunnelService))),
+    ( (__param(11, IHostService))),
+    ( (__param(12, ILogService))),
+    ( (__param(13, IStorageService))),
+    ( (__param(14, IPreferencesService)))
+], AutomaticPortForwarding)));
 class OnAutoForwardedAction extends Disposable {
     static { this.NOTIFY_COOL_DOWN = 5000; }
     constructor(notificationService, remoteExplorerService, openerService, externalOpenerService, tunnelService, hostService, logService, contextKeyService) {
@@ -419,8 +396,8 @@ class OnAutoForwardedAction extends Disposable {
         this.hostService = hostService;
         this.logService = logService;
         this.contextKeyService = contextKeyService;
-        this.alreadyOpenedOnce = ( new Set());
-        this.lastNotifyTime = ( new Date());
+        this.alreadyOpenedOnce = ( (new Set()));
+        this.lastNotifyTime = ( (new Date()));
         this.lastNotifyTime.setFullYear(this.lastNotifyTime.getFullYear() - 1);
     }
     async doAction(tunnels) {
@@ -434,7 +411,7 @@ class OnAutoForwardedAction extends Disposable {
             this.logService.trace(`ForwardedPorts: (OnAutoForwardedAction) onAutoForward action is ${attributes}`);
             switch (attributes) {
                 case OnPortForward.OpenBrowserOnce: {
-                    if (( this.alreadyOpenedOnce.has(tunnel.localAddress))) {
+                    if (( (this.alreadyOpenedOnce.has(tunnel.localAddress)))) {
                         break;
                     }
                     this.alreadyOpenedOnce.add(tunnel.localAddress);
@@ -451,7 +428,7 @@ class OnAutoForwardedAction extends Disposable {
                 }
                 case OnPortForward.Silent: break;
                 default: {
-                    const elapsed = ( new Date()).getTime() - this.lastNotifyTime.getTime();
+                    const elapsed = ( (new Date())).getTime() - this.lastNotifyTime.getTime();
                     this.logService.trace(`ForwardedPorts: (OnAutoForwardedAction) time elapsed since last notification ${elapsed} ms`);
                     if (elapsed > OnAutoForwardedAction.NOTIFY_COOL_DOWN) {
                         await this.showNotification(tunnel);
@@ -487,26 +464,28 @@ class OnAutoForwardedAction extends Disposable {
         }
         this.logService.trace(`ForwardedPorts: (OnAutoForwardedAction) Waiting for "better" tunnel than ${firstTunnel.tunnelRemotePort}`);
         this.newerTunnel = undefined;
-        return ( new Promise(resolve => {
-            setTimeout(() => {
-                if (this.newerTunnel) {
-                    resolve(undefined);
-                }
-                else if (this.doActionTunnels?.includes(firstTunnel)) {
-                    resolve(firstTunnel);
-                }
-                else {
-                    resolve(undefined);
-                }
-            }, 3000);
-        }));
+        return (
+             (new Promise(resolve => {
+                setTimeout(() => {
+                    if (this.newerTunnel) {
+                        resolve(undefined);
+                    }
+                    else if (this.doActionTunnels?.includes(firstTunnel)) {
+                        resolve(firstTunnel);
+                    }
+                    else {
+                        resolve(undefined);
+                    }
+                }, 3000);
+            }))
+        );
     }
     async basicMessage(tunnel) {
         const properties = await this.remoteExplorerService.tunnelModel.getAttributes([{ host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort }], false);
         const label = properties?.get(tunnel.tunnelRemotePort)?.label;
         return ( localizeWithPath(
-            'vs/workbench/contrib/remote/browser/remoteExplorer',
-            'remote.tunnelsView.automaticForward',
+            _moduleId,
+            11,
             "Your application{0} running on port {1} is available.  ",
             label ? ` (${label})` : '',
             tunnel.tunnelRemotePort
@@ -514,8 +493,8 @@ class OnAutoForwardedAction extends Disposable {
     }
     linkMessage() {
         return ( localizeWithPath(
-            'vs/workbench/contrib/remote/browser/remoteExplorer',
-            { key: 'remote.tunnelsView.notificationLink2', comment: ['[See all forwarded ports]({0}) is a link. Only translate `See all forwarded ports`. Do not change brackets and parentheses or {0}'] },
+            _moduleId,
+            12,
             "[See all forwarded ports]({0})",
             `command:${TunnelPanel.ID}.focus`
         ));
@@ -532,8 +511,8 @@ class OnAutoForwardedAction extends Disposable {
         }
         if ((tunnel.tunnelLocalPort !== tunnel.tunnelRemotePort) && this.tunnelService.canElevate && this.tunnelService.isPortPrivileged(tunnel.tunnelRemotePort)) {
             message += ( localizeWithPath(
-                'vs/workbench/contrib/remote/browser/remoteExplorer',
-                'remote.tunnelsView.elevationMessage',
+                _moduleId,
+                13,
                 "You'll need to run as superuser to use port {0} locally.  ",
                 tunnel.tunnelRemotePort
             ));
@@ -545,7 +524,7 @@ class OnAutoForwardedAction extends Disposable {
         message += this.linkMessage();
         this.lastNotification = this.notificationService.prompt(Severity$1.Info, message, choices, { neverShowAgain: { id: 'remote.tunnelsView.autoForwardNeverShow', isSecondary: true } });
         this.lastShownPort = tunnel.tunnelRemotePort;
-        this.lastNotifyTime = ( new Date());
+        this.lastNotifyTime = ( (new Date()));
         this.lastNotification.onDidClose(() => {
             this.lastNotification = undefined;
             this.lastShownPort = undefined;
@@ -553,11 +532,7 @@ class OnAutoForwardedAction extends Disposable {
     }
     makePublicChoice(tunnel) {
         return {
-            label: ( localizeWithPath(
-                'vs/workbench/contrib/remote/browser/remoteExplorer',
-                'remote.tunnelsView.makePublic',
-                "Make Public"
-            )),
+            label: ( localizeWithPath(_moduleId, 14, "Make Public")),
             run: async () => {
                 const oldTunnelDetails = mapHasAddressLocalhostOrAllInterfaces(this.remoteExplorerService.tunnelModel.forwarded, tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort);
                 await this.remoteExplorerService.close({ host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort }, TunnelCloseReason.Other);
@@ -588,12 +563,7 @@ class OnAutoForwardedAction extends Disposable {
     }
     elevateChoice(tunnel) {
         return {
-            label: ( localizeWithPath(
-                'vs/workbench/contrib/remote/browser/remoteExplorer',
-                'remote.tunnelsView.elevationButton',
-                "Use Port {0} as Sudo...",
-                tunnel.tunnelRemotePort
-            )),
+            label: ( localizeWithPath(_moduleId, 15, "Use Port {0} as Sudo...", tunnel.tunnelRemotePort)),
             run: async () => {
                 await this.remoteExplorerService.close({ host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort }, TunnelCloseReason.Other);
                 const newTunnel = await this.remoteExplorerService.forward({
@@ -631,7 +601,7 @@ class OutputAutomaticPortForwarding extends Disposable {
         this.logService = logService;
         this.contextKeyService = contextKeyService;
         this.privilegedOnly = privilegedOnly;
-        this.notifier = ( new OnAutoForwardedAction(
+        this.notifier = ( (new OnAutoForwardedAction(
             notificationService,
             remoteExplorerService,
             openerService,
@@ -640,7 +610,7 @@ class OutputAutomaticPortForwarding extends Disposable {
             hostService,
             logService,
             contextKeyService
-        ));
+        )));
         this._register(configurationService.onDidChangeConfiguration((e) => {
             if (e.affectsConfiguration(PORT_AUTO_FORWARD_SETTING)) {
                 this.tryStartStopUrlFinder();
@@ -667,7 +637,7 @@ class OutputAutomaticPortForwarding extends Disposable {
             return;
         }
         this.portsFeatures?.dispose();
-        this.urlFinder = this._register(( new UrlFinder(this.terminalService, this.debugService)));
+        this.urlFinder = this._register(( (new UrlFinder(this.terminalService, this.debugService))));
         this._register(this.urlFinder.onDidMatchLocalUrl(async (localUrl) => {
             if (mapHasAddressLocalhostOrAllInterfaces(this.remoteExplorerService.tunnelModel.detected, localUrl.host, localUrl.port)) {
                 return;
@@ -707,10 +677,10 @@ class ProcAutomaticPortForwarding extends Disposable {
         this.hostService = hostService;
         this.logService = logService;
         this.contextKeyService = contextKeyService;
-        this.autoForwarded = ( new Set());
-        this.notifiedOnly = ( new Set());
-        this.initialCandidates = ( new Set());
-        this.notifier = ( new OnAutoForwardedAction(
+        this.autoForwarded = ( (new Set()));
+        this.notifiedOnly = ( (new Set()));
+        this.initialCandidates = ( (new Set()));
+        this.notifier = ( (new OnAutoForwardedAction(
             notificationService,
             remoteExplorerService,
             openerService,
@@ -719,7 +689,7 @@ class ProcAutomaticPortForwarding extends Disposable {
             hostService,
             logService,
             contextKeyService
-        ));
+        )));
         alreadyAutoForwarded?.forEach(port => this.autoForwarded.add(port));
         this.initialize();
     }
@@ -728,9 +698,9 @@ class ProcAutomaticPortForwarding extends Disposable {
     }
     async initialize() {
         if (!this.remoteExplorerService.tunnelModel.environmentTunnelsSet) {
-            await ( new Promise(
+            await ( (new Promise(
                 resolve => this.remoteExplorerService.tunnelModel.onEnvironmentTunnelsSet(() => resolve())
-            ));
+            )));
         }
         this._register(this.configurationService.onDidChangeConfiguration(async (e) => {
             if (e.affectsConfiguration(PORT_AUTO_FORWARD_SETTING)) {
@@ -773,15 +743,15 @@ class ProcAutomaticPortForwarding extends Disposable {
         }
         let startingCandidates = this.remoteExplorerService.tunnelModel.candidatesOrUndefined;
         if (!startingCandidates) {
-            await ( new Promise(
+            await ( (new Promise(
                 resolve => this.remoteExplorerService.tunnelModel.onCandidatesChanged(() => resolve())
-            ));
+            )));
             startingCandidates = this.remoteExplorerService.tunnelModel.candidates;
         }
         for (const value of startingCandidates) {
             this.initialCandidates.add(makeAddress(value.host, value.port));
         }
-        this.logService.debug(`ForwardedPorts: (ProcForwarding) Initial candidates set to ${( startingCandidates.map(candidate => candidate.port)).join(', ')}`);
+        this.logService.debug(`ForwardedPorts: (ProcForwarding) Initial candidates set to ${( (startingCandidates.map(candidate => candidate.port))).join(', ')}`);
     }
     async forwardCandidates() {
         let attributes;
@@ -797,10 +767,10 @@ class ProcAutomaticPortForwarding extends Disposable {
             }
             const portAttributes = attributes?.get(value.port);
             const address = makeAddress(value.host, value.port);
-            if (( this.initialCandidates.has(address)) && (portAttributes?.onAutoForward === undefined)) {
+            if (( (this.initialCandidates.has(address))) && (portAttributes?.onAutoForward === undefined)) {
                 continue;
             }
-            if (( this.notifiedOnly.has(address)) || ( this.autoForwarded.has(address))) {
+            if (( (this.notifiedOnly.has(address))) || ( (this.autoForwarded.has(address)))) {
                 continue;
             }
             const alreadyForwarded = mapHasAddressLocalhostOrAllInterfaces(this.remoteExplorerService.tunnelModel.forwarded, value.host, value.port);
@@ -834,7 +804,7 @@ class ProcAutomaticPortForwarding extends Disposable {
         const removedPorts = [];
         let autoForwarded;
         if (this.unforwardOnly) {
-            autoForwarded = ( new Map());
+            autoForwarded = ( (new Map()));
             for (const entry of this.remoteExplorerService.tunnelModel.forwarded.entries()) {
                 if (entry[1].source.source === TunnelSource.Auto) {
                     autoForwarded.set(entry[0], entry[1]);
@@ -842,7 +812,7 @@ class ProcAutomaticPortForwarding extends Disposable {
             }
         }
         else {
-            autoForwarded = ( new Map(this.autoForwarded.entries()));
+            autoForwarded = ( (new Map(this.autoForwarded.entries())));
         }
         for (const removedPort of removed) {
             const key = removedPort[0];
@@ -858,11 +828,11 @@ class ProcAutomaticPortForwarding extends Disposable {
                 await this.remoteExplorerService.close(value, TunnelCloseReason.AutoForwardEnd);
                 removedPorts.push(value.port);
             }
-            else if (( this.notifiedOnly.has(key))) {
+            else if (( (this.notifiedOnly.has(key)))) {
                 this.notifiedOnly.delete(key);
                 removedPorts.push(value.port);
             }
-            else if (( this.initialCandidates.has(key))) {
+            else if (( (this.initialCandidates.has(key)))) {
                 this.initialCandidates.delete(key);
             }
         }