@codingame/monaco-vscode-views-service-override 1.83.1 → 1.83.2

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

@@ -46,7 +46,7 @@ import { defaultButtonStyles, defaultInputBoxStyles } from 'monaco-editor/esm/vs
 import { makeAddress, forwardedPortsViewEnabled, parseAddress, TunnelCloseReason, mapHasAddressLocalhostOrAllInterfaces } from 'vscode/vscode/vs/workbench/services/remote/common/tunnelModel';
 
 var TunnelPanel_1;
-const openPreviewEnabledContext = ( (new RawContextKey('openPreviewEnabled', false)));
+const openPreviewEnabledContext = ( new RawContextKey('openPreviewEnabled', false));
 class TunnelTreeVirtualDelegate {
     constructor(remoteExplorerService) {
         this.remoteExplorerService = remoteExplorerService;
@@ -84,11 +84,11 @@ class IconColumn {
 }
 class PortColumn {
     constructor() {
-        this.label = ( (nls.localize('tunnel.portColumn.label', "Port")));
-        this.tooltip = ( (nls.localize(
+        this.label = ( nls.localize('tunnel.portColumn.label', "Port"));
+        this.tooltip = ( nls.localize(
             'tunnel.portColumn.tooltip',
             "The label and remote port number of the forwarded port."
-        )));
+        ));
         this.weight = 1;
         this.templateId = 'actionbar';
     }
@@ -110,11 +110,11 @@ class PortColumn {
 }
 class LocalAddressColumn {
     constructor() {
-        this.label = ( (nls.localize('tunnel.addressColumn.label', "Forwarded Address")));
-        this.tooltip = ( (nls.localize(
+        this.label = ( nls.localize('tunnel.addressColumn.label', "Forwarded Address"));
+        this.tooltip = ( nls.localize(
             'tunnel.addressColumn.tooltip',
             "The address that the forwarded port is available at."
-        )));
+        ));
         this.weight = 1;
         this.templateId = 'actionbar';
     }
@@ -142,21 +142,21 @@ class LocalAddressColumn {
             let clickLabel = '';
             if (editorConf.multiCursorModifier === 'ctrlCmd') {
                 if (isMacintosh) {
-                    clickLabel = ( (nls.localize('portsLink.followLinkAlt.mac', "option + click")));
+                    clickLabel = ( nls.localize('portsLink.followLinkAlt.mac', "option + click"));
                 }
                 else {
-                    clickLabel = ( (nls.localize('portsLink.followLinkAlt', "alt + click")));
+                    clickLabel = ( nls.localize('portsLink.followLinkAlt', "alt + click"));
                 }
             }
             else {
                 if (isMacintosh) {
-                    clickLabel = ( (nls.localize('portsLink.followLinkCmd', "cmd + click")));
+                    clickLabel = ( nls.localize('portsLink.followLinkCmd', "cmd + click"));
                 }
                 else {
-                    clickLabel = ( (nls.localize('portsLink.followLinkCtrl', "ctrl + click")));
+                    clickLabel = ( nls.localize('portsLink.followLinkCtrl', "ctrl + click"));
                 }
             }
-            const markdown = ( (new MarkdownString('', true)));
+            const markdown = ( new MarkdownString('', true));
             const uri = localAddress.startsWith('http') ? localAddress : `http://${localAddress}`;
             return markdown.appendLink(uri, 'Follow link').appendMarkdown(` (${clickLabel})`);
         };
@@ -164,11 +164,11 @@ class LocalAddressColumn {
 }
 class RunningProcessColumn {
     constructor() {
-        this.label = ( (nls.localize('tunnel.processColumn.label', "Running Process")));
-        this.tooltip = ( (nls.localize(
+        this.label = ( nls.localize('tunnel.processColumn.label', "Running Process"));
+        this.tooltip = ( nls.localize(
             'tunnel.processColumn.tooltip',
             "The command line of the process that is using the port."
-        )));
+        ));
         this.weight = 2;
         this.templateId = 'actionbar';
     }
@@ -182,11 +182,11 @@ class RunningProcessColumn {
 }
 class OriginColumn {
     constructor() {
-        this.label = ( (nls.localize('tunnel.originColumn.label', "Origin")));
-        this.tooltip = ( (nls.localize(
+        this.label = ( nls.localize('tunnel.originColumn.label', "Origin"));
+        this.tooltip = ( nls.localize(
             'tunnel.originColumn.tooltip',
             "The source that a forwarded port originates from. Can be an extension, user forwarded, statically forwarded, or automatically forwarded."
-        )));
+        ));
         this.weight = 1;
         this.templateId = 'actionbar';
     }
@@ -201,8 +201,8 @@ class OriginColumn {
 }
 class PrivacyColumn {
     constructor() {
-        this.label = ( (nls.localize('tunnel.privacyColumn.label', "Visibility")));
-        this.tooltip = ( (nls.localize('tunnel.privacyColumn.tooltip', "The availability of the forwarded port.")));
+        this.label = ( nls.localize('tunnel.privacyColumn.label', "Visibility"));
+        this.tooltip = ( nls.localize('tunnel.privacyColumn.tooltip', "The availability of the forwarded port."));
         this.weight = 1;
         this.templateId = 'actionbar';
     }
@@ -237,17 +237,17 @@ let ActionBarRenderer = class ActionBarRenderer extends Disposable {
     renderTemplate(container) {
         const cell = dom.append(container, dom.$('.ports-view-actionbar-cell'));
         const icon = dom.append(cell, dom.$('.ports-view-actionbar-cell-icon'));
-        const label = ( (new IconLabel(cell, {
+        const label = ( new IconLabel(cell, {
             supportHighlights: true,
             hoverDelegate: {
                 showHover: (options) => this.hoverService.showHover(options),
                 delay: this.configurationService.getValue('workbench.hover.delay')
             }
-        })));
+        }));
         const actionsContainer = dom.append(cell, dom.$('.actions'));
-        const actionBar = ( (new ActionBar(actionsContainer, {
+        const actionBar = ( new ActionBar(actionsContainer, {
             actionViewItemProvider: createActionViewItem.bind(undefined, this.instantiationService)
-        })));
+        }));
         return { label, icon, actionBar, container: cell, elementDisposable: Disposable.None };
     }
     renderElement(element, index, templateData) {
@@ -283,7 +283,7 @@ let ActionBarRenderer = class ActionBarRenderer extends Disposable {
     renderButton(element, templateData) {
         templateData.container.style.paddingLeft = '7px';
         templateData.container.style.height = '28px';
-        templateData.button = this._register(( (new Button(templateData.container, defaultButtonStyles))));
+        templateData.button = this._register(( new Button(templateData.container, defaultButtonStyles)));
         templateData.button.label = element.label;
         templateData.button.element.title = element.tooltip;
         this._register(templateData.button.onDidClick(() => {
@@ -332,7 +332,7 @@ let ActionBarRenderer = class ActionBarRenderer extends Disposable {
             [TunnelProtocolContextKey.key, element.tunnel.protocol]
         ];
         const contextKeyService = this.contextKeyService.createOverlay(context);
-        const disposableStore = ( (new DisposableStore()));
+        const disposableStore = ( new DisposableStore());
         templateData.elementDisposable = disposableStore;
         if (element.menuId) {
             const menu = disposableStore.add(this.menuService.createMenu(element.menuId, contextKeyService));
@@ -364,8 +364,8 @@ let ActionBarRenderer = class ActionBarRenderer extends Disposable {
         }
         container.style.paddingLeft = '5px';
         const value = editableData.startingValue || '';
-        const inputBox = ( (new InputBox(container, this.contextViewService, {
-            ariaLabel: ( (nls.localize('remote.tunnelsView.input', "Press Enter to confirm or Escape to cancel."))),
+        const inputBox = ( new InputBox(container, this.contextViewService, {
+            ariaLabel: ( nls.localize('remote.tunnelsView.input', "Press Enter to confirm or Escape to cancel.")),
             validationOptions: {
                 validation: (value) => {
                     const message = editableData.validationMessage(value);
@@ -381,7 +381,7 @@ let ActionBarRenderer = class ActionBarRenderer extends Disposable {
             },
             placeholder: editableData.placeholder || '',
             inputBoxStyles: defaultInputBoxStyles
-        })));
+        }));
         inputBox.value = value;
         inputBox.focus();
         inputBox.select({ start: 0, end: editableData.startingValue ? editableData.startingValue.length : 0 });
@@ -433,58 +433,54 @@ let ActionBarRenderer = class ActionBarRenderer extends Disposable {
         templateData.button?.dispose();
     }
 };
-ActionBarRenderer = ( (__decorate([
-    ( (__param(0, IInstantiationService))),
-    ( (__param(1, IContextKeyService))),
-    ( (__param(2, IMenuService))),
-    ( (__param(3, IContextViewService))),
-    ( (__param(4, IRemoteExplorerService))),
-    ( (__param(5, ICommandService))),
-    ( (__param(6, IConfigurationService))),
-    ( (__param(7, IHoverService)))
-], ActionBarRenderer)));
+ActionBarRenderer = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IContextKeyService)),
+    ( __param(2, IMenuService)),
+    ( __param(3, IContextViewService)),
+    ( __param(4, IRemoteExplorerService)),
+    ( __param(5, ICommandService)),
+    ( __param(6, IConfigurationService)),
+    ( __param(7, IHoverService))
+], ActionBarRenderer));
 class TunnelItem {
     static createFromTunnel(remoteExplorerService, tunnelService, tunnel, type = TunnelType.Forwarded, closeable) {
-        return (
-             (new TunnelItem(
-                type,
-                tunnel.remoteHost,
-                tunnel.remotePort,
-                tunnel.source,
-                !!tunnel.hasRunningProcess,
-                tunnel.protocol,
-                tunnel.localUri,
-                tunnel.localAddress,
-                tunnel.localPort,
-                closeable === undefined ? tunnel.closeable : closeable,
-                tunnel.name,
-                tunnel.runningProcess,
-                tunnel.pid,
-                tunnel.privacy,
-                remoteExplorerService,
-                tunnelService
-            ))
-        );
+        return ( new TunnelItem(
+            type,
+            tunnel.remoteHost,
+            tunnel.remotePort,
+            tunnel.source,
+            !!tunnel.hasRunningProcess,
+            tunnel.protocol,
+            tunnel.localUri,
+            tunnel.localAddress,
+            tunnel.localPort,
+            closeable === undefined ? tunnel.closeable : closeable,
+            tunnel.name,
+            tunnel.runningProcess,
+            tunnel.pid,
+            tunnel.privacy,
+            remoteExplorerService,
+            tunnelService
+        ));
     }
     strip() {
-        return (
-             (new TunnelItem(
-                this.tunnelType,
-                this.remoteHost,
-                this.remotePort,
-                this.source,
-                this.hasRunningProcess,
-                this.protocol,
-                this.localUri,
-                this.localAddress,
-                this.localPort,
-                this.closeable,
-                this.name,
-                this.runningProcess,
-                this.pid,
-                this._privacy
-            ))
-        );
+        return ( new TunnelItem(
+            this.tunnelType,
+            this.remoteHost,
+            this.remotePort,
+            this.source,
+            this.hasRunningProcess,
+            this.protocol,
+            this.localUri,
+            this.localAddress,
+            this.localPort,
+            this.closeable,
+            this.name,
+            this.runningProcess,
+            this.pid,
+            this._privacy
+        ));
     }
     constructor(tunnelType, remoteHost, remotePort, source, hasRunningProcess, protocol, localUri, localAddress, localPort, closeable, name, runningProcess, pid, _privacy, remoteExplorerService, tunnelService) {
         this.tunnelType = tunnelType;
@@ -535,36 +531,36 @@ class TunnelItem {
             }
         }
         else if (this.hasRunningProcess) {
-            description = ( (nls.localize('tunnelView.runningProcess.inacessable', "Process information unavailable")));
+            description = ( nls.localize('tunnelView.runningProcess.inacessable', "Process information unavailable"));
         }
         return description;
     }
     get tooltipPostfix() {
         let information;
         if (this.localAddress) {
-            information = ( (nls.localize(
+            information = ( nls.localize(
                 'remote.tunnel.tooltipForwarded',
                 "Remote port {0}:{1} forwarded to local address {2}. ",
                 this.remoteHost,
                 this.remotePort,
                 this.localAddress
-            )));
+            ));
         }
         else {
-            information = ( (nls.localize(
+            information = ( nls.localize(
                 'remote.tunnel.tooltipCandidate',
                 "Remote port {0}:{1} not forwarded. ",
                 this.remoteHost,
                 this.remotePort
-            )));
+            ));
         }
         return information;
     }
     get iconTooltip() {
         const isAdd = this.tunnelType === TunnelType.Add;
         if (!isAdd) {
-            return `${this.processDescription ? ( ( nls.localize('tunnel.iconColumn.running', "Port has running process."))) :
-                ( ( nls.localize('tunnel.iconColumn.notRunning', "No running process.")))}`;
+            return `${this.processDescription ? ( nls.localize('tunnel.iconColumn.running', "Port has running process.")) :
+                ( nls.localize('tunnel.iconColumn.notRunning', "No running process."))}`;
         }
         else {
             return this.label;
@@ -573,7 +569,7 @@ class TunnelItem {
     get portTooltip() {
         const isAdd = this.tunnelType === TunnelType.Add;
         if (!isAdd) {
-            return `${this.name ? ( ( nls.localize('remote.tunnel.tooltipName', "Port labeled {0}. ", this.name))) : ''}`;
+            return `${this.name ? ( nls.localize('remote.tunnel.tooltipName', "Port labeled {0}. ", this.name)) : ''}`;
         }
         else {
             return '';
@@ -591,37 +587,33 @@ class TunnelItem {
                 {
                     id: '',
                     themeIcon: Codicon.question.id,
-                    label: ( (nls.localize('tunnelPrivacy.unknown', "Unknown")))
+                    label: ( nls.localize('tunnelPrivacy.unknown', "Unknown"))
                 };
         }
         else {
             return {
                 id: TunnelPrivacyId.Private,
                 themeIcon: privatePortIcon.id,
-                label: ( (nls.localize('tunnelPrivacy.private', "Private")))
+                label: ( nls.localize('tunnelPrivacy.private', "Private"))
             };
         }
     }
 }
-const TunnelTypeContextKey = ( (new RawContextKey('tunnelType', TunnelType.Add, true)));
-const TunnelCloseableContextKey = ( (new RawContextKey('tunnelCloseable', false, true)));
-const TunnelPrivacyContextKey = ( (new RawContextKey('tunnelPrivacy', undefined, true)));
-const TunnelPrivacyEnabledContextKey = ( (new RawContextKey('tunnelPrivacyEnabled', false, true)));
-const TunnelProtocolContextKey = ( (new RawContextKey('tunnelProtocol', TunnelProtocol.Http, true)));
-const TunnelViewFocusContextKey = ( (new RawContextKey(
-    'tunnelViewFocus',
-    false,
-     (nls.localize('tunnel.focusContext', "Whether the Ports view has focus."))
-)));
+const TunnelTypeContextKey = ( new RawContextKey('tunnelType', TunnelType.Add, true));
+const TunnelCloseableContextKey = ( new RawContextKey('tunnelCloseable', false, true));
+const TunnelPrivacyContextKey = ( new RawContextKey('tunnelPrivacy', undefined, true));
+const TunnelPrivacyEnabledContextKey = ( new RawContextKey('tunnelPrivacyEnabled', false, true));
+const TunnelProtocolContextKey = ( new RawContextKey('tunnelProtocol', TunnelProtocol.Http, true));
+const TunnelViewFocusContextKey = ( new RawContextKey('tunnelViewFocus', false, ( nls.localize('tunnel.focusContext', "Whether the Ports view has focus."))));
 const TunnelViewSelectionKeyName = 'tunnelViewSelection';
-const TunnelViewSelectionContextKey = ( (new RawContextKey(TunnelViewSelectionKeyName, undefined, true)));
+const TunnelViewSelectionContextKey = ( new RawContextKey(TunnelViewSelectionKeyName, undefined, true));
 const TunnelViewMultiSelectionKeyName = 'tunnelViewMultiSelection';
-const TunnelViewMultiSelectionContextKey = ( (new RawContextKey(TunnelViewMultiSelectionKeyName, undefined, true)));
-const PortChangableContextKey = ( (new RawContextKey('portChangable', false, true)));
+const TunnelViewMultiSelectionContextKey = ( new RawContextKey(TunnelViewMultiSelectionKeyName, undefined, true));
+const PortChangableContextKey = ( new RawContextKey('portChangable', false, true));
 let TunnelPanel = class TunnelPanel extends ViewPane {
     static { TunnelPanel_1 = this; }
     static { this.ID = TUNNEL_VIEW_ID; }
-    static { this.TITLE = ( (nls.localize('remote.tunnel', "Ports"))); }
+    static { this.TITLE = ( nls.localize('remote.tunnel', "Ports")); }
     constructor(viewModel, options, keybindingService, contextMenuService, contextKeyService, configurationService, instantiationService, viewDescriptorService, openerService, quickInputService, commandService, menuService, themeService, remoteExplorerService, telemetryService, tunnelService, contextViewService, hoverService) {
         super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
         this.viewModel = viewModel;
@@ -632,7 +624,7 @@ let TunnelPanel = class TunnelPanel extends ViewPane {
         this.tunnelService = tunnelService;
         this.contextViewService = contextViewService;
         this.hoverService = hoverService;
-        this.tableDisposables = this._register(( (new DisposableStore())));
+        this.tableDisposables = this._register(( new DisposableStore()));
         this.isEditing = false;
         this.titleActions = [];
         this.lastFocus = [];
@@ -680,7 +672,7 @@ let TunnelPanel = class TunnelPanel extends ViewPane {
                 command: {
                     id: optionId,
                     title: privacyOption.label,
-                    toggled: ( (TunnelPrivacyContextKey.isEqualTo(privacyOption.id)))
+                    toggled: ( TunnelPrivacyContextKey.isEqualTo(privacyOption.id))
                 }
             }));
         }
@@ -697,7 +689,7 @@ let TunnelPanel = class TunnelPanel extends ViewPane {
         const widgetContainer = dom.append(this.panelContainer, dom.$('.customview-tree'));
         widgetContainer.classList.add('ports-view');
         widgetContainer.classList.add('file-icon-themable-tree', 'show-file-icons');
-        const actionBarRenderer = ( (new ActionBarRenderer(
+        const actionBarRenderer = ( new ActionBarRenderer(
             this.instantiationService,
             this.contextKeyService,
             this.menuService,
@@ -706,13 +698,13 @@ let TunnelPanel = class TunnelPanel extends ViewPane {
             this.commandService,
             this.configurationService,
             this.hoverService
-        )));
-        const columns = [( (new IconColumn())), ( (new PortColumn())), ( (new LocalAddressColumn())), ( (new RunningProcessColumn()))];
+        ));
+        const columns = [( new IconColumn()), ( new PortColumn()), ( new LocalAddressColumn()), ( new RunningProcessColumn())];
         if (this.tunnelService.canChangePrivacy) {
-            columns.push(( (new PrivacyColumn())));
+            columns.push(( new PrivacyColumn()));
         }
-        columns.push(( (new OriginColumn())));
-        this.table = this.instantiationService.createInstance(WorkbenchTable, 'RemoteTunnels', widgetContainer, ( (new TunnelTreeVirtualDelegate(this.remoteExplorerService))), columns, [actionBarRenderer], {
+        columns.push(( new OriginColumn()));
+        this.table = this.instantiationService.createInstance(WorkbenchTable, 'RemoteTunnels', widgetContainer, ( new TunnelTreeVirtualDelegate(this.remoteExplorerService)), columns, [actionBarRenderer], {
             keyboardNavigationLabelProvider: {
                 getKeyboardNavigationLabel: (item) => {
                     return item.label;
@@ -728,11 +720,11 @@ let TunnelPanel = class TunnelPanel extends ViewPane {
                         return item.label;
                     }
                 },
-                getWidgetAriaLabel: () => ( (nls.localize('tunnelView', "Tunnel View")))
+                getWidgetAriaLabel: () => ( nls.localize('tunnelView', "Tunnel View"))
             },
             openOnSingleClick: true
         });
-        const actionRunner = ( (new ActionRunner()));
+        const actionRunner = ( new ActionRunner());
         actionBarRenderer.actionRunner = actionRunner;
         this.tableDisposables.add(this.table);
         this.tableDisposables.add(this.table.onContextMenu(e => this.onContextMenu(e, actionRunner)));
@@ -844,7 +836,7 @@ let TunnelPanel = class TunnelPanel extends ViewPane {
     onSelectionChanged(event) {
         const elements = event.elements;
         if (elements.length > 1) {
-            this.tunnelViewMultiSelectionContext.set(( (elements.map(element => makeAddress(element.remoteHost, element.remotePort)))));
+            this.tunnelViewMultiSelectionContext.set(( elements.map(element => makeAddress(element.remoteHost, element.remotePort))));
         }
         else {
             this.tunnelViewMultiSelectionContext.set(undefined);
@@ -880,9 +872,7 @@ let TunnelPanel = class TunnelPanel extends ViewPane {
             getActionViewItem: (action) => {
                 const keybinding = this.keybindingService.lookupKeybinding(action.id);
                 if (keybinding) {
-                    return (
-                         (new ActionViewItem(action, action, { label: true, keybinding: keybinding.getLabel() }))
-                    );
+                    return ( new ActionViewItem(action, action, { label: true, keybinding: keybinding.getLabel() }));
                 }
                 return undefined;
             },
@@ -907,31 +897,31 @@ let TunnelPanel = class TunnelPanel extends ViewPane {
         this.table.layout(height, width);
     }
 };
-TunnelPanel = TunnelPanel_1 = ( (__decorate([
-    ( (__param(2, IKeybindingService))),
-    ( (__param(3, IContextMenuService))),
-    ( (__param(4, IContextKeyService))),
-    ( (__param(5, IConfigurationService))),
-    ( (__param(6, IInstantiationService))),
-    ( (__param(7, IViewDescriptorService))),
-    ( (__param(8, IOpenerService))),
-    ( (__param(9, IQuickInputService))),
-    ( (__param(10, ICommandService))),
-    ( (__param(11, IMenuService))),
-    ( (__param(12, IThemeService))),
-    ( (__param(13, IRemoteExplorerService))),
-    ( (__param(14, ITelemetryService))),
-    ( (__param(15, ITunnelService))),
-    ( (__param(16, IContextViewService))),
-    ( (__param(17, IHoverService)))
-], TunnelPanel)));
+TunnelPanel = TunnelPanel_1 = ( __decorate([
+    ( __param(2, IKeybindingService)),
+    ( __param(3, IContextMenuService)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, IViewDescriptorService)),
+    ( __param(8, IOpenerService)),
+    ( __param(9, IQuickInputService)),
+    ( __param(10, ICommandService)),
+    ( __param(11, IMenuService)),
+    ( __param(12, IThemeService)),
+    ( __param(13, IRemoteExplorerService)),
+    ( __param(14, ITelemetryService)),
+    ( __param(15, ITunnelService)),
+    ( __param(16, IContextViewService)),
+    ( __param(17, IHoverService))
+], TunnelPanel));
 function isITunnelItem(item) {
     return item && item.tunnelType && item.remoteHost && item.source;
 }
 var LabelTunnelAction;
-( ((function(LabelTunnelAction) {
+( (function(LabelTunnelAction) {
     LabelTunnelAction.ID = 'remote.tunnel.label';
-    LabelTunnelAction.LABEL = ( (nls.localize('remote.tunnel.label', "Set Port Label")));
+    LabelTunnelAction.LABEL = ( nls.localize('remote.tunnel.label', "Set Port Label"));
     LabelTunnelAction.COMMAND_ID_KEYWORD = 'label';
     function handler() {
         return async (accessor, arg) => {
@@ -950,53 +940,51 @@ var LabelTunnelAction;
             }
             if (tunnelContext) {
                 const tunnelItem = tunnelContext;
-                return (
-                     (new Promise(resolve => {
-                        const startingValue = tunnelItem.name ? tunnelItem.name : `${tunnelItem.remotePort}`;
-                        remoteExplorerService.setEditable(tunnelItem, TunnelEditId.Label, {
-                            onFinish: async (value, success) => {
-                                value = value.trim();
-                                remoteExplorerService.setEditable(tunnelItem, TunnelEditId.Label, null);
-                                const changed = success && (value !== startingValue);
-                                if (changed) {
-                                    await remoteExplorerService.tunnelModel.name(tunnelItem.remoteHost, tunnelItem.remotePort, value);
-                                }
-                                resolve(changed ? { port: tunnelItem.remotePort, label: value } : undefined);
-                            },
-                            validationMessage: () => null,
-                            placeholder: ( (nls.localize('remote.tunnelsView.labelPlaceholder', "Port label"))),
-                            startingValue
-                        });
-                    }))
-                );
+                return ( new Promise(resolve => {
+                    const startingValue = tunnelItem.name ? tunnelItem.name : `${tunnelItem.remotePort}`;
+                    remoteExplorerService.setEditable(tunnelItem, TunnelEditId.Label, {
+                        onFinish: async (value, success) => {
+                            value = value.trim();
+                            remoteExplorerService.setEditable(tunnelItem, TunnelEditId.Label, null);
+                            const changed = success && (value !== startingValue);
+                            if (changed) {
+                                await remoteExplorerService.tunnelModel.name(tunnelItem.remoteHost, tunnelItem.remotePort, value);
+                            }
+                            resolve(changed ? { port: tunnelItem.remotePort, label: value } : undefined);
+                        },
+                        validationMessage: () => null,
+                        placeholder: ( nls.localize('remote.tunnelsView.labelPlaceholder', "Port label")),
+                        startingValue
+                    });
+                }));
             }
             return undefined;
         };
     }
     LabelTunnelAction.handler = handler;
-})(LabelTunnelAction || (LabelTunnelAction = {}))));
-const invalidPortString = ( (nls.localize(
+})(LabelTunnelAction || (LabelTunnelAction = {})));
+const invalidPortString = ( nls.localize(
     'remote.tunnelsView.portNumberValid',
     "Forwarded port should be a number or a host:port."
-)));
+));
 const maxPortNumber = 65536;
-const invalidPortNumberString = ( (nls.localize(
+const invalidPortNumberString = ( nls.localize(
     'remote.tunnelsView.portNumberToHigh',
     "Port number must be \u2265 0 and < {0}.",
     maxPortNumber
-)));
-const requiresSudoString = ( (nls.localize('remote.tunnelView.inlineElevationMessage', "May Require Sudo")));
-const alreadyForwarded = ( (nls.localize('remote.tunnelView.alreadyForwarded', "Port is already forwarded")));
+));
+const requiresSudoString = ( nls.localize('remote.tunnelView.inlineElevationMessage', "May Require Sudo"));
+const alreadyForwarded = ( nls.localize('remote.tunnelView.alreadyForwarded', "Port is already forwarded"));
 var ForwardPortAction;
-( ((function(ForwardPortAction) {
+( (function(ForwardPortAction) {
     ForwardPortAction.INLINE_ID = 'remote.tunnel.forwardInline';
     ForwardPortAction.COMMANDPALETTE_ID = 'remote.tunnel.forwardCommandPalette';
-    ForwardPortAction.LABEL = { value: ( (nls.localize('remote.tunnel.forward', "Forward a Port"))), original: 'Forward a Port' };
-    ForwardPortAction.TREEITEM_LABEL = ( (nls.localize('remote.tunnel.forwardItem', "Forward Port")));
-    const forwardPrompt = ( (nls.localize(
+    ForwardPortAction.LABEL = { value: ( nls.localize('remote.tunnel.forward', "Forward a Port")), original: 'Forward a Port' };
+    ForwardPortAction.TREEITEM_LABEL = ( nls.localize('remote.tunnel.forwardItem', "Forward Port"));
+    const forwardPrompt = ( nls.localize(
         'remote.tunnel.forwardPrompt',
         "Port number or address (eg. 3000 or 10.10.10.10:2000)."
-    )));
+    ));
     function validateInput(remoteExplorerService, tunnelService, value, canElevate) {
         const parsed = parseAddress(value);
         if (!parsed) {
@@ -1015,21 +1003,21 @@ var ForwardPortAction;
     }
     function error(notificationService, tunnelOrError, host, port) {
         if (!tunnelOrError) {
-            notificationService.warn(( (nls.localize(
+            notificationService.warn(( nls.localize(
                 'remote.tunnel.forwardError',
                 "Unable to forward {0}:{1}. The host may not be available or that remote port may already be forwarded",
                 host,
                 port
-            ))));
+            )));
         }
         else if (typeof tunnelOrError === 'string') {
-            notificationService.warn(( (nls.localize(
+            notificationService.warn(( nls.localize(
                 'remote.tunnel.forwardErrorProvided',
                 "Unable to forward {0}:{1}. {2}",
                 host,
                 port,
                 tunnelOrError
-            ))));
+            )));
         }
     }
     function inlineHandler() {
@@ -1076,32 +1064,32 @@ var ForwardPortAction;
         };
     }
     ForwardPortAction.commandPaletteHandler = commandPaletteHandler;
-})(ForwardPortAction || (ForwardPortAction = {}))));
+})(ForwardPortAction || (ForwardPortAction = {})));
 function makeTunnelPicks(tunnels, remoteExplorerService, tunnelService) {
-    const picks = ( (tunnels.map(forwarded => {
+    const picks = ( tunnels.map(forwarded => {
         const item = TunnelItem.createFromTunnel(remoteExplorerService, tunnelService, forwarded);
         return {
             label: item.label,
             description: item.processDescription,
             tunnel: item
         };
-    })));
+    }));
     if (picks.length === 0) {
         picks.push({
-            label: ( (nls.localize(
+            label: ( nls.localize(
                 'remote.tunnel.closeNoPorts',
                 "No ports currently forwarded. Try running the {0} command",
                 ForwardPortAction.LABEL.value
-            )))
+            ))
         });
     }
     return picks;
 }
 var ClosePortAction;
-( ((function(ClosePortAction) {
+( (function(ClosePortAction) {
     ClosePortAction.INLINE_ID = 'remote.tunnel.closeInline';
     ClosePortAction.COMMANDPALETTE_ID = 'remote.tunnel.closeCommandPalette';
-    ClosePortAction.LABEL = { value: ( (nls.localize('remote.tunnel.close', "Stop Forwarding Port"))), original: 'Stop Forwarding Port' };
+    ClosePortAction.LABEL = { value: ( nls.localize('remote.tunnel.close', "Stop Forwarding Port")), original: 'Stop Forwarding Port' };
     function inlineHandler() {
         return async (accessor, arg) => {
             const contextKeyService = accessor.get(IContextKeyService);
@@ -1129,9 +1117,9 @@ var ClosePortAction;
             if (!ports || ports.length === 0) {
                 return;
             }
-            return Promise.all(( (ports.map(
+            return Promise.all(( ports.map(
                 port => remoteExplorerService.close({ host: port.remoteHost, port: port.remotePort }, TunnelCloseReason.User)
-            ))));
+            )));
         };
     }
     ClosePortAction.inlineHandler = inlineHandler;
@@ -1141,8 +1129,8 @@ var ClosePortAction;
             const remoteExplorerService = accessor.get(IRemoteExplorerService);
             const tunnelService = accessor.get(ITunnelService);
             const commandService = accessor.get(ICommandService);
-            const picks = makeTunnelPicks(Array.from(( (remoteExplorerService.tunnelModel.forwarded.values()))).filter(tunnel => tunnel.closeable), remoteExplorerService, tunnelService);
-            const result = await quickInputService.pick(picks, { placeHolder: ( (nls.localize('remote.tunnel.closePlaceholder', "Choose a port to stop forwarding"))) });
+            const picks = makeTunnelPicks(Array.from(( remoteExplorerService.tunnelModel.forwarded.values())).filter(tunnel => tunnel.closeable), remoteExplorerService, tunnelService);
+            const result = await quickInputService.pick(picks, { placeHolder: ( nls.localize('remote.tunnel.closePlaceholder', "Choose a port to stop forwarding")) });
             if (result && result.tunnel) {
                 await remoteExplorerService.close({ host: result.tunnel.remoteHost, port: result.tunnel.remotePort }, TunnelCloseReason.User);
             }
@@ -1152,11 +1140,11 @@ var ClosePortAction;
         };
     }
     ClosePortAction.commandPaletteHandler = commandPaletteHandler;
-})(ClosePortAction || (ClosePortAction = {}))));
+})(ClosePortAction || (ClosePortAction = {})));
 var OpenPortInBrowserAction;
-( ((function(OpenPortInBrowserAction) {
+( (function(OpenPortInBrowserAction) {
     OpenPortInBrowserAction.ID = 'remote.tunnel.open';
-    OpenPortInBrowserAction.LABEL = ( (nls.localize('remote.tunnel.open', "Open in Browser")));
+    OpenPortInBrowserAction.LABEL = ( nls.localize('remote.tunnel.open', "Open in Browser"));
     function handler() {
         return async (accessor, arg) => {
             let key;
@@ -1182,11 +1170,11 @@ var OpenPortInBrowserAction;
         return Promise.resolve();
     }
     OpenPortInBrowserAction.run = run;
-})(OpenPortInBrowserAction || (OpenPortInBrowserAction = {}))));
+})(OpenPortInBrowserAction || (OpenPortInBrowserAction = {})));
 var OpenPortInPreviewAction;
-( ((function(OpenPortInPreviewAction) {
+( (function(OpenPortInPreviewAction) {
     OpenPortInPreviewAction.ID = 'remote.tunnel.openPreview';
-    OpenPortInPreviewAction.LABEL = ( (nls.localize('remote.tunnel.openPreview', "Preview in Editor")));
+    OpenPortInPreviewAction.LABEL = ( nls.localize('remote.tunnel.openPreview', "Preview in Editor"));
     function handler() {
         return async (accessor, arg) => {
             let key;
@@ -1209,21 +1197,21 @@ var OpenPortInPreviewAction;
         const tunnel = model.forwarded.get(key) || model.detected.get(key);
         if (tunnel) {
             const remoteHost = tunnel.remoteHost.includes(':') ? `[${tunnel.remoteHost}]` : tunnel.remoteHost;
-            const sourceUri = ( (URI.parse(`http://${remoteHost}:${tunnel.remotePort}`)));
-            const opener = await externalOpenerService.getOpener(tunnel.localUri, { sourceUri }, ( (new CancellationTokenSource())).token);
+            const sourceUri = ( URI.parse(`http://${remoteHost}:${tunnel.remotePort}`));
+            const opener = await externalOpenerService.getOpener(tunnel.localUri, { sourceUri }, ( new CancellationTokenSource()).token);
             if (opener) {
-                return opener.openExternalUri(tunnel.localUri, { sourceUri }, ( (new CancellationTokenSource())).token);
+                return opener.openExternalUri(tunnel.localUri, { sourceUri }, ( new CancellationTokenSource()).token);
             }
             return openerService.open(tunnel.localUri);
         }
         return Promise.resolve();
     }
     OpenPortInPreviewAction.run = run;
-})(OpenPortInPreviewAction || (OpenPortInPreviewAction = {}))));
+})(OpenPortInPreviewAction || (OpenPortInPreviewAction = {})));
 var OpenPortInBrowserCommandPaletteAction;
-( ((function(OpenPortInBrowserCommandPaletteAction) {
+( (function(OpenPortInBrowserCommandPaletteAction) {
     OpenPortInBrowserCommandPaletteAction.ID = 'remote.tunnel.openCommandPalette';
-    OpenPortInBrowserCommandPaletteAction.LABEL = ( (nls.localize('remote.tunnel.openCommandPalette', "Open Port in Browser")));
+    OpenPortInBrowserCommandPaletteAction.LABEL = ( nls.localize('remote.tunnel.openCommandPalette', "Open Port in Browser"));
     function handler() {
         return async (accessor, arg) => {
             const remoteExplorerService = accessor.get(IRemoteExplorerService);
@@ -1232,28 +1220,28 @@ var OpenPortInBrowserCommandPaletteAction;
             const quickPickService = accessor.get(IQuickInputService);
             const openerService = accessor.get(IOpenerService);
             const commandService = accessor.get(ICommandService);
-            const options = ( ([...model.forwarded, ...model.detected].map(value => {
+            const options = ( [...model.forwarded, ...model.detected].map(value => {
                 const tunnelItem = TunnelItem.createFromTunnel(remoteExplorerService, tunnelService, value[1]);
                 return {
                     label: tunnelItem.label,
                     description: tunnelItem.processDescription,
                     tunnel: tunnelItem
                 };
-            })));
+            }));
             if (options.length === 0) {
                 options.push({
-                    label: ( (nls.localize(
+                    label: ( nls.localize(
                         'remote.tunnel.openCommandPaletteNone',
                         "No ports currently forwarded. Open the Ports view to get started."
-                    )))
+                    ))
                 });
             }
             else {
                 options.push({
-                    label: ( (nls.localize('remote.tunnel.openCommandPaletteView', "Open the Ports view...")))
+                    label: ( nls.localize('remote.tunnel.openCommandPaletteView', "Open the Ports view..."))
                 });
             }
-            const picked = await quickPickService.pick(options, { placeHolder: ( (nls.localize('remote.tunnel.openCommandPalettePick', "Choose the port to open"))) });
+            const picked = await quickPickService.pick(options, { placeHolder: ( nls.localize('remote.tunnel.openCommandPalettePick', "Choose the port to open")) });
             if (picked && picked.tunnel) {
                 return OpenPortInBrowserAction.run(model, openerService, makeAddress(picked.tunnel.remoteHost, picked.tunnel.remotePort));
             }
@@ -1265,17 +1253,17 @@ var OpenPortInBrowserCommandPaletteAction;
     OpenPortInBrowserCommandPaletteAction.handler = handler;
 })(
     OpenPortInBrowserCommandPaletteAction || (OpenPortInBrowserCommandPaletteAction = {})
-)));
+));
 var CopyAddressAction;
-( ((function(CopyAddressAction) {
+( (function(CopyAddressAction) {
     CopyAddressAction.INLINE_ID = 'remote.tunnel.copyAddressInline';
     CopyAddressAction.COMMANDPALETTE_ID = 'remote.tunnel.copyAddressCommandPalette';
-    CopyAddressAction.INLINE_LABEL = ( (nls.localize('remote.tunnel.copyAddressInline', "Copy Local Address")));
-    CopyAddressAction.COMMANDPALETTE_LABEL = ( (nls.localize('remote.tunnel.copyAddressCommandPalette', "Copy Forwarded Port Address")));
+    CopyAddressAction.INLINE_LABEL = ( nls.localize('remote.tunnel.copyAddressInline', "Copy Local Address"));
+    CopyAddressAction.COMMANDPALETTE_LABEL = ( nls.localize('remote.tunnel.copyAddressCommandPalette', "Copy Forwarded Port Address"));
     async function copyAddress(remoteExplorerService, clipboardService, tunnelItem) {
         const address = remoteExplorerService.tunnelModel.address(tunnelItem.remoteHost, tunnelItem.remotePort);
         if (address) {
-            await clipboardService.writeText(( (address.toString())));
+            await clipboardService.writeText(( address.toString()));
         }
     }
     function inlineHandler() {
@@ -1302,8 +1290,8 @@ var CopyAddressAction;
             const tunnelService = accessor.get(ITunnelService);
             const commandService = accessor.get(ICommandService);
             const clipboardService = accessor.get(IClipboardService);
-            const tunnels = Array.from(( (remoteExplorerService.tunnelModel.forwarded.values()))).concat(Array.from(( (remoteExplorerService.tunnelModel.detected.values()))));
-            const result = await quickInputService.pick(makeTunnelPicks(tunnels, remoteExplorerService, tunnelService), { placeHolder: ( (nls.localize('remote.tunnel.copyAddressPlaceholdter', "Choose a forwarded port"))) });
+            const tunnels = Array.from(( remoteExplorerService.tunnelModel.forwarded.values())).concat(Array.from(( remoteExplorerService.tunnelModel.detected.values())));
+            const result = await quickInputService.pick(makeTunnelPicks(tunnels, remoteExplorerService, tunnelService), { placeHolder: ( nls.localize('remote.tunnel.copyAddressPlaceholdter', "Choose a forwarded port")) });
             if (result && result.tunnel) {
                 await copyAddress(remoteExplorerService, clipboardService, result.tunnel);
             }
@@ -1313,14 +1301,14 @@ var CopyAddressAction;
         };
     }
     CopyAddressAction.commandPaletteHandler = commandPaletteHandler;
-})(CopyAddressAction || (CopyAddressAction = {}))));
+})(CopyAddressAction || (CopyAddressAction = {})));
 var ChangeLocalPortAction;
-( ((function(ChangeLocalPortAction) {
+( (function(ChangeLocalPortAction) {
     ChangeLocalPortAction.ID = 'remote.tunnel.changeLocalPort';
-    ChangeLocalPortAction.LABEL = ( (nls.localize('remote.tunnel.changeLocalPort', "Change Local Address Port")));
+    ChangeLocalPortAction.LABEL = ( nls.localize('remote.tunnel.changeLocalPort', "Change Local Address Port"));
     function validateInput(tunnelService, value, canElevate) {
         if (!value.match(/^[0-9]+$/)) {
-            return { content: ( (nls.localize('remote.tunnelsView.portShouldBeNumber', "Local port should be a number."))), severity: Severity.Error };
+            return { content: ( nls.localize('remote.tunnelsView.portShouldBeNumber', "Local port should be a number.")), severity: Severity.Error };
         }
         else if (Number(value) >= maxPortNumber) {
             return { content: invalidPortNumberString, severity: Severity.Error };
@@ -1363,25 +1351,25 @@ var ChangeLocalPortAction;
                                 source: tunnelItem.source
                             });
                             if (newForward && (typeof newForward !== 'string') && newForward.tunnelLocalPort !== numberValue) {
-                                notificationService.warn(( (nls.localize(
+                                notificationService.warn(( nls.localize(
                                     'remote.tunnel.changeLocalPortNumber',
                                     "The local port {0} is not available. Port number {1} has been used instead",
                                     value,
                                     newForward.tunnelLocalPort ?? newForward.localAddress
-                                ))));
+                                )));
                             }
                         }
                     },
                     validationMessage: (value) => validateInput(tunnelService, value, tunnelService.canElevate),
-                    placeholder: ( (nls.localize('remote.tunnelsView.changePort', "New local port")))
+                    placeholder: ( nls.localize('remote.tunnelsView.changePort', "New local port"))
                 });
             }
         };
     }
     ChangeLocalPortAction.handler = handler;
-})(ChangeLocalPortAction || (ChangeLocalPortAction = {}))));
+})(ChangeLocalPortAction || (ChangeLocalPortAction = {})));
 var ChangeTunnelPrivacyAction;
-( ((function(ChangeTunnelPrivacyAction) {
+( (function(ChangeTunnelPrivacyAction) {
     function handler(privacyId) {
         return async (accessor, arg) => {
             if (isITunnelItem(arg)) {
@@ -1400,13 +1388,13 @@ var ChangeTunnelPrivacyAction;
         };
     }
     ChangeTunnelPrivacyAction.handler = handler;
-})(ChangeTunnelPrivacyAction || (ChangeTunnelPrivacyAction = {}))));
+})(ChangeTunnelPrivacyAction || (ChangeTunnelPrivacyAction = {})));
 var SetTunnelProtocolAction;
-( ((function(SetTunnelProtocolAction) {
+( (function(SetTunnelProtocolAction) {
     SetTunnelProtocolAction.ID_HTTP = 'remote.tunnel.setProtocolHttp';
     SetTunnelProtocolAction.ID_HTTPS = 'remote.tunnel.setProtocolHttps';
-    SetTunnelProtocolAction.LABEL_HTTP = ( (nls.localize('remote.tunnel.protocolHttp', "HTTP")));
-    SetTunnelProtocolAction.LABEL_HTTPS = ( (nls.localize('remote.tunnel.protocolHttps', "HTTPS")));
+    SetTunnelProtocolAction.LABEL_HTTP = ( nls.localize('remote.tunnel.protocolHttp', "HTTP"));
+    SetTunnelProtocolAction.LABEL_HTTPS = ( nls.localize('remote.tunnel.protocolHttps', "HTTPS"));
     async function handler(arg, protocol, remoteExplorerService) {
         if (isITunnelItem(arg)) {
             const attributes = {
@@ -1427,18 +1415,15 @@ var SetTunnelProtocolAction;
         };
     }
     SetTunnelProtocolAction.handlerHttps = handlerHttps;
-})(SetTunnelProtocolAction || (SetTunnelProtocolAction = {}))));
+})(SetTunnelProtocolAction || (SetTunnelProtocolAction = {})));
 const tunnelViewCommandsWeightBonus = 10;
-const isForwardedExpr = ( (TunnelTypeContextKey.isEqualTo(TunnelType.Forwarded)));
-const isForwardedOrDetectedExpr = ( (ContextKeyExpr.or(
-    isForwardedExpr,
-     (TunnelTypeContextKey.isEqualTo(TunnelType.Detected))
-)));
-const isNotMultiSelectionExpr = ( (TunnelViewMultiSelectionContextKey.isEqualTo(undefined)));
+const isForwardedExpr = ( TunnelTypeContextKey.isEqualTo(TunnelType.Forwarded));
+const isForwardedOrDetectedExpr = ( ContextKeyExpr.or(isForwardedExpr, ( TunnelTypeContextKey.isEqualTo(TunnelType.Detected))));
+const isNotMultiSelectionExpr = ( TunnelViewMultiSelectionContextKey.isEqualTo(undefined));
 KeybindingsRegistry.registerCommandAndKeybindingRule({
     id: LabelTunnelAction.ID,
     weight: 200  + tunnelViewCommandsWeightBonus,
-    when: ( (ContextKeyExpr.and(TunnelViewFocusContextKey, isForwardedExpr, isNotMultiSelectionExpr))),
+    when: ( ContextKeyExpr.and(TunnelViewFocusContextKey, isForwardedExpr, isNotMultiSelectionExpr)),
     primary: 60 ,
     mac: {
         primary: 3
@@ -1450,7 +1435,7 @@ CommandsRegistry.registerCommand(ForwardPortAction.COMMANDPALETTE_ID, ForwardPor
 KeybindingsRegistry.registerCommandAndKeybindingRule({
     id: ClosePortAction.INLINE_ID,
     weight: 200  + tunnelViewCommandsWeightBonus,
-    when: ( (ContextKeyExpr.and(TunnelCloseableContextKey, TunnelViewFocusContextKey))),
+    when: ( ContextKeyExpr.and(TunnelCloseableContextKey, TunnelViewFocusContextKey)),
     primary: 20 ,
     mac: {
         primary: 2048  | 1 ,
@@ -1465,11 +1450,11 @@ CommandsRegistry.registerCommand(OpenPortInBrowserCommandPaletteAction.ID, OpenP
 KeybindingsRegistry.registerCommandAndKeybindingRule({
     id: CopyAddressAction.INLINE_ID,
     weight: 200  + tunnelViewCommandsWeightBonus,
-    when: ( (ContextKeyExpr.and(
+    when: ( ContextKeyExpr.and(
         TunnelViewFocusContextKey,
         isForwardedOrDetectedExpr,
         isNotMultiSelectionExpr
-    ))),
+    )),
     primary: 2048  | 33 ,
     handler: CopyAddressAction.inlineHandler()
 });
@@ -1512,7 +1497,7 @@ MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
         id: OpenPortInBrowserAction.ID,
         title: OpenPortInBrowserAction.LABEL,
     },
-    when: ( (ContextKeyExpr.and(isForwardedOrDetectedExpr, isNotMultiSelectionExpr)))
+    when: ( ContextKeyExpr.and(isForwardedOrDetectedExpr, isNotMultiSelectionExpr))
 }));
 MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
     group: '._open',
@@ -1521,7 +1506,7 @@ MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
         id: OpenPortInPreviewAction.ID,
         title: OpenPortInPreviewAction.LABEL,
     },
-    when: ( (ContextKeyExpr.and(isForwardedOrDetectedExpr, isNotMultiSelectionExpr)))
+    when: ( ContextKeyExpr.and(isForwardedOrDetectedExpr, isNotMultiSelectionExpr))
 }));
 MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
     group: '0_manage',
@@ -1531,7 +1516,7 @@ MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
         title: LabelTunnelAction.LABEL,
         icon: labelPortIcon
     },
-    when: ( (ContextKeyExpr.and(isForwardedExpr, isNotMultiSelectionExpr)))
+    when: ( ContextKeyExpr.and(isForwardedExpr, isNotMultiSelectionExpr))
 }));
 MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
     group: '2_localaddress',
@@ -1540,7 +1525,7 @@ MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
         id: CopyAddressAction.INLINE_ID,
         title: CopyAddressAction.INLINE_LABEL,
     },
-    when: ( (ContextKeyExpr.and(isForwardedOrDetectedExpr, isNotMultiSelectionExpr)))
+    when: ( ContextKeyExpr.and(isForwardedOrDetectedExpr, isNotMultiSelectionExpr))
 }));
 MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
     group: '2_localaddress',
@@ -1549,21 +1534,21 @@ MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
         id: ChangeLocalPortAction.ID,
         title: ChangeLocalPortAction.LABEL,
     },
-    when: ( (ContextKeyExpr.and(isForwardedExpr, PortChangableContextKey, isNotMultiSelectionExpr)))
+    when: ( ContextKeyExpr.and(isForwardedExpr, PortChangableContextKey, isNotMultiSelectionExpr))
 }));
 MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
     group: '2_localaddress',
     order: 2,
     submenu: MenuId.TunnelPrivacy,
-    title: ( (nls.localize('tunnelContext.privacyMenu', "Port Visibility"))),
-    when: ( (ContextKeyExpr.and(isForwardedExpr, TunnelPrivacyEnabledContextKey)))
+    title: ( nls.localize('tunnelContext.privacyMenu', "Port Visibility")),
+    when: ( ContextKeyExpr.and(isForwardedExpr, TunnelPrivacyEnabledContextKey))
 }));
 MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
     group: '2_localaddress',
     order: 3,
     submenu: MenuId.TunnelProtocol,
-    title: ( (nls.localize('tunnelContext.protocolMenu', "Change Port Protocol"))),
-    when: ( (ContextKeyExpr.and(isForwardedExpr, isNotMultiSelectionExpr)))
+    title: ( nls.localize('tunnelContext.protocolMenu', "Change Port Protocol")),
+    when: ( ContextKeyExpr.and(isForwardedExpr, isNotMultiSelectionExpr))
 }));
 MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
     group: '3_forward',
