@codingame/monaco-vscode-api 25.1.2 → 26.0.1

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

@@ -71,7 +71,7 @@ import Severity$1 from '../../../../base/common/severity.js';
 
 var TunnelPanel_1;
 registerCss(tunnelView);
-const openPreviewEnabledContext = ( new RawContextKey('openPreviewEnabled', false));
+const openPreviewEnabledContext = ( new RawContextKey("openPreviewEnabled", false));
 class TunnelTreeVirtualDelegate {
     constructor(remoteExplorerService) {
         this.remoteExplorerService = remoteExplorerService;
@@ -87,30 +87,38 @@ let TunnelViewModel = class TunnelViewModel {
         this.tunnelService = tunnelService;
         this._candidates = ( new Map());
         this.input = {
-            label: ( localize(10314, "Add Port")),
+            label: ( localize(10632, "Add Port")),
             icon: undefined,
             tunnelType: TunnelType.Add,
             hasRunningProcess: false,
-            remoteHost: '',
+            remoteHost: "",
             remotePort: 0,
-            processDescription: '',
-            tooltipPostfix: '',
-            iconTooltip: '',
-            portTooltip: '',
-            processTooltip: '',
-            originTooltip: '',
-            privacyTooltip: '',
-            source: { source: TunnelSource.User, description: '' },
+            processDescription: "",
+            tooltipPostfix: "",
+            iconTooltip: "",
+            portTooltip: "",
+            processTooltip: "",
+            originTooltip: "",
+            privacyTooltip: "",
+            source: {
+                source: TunnelSource.User,
+                description: ""
+            },
             protocol: TunnelProtocol.Http,
             privacy: {
                 id: TunnelPrivacyId.Private,
                 themeIcon: privatePortIcon.id,
-                label: ( localize(10315, "Private"))
+                label: ( localize(10633, "Private"))
             },
             strip: () => undefined
         };
         this.model = remoteExplorerService.tunnelModel;
-        this.onForwardedPortsChanged = Event.any(this.model.onForwardPort, this.model.onClosePort, this.model.onPortName, this.model.onCandidatesChanged);
+        this.onForwardedPortsChanged = Event.any(
+            this.model.onForwardPort,
+            this.model.onClosePort,
+            this.model.onPortName,
+            this.model.onCandidatesChanged
+        );
     }
     get all() {
         const result = [];
@@ -141,8 +149,7 @@ let TunnelViewModel = class TunnelViewModel {
         })).sort((a, b) => {
             if (a.remotePort === b.remotePort) {
                 return a.remoteHost < b.remoteHost ? -1 : 1;
-            }
-            else {
+            } else {
                 return a.remotePort < b.remotePort ? -1 : 1;
             }
         });
@@ -150,82 +157,94 @@ let TunnelViewModel = class TunnelViewModel {
     }
     get detected() {
         return ( Array.from(( this.model.detected.values())).map(tunnel => {
-            const tunnelItem = TunnelItem.createFromTunnel(this.remoteExplorerService, this.tunnelService, tunnel, TunnelType.Detected, false);
+            const tunnelItem = TunnelItem.createFromTunnel(
+                this.remoteExplorerService,
+                this.tunnelService,
+                tunnel,
+                TunnelType.Detected,
+                false
+            );
             this.addProcessInfoFromCandidate(tunnelItem);
             return tunnelItem;
         }));
     }
     isEmpty() {
-        return (this.detected.length === 0) &&
-            ((this.forwarded.length === 0) || (this.forwarded.length === 1 &&
-                (this.forwarded[0].tunnelType === TunnelType.Add) && !this.remoteExplorerService.getEditableData(undefined)));
+        return (this.detected.length === 0) && ((this.forwarded.length === 0) || (this.forwarded.length === 1 && (this.forwarded[0].tunnelType === TunnelType.Add) && !this.remoteExplorerService.getEditableData(undefined)));
     }
 };