@@ -1587,7 +1572,7 @@ MenuRegistry.appendMenuItem(MenuId.TunnelProtocol, ({
     command: {
         id: SetTunnelProtocolAction.ID_HTTP,
         title: SetTunnelProtocolAction.LABEL_HTTP,
-        toggled: ( (TunnelProtocolContextKey.isEqualTo(TunnelProtocol.Http)))
+        toggled: ( TunnelProtocolContextKey.isEqualTo(TunnelProtocol.Http))
     }
 }));
 MenuRegistry.appendMenuItem(MenuId.TunnelProtocol, ({
@@ -1595,7 +1580,7 @@ MenuRegistry.appendMenuItem(MenuId.TunnelProtocol, ({
     command: {
         id: SetTunnelProtocolAction.ID_HTTPS,
         title: SetTunnelProtocolAction.LABEL_HTTPS,
-        toggled: ( (TunnelProtocolContextKey.isEqualTo(TunnelProtocol.Https)))
+        toggled: ( TunnelProtocolContextKey.isEqualTo(TunnelProtocol.Https))
     }
 }));
 MenuRegistry.appendMenuItem(MenuId.TunnelPortInline, ({
@@ -1606,7 +1591,7 @@ MenuRegistry.appendMenuItem(MenuId.TunnelPortInline, ({
         title: ForwardPortAction.TREEITEM_LABEL,
         icon: forwardPortIcon
     },
-    when: ( (TunnelTypeContextKey.isEqualTo(TunnelType.Candidate)))
+    when: ( TunnelTypeContextKey.isEqualTo(TunnelType.Candidate))
 }));
 MenuRegistry.appendMenuItem(MenuId.TunnelPortInline, ({
     group: '0_manage',
@@ -1660,9 +1645,9 @@ registerColor('ports.iconRunningProcessForeground', {
     dark: STATUS_BAR_REMOTE_ITEM_BACKGROUND,
     hcDark: STATUS_BAR_REMOTE_ITEM_BACKGROUND,
     hcLight: STATUS_BAR_REMOTE_ITEM_BACKGROUND
-}, ( (nls.localize(
+}, ( nls.localize(
     'portWithRunningProcess.foreground',
     "The color of the icon for a port that has an associated running process."
-))));
+)));
 
 export { ForwardPortAction, OpenPortInBrowserAction, OpenPortInPreviewAction, TunnelPanel, openPreviewEnabledContext };