-TunnelViewModel = ( __decorate([
-    ( __param(0, IRemoteExplorerService)),
-    ( __param(1, ITunnelService))
-], TunnelViewModel));
+TunnelViewModel = ( __decorate([( __param(0, IRemoteExplorerService)), ( __param(1, ITunnelService))], TunnelViewModel));
 function emptyCell(item) {
-    return { label: '', tunnel: item, editId: TunnelEditId.None, tooltip: '' };
+    return {
+        label: "",
+        tunnel: item,
+        editId: TunnelEditId.None,
+        tooltip: ""
+    };
 }
 class IconColumn {
     constructor() {
-        this.label = '';
-        this.tooltip = '';
+        this.label = "";
+        this.tooltip = "";
         this.weight = 1;
         this.minimumWidth = 40;
         this.maximumWidth = 40;
-        this.templateId = 'actionbar';
+        this.templateId = "actionbar";
     }
     project(row) {
         if (row.tunnelType === TunnelType.Add) {
             return emptyCell(row);
         }
         const icon = row.processDescription ? forwardedPortWithProcessIcon : forwardedPortWithoutProcessIcon;
-        let tooltip = '';
+        let tooltip = "";
         if (row instanceof TunnelItem) {
             tooltip = `${row.iconTooltip} ${row.tooltipPostfix}`;
         }
         return {
-            label: '', icon, tunnel: row, editId: TunnelEditId.None, tooltip
+            label: "",
+            icon,
+            tunnel: row,
+            editId: TunnelEditId.None,
+            tooltip
         };
     }
 }
 class PortColumn {
     constructor() {
-        this.label = ( localize(10316, "Port"));
-        this.tooltip = ( localize(10317, "The label and remote port number of the forwarded port."));
+        this.label = ( localize(10634, "Port"));
+        this.tooltip = ( localize(10635, "The label and remote port number of the forwarded port."));
         this.weight = 1;
-        this.templateId = 'actionbar';
+        this.templateId = "actionbar";
     }
     project(row) {
         const isAdd = row.tunnelType === TunnelType.Add;
         const label = row.label;
-        let tooltip = '';
+        let tooltip = "";
         if (row instanceof TunnelItem && !isAdd) {
             tooltip = `${row.portTooltip} ${row.tooltipPostfix}`;
-        }
-        else {
+        } else {
             tooltip = label;
         }
         return {
-            label, tunnel: row, menuId: MenuId.TunnelPortInline,
-            editId: row.tunnelType === TunnelType.Add ? TunnelEditId.New : TunnelEditId.Label, tooltip
+            label,
+            tunnel: row,
+            menuId: MenuId.TunnelPortInline,
+            editId: row.tunnelType === TunnelType.Add ? TunnelEditId.New : TunnelEditId.Label,
+            tooltip
         };
     }
 }
 class LocalAddressColumn {
     constructor() {
-        this.label = ( localize(10318, "Forwarded Address"));
-        this.tooltip = ( localize(10319, "The address that the forwarded port is available at."));
+        this.label = ( localize(10636, "Forwarded Address"));
+        this.tooltip = ( localize(10637, "The address that the forwarded port is available at."));
         this.weight = 1;
-        this.templateId = 'actionbar';
+        this.templateId = "actionbar";
     }
     project(row) {
         if (row.tunnelType === TunnelType.Add) {
             return emptyCell(row);
         }
-        const label = row.localAddress ?? '';
+        const label = row.localAddress ?? "";
         let tooltip = label;
         if (row instanceof TunnelItem) {
             tooltip = row.tooltipPostfix;
@@ -240,86 +259,110 @@ class LocalAddressColumn {
         };
     }
     static getHoverText(localAddress) {
-        return function (configurationService) {
-            const editorConf = configurationService.getValue('editor');
-            let clickLabel = '';
-            if (editorConf.multiCursorModifier === 'ctrlCmd') {
+        return function(configurationService) {
+            const editorConf = configurationService.getValue("editor");
+            let clickLabel = "";
+            if (editorConf.multiCursorModifier === "ctrlCmd") {
                 if (isMacintosh) {
-                    clickLabel = ( localize(10320, "option + click"));
-                }
-                else {
-                    clickLabel = ( localize(10321, "alt + click"));
+                    clickLabel = ( localize(10638, "option + click"));
+                } else {
+                    clickLabel = ( localize(10639, "alt + click"));
                 }
-            }
-            else {
+            } else {
                 if (isMacintosh) {
-                    clickLabel = ( localize(10322, "cmd + click"));
-                }
-                else {
-                    clickLabel = ( localize(10323, "ctrl + click"));
+                    clickLabel = ( localize(10640, "cmd + click"));
+                } else {
+                    clickLabel = ( localize(10641, "ctrl + click"));
                 }
             }
-            const markdown = ( new MarkdownString('', true));
-            const uri = localAddress.startsWith('http') ? localAddress : `http://${localAddress}`;
-            return markdown.appendLink(uri, 'Follow link').appendMarkdown(` (${clickLabel})`);
+            const markdown = ( new MarkdownString("", true));
+            const uri = localAddress.startsWith("http") ? localAddress : `http://${localAddress}`;
+            return markdown.appendLink(uri, "Follow link").appendMarkdown(` (${clickLabel})`);
         };
     }
 }
 class RunningProcessColumn {
     constructor() {
-        this.label = ( localize(10324, "Running Process"));
-        this.tooltip = ( localize(10325, "The command line of the process that is using the port."));
+        this.label = ( localize(10642, "Running Process"));
+        this.tooltip = ( localize(10643, "The command line of the process that is using the port."));
         this.weight = 2;
-        this.templateId = 'actionbar';
+        this.templateId = "actionbar";
     }
     project(row) {
         if (row.tunnelType === TunnelType.Add) {
             return emptyCell(row);
         }
-        const label = row.processDescription ?? '';
-        return { label, tunnel: row, editId: TunnelEditId.None, tooltip: row instanceof TunnelItem ? row.processTooltip : '' };
+        const label = row.processDescription ?? "";
+        return {
+            label,
+            tunnel: row,
+            editId: TunnelEditId.None,
+            tooltip: row instanceof TunnelItem ? row.processTooltip : ""
+        };
     }
 }
 class OriginColumn {
     constructor() {
-        this.label = ( localize(10326, "Origin"));
+        this.label = ( localize(10644, "Origin"));
         this.tooltip = ( localize(
-            10327,
+            10645,
             "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';
+        this.templateId = "actionbar";
     }
     project(row) {
         if (row.tunnelType === TunnelType.Add) {
             return emptyCell(row);
         }
         const label = row.source.description;
-        const tooltip = `${row instanceof TunnelItem ? row.originTooltip : ''}. ${row instanceof TunnelItem ? row.tooltipPostfix : ''}`;
-        return { label, menuId: MenuId.TunnelOriginInline, tunnel: row, editId: TunnelEditId.None, tooltip };
+        const tooltip = `${row instanceof TunnelItem ? row.originTooltip : ""}. ${row instanceof TunnelItem ? row.tooltipPostfix : ""}`;
+        return {
+            label,
+            menuId: MenuId.TunnelOriginInline,
+            tunnel: row,
+            editId: TunnelEditId.None,
+            tooltip
+        };
     }
 }
 class PrivacyColumn {
     constructor() {
-        this.label = ( localize(10328, "Visibility"));
-        this.tooltip = ( localize(10329, "The availability of the forwarded port."));
+        this.label = ( localize(10646, "Visibility"));
+        this.tooltip = ( localize(10647, "The availability of the forwarded port."));
         this.weight = 1;
-        this.templateId = 'actionbar';
+        this.templateId = "actionbar";
     }
     project(row) {
         if (row.tunnelType === TunnelType.Add) {
             return emptyCell(row);
         }
         const label = row.privacy?.label;
-        let tooltip = '';
+        let tooltip = "";
         if (row instanceof TunnelItem) {
             tooltip = `${row.privacy.label} ${row.tooltipPostfix}`;
         }
-        return { label, tunnel: row, icon: { id: row.privacy.themeIcon }, editId: TunnelEditId.None, tooltip };
+        return {
+            label,
+            tunnel: row,
+            icon: {
+                id: row.privacy.themeIcon
+            },
+            editId: TunnelEditId.None,
+            tooltip
+        };
     }
 }
 let ActionBarRenderer = class ActionBarRenderer extends Disposable {
-    constructor(instantiationService, contextKeyService, menuService, contextViewService, remoteExplorerService, commandService, configurationService) {
+    constructor(
+        instantiationService,
+        contextKeyService,
+        menuService,
+        contextViewService,
+        remoteExplorerService,
+        commandService,
+        configurationService
+    ) {
         super();
         this.instantiationService = instantiationService;
         this.contextKeyService = contextKeyService;
@@ -328,59 +371,62 @@ let ActionBarRenderer = class ActionBarRenderer extends Disposable {
         this.remoteExplorerService = remoteExplorerService;
         this.commandService = commandService;
         this.configurationService = configurationService;
-        this.templateId = 'actionbar';
-        this._hoverDelegate = getDefaultHoverDelegate('mouse');
+        this.templateId = "actionbar";
+        this._hoverDelegate = getDefaultHoverDelegate("mouse");
     }
     set actionRunner(actionRunner) {
         this._actionRunner = actionRunner;
     }
     renderTemplate(container) {
-        const cell = append(container, $('.ports-view-actionbar-cell'));
-        const icon = append(cell, $('.ports-view-actionbar-cell-icon'));
+        const cell = append(container, $(".ports-view-actionbar-cell"));
+        const icon = append(cell, $(".ports-view-actionbar-cell-icon"));
         const label = ( new IconLabel(cell, {
             supportHighlights: true,
             hoverDelegate: this._hoverDelegate
         }));
-        const actionsContainer = append(cell, $('.actions'));
+        const actionsContainer = append(cell, $(".actions"));
         const actionBar = ( new ActionBar(actionsContainer, {
             actionViewItemProvider: createActionViewItem.bind(undefined, this.instantiationService),
             hoverDelegate: this._hoverDelegate
         }));
-        return { label, icon, actionBar, container: cell, elementDisposable: Disposable.None };
+        return {
+            label,
+            icon,
+            actionBar,
+            container: cell,
+            elementDisposable: Disposable.None
+        };
     }
     renderElement(element, index, templateData) {
         templateData.actionBar.clear();
-        templateData.icon.className = 'ports-view-actionbar-cell-icon';
-        templateData.icon.style.display = 'none';
-        templateData.label.setLabel('');
-        templateData.label.element.style.display = 'none';
-        templateData.container.style.height = '22px';
+        templateData.icon.className = "ports-view-actionbar-cell-icon";
+        templateData.icon.style.display = "none";
+        templateData.label.setLabel("");
+        templateData.label.element.style.display = "none";
+        templateData.container.style.height = "22px";
         if (templateData.button) {
-            templateData.button.element.style.display = 'none';
+            templateData.button.element.style.display = "none";
             templateData.button.dispose();
         }
-        templateData.container.style.paddingLeft = '0px';
+        templateData.container.style.paddingLeft = "0px";
         templateData.elementDisposable.dispose();
         let editableData;
         if (element.editId === TunnelEditId.New && (editableData = this.remoteExplorerService.getEditableData(undefined))) {
             this.renderInputBox(templateData.container, editableData);
-        }
-        else {
+        } else {
             editableData = this.remoteExplorerService.getEditableData(element.tunnel, element.editId);
             if (editableData) {
                 this.renderInputBox(templateData.container, editableData);
-            }
-            else if ((element.tunnel.tunnelType === TunnelType.Add) && (element.menuId === MenuId.TunnelPortInline)) {
+            } else if ((element.tunnel.tunnelType === TunnelType.Add) && (element.menuId === MenuId.TunnelPortInline)) {
                 this.renderButton(element, templateData);
-            }
-            else {
+            } else {
                 this.renderActionBarItem(element, templateData);
             }
         }
     }
     renderButton(element, templateData) {
-        templateData.container.style.paddingLeft = '7px';
-        templateData.container.style.height = '28px';
+        templateData.container.style.paddingLeft = "7px";
+        templateData.container.style.height = "28px";
         templateData.button = this._register(( new Button(templateData.container, defaultButtonStyles)));
         templateData.button.label = element.label;
         templateData.button.element.title = element.tooltip;
@@ -413,17 +459,18 @@ let ActionBarRenderer = class ActionBarRenderer extends Disposable {
         return context;
     }
     renderActionBarItem(element, templateData) {
-        templateData.label.element.style.display = 'flex';
+        templateData.label.element.style.display = "flex";
         templateData.label.setLabel(element.label, undefined, {
-            title: element.markdownTooltip ?
-                { markdown: element.markdownTooltip(this.configurationService), markdownNotSupportedFallback: element.tooltip }
-                : element.tooltip,
-            extraClasses: element.menuId === MenuId.TunnelLocalAddressInline ? ['ports-view-actionbar-cell-localaddress'] : undefined
+            title: element.markdownTooltip ? {
+                markdown: element.markdownTooltip(this.configurationService),
+                markdownNotSupportedFallback: element.tooltip
+            } : element.tooltip,
+            extraClasses: element.menuId === MenuId.TunnelLocalAddressInline ? ["ports-view-actionbar-cell-localaddress"] : undefined
         });
         templateData.actionBar.context = this.tunnelContext(element.tunnel);
-        templateData.container.style.paddingLeft = '10px';
+        templateData.container.style.paddingLeft = "10px";
         const context = [
-            ['view', TUNNEL_VIEW_ID],
+            ["view", TUNNEL_VIEW_ID],
             [TunnelTypeContextKey.key, element.tunnel.tunnelType],
             [TunnelCloseableContextKey.key, element.tunnel.closeable],
             [TunnelPrivacyContextKey.key, element.tunnel.privacy.id],
@@ -434,15 +481,20 @@ let ActionBarRenderer = class ActionBarRenderer extends Disposable {
         templateData.elementDisposable = disposableStore;
         if (element.menuId) {
             const menu = disposableStore.add(this.menuService.createMenu(element.menuId, contextKeyService));
-            let actions = getFlatActionBarActions(menu.getActions({ shouldForwardArgs: true }));
+            let actions = getFlatActionBarActions(menu.getActions({
+                shouldForwardArgs: true
+            }));
             if (actions) {
-                const labelActions = actions.filter(action => action.id.toLowerCase().indexOf('label') >= 0);
+                const labelActions = actions.filter(action => action.id.toLowerCase().indexOf("label") >= 0);
                 if (labelActions.length > 1) {
                     labelActions.sort((a, b) => a.label.length - b.label.length);
                     labelActions.pop();
                     actions = actions.filter(action => labelActions.indexOf(action) < 0);
                 }
-                templateData.actionBar.push(actions, { icon: true, label: false });
+                templateData.actionBar.push(actions, {
+                    icon: true,
+                    label: false
+                });
                 if (this._actionRunner) {
                     templateData.actionBar.actionRunner = this._actionRunner;
                 }
@@ -451,7 +503,7 @@ let ActionBarRenderer = class ActionBarRenderer extends Disposable {
         if (element.icon) {
             templateData.icon.className = `ports-view-actionbar-cell-icon ${ThemeIcon.asClassName(element.icon)}`;
             templateData.icon.title = element.tooltip;
-            templateData.icon.style.display = 'inline';
+            templateData.icon.style.display = "inline";
         }
     }
     renderInputBox(container, editableData) {
@@ -459,12 +511,12 @@ let ActionBarRenderer = class ActionBarRenderer extends Disposable {
             this.inputDone(false, false);
             this.inputDone = undefined;
         }
-        container.style.paddingLeft = '5px';
-        const value = editableData.startingValue || '';
+        container.style.paddingLeft = "5px";
+        const value = editableData.startingValue || "";
         const inputBox = ( new InputBox(container, this.contextViewService, {
-            ariaLabel: ( localize(10330, "Press Enter to confirm or Escape to cancel.")),
+            ariaLabel: ( localize(10648, "Press Enter to confirm or Escape to cancel.")),
             validationOptions: {
-                validation: (value) => {
+                validation: value => {
                     const message = editableData.validationMessage(value);
                     if (!message) {
                         return null;
@@ -476,18 +528,21 @@ let ActionBarRenderer = class ActionBarRenderer extends Disposable {
                     };
                 }
             },
-            placeholder: editableData.placeholder || '',
+            placeholder: editableData.placeholder || "",
             inputBoxStyles: defaultInputBoxStyles
         }));
         inputBox.value = value;
         inputBox.focus();
-        inputBox.select({ start: 0, end: editableData.startingValue ? editableData.startingValue.length : 0 });
+        inputBox.select({
+            start: 0,
+            end: editableData.startingValue ? editableData.startingValue.length : 0
+        });
         const done = createSingleCallFunction(async (success, finishEditing) => {
             dispose(toDispose);
             if (this.inputDone) {
                 this.inputDone = undefined;
             }
-            inputBox.element.style.display = 'none';
+            inputBox.element.style.display = "none";
             const inputValue = inputBox.value;
             if (finishEditing) {
                 return editableData.onFinish(inputValue, success);
@@ -496,17 +551,15 @@ let ActionBarRenderer = class ActionBarRenderer extends Disposable {
         this.inputDone = done;
         const toDispose = [
             inputBox,
-            addStandardDisposableListener(inputBox.inputElement, EventType.KEY_DOWN, async (e) => {
+            addStandardDisposableListener(inputBox.inputElement, EventType.KEY_DOWN, async e => {
                 if (e.equals(KeyCode.Enter)) {
                     e.stopPropagation();
                     if (inputBox.validate() !== MessageType.ERROR) {
                         return done(true, true);
-                    }
-                    else {
+                    } else {
                         return done(false, true);
                     }
-                }
-                else if (e.equals(KeyCode.Escape)) {
+                } else if (e.equals(KeyCode.Escape)) {
                     e.preventDefault();
                     e.stopPropagation();
                     return done(false, true);
@@ -530,17 +583,15 @@ 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))
-], ActionBarRenderer));
+ActionBarRenderer = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IContextKeyService)), ( __param(2, IMenuService)), ( __param(3, IContextViewService)), ( __param(4, IRemoteExplorerService)), ( __param(5, ICommandService)), ( __param(6, IConfigurationService))], ActionBarRenderer));
 class TunnelItem {
-    static createFromTunnel(remoteExplorerService, tunnelService, tunnel, type = TunnelType.Forwarded, closeable) {
+    static createFromTunnel(
+        remoteExplorerService,
+        tunnelService,
+        tunnel,
+        type = TunnelType.Forwarded,
+        closeable
+    ) {
         return ( new TunnelItem(
             type,
             tunnel.remoteHost,
@@ -578,7 +629,24 @@ class TunnelItem {
             this._privacy
         ));
     }
-    constructor(tunnelType, remoteHost, remotePort, source, hasRunningProcess, protocol, localUri, localAddress, localPort, closeable, name, runningProcess, pid, _privacy, remoteExplorerService, tunnelService) {
+    constructor(
+        tunnelType,
+        remoteHost,
+        remotePort,
+        source,
+        hasRunningProcess,
+        protocol,
+        localUri,
+        localAddress,
+        localPort,
+        closeable,
+        name,
+        runningProcess,
+        pid,
+        _privacy,
+        remoteExplorerService,
+        tunnelService
+    ) {
         this.tunnelType = tunnelType;
         this.remoteHost = remoteHost;
         this.remotePort = remotePort;
@@ -600,13 +668,10 @@ class TunnelItem {
         if (this.tunnelType === TunnelType.Add && this.name) {
             return this.name;
         }
-        const portNumberLabel = (isLocalhost(this.remoteHost) || isAllInterfaces(this.remoteHost))
-            ? `${this.remotePort}`
-            : `${this.remoteHost}:${this.remotePort}`;
+        const portNumberLabel = (isLocalhost(this.remoteHost) || isAllInterfaces(this.remoteHost)) ? `${this.remotePort}` : `${this.remoteHost}:${this.remotePort}`;
         if (this.name) {
             return `${this.name} (${portNumberLabel})`;
-        }
-        else {
+        } else {
             return portNumberLabel;
         }
     }
@@ -614,20 +679,18 @@ class TunnelItem {
         this.runningProcess = description;
     }
     get processDescription() {
-        let description = '';
+        let description = "";
         if (this.runningProcess) {
             if (this.pid && this.remoteExplorerService?.namedProcesses.has(this.pid)) {
                 description = this.remoteExplorerService.namedProcesses.get(this.pid);
-            }
-            else {
-                description = this.runningProcess.replace(/\0/g, ' ').trim();
+            } else {
+                description = this.runningProcess.replace(/\0/g, " ").trim();
             }
             if (this.pid) {
                 description += ` (${this.pid})`;
             }
-        }
-        else if (this.hasRunningProcess) {
-            description = ( localize(10331, "Process information unavailable"));
+        } else if (this.hasRunningProcess) {
+            description = ( localize(10649, "Process information unavailable"));
         }
         return description;
     }
@@ -635,16 +698,15 @@ class TunnelItem {
         let information;
         if (this.localAddress) {
             information = ( localize(
-                10332,
+                10650,
                 "Remote port {0}:{1} forwarded to local address {2}. ",
                 this.remoteHost,
                 this.remotePort,
                 this.localAddress
             ));
-        }
-        else {
+        } else {
             information = ( localize(
-                10333,
+                10651,
                 "Remote port {0}:{1} not forwarded. ",
                 this.remoteHost,
                 this.remotePort
@@ -655,64 +717,94 @@ class TunnelItem {
     get iconTooltip() {
         const isAdd = this.tunnelType === TunnelType.Add;
         if (!isAdd) {
-            return `${this.processDescription ? ( localize(10334, "Port has running process.")) :
-                ( localize(10335, "No running process."))}`;
-        }
-        else {
+            return `${this.processDescription ? ( localize(10652, "Port has running process.")) : ( localize(10653, "No running process."))}`;
+        } else {
             return this.label;
         }
     }
     get portTooltip() {
         const isAdd = this.tunnelType === TunnelType.Add;
         if (!isAdd) {
-            return `${this.name ? ( localize(10336, "Port labeled {0}. ", this.name)) : ''}`;
-        }
-        else {
-            return '';
+            return `${this.name ? ( localize(10654, "Port labeled {0}. ", this.name)) : ""}`;
+        } else {
+            return "";
         }
     }
     get processTooltip() {
-        return this.processDescription ?? '';
+        return this.processDescription ?? "";
     }
     get originTooltip() {
         return this.source.description;
     }
     get privacy() {
         if (this.tunnelService?.privacyOptions) {
-            return this.tunnelService?.privacyOptions.find(element => element.id === this._privacy) ??
-                {
-                    id: '',
-                    themeIcon: Codicon.question.id,
-                    label: ( localize(10337, "Unknown"))
-                };
-        }
-        else {
+            return this.tunnelService?.privacyOptions.find(element => element.id === this._privacy) ?? {
+                id: "",
+                themeIcon: Codicon.question.id,
+                label: ( localize(10655, "Unknown"))
+            };
+        } else {
             return {
                 id: TunnelPrivacyId.Private,
                 themeIcon: privatePortIcon.id,
-                label: ( localize(10315, "Private"))
+                label: ( localize(10633, "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, ( localize(10338, "Whether the Ports view has focus."))));
-const TunnelViewSelectionKeyName = 'tunnelViewSelection';
+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, ( localize(10656, "Whether the Ports view has focus."))));
+const TunnelViewSelectionKeyName = "tunnelViewSelection";
 const TunnelViewSelectionContextKey = ( new RawContextKey(TunnelViewSelectionKeyName, undefined, true));
-const TunnelViewMultiSelectionKeyName = 'tunnelViewMultiSelection';
+const TunnelViewMultiSelectionKeyName = "tunnelViewMultiSelection";
 const TunnelViewMultiSelectionContextKey = ( new RawContextKey(TunnelViewMultiSelectionKeyName, undefined, true));
-const PortChangableContextKey = ( new RawContextKey('portChangable', false, true));
-const ProtocolChangeableContextKey = ( new RawContextKey('protocolChangable', true, true));
+const PortChangableContextKey = ( new RawContextKey("portChangable", false, true));
+const ProtocolChangeableContextKey = ( new RawContextKey("protocolChangable", true, true));
 let TunnelPanel = class TunnelPanel extends ViewPane {
-    static { TunnelPanel_1 = this; }
-    static { this.ID = TUNNEL_VIEW_ID; }
-    static { this.TITLE = ( localize2(10339, "Ports")); }
-    constructor(viewModel, options, keybindingService, contextMenuService, contextKeyService, configurationService, instantiationService, viewDescriptorService, openerService, quickInputService, commandService, menuService, themeService, remoteExplorerService, hoverService, tunnelService, contextViewService) {
-        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, hoverService);
+    static {
+        TunnelPanel_1 = this;
+    }
+    static {
+        this.ID = TUNNEL_VIEW_ID;
+    }
+    static {
+        this.TITLE = ( localize2(10657, "Ports"));
+    }
+    constructor(
+        viewModel,
+        options,
+        keybindingService,
+        contextMenuService,
+        contextKeyService,
+        configurationService,
+        instantiationService,
+        viewDescriptorService,
+        openerService,
+        quickInputService,
+        commandService,
+        menuService,
+        themeService,
+        remoteExplorerService,
+        hoverService,
+        tunnelService,
+        contextViewService
+    ) {
+        super(
+            options,
+            keybindingService,
+            contextMenuService,
+            configurationService,
+            contextKeyService,
+            viewDescriptorService,
+            instantiationService,
+            openerService,
+            themeService,
+            hoverService
+        );
         this.viewModel = viewModel;
         this.quickInputService = quickInputService;
         this.commandService = commandService;
@@ -738,7 +830,7 @@ let TunnelPanel = class TunnelPanel extends ViewPane {
         this.tunnelViewSelectionContext = TunnelViewSelectionContextKey.bindTo(contextKeyService);
         this.tunnelViewMultiSelectionContext = TunnelViewMultiSelectionContextKey.bindTo(contextKeyService);
         this.portChangableContextKey = PortChangableContextKey.bindTo(contextKeyService);
-        const overlayContextKeyService = this.contextKeyService.createOverlay([['view', TunnelPanel_1.ID]]);
+        const overlayContextKeyService = this.contextKeyService.createOverlay([["view", TunnelPanel_1.ID]]);
         const titleMenu = this._register(this.menuService.createMenu(MenuId.TunnelTitle, overlayContextKeyService));
         const updateActions = () => {
             this.titleActions = getFlatActionBarActions(titleMenu.getActions());
@@ -791,9 +883,9 @@ let TunnelPanel = class TunnelPanel extends ViewPane {
         }
         this.tableDisposables.clear();
         clearNode(this.panelContainer);
-        const widgetContainer = append(this.panelContainer, $('.customview-tree'));
-        widgetContainer.classList.add('ports-view');
-        widgetContainer.classList.add('file-icon-themable-tree', 'show-file-icons');
+        const widgetContainer = append(this.panelContainer, $(".customview-tree"));
+        widgetContainer.classList.add("ports-view");
+        widgetContainer.classList.add("file-icon-themable-tree", "show-file-icons");
         const actionBarRenderer = ( new ActionBarRenderer(
             this.instantiationService,
             this.contextKeyService,
@@ -808,23 +900,22 @@ let TunnelPanel = class TunnelPanel extends ViewPane {
             columns.push(( new PrivacyColumn()));
         }
         columns.push(( new OriginColumn()));
-        this.table = this.instantiationService.createInstance(WorkbenchTable, 'RemoteTunnels', widgetContainer, ( new TunnelTreeVirtualDelegate(this.remoteExplorerService)), columns, [actionBarRenderer], {
+        this.table = this.instantiationService.createInstance(WorkbenchTable, "RemoteTunnels", widgetContainer, ( new TunnelTreeVirtualDelegate(this.remoteExplorerService)), columns, [actionBarRenderer], {
             keyboardNavigationLabelProvider: {
-                getKeyboardNavigationLabel: (item) => {
+                getKeyboardNavigationLabel: item => {
                     return item.label;
                 }
             },
             multipleSelectionSupport: true,
             accessibilityProvider: {
-                getAriaLabel: (item) => {
+                getAriaLabel: item => {
                     if (item instanceof TunnelItem) {
-                        return `${item.tooltipPostfix} ${item.portTooltip} ${item.iconTooltip} ${item.processTooltip} ${item.originTooltip} ${this.tunnelService.canChangePrivacy ? item.privacy.label : ''}`;
-                    }
-                    else {
+                        return `${item.tooltipPostfix} ${item.portTooltip} ${item.iconTooltip} ${item.processTooltip} ${item.originTooltip} ${this.tunnelService.canChangePrivacy ? item.privacy.label : ""}`;
+                    } else {
                         return item.label;
                     }
                 },
-                getWidgetAriaLabel: () => ( localize(10340, "Tunnel View"))
+                getWidgetAriaLabel: () => ( localize(10658, "Tunnel View"))
             },
             openOnSingleClick: true
         });
@@ -840,19 +931,20 @@ let TunnelPanel = class TunnelPanel extends ViewPane {
         const rerender = () => this.table?.splice(0, Number.POSITIVE_INFINITY, this.viewModel.all);
         rerender();
         let lastPortCount = this.portCount;
-        this.tableDisposables.add(Event.debounce(this.viewModel.onForwardedPortsChanged, (_last, e) => e, 50)(() => {
-            const newPortCount = this.portCount;
-            if (((lastPortCount === 0) || (newPortCount === 0)) && (lastPortCount !== newPortCount)) {
-                this._onDidChangeViewWelcomeState.fire();
-            }
-            lastPortCount = newPortCount;
-            rerender();
-        }));
+        this.tableDisposables.add(
+            Event.debounce(this.viewModel.onForwardedPortsChanged, (_last, e) => e, 50)(() => {
+                const newPortCount = this.portCount;
+                if (((lastPortCount === 0) || (newPortCount === 0)) && (lastPortCount !== newPortCount)) {
+                    this._onDidChangeViewWelcomeState.fire();
+                }
+                lastPortCount = newPortCount;
+                rerender();
+            })
+        );
         this.tableDisposables.add(this.table.onMouseClick(e => {
             if (this.hasOpenLinkModifier(e.browserEvent) && this.table) {
                 const selection = this.table.getSelectedElements();
-                if ((selection.length === 0) ||
-                    ((selection.length === 1) && (selection[0] === e.element))) {
+                if ((selection.length === 0) || ((selection.length === 1) && (selection[0] === e.element))) {
                     this.commandService.executeCommand(OpenPortInBrowserAction.ID, e.element);
                 }
             }
@@ -861,7 +953,7 @@ let TunnelPanel = class TunnelPanel extends ViewPane {
             if (!e.element || (e.element.tunnelType !== TunnelType.Forwarded)) {
                 return;
             }
-            if (e.browserEvent?.type === 'dblclick') {
+            if (e.browserEvent?.type === "dblclick") {
                 this.commandService.executeCommand(LabelTunnelAction.ID);
             }
         }));
@@ -869,16 +961,15 @@ let TunnelPanel = class TunnelPanel extends ViewPane {
             this.isEditing = !!this.remoteExplorerService.getEditableData(e?.tunnel, e?.editId);
             this._onDidChangeViewWelcomeState.fire();
             if (!this.isEditing) {
-                widgetContainer.classList.remove('highlight');
+                widgetContainer.classList.remove("highlight");
             }
             rerender();
             if (this.isEditing) {
-                widgetContainer.classList.add('highlight');
+                widgetContainer.classList.add("highlight");
                 if (!e) {
                     this.table?.reveal(this.table.indexOf(this.viewModel.input));
                 }
-            }
-            else {
+            } else {
                 if (e && (e.tunnel.tunnelType !== TunnelType.Add)) {
                     this.table?.setFocus(this.lastFocus);
                 }
@@ -888,7 +979,7 @@ let TunnelPanel = class TunnelPanel extends ViewPane {
     }
     renderBody(container) {
         super.renderBody(container);
-        this.panelContainer = append(container, $('.tree-explorer-viewlet-tree-view'));
+        this.panelContainer = append(container, $(".tree-explorer-viewlet-tree-view"));
         this.createTable();
     }
     shouldShowWelcome() {
@@ -909,10 +1000,11 @@ let TunnelPanel = class TunnelPanel extends ViewPane {
             this.tunnelTypeContext.set(item.tunnelType);
             this.tunnelCloseableContext.set(!!item.closeable);
             this.tunnelPrivacyContext.set(item.privacy.id);
-            this.tunnelProtocolContext.set(item.protocol === TunnelProtocol.Https ? TunnelProtocol.Https : TunnelProtocol.Https);
+            this.tunnelProtocolContext.set(
+                item.protocol === TunnelProtocol.Https ? TunnelProtocol.Https : TunnelProtocol.Https
+            );
             this.portChangableContextKey.set(!!item.localPort);
-        }
-        else {
+        } else {
             this.tunnelTypeContext.reset();
             this.tunnelViewSelectionContext.reset();
             this.tunnelCloseableContext.reset();
@@ -922,16 +1014,14 @@ let TunnelPanel = class TunnelPanel extends ViewPane {
         }
     }
     hasOpenLinkModifier(e) {
-        const editorConf = this.configurationService.getValue('editor');
+        const editorConf = this.configurationService.getValue("editor");
         let modifierKey = false;
-        if (editorConf.multiCursorModifier === 'ctrlCmd') {
+        if (editorConf.multiCursorModifier === "ctrlCmd") {
             modifierKey = e.altKey;
-        }
-        else {
+        } else {
             if (isMacintosh) {
                 modifierKey = e.metaKey;
-            }
-            else {
+            } else {
                 modifierKey = e.ctrlKey;
             }
         }
@@ -941,8 +1031,7 @@ let TunnelPanel = class TunnelPanel extends ViewPane {
         const elements = event.elements;
         if (elements.length > 1) {
             this.tunnelViewMultiSelectionContext.set(( elements.map(element => makeAddress(element.remoteHost, element.remotePort))));
-        }
-        else {
+        } else {
             this.tunnelViewMultiSelectionContext.set(undefined);
         }
     }
@@ -960,8 +1049,7 @@ let TunnelPanel = class TunnelPanel extends ViewPane {
             this.tunnelPrivacyContext.set(node.privacy.id);
             this.tunnelProtocolContext.set(node.protocol);
             this.portChangableContextKey.set(!!node.localPort);
-        }
-        else {
+        } else {
             this.tunnelTypeContext.set(TunnelType.Add);
             this.tunnelCloseableContext.set(false);
             this.tunnelPrivacyContext.set(undefined);
@@ -970,17 +1058,22 @@ let TunnelPanel = class TunnelPanel extends ViewPane {
         }
         this.contextMenuService.showContextMenu({
             menuId: MenuId.TunnelContext,
-            menuActionOptions: { shouldForwardArgs: true },
+            menuActionOptions: {
+                shouldForwardArgs: true
+            },
             contextKeyService: this.table?.contextKeyService,
             getAnchor: () => event.anchor,
-            getActionViewItem: (action) => {
+            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;
             },
-            onHide: (wasCancelled) => {
+            onHide: wasCancelled => {
                 if (wasCancelled) {
                     this.table?.domFocus();
                 }
@@ -1001,53 +1094,36 @@ 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, IHoverService)),
-    ( __param(15, ITunnelService)),
-    ( __param(16, IContextViewService))
-], 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, IHoverService)), ( __param(15, ITunnelService)), ( __param(16, IContextViewService))], TunnelPanel));
 class TunnelPanelDescriptor {
     constructor(viewModel, environmentService) {
         this.id = TunnelPanel.ID;
         this.name = TunnelPanel.TITLE;
         this.canToggleVisibility = true;
         this.hideByDefault = false;
-        this.group = 'details@0';
+        this.group = "details@0";
         this.order = -500;
         this.canMoveView = true;
         this.containerIcon = portsViewIcon;
         this.ctorDescriptor = ( new SyncDescriptor(TunnelPanel, [viewModel]));
-        this.remoteAuthority = environmentService.remoteAuthority ? environmentService.remoteAuthority.split('+')[0] : undefined;
+        this.remoteAuthority = environmentService.remoteAuthority ? environmentService.remoteAuthority.split("+")[0] : undefined;
     }
 }
 function isITunnelItem(item) {
     return item && item.tunnelType && item.remoteHost && item.source;
 }
 var LabelTunnelAction;
-(function (LabelTunnelAction) {
-    LabelTunnelAction.ID = 'remote.tunnel.label';
-    LabelTunnelAction.LABEL = ( localize(10341, "Set Port Label"));
-    LabelTunnelAction.COMMAND_ID_KEYWORD = 'label';
+(function(LabelTunnelAction) {
+    LabelTunnelAction.ID = "remote.tunnel.label";
+    LabelTunnelAction.LABEL = ( localize(10659, "Set Port Label"));
+    LabelTunnelAction.COMMAND_ID_KEYWORD = "label";
     function handler() {
         return async (accessor, arg) => {
             const remoteExplorerService = accessor.get(IRemoteExplorerService);
             let tunnelContext;
             if (isITunnelItem(arg)) {
                 tunnelContext = arg;
-            }
-            else {
+            } else {
                 const context = accessor.get(IContextKeyService).getContextKeyValue(TunnelViewSelectionKeyName);
                 const tunnel = context ? remoteExplorerService.tunnelModel.forwarded.get(context) : undefined;
                 if (tunnel) {
@@ -1067,10 +1143,13 @@ var LabelTunnelAction;
                             if (changed) {
                                 await remoteExplorerService.tunnelModel.name(tunnelItem.remoteHost, tunnelItem.remotePort, value);
                             }
-                            resolve(changed ? { port: tunnelItem.remotePort, label: value } : undefined);
+                            resolve(changed ? {
+                                port: tunnelItem.remotePort,
+                                label: value
+                            } : undefined);
                         },
                         validationMessage: () => null,
-                        placeholder: ( localize(10342, "Port label")),
+                        placeholder: ( localize(10660, "Port label")),
                         startingValue
                     });
                 }));
@@ -1080,45 +1159,53 @@ var LabelTunnelAction;
     }
     LabelTunnelAction.handler = handler;
 })(LabelTunnelAction || (LabelTunnelAction = {}));
-const invalidPortString = ( localize(10343, "Forwarded port should be a number or a host:port."));
+const invalidPortString = ( localize(10661, "Forwarded port should be a number or a host:port."));
 const maxPortNumber = 65536;
-const invalidPortNumberString = ( localize(10344, "Port number must be \u2265 0 and < {0}.", maxPortNumber));
-const requiresSudoString = ( localize(10345, "May Require Sudo"));
-const alreadyForwarded = ( localize(10346, "Port is already forwarded"));
+const invalidPortNumberString = ( localize(10662, "Port number must be ≥ 0 and < {0}.", maxPortNumber));
+const requiresSudoString = ( localize(10663, "May Require Sudo"));
+const alreadyForwarded = ( localize(10664, "Port is already forwarded"));
 var ForwardPortAction;
-(function (ForwardPortAction) {
-    ForwardPortAction.INLINE_ID = 'remote.tunnel.forwardInline';
-    ForwardPortAction.COMMANDPALETTE_ID = 'remote.tunnel.forwardCommandPalette';
-    ForwardPortAction.LABEL = ( localize2(10347, "Forward a Port"));
-    ForwardPortAction.TREEITEM_LABEL = ( localize(10348, "Forward Port"));
-    const forwardPrompt = ( localize(10349, "Port number or address (eg. 3000 or 10.10.10.10:2000)."));
+(function(ForwardPortAction) {
+    ForwardPortAction.INLINE_ID = "remote.tunnel.forwardInline";
+    ForwardPortAction.COMMANDPALETTE_ID = "remote.tunnel.forwardCommandPalette";
+    ForwardPortAction.LABEL = ( localize2(10665, "Forward a Port"));
+    ForwardPortAction.TREEITEM_LABEL = ( localize(10666, "Forward Port"));
+    const forwardPrompt = ( localize(10667, "Port number or address (eg. 3000 or 10.10.10.10:2000)."));
     function validateInput(remoteExplorerService, tunnelService, value, canElevate) {
         const parsed = parseAddress(value);
         if (!parsed) {
-            return { content: invalidPortString, severity: Severity$1.Error };
-        }
-        else if (parsed.port >= maxPortNumber) {
-            return { content: invalidPortNumberString, severity: Severity$1.Error };
-        }
-        else if (canElevate && tunnelService.isPortPrivileged(parsed.port)) {
-            return { content: requiresSudoString, severity: Severity$1.Info };
-        }
-        else if (mapHasAddressLocalhostOrAllInterfaces(remoteExplorerService.tunnelModel.forwarded, parsed.host, parsed.port)) {
-            return { content: alreadyForwarded, severity: Severity$1.Error };
+            return {
+                content: invalidPortString,
+                severity: Severity$1.Error
+            };
+        } else if (parsed.port >= maxPortNumber) {
+            return {
+                content: invalidPortNumberString,
+                severity: Severity$1.Error
+            };
+        } else if (canElevate && tunnelService.isPortPrivileged(parsed.port)) {
+            return {
+                content: requiresSudoString,
+                severity: Severity$1.Info
+            };
+        } else if (mapHasAddressLocalhostOrAllInterfaces(remoteExplorerService.tunnelModel.forwarded, parsed.host, parsed.port)) {
+            return {
+                content: alreadyForwarded,
+                severity: Severity$1.Error
+            };
         }
         return null;
     }
     function error(notificationService, tunnelOrError, host, port) {
         if (!tunnelOrError) {
             notificationService.warn(( localize(
-                10350,
+                10668,
                 "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(( localize(10351, "Unable to forward {0}:{1}. {2}", host, port, tunnelOrError)));
+        } else if (typeof tunnelOrError === "string") {
+            notificationService.warn(( localize(10669, "Unable to forward {0}:{1}. {2}", host, port, tunnelOrError)));
         }
     }
     function inlineHandler() {
@@ -1132,12 +1219,17 @@ var ForwardPortAction;
                     let parsed;
                     if (success && (parsed = parseAddress(value))) {
                         remoteExplorerService.forward({
-                            remote: { host: parsed.host, port: parsed.port },
+                            remote: {
+                                host: parsed.host,
+                                port: parsed.port
+                            },
                             elevateIfNeeded: true
-                        }).then(tunnelOrError => error(notificationService, tunnelOrError, parsed.host, parsed.port));
+                        }).then(
+                            tunnelOrError => error(notificationService, tunnelOrError, parsed.host, parsed.port)
+                        );
                     }
                 },
-                validationMessage: (value) => validateInput(remoteExplorerService, tunnelService, value, tunnelService.canElevate),
+                validationMessage: value => validateInput(remoteExplorerService, tunnelService, value, tunnelService.canElevate),
                 placeholder: forwardPrompt
             });
         };
@@ -1153,12 +1245,17 @@ var ForwardPortAction;
             await viewsService.openView(TunnelPanel.ID, true);
             const value = await quickInputService.input({
                 prompt: forwardPrompt,
-                validateInput: (value) => Promise.resolve(validateInput(remoteExplorerService, tunnelService, value, tunnelService.canElevate))
+                validateInput: value => Promise.resolve(
+                    validateInput(remoteExplorerService, tunnelService, value, tunnelService.canElevate)
+                )
             });
             let parsed;
             if (value && (parsed = parseAddress(value))) {
                 remoteExplorerService.forward({
-                    remote: { host: parsed.host, port: parsed.port },
+                    remote: {
+                        host: parsed.host,
+                        port: parsed.port
+                    },
                     elevateIfNeeded: true
                 }).then(tunnel => error(notificationService, tunnel, parsed.host, parsed.port));
             }
@@ -1178,7 +1275,7 @@ function makeTunnelPicks(tunnels, remoteExplorerService, tunnelService) {
     if (picks.length === 0) {
         picks.push({
             label: ( localize(
-                10352,
+                10670,
                 "No ports currently forwarded. Try running the {0} command",
                 ForwardPortAction.LABEL.value
             ))
@@ -1187,10 +1284,10 @@ function makeTunnelPicks(tunnels, remoteExplorerService, tunnelService) {
     return picks;
 }
 var ClosePortAction;
-(function (ClosePortAction) {
-    ClosePortAction.INLINE_ID = 'remote.tunnel.closeInline';
-    ClosePortAction.COMMANDPALETTE_ID = 'remote.tunnel.closeCommandPalette';
-    ClosePortAction.LABEL = ( localize2(10353, "Stop Forwarding Port"));
+(function(ClosePortAction) {
+    ClosePortAction.INLINE_ID = "remote.tunnel.closeInline";
+    ClosePortAction.COMMANDPALETTE_ID = "remote.tunnel.closeCommandPalette";
+    ClosePortAction.LABEL = ( localize2(10671, "Stop Forwarding Port"));
     function inlineHandler() {
         return async (accessor, arg) => {
             const contextKeyService = accessor.get(IContextKeyService);
@@ -1204,11 +1301,9 @@ var ClosePortAction;
                         ports?.push(tunnel);
                     }
                 });
-            }
-            else if (isITunnelItem(arg)) {
+            } else if (isITunnelItem(arg)) {
                 ports = [arg];
-            }
-            else {
+            } else {
                 const context = contextKeyService.getContextKeyValue(TunnelViewSelectionKeyName);
                 const tunnel = context ? remoteExplorerService.tunnelModel.forwarded.get(context) : undefined;
                 if (tunnel) {
@@ -1218,24 +1313,29 @@ var ClosePortAction;
             if (!ports || ports.length === 0) {
                 return;
             }
-            return Promise.all(( ports.map(
-                port => remoteExplorerService.close({ host: port.remoteHost, port: port.remotePort }, TunnelCloseReason.User)
-            )));
+            return Promise.all(( ports.map(port => remoteExplorerService.close({
+                host: port.remoteHost,
+                port: port.remotePort
+            }, TunnelCloseReason.User))));
         };
     }
     ClosePortAction.inlineHandler = inlineHandler;
     function commandPaletteHandler() {
-        return async (accessor) => {
+        return async accessor => {
             const quickInputService = accessor.get(IQuickInputService);
             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: ( localize(10354, "Choose a port to stop forwarding")) });
+            const result = await quickInputService.pick(picks, {
+                placeHolder: ( localize(10672, "Choose a port to stop forwarding"))
+            });
             if (result && result.tunnel) {
-                await remoteExplorerService.close({ host: result.tunnel.remoteHost, port: result.tunnel.remotePort }, TunnelCloseReason.User);
-            }
-            else if (result) {
+                await remoteExplorerService.close({
+                    host: result.tunnel.remoteHost,
+                    port: result.tunnel.remotePort
+                }, TunnelCloseReason.User);
+            } else if (result) {
                 await commandService.executeCommand(ForwardPortAction.COMMANDPALETTE_ID);
             }
         };
@@ -1243,16 +1343,15 @@ var ClosePortAction;
     ClosePortAction.commandPaletteHandler = commandPaletteHandler;
 })(ClosePortAction || (ClosePortAction = {}));
 var OpenPortInBrowserAction;
-(function (OpenPortInBrowserAction) {
-    OpenPortInBrowserAction.ID = 'remote.tunnel.open';
-    OpenPortInBrowserAction.LABEL = ( localize(10355, "Open in Browser"));
+(function(OpenPortInBrowserAction) {
+    OpenPortInBrowserAction.ID = "remote.tunnel.open";
+    OpenPortInBrowserAction.LABEL = ( localize(10673, "Open in Browser"));
     function handler() {
         return async (accessor, arg) => {
             let key;
             if (isITunnelItem(arg)) {
                 key = makeAddress(arg.remoteHost, arg.remotePort);
-            }
-            else if (isRemoteTunnel(arg)) {
+            } else if (isRemoteTunnel(arg)) {
                 key = makeAddress(arg.tunnelRemoteHost, arg.tunnelRemotePort);
             }
             if (key) {
@@ -1266,23 +1365,24 @@ var OpenPortInBrowserAction;
     function run(model, openerService, key) {
         const tunnel = model.forwarded.get(key) || model.detected.get(key);
         if (tunnel) {
-            return openerService.open(tunnel.localUri, { allowContributedOpeners: false });
+            return openerService.open(tunnel.localUri, {
+                allowContributedOpeners: false
+            });
         }
         return Promise.resolve();
     }
     OpenPortInBrowserAction.run = run;
 })(OpenPortInBrowserAction || (OpenPortInBrowserAction = {}));
 var OpenPortInPreviewAction;
-(function (OpenPortInPreviewAction) {
-    OpenPortInPreviewAction.ID = 'remote.tunnel.openPreview';
-    OpenPortInPreviewAction.LABEL = ( localize(10356, "Preview in Editor"));
+(function(OpenPortInPreviewAction) {
+    OpenPortInPreviewAction.ID = "remote.tunnel.openPreview";
+    OpenPortInPreviewAction.LABEL = ( localize(10674, "Preview in Editor"));
     function handler() {
         return async (accessor, arg) => {
             let key;
             if (isITunnelItem(arg)) {
                 key = makeAddress(arg.remoteHost, arg.remotePort);
-            }
-            else if (isRemoteTunnel(arg)) {
+            } else if (isRemoteTunnel(arg)) {
                 key = makeAddress(arg.tunnelRemoteHost, arg.tunnelRemotePort);
             }
             if (key) {
@@ -1297,11 +1397,15 @@ var OpenPortInPreviewAction;
     async function run(model, openerService, externalOpenerService, key) {
         const tunnel = model.forwarded.get(key) || model.detected.get(key);
         if (tunnel) {
-            const remoteHost = tunnel.remoteHost.includes(':') ? `[${tunnel.remoteHost}]` : tunnel.remoteHost;
+            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 }, CancellationToken.None);
+            const opener = await externalOpenerService.getOpener(tunnel.localUri, {
+                sourceUri
+            }, CancellationToken.None);
             if (opener) {
-                return opener.openExternalUri(tunnel.localUri, { sourceUri }, CancellationToken.None);
+                return opener.openExternalUri(tunnel.localUri, {
+                    sourceUri
+                }, CancellationToken.None);
             }
             return openerService.open(tunnel.localUri);
         }
@@ -1310,9 +1414,9 @@ var OpenPortInPreviewAction;
     OpenPortInPreviewAction.run = run;
 })(OpenPortInPreviewAction || (OpenPortInPreviewAction = {}));
 var OpenPortInBrowserCommandPaletteAction;
-(function (OpenPortInBrowserCommandPaletteAction) {
-    OpenPortInBrowserCommandPaletteAction.ID = 'remote.tunnel.openCommandPalette';
-    OpenPortInBrowserCommandPaletteAction.LABEL = ( localize(10357, "Open Port in Browser"));
+(function(OpenPortInBrowserCommandPaletteAction) {
+    OpenPortInBrowserCommandPaletteAction.ID = "remote.tunnel.openCommandPalette";
+    OpenPortInBrowserCommandPaletteAction.LABEL = ( localize(10675, "Open Port in Browser"));
     function handler() {
         return async (accessor, arg) => {
             const remoteExplorerService = accessor.get(IRemoteExplorerService);
@@ -1331,31 +1435,37 @@ var OpenPortInBrowserCommandPaletteAction;
             }));
             if (options.length === 0) {
                 options.push({
-                    label: ( localize(10358, "No ports currently forwarded. Open the Ports view to get started."))
+                    label: ( localize(10676, "No ports currently forwarded. Open the Ports view to get started."))
                 });
-            }
-            else {
+            } else {
                 options.push({
-                    label: ( localize(10359, "Open the Ports view..."))
+                    label: ( localize(10677, "Open the Ports view..."))
                 });
             }
-            const picked = await quickPickService.pick(options, { placeHolder: ( localize(10360, "Choose the port to open")) });
+            const picked = await quickPickService.pick(options, {
+                placeHolder: ( localize(10678, "Choose the port to open"))
+            });
             if (picked && picked.tunnel) {
-                return OpenPortInBrowserAction.run(model, openerService, makeAddress(picked.tunnel.remoteHost, picked.tunnel.remotePort));
-            }
-            else if (picked) {
+                return OpenPortInBrowserAction.run(
+                    model,
+                    openerService,
+                    makeAddress(picked.tunnel.remoteHost, picked.tunnel.remotePort)
+                );
+            } else if (picked) {
                 return commandService.executeCommand(`${TUNNEL_VIEW_ID}.focus`);
             }
         };
     }
     OpenPortInBrowserCommandPaletteAction.handler = handler;
-})(OpenPortInBrowserCommandPaletteAction || (OpenPortInBrowserCommandPaletteAction = {}));
+})(
+    OpenPortInBrowserCommandPaletteAction || (OpenPortInBrowserCommandPaletteAction = {})
+);
 var CopyAddressAction;
-(function (CopyAddressAction) {
-    CopyAddressAction.INLINE_ID = 'remote.tunnel.copyAddressInline';
-    CopyAddressAction.COMMANDPALETTE_ID = 'remote.tunnel.copyAddressCommandPalette';
-    CopyAddressAction.INLINE_LABEL = ( localize(10361, "Copy Local Address"));
-    CopyAddressAction.COMMANDPALETTE_LABEL = ( localize(10362, "Copy Forwarded Port Address"));
+(function(CopyAddressAction) {
+    CopyAddressAction.INLINE_ID = "remote.tunnel.copyAddressInline";
+    CopyAddressAction.COMMANDPALETTE_ID = "remote.tunnel.copyAddressCommandPalette";
+    CopyAddressAction.INLINE_LABEL = ( localize(10679, "Copy Local Address"));
+    CopyAddressAction.COMMANDPALETTE_LABEL = ( localize(10680, "Copy Forwarded Port Address"));
     async function copyAddress(remoteExplorerService, clipboardService, tunnelItem) {
         const address = remoteExplorerService.tunnelModel.address(tunnelItem.remoteHost, tunnelItem.remotePort);
         if (address) {
@@ -1368,8 +1478,7 @@ var CopyAddressAction;
             let tunnelItem;
             if (isITunnelItem(arg)) {
                 tunnelItem = arg;
-            }
-            else {
+            } else {
                 const context = accessor.get(IContextKeyService).getContextKeyValue(TunnelViewSelectionKeyName);
                 tunnelItem = context ? remoteExplorerService.tunnelModel.forwarded.get(context) : undefined;
             }
@@ -1387,11 +1496,12 @@ var CopyAddressAction;
             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: ( localize(10363, "Choose a forwarded port")) });
+            const result = await quickInputService.pick(makeTunnelPicks(tunnels, remoteExplorerService, tunnelService), {
+                placeHolder: ( localize(10681, "Choose a forwarded port"))
+            });
             if (result && result.tunnel) {
                 await copyAddress(remoteExplorerService, clipboardService, result.tunnel);
-            }
-            else if (result) {
+            } else if (result) {
                 await commandService.executeCommand(ForwardPortAction.COMMANDPALETTE_ID);
             }
         };
@@ -1399,18 +1509,25 @@ var CopyAddressAction;
     CopyAddressAction.commandPaletteHandler = commandPaletteHandler;
 })(CopyAddressAction || (CopyAddressAction = {}));
 var ChangeLocalPortAction;
-(function (ChangeLocalPortAction) {
-    ChangeLocalPortAction.ID = 'remote.tunnel.changeLocalPort';
-    ChangeLocalPortAction.LABEL = ( localize(10364, "Change Local Address Port"));
+(function(ChangeLocalPortAction) {
+    ChangeLocalPortAction.ID = "remote.tunnel.changeLocalPort";
+    ChangeLocalPortAction.LABEL = ( localize(10682, "Change Local Address Port"));
     function validateInput(tunnelService, value, canElevate) {
         if (!value.match(/^[0-9]+$/)) {
-            return { content: ( localize(10365, "Local port should be a number.")), severity: Severity$1.Error };
-        }
-        else if (Number(value) >= maxPortNumber) {
-            return { content: invalidPortNumberString, severity: Severity$1.Error };
-        }
-        else if (canElevate && tunnelService.isPortPrivileged(Number(value))) {
-            return { content: requiresSudoString, severity: Severity$1.Info };
+            return {
+                content: ( localize(10683, "Local port should be a number.")),
+                severity: Severity$1.Error
+            };
+        } else if (Number(value) >= maxPortNumber) {
+            return {
+                content: invalidPortNumberString,
+                severity: Severity$1.Error
+            };
+        } else if (canElevate && tunnelService.isPortPrivileged(Number(value))) {
+            return {
+                content: requiresSudoString,
+                severity: Severity$1.Info
+            };
         }
         return null;
     }
@@ -1422,8 +1539,7 @@ var ChangeLocalPortAction;
             let tunnelContext;
             if (isITunnelItem(arg)) {
                 tunnelContext = arg;
-            }
-            else {
+            } else {
                 const context = accessor.get(IContextKeyService).getContextKeyValue(TunnelViewSelectionKeyName);
                 const tunnel = context ? remoteExplorerService.tunnelModel.forwarded.get(context) : undefined;
                 if (tunnel) {
@@ -1437,18 +1553,24 @@ var ChangeLocalPortAction;
                     onFinish: async (value, success) => {
                         remoteExplorerService.setEditable(tunnelItem, TunnelEditId.LocalPort, null);
                         if (success) {
-                            await remoteExplorerService.close({ host: tunnelItem.remoteHost, port: tunnelItem.remotePort }, TunnelCloseReason.Other);
+                            await remoteExplorerService.close({
+                                host: tunnelItem.remoteHost,
+                                port: tunnelItem.remotePort
+                            }, TunnelCloseReason.Other);
                             const numberValue = Number(value);
                             const newForward = await remoteExplorerService.forward({
-                                remote: { host: tunnelItem.remoteHost, port: tunnelItem.remotePort },
+                                remote: {
+                                    host: tunnelItem.remoteHost,
+                                    port: tunnelItem.remotePort
+                                },
                                 local: numberValue,
                                 name: tunnelItem.name,
                                 elevateIfNeeded: true,
                                 source: tunnelItem.source
                             });
-                            if (newForward && (typeof newForward !== 'string') && newForward.tunnelLocalPort !== numberValue) {
+                            if (newForward && (typeof newForward !== "string") && newForward.tunnelLocalPort !== numberValue) {
                                 notificationService.warn(( localize(
-                                    10366,
+                                    10684,
                                     "The local port {0} is not available. Port number {1} has been used instead",
                                     value,
                                     newForward.tunnelLocalPort ?? newForward.localAddress
@@ -1456,8 +1578,8 @@ var ChangeLocalPortAction;
                             }
                         }
                     },
-                    validationMessage: (value) => validateInput(tunnelService, value, tunnelService.canElevate),
-                    placeholder: ( localize(10367, "New local port"))
+                    validationMessage: value => validateInput(tunnelService, value, tunnelService.canElevate),
+                    placeholder: ( localize(10685, "New local port"))
                 });
             }
         };
@@ -1465,14 +1587,20 @@ var ChangeLocalPortAction;
     ChangeLocalPortAction.handler = handler;
 })(ChangeLocalPortAction || (ChangeLocalPortAction = {}));
 var ChangeTunnelPrivacyAction;
-(function (ChangeTunnelPrivacyAction) {
+(function(ChangeTunnelPrivacyAction) {
     function handler(privacyId) {
         return async (accessor, arg) => {
             if (isITunnelItem(arg)) {
                 const remoteExplorerService = accessor.get(IRemoteExplorerService);
-                await remoteExplorerService.close({ host: arg.remoteHost, port: arg.remotePort }, TunnelCloseReason.Other);
+                await remoteExplorerService.close({
+                    host: arg.remoteHost,
+                    port: arg.remotePort
+                }, TunnelCloseReason.Other);
                 return remoteExplorerService.forward({
-                    remote: { host: arg.remoteHost, port: arg.remotePort },
+                    remote: {
+                        host: arg.remoteHost,
+                        port: arg.remotePort
+                    },
                     local: arg.localPort,
                     name: arg.name,
                     elevateIfNeeded: true,
@@ -1486,11 +1614,11 @@ var ChangeTunnelPrivacyAction;
     ChangeTunnelPrivacyAction.handler = handler;
 })(ChangeTunnelPrivacyAction || (ChangeTunnelPrivacyAction = {}));
 var SetTunnelProtocolAction;
-(function (SetTunnelProtocolAction) {
-    SetTunnelProtocolAction.ID_HTTP = 'remote.tunnel.setProtocolHttp';
-    SetTunnelProtocolAction.ID_HTTPS = 'remote.tunnel.setProtocolHttps';
-    SetTunnelProtocolAction.LABEL_HTTP = ( localize(10368, "HTTP"));
-    SetTunnelProtocolAction.LABEL_HTTPS = ( localize(10369, "HTTPS"));
+(function(SetTunnelProtocolAction) {
+    SetTunnelProtocolAction.ID_HTTP = "remote.tunnel.setProtocolHttp";
+    SetTunnelProtocolAction.ID_HTTPS = "remote.tunnel.setProtocolHttps";
+    SetTunnelProtocolAction.LABEL_HTTP = ( localize(10686, "HTTP"));
+    SetTunnelProtocolAction.LABEL_HTTPS = ( localize(10687, "HTTPS"));
     async function handler(arg, protocol, remoteExplorerService, environmentService) {
         if (isITunnelItem(arg)) {
             const attributes = {
@@ -1502,13 +1630,23 @@ var SetTunnelProtocolAction;
     }
     function handlerHttp() {
         return async (accessor, arg) => {
-            return handler(arg, TunnelProtocol.Http, accessor.get(IRemoteExplorerService), accessor.get(IWorkbenchEnvironmentService));
+            return handler(
+                arg,
+                TunnelProtocol.Http,
+                accessor.get(IRemoteExplorerService),
+                accessor.get(IWorkbenchEnvironmentService)
+            );
         };
     }
     SetTunnelProtocolAction.handlerHttp = handlerHttp;
     function handlerHttps() {
         return async (accessor, arg) => {
-            return handler(arg, TunnelProtocol.Https, accessor.get(IRemoteExplorerService), accessor.get(IWorkbenchEnvironmentService));
+            return handler(
+                arg,
+                TunnelProtocol.Https,
+                accessor.get(IRemoteExplorerService),
+                accessor.get(IWorkbenchEnvironmentService)
+            );
         };
     }
     SetTunnelProtocolAction.handlerHttps = handlerHttps;
@@ -1528,7 +1666,10 @@ KeybindingsRegistry.registerCommandAndKeybindingRule({
     handler: LabelTunnelAction.handler()
 });
 CommandsRegistry.registerCommand(ForwardPortAction.INLINE_ID, ForwardPortAction.inlineHandler());
-CommandsRegistry.registerCommand(ForwardPortAction.COMMANDPALETTE_ID, ForwardPortAction.commandPaletteHandler());
+CommandsRegistry.registerCommand(
+    ForwardPortAction.COMMANDPALETTE_ID,
+    ForwardPortAction.commandPaletteHandler()
+);
 KeybindingsRegistry.registerCommandAndKeybindingRule({
     id: ClosePortAction.INLINE_ID,
     weight: KeybindingWeight.WorkbenchContrib + tunnelViewCommandsWeightBonus,
@@ -1543,7 +1684,10 @@ KeybindingsRegistry.registerCommandAndKeybindingRule({
 CommandsRegistry.registerCommand(ClosePortAction.COMMANDPALETTE_ID, ClosePortAction.commandPaletteHandler());
 CommandsRegistry.registerCommand(OpenPortInBrowserAction.ID, OpenPortInBrowserAction.handler());
 CommandsRegistry.registerCommand(OpenPortInPreviewAction.ID, OpenPortInPreviewAction.handler());
-CommandsRegistry.registerCommand(OpenPortInBrowserCommandPaletteAction.ID, OpenPortInBrowserCommandPaletteAction.handler());
+CommandsRegistry.registerCommand(
+    OpenPortInBrowserCommandPaletteAction.ID,
+    OpenPortInBrowserCommandPaletteAction.handler()
+);
 KeybindingsRegistry.registerCommandAndKeybindingRule({
     id: CopyAddressAction.INLINE_ID,
     weight: KeybindingWeight.WorkbenchContrib + tunnelViewCommandsWeightBonus,
@@ -1555,7 +1699,10 @@ KeybindingsRegistry.registerCommandAndKeybindingRule({
     primary: KeyMod$1.CtrlCmd | KeyCode.KeyC,
     handler: CopyAddressAction.inlineHandler()
 });
-CommandsRegistry.registerCommand(CopyAddressAction.COMMANDPALETTE_ID, CopyAddressAction.commandPaletteHandler());
+CommandsRegistry.registerCommand(
+    CopyAddressAction.COMMANDPALETTE_ID,
+    CopyAddressAction.commandPaletteHandler()
+);
 CommandsRegistry.registerCommand(ChangeLocalPortAction.ID, ChangeLocalPortAction.handler());
 CommandsRegistry.registerCommand(SetTunnelProtocolAction.ID_HTTP, SetTunnelProtocolAction.handlerHttp());
 CommandsRegistry.registerCommand(SetTunnelProtocolAction.ID_HTTPS, SetTunnelProtocolAction.handlerHttps());
@@ -1588,25 +1735,25 @@ MenuRegistry.appendMenuItem(MenuId.CommandPalette, ({
     when: forwardedPortsViewEnabled
 }));
 MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
-    group: '._open',
+    group: "._open",
     order: 0,
     command: {
         id: OpenPortInBrowserAction.ID,
-        title: OpenPortInBrowserAction.LABEL,
+        title: OpenPortInBrowserAction.LABEL
     },
     when: ( ContextKeyExpr.and(isForwardedOrDetectedExpr, isNotMultiSelectionExpr))
 }));
 MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
-    group: '._open',
+    group: "._open",
     order: 1,
     command: {
         id: OpenPortInPreviewAction.ID,
-        title: OpenPortInPreviewAction.LABEL,
+        title: OpenPortInPreviewAction.LABEL
     },
     when: ( ContextKeyExpr.and(isForwardedOrDetectedExpr, isNotMultiSelectionExpr))
 }));
 MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
-    group: '0_manage',
+    group: "0_manage",
     order: 1,
     command: {
         id: LabelTunnelAction.ID,
@@ -1616,53 +1763,53 @@ MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
     when: ( ContextKeyExpr.and(isForwardedExpr, isNotMultiSelectionExpr))
 }));
 MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
-    group: '2_localaddress',
+    group: "2_localaddress",
     order: 0,
     command: {
         id: CopyAddressAction.INLINE_ID,
-        title: CopyAddressAction.INLINE_LABEL,
+        title: CopyAddressAction.INLINE_LABEL
     },
     when: ( ContextKeyExpr.and(isForwardedOrDetectedExpr, isNotMultiSelectionExpr))
 }));
 MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
-    group: '2_localaddress',
+    group: "2_localaddress",
     order: 1,
     command: {
         id: ChangeLocalPortAction.ID,
-        title: ChangeLocalPortAction.LABEL,
+        title: ChangeLocalPortAction.LABEL
     },
     when: ( ContextKeyExpr.and(isForwardedExpr, PortChangableContextKey, isNotMultiSelectionExpr))
 }));
 MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
-    group: '2_localaddress',
+    group: "2_localaddress",
     order: 2,
     submenu: MenuId.TunnelPrivacy,
-    title: ( localize(10370, "Port Visibility")),
+    title: ( localize(10688, "Port Visibility")),
     when: ( ContextKeyExpr.and(isForwardedExpr, TunnelPrivacyEnabledContextKey))
 }));
 MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
-    group: '2_localaddress',
+    group: "2_localaddress",
     order: 3,
     submenu: MenuId.TunnelProtocol,
-    title: ( localize(10371, "Change Port Protocol")),
+    title: ( localize(10689, "Change Port Protocol")),
     when: ( ContextKeyExpr.and(isForwardedExpr, isNotMultiSelectionExpr, ProtocolChangeableContextKey))
 }));
 MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
-    group: '3_forward',
+    group: "3_forward",
     order: 0,
     command: {
         id: ClosePortAction.INLINE_ID,
-        title: ClosePortAction.LABEL,
+        title: ClosePortAction.LABEL
     },
     when: TunnelCloseableContextKey
 }));
 MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
-    group: '3_forward',
+    group: "3_forward",
     order: 1,
     command: {
         id: ForwardPortAction.INLINE_ID,
-        title: ForwardPortAction.LABEL,
-    },
+        title: ForwardPortAction.LABEL
+    }
 }));
 MenuRegistry.appendMenuItem(MenuId.TunnelProtocol, ({
     order: 0,
@@ -1681,7 +1828,7 @@ MenuRegistry.appendMenuItem(MenuId.TunnelProtocol, ({
     }
 }));
 MenuRegistry.appendMenuItem(MenuId.TunnelPortInline, ({
-    group: '0_manage',
+    group: "0_manage",
     order: 0,
     command: {
         id: ForwardPortAction.INLINE_ID,
@@ -1691,7 +1838,7 @@ MenuRegistry.appendMenuItem(MenuId.TunnelPortInline, ({
     when: ( TunnelTypeContextKey.isEqualTo(TunnelType.Candidate))
 }));
 MenuRegistry.appendMenuItem(MenuId.TunnelPortInline, ({
-    group: '0_manage',
+    group: "0_manage",
     order: 4,
     command: {
         id: LabelTunnelAction.ID,
@@ -1701,7 +1848,7 @@ MenuRegistry.appendMenuItem(MenuId.TunnelPortInline, ({
     when: isForwardedExpr
 }));
 MenuRegistry.appendMenuItem(MenuId.TunnelPortInline, ({
-    group: '0_manage',
+    group: "0_manage",
     order: 5,
     command: {
         id: ClosePortAction.INLINE_ID,
@@ -1737,9 +1884,13 @@ MenuRegistry.appendMenuItem(MenuId.TunnelLocalAddressInline, ({
     },
     when: isForwardedOrDetectedExpr
 }));
-registerColor('ports.iconRunningProcessForeground', STATUS_BAR_REMOTE_ITEM_BACKGROUND, ( localize(
-    10372,
+registerColor(
+    "ports.iconRunningProcessForeground",
+    STATUS_BAR_REMOTE_ITEM_BACKGROUND,
+    ( localize(
+    10690,
     "The color of the icon for a port that has an associated running process."
-)));
+))
+);
 
 export { ForwardPortAction, OpenPortInBrowserAction, OpenPortInPreviewAction, TunnelPanel, TunnelPanelDescriptor, TunnelViewModel, openPreviewEnabledContext };