@codingame/monaco-vscode-api 1.78.8 → 1.79.0

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

@@ -0,0 +1,1636 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import "../../../../../../assets/tunnelView.css";
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { IViewDescriptorService, IViewsService } from '../../../common/views.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { IContextMenuService, IContextViewService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { ContextKeyExpr, RawContextKey, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { CommandsRegistry, ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { toDisposable, Disposable, dispose, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { IconLabel } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLabel.js';
+import { ActionRunner } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { MenuRegistry, MenuId, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { createAndFillInActionBarActions, createActionViewItem } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { TUNNEL_VIEW_ID, TunnelType, makeAddress, IRemoteExplorerService, TunnelEditId, parseAddress, mapHasAddressLocalhostOrAllInterfaces } from '../../../services/remote/common/remoteExplorerService.js';
+import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+import { INotificationService, Severity } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { InputBox } from 'monaco-editor/esm/vs/base/browser/ui/inputbox/inputBox.js';
+import { once } from 'monaco-editor/esm/vs/base/common/functional.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { ViewPane } from '../../../browser/parts/views/viewPane.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { TunnelProtocol, TunnelPrivacyId, ITunnelService, isLocalhost, isAllInterfaces } from '../../../../platform/tunnel/common/tunnel.js';
+import { KeybindingsRegistry } from 'monaco-editor/esm/vs/platform/keybinding/common/keybindingsRegistry.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { ActionViewItem } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionViewItems.js';
+import { labelPortIcon, forwardPortIcon, stopForwardIcon, copyAddressIcon, openBrowserIcon, openPreviewIcon, privatePortIcon, forwardedPortWithProcessIcon, forwardedPortWithoutProcessIcon } from './remoteIcons.js';
+import { IExternalUriOpenerService } from '../../externalUriOpener/common/externalUriOpenerService.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { WorkbenchTable } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { Button } from 'monaco-editor/esm/vs/base/browser/ui/button/button.js';
+import { registerColor } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { MarkdownString } from 'monaco-editor/esm/vs/base/common/htmlContent.js';
+import { IHoverService } from '../../../services/hover/browser/hover.js';
+import { STATUS_BAR_HOST_NAME_BACKGROUND } from '../../../common/theme.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { defaultButtonStyles, defaultInputBoxStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+const forwardedPortsViewEnabled = ( (new RawContextKey(
+    'forwardedPortsViewEnabled',
+    false,
+     (nls.localize('tunnel.forwardedPortsViewEnabled', "Whether the Ports view is enabled."))
+)));
+const openPreviewEnabledContext = ( (new RawContextKey('openPreviewEnabled', false)));
+class TunnelTreeVirtualDelegate {
+    constructor(remoteExplorerService) {
+        this.remoteExplorerService = remoteExplorerService;
+        this.headerRowHeight = 22;
+    }
+    getHeight(row) {
+        return (row.tunnelType === TunnelType.Add && !this.remoteExplorerService.getEditableData(undefined)) ? 30 : 22;
+    }
+}
+function emptyCell(item) {
+    return { label: '', tunnel: item, editId: TunnelEditId.None, tooltip: '' };
+}
+class IconColumn {
+    constructor() {
+        this.label = '';
+        this.tooltip = '';
+        this.weight = 1;
+        this.minimumWidth = 40;
+        this.maximumWidth = 40;
+        this.templateId = 'actionbar';
+    }
+    project(row) {
+        if (row.tunnelType === TunnelType.Add) {
+            return emptyCell(row);
+        }
+        const icon = row.processDescription ? forwardedPortWithProcessIcon : forwardedPortWithoutProcessIcon;
+        let tooltip = '';
+        if (row instanceof TunnelItem) {
+            tooltip = `${row.iconTooltip} ${row.tooltipPostfix}`;
+        }
+        return {
+            label: '', icon, tunnel: row, editId: TunnelEditId.None, tooltip
+        };
+    }
+}
+class PortColumn {
+    constructor() {
+        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';
+    }
+    project(row) {
+        const isAdd = row.tunnelType === TunnelType.Add;
+        const label = row.label;
+        let tooltip = '';
+        if (row instanceof TunnelItem && !isAdd) {
+            tooltip = `${row.portTooltip} ${row.tooltipPostfix}`;
+        }
+        else {
+            tooltip = label;
+        }
+        return {
+            label, tunnel: row, menuId: MenuId.TunnelPortInline,
+            editId: row.tunnelType === TunnelType.Add ? TunnelEditId.New : TunnelEditId.Label, tooltip
+        };
+    }
+}
+class LocalAddressColumn {
+    constructor() {
+        this.label = ( (nls.localize('tunnel.addressColumn.label', "Local Address")));
+        this.tooltip = ( (nls.localize(
+            'tunnel.addressColumn.tooltip',
+            "The address that the forwarded port is available at locally."
+        )));
+        this.weight = 1;
+        this.templateId = 'actionbar';
+    }
+    project(row) {
+        if (row.tunnelType === TunnelType.Add) {
+            return emptyCell(row);
+        }
+        const label = row.localAddress ?? '';
+        let tooltip = label;
+        if (row instanceof TunnelItem) {
+            tooltip = row.tooltipPostfix;
+        }
+        return {
+            label,
+            menuId: MenuId.TunnelLocalAddressInline,
+            tunnel: row,
+            editId: TunnelEditId.LocalPort,
+            tooltip,
+            markdownTooltip: label ? LocalAddressColumn.getHoverText(label) : undefined
+        };
+    }
+    static getHoverText(localAddress) {
+        return function (configurationService) {
+            const editorConf = configurationService.getValue('editor');
+            let clickLabel = '';
+            if (editorConf.multiCursorModifier === 'ctrlCmd') {
+                if (isMacintosh) {
+                    clickLabel = ( (nls.localize('portsLink.followLinkAlt.mac', "option + click")));
+                }
+                else {
+                    clickLabel = ( (nls.localize('portsLink.followLinkAlt', "alt + click")));
+                }
+            }
+            else {
+                if (isMacintosh) {
+                    clickLabel = ( (nls.localize('portsLink.followLinkCmd', "cmd + click")));
+                }
+                else {
+                    clickLabel = ( (nls.localize('portsLink.followLinkCtrl', "ctrl + click")));
+                }
+            }
+            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 = ( (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';
+    }
+    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 : '' };
+    }
+}
+class OriginColumn {
+    constructor() {
+        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';
+    }
+    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 };
+    }
+}
+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.weight = 1;
+        this.templateId = 'actionbar';
+    }
+    project(row) {
+        if (row.tunnelType === TunnelType.Add) {
+            return emptyCell(row);
+        }
+        const label = row.privacy?.label;
+        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 };
+    }
+}
+let ActionBarRenderer = class ActionBarRenderer extends Disposable {
+    constructor(instantiationService, contextKeyService, menuService, contextViewService, remoteExplorerService, commandService, configurationService, hoverService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this.menuService = menuService;
+        this.contextViewService = contextViewService;
+        this.remoteExplorerService = remoteExplorerService;
+        this.commandService = commandService;
+        this.configurationService = configurationService;
+        this.hoverService = hoverService;
+        this.templateId = 'actionbar';
+    }
+    set actionRunner(actionRunner) {
+        this._actionRunner = actionRunner;
+    }
+    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, {
+            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, {
+            actionViewItemProvider: createActionViewItem.bind(undefined, this.instantiationService)
+        })));
+        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';
+        if (templateData.button) {
+            templateData.button.element.style.display = 'none';
+            templateData.button.dispose();
+        }
+        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 {
+            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)) {
+                this.renderButton(element, templateData);
+            }
+            else {
+                this.renderActionBarItem(element, templateData);
+            }
+        }
+    }
+    renderButton(element, templateData) {
+        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;
+        this._register(templateData.button.onDidClick(() => {
+            this.commandService.executeCommand(ForwardPortAction.INLINE_ID);
+        }));
+    }
+    tunnelContext(tunnel) {
+        let context;
+        if (tunnel instanceof TunnelItem) {
+            context = tunnel.strip();
+        }
+        if (!context) {
+            context = {
+                tunnelType: tunnel.tunnelType,
+                remoteHost: tunnel.remoteHost,
+                remotePort: tunnel.remotePort,
+                localAddress: tunnel.localAddress,
+                protocol: tunnel.protocol,
+                localUri: tunnel.localUri,
+                localPort: tunnel.localPort,
+                name: tunnel.name,
+                closeable: tunnel.closeable,
+                source: tunnel.source,
+                privacy: tunnel.privacy,
+                processDescription: tunnel.processDescription,
+                label: tunnel.label
+            };
+        }
+        return context;
+    }
+    renderActionBarItem(element, templateData) {
+        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
+        });
+        templateData.actionBar.context = this.tunnelContext(element.tunnel);
+        templateData.container.style.paddingLeft = '10px';
+        const context = [
+            ['view', TUNNEL_VIEW_ID],
+            [TunnelTypeContextKey.key, element.tunnel.tunnelType],
+            [TunnelCloseableContextKey.key, element.tunnel.closeable],
+            [TunnelPrivacyContextKey.key, element.tunnel.privacy.id],
+            [TunnelProtocolContextKey.key, element.tunnel.protocol]
+        ];
+        const contextKeyService = this.contextKeyService.createOverlay(context);
+        const disposableStore = ( (new DisposableStore()));
+        templateData.elementDisposable = disposableStore;
+        if (element.menuId) {
+            const menu = disposableStore.add(this.menuService.createMenu(element.menuId, contextKeyService));
+            let actions = [];
+            createAndFillInActionBarActions(menu, { shouldForwardArgs: true }, actions);
+            if (actions) {
+                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 });
+                if (this._actionRunner) {
+                    templateData.actionBar.actionRunner = this._actionRunner;
+                }
+            }
+        }
+        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';
+        }
+    }
+    renderInputBox(container, editableData) {
+        if (this.inputDone) {
+            this.inputDone(false, false);
+            this.inputDone = undefined;
+        }
+        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."))),
+            validationOptions: {
+                validation: (value) => {
+                    const message = editableData.validationMessage(value);
+                    if (!message) {
+                        return null;
+                    }
+                    return {
+                        content: message.content,
+                        formatContent: true,
+                        type: message.severity === Severity.Error ? 3  : 1
+                    };
+                }
+            },
+            placeholder: editableData.placeholder || '',
+            inputBoxStyles: defaultInputBoxStyles
+        })));
+        inputBox.value = value;
+        inputBox.focus();
+        inputBox.select({ start: 0, end: editableData.startingValue ? editableData.startingValue.length : 0 });
+        const done = once(async (success, finishEditing) => {
+            dispose(toDispose);
+            if (this.inputDone) {
+                this.inputDone = undefined;
+            }
+            inputBox.element.style.display = 'none';
+            const inputValue = inputBox.value;
+            if (finishEditing) {
+                return editableData.onFinish(inputValue, success);
+            }
+        });
+        this.inputDone = done;
+        const toDispose = [
+            inputBox,
+            dom.addStandardDisposableListener(inputBox.inputElement, dom.EventType.KEY_DOWN, async (e) => {
+                if (e.equals(3 )) {
+                    e.stopPropagation();
+                    if (inputBox.validate() !== 3 ) {
+                        return done(true, true);
+                    }
+                    else {
+                        return done(false, true);
+                    }
+                }
+                else if (e.equals(9 )) {
+                    e.preventDefault();
+                    e.stopPropagation();
+                    return done(false, true);
+                }
+            }),
+            dom.addDisposableListener(inputBox.inputElement, dom.EventType.BLUR, () => {
+                return done(inputBox.validate() !== 3 , true);
+            })
+        ];
+        return toDisposable(() => {
+            done(false, false);
+        });
+    }
+    disposeElement(element, index, templateData, height) {
+        templateData.elementDisposable.dispose();
+    }
+    disposeTemplate(templateData) {
+        templateData.label.dispose();
+        templateData.actionBar.dispose();
+        templateData.elementDisposable.dispose();
+        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)));
+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
+            ))
+        );
+    }
+    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
+            ))
+        );
+    }
+    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;
+        this.source = source;
+        this.hasRunningProcess = hasRunningProcess;
+        this.protocol = protocol;
+        this.localUri = localUri;
+        this.localAddress = localAddress;
+        this.localPort = localPort;
+        this.closeable = closeable;
+        this.name = name;
+        this.runningProcess = runningProcess;
+        this.pid = pid;
+        this._privacy = _privacy;
+        this.remoteExplorerService = remoteExplorerService;
+        this.tunnelService = tunnelService;
+    }
+    get label() {
+        if (this.tunnelType === TunnelType.Add && this.name) {
+            return this.name;
+        }
+        const portNumberLabel = (isLocalhost(this.remoteHost) || isAllInterfaces(this.remoteHost))
+            ? `${this.remotePort}`
+            : `${this.remoteHost}:${this.remotePort}`;
+        if (this.name) {
+            return `${this.name} (${portNumberLabel})`;
+        }
+        else {
+            return portNumberLabel;
+        }
+    }
+    set processDescription(description) {
+        this.runningProcess = description;
+    }
+    get processDescription() {
+        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();
+            }
+            if (this.pid) {
+                description += ` (${this.pid})`;
+            }
+        }
+        else if (this.hasRunningProcess) {
+            description = ( (nls.localize('tunnelView.runningProcess.inacessable', "Process information unavailable")));
+        }
+        return description;
+    }
+    get tooltipPostfix() {
+        let information;
+        if (this.localAddress) {
+            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(
+                '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.")))}`;
+        }
+        else {
+            return this.label;
+        }
+    }
+    get portTooltip() {
+        const isAdd = this.tunnelType === TunnelType.Add;
+        if (!isAdd) {
+            return `${this.name ? ( ( nls.localize('remote.tunnel.tooltipName', "Port labeled {0}. ", this.name))) : ''}`;
+        }
+        else {
+            return '';
+        }
+    }
+    get processTooltip() {
+        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: ( (nls.localize('tunnelPrivacy.unknown', "Unknown")))
+                };
+        }
+        else {
+            return {
+                id: TunnelPrivacyId.Private,
+                themeIcon: privatePortIcon.id,
+                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 TunnelViewSelectionKeyName = 'tunnelViewSelection';
+const TunnelViewSelectionContextKey = ( (new RawContextKey(TunnelViewSelectionKeyName, undefined, true)));
+const TunnelViewMultiSelectionKeyName = 'tunnelViewMultiSelection';
+const TunnelViewMultiSelectionContextKey = ( (new RawContextKey(TunnelViewMultiSelectionKeyName, undefined, true)));
+const PortChangableContextKey = ( (new RawContextKey('portChangable', false, true)));
+let TunnelPanel = class TunnelPanel extends ViewPane {
+    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;
+        this.quickInputService = quickInputService;
+        this.commandService = commandService;
+        this.menuService = menuService;
+        this.remoteExplorerService = remoteExplorerService;
+        this.tunnelService = tunnelService;
+        this.contextViewService = contextViewService;
+        this.hoverService = hoverService;
+        this.isEditing = false;
+        this.titleActions = [];
+        this.lastFocus = [];
+        this.tunnelTypeContext = TunnelTypeContextKey.bindTo(contextKeyService);
+        this.tunnelCloseableContext = TunnelCloseableContextKey.bindTo(contextKeyService);
+        this.tunnelPrivacyContext = TunnelPrivacyContextKey.bindTo(contextKeyService);
+        this.tunnelPrivacyEnabledContext = TunnelPrivacyEnabledContextKey.bindTo(contextKeyService);
+        this.tunnelPrivacyEnabledContext.set(tunnelService.privacyOptions.length !== 0);
+        this.tunnelProtocolContext = TunnelProtocolContextKey.bindTo(contextKeyService);
+        this.tunnelViewFocusContext = TunnelViewFocusContextKey.bindTo(contextKeyService);
+        this.tunnelViewSelectionContext = TunnelViewSelectionContextKey.bindTo(contextKeyService);
+        this.tunnelViewMultiSelectionContext = TunnelViewMultiSelectionContextKey.bindTo(contextKeyService);
+        this.portChangableContextKey = PortChangableContextKey.bindTo(contextKeyService);
+        const overlayContextKeyService = this.contextKeyService.createOverlay([['view', TunnelPanel.ID]]);
+        const titleMenu = this._register(this.menuService.createMenu(MenuId.TunnelTitle, overlayContextKeyService));
+        const updateActions = () => {
+            this.titleActions = [];
+            createAndFillInActionBarActions(titleMenu, undefined, this.titleActions);
+            this.updateActions();
+        };
+        this._register(titleMenu.onDidChange(updateActions));
+        updateActions();
+        this._register(toDisposable(() => {
+            this.titleActions = [];
+        }));
+        this.registerPrivacyActions();
+    }
+    registerPrivacyActions() {
+        for (const privacyOption of this.tunnelService.privacyOptions) {
+            const optionId = `remote.tunnel.privacy${privacyOption.id}`;
+            CommandsRegistry.registerCommand(optionId, ChangeTunnelPrivacyAction.handler(privacyOption.id));
+            MenuRegistry.appendMenuItem(MenuId.TunnelPrivacy, ({
+                order: 0,
+                command: {
+                    id: optionId,
+                    title: privacyOption.label,
+                    toggled: ( (TunnelPrivacyContextKey.isEqualTo(privacyOption.id)))
+                }
+            }));
+        }
+    }
+    get portCount() {
+        return this.remoteExplorerService.tunnelModel.forwarded.size + this.remoteExplorerService.tunnelModel.detected.size;
+    }
+    renderBody(container) {
+        super.renderBody(container);
+        const panelContainer = dom.append(container, dom.$('.tree-explorer-viewlet-tree-view'));
+        const widgetContainer = dom.append(panelContainer, dom.$('.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,
+            this.menuService,
+            this.contextViewService,
+            this.remoteExplorerService,
+            this.commandService,
+            this.configurationService,
+            this.hoverService
+        )));
+        const columns = [( (new IconColumn())), ( (new PortColumn())), ( (new LocalAddressColumn())), ( (new RunningProcessColumn()))];
+        if (this.tunnelService.canChangePrivacy) {
+            columns.push(( (new PrivacyColumn())));
+        }
+        columns.push(( (new OriginColumn())));
+        this.table = this.instantiationService.createInstance(WorkbenchTable, 'RemoteTunnels', widgetContainer, ( (new TunnelTreeVirtualDelegate(this.remoteExplorerService))), columns, [actionBarRenderer], {
+            keyboardNavigationLabelProvider: {
+                getKeyboardNavigationLabel: (item) => {
+                    return item.label;
+                }
+            },
+            multipleSelectionSupport: true,
+            accessibilityProvider: {
+                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.label;
+                    }
+                },
+                getWidgetAriaLabel: () => ( (nls.localize('tunnelView', "Tunnel View")))
+            },
+            openOnSingleClick: true
+        });
+        const actionRunner = ( (new ActionRunner()));
+        actionBarRenderer.actionRunner = actionRunner;
+        this._register(this.table.onContextMenu(e => this.onContextMenu(e, actionRunner)));
+        this._register(this.table.onMouseDblClick(e => this.onMouseDblClick(e)));
+        this._register(this.table.onDidChangeFocus(e => this.onFocusChanged(e)));
+        this._register(this.table.onDidChangeSelection(e => this.onSelectionChanged(e)));
+        this._register(this.table.onDidFocus(() => this.tunnelViewFocusContext.set(true)));
+        this._register(this.table.onDidBlur(() => this.tunnelViewFocusContext.set(false)));
+        const rerender = () => this.table.splice(0, Number.POSITIVE_INFINITY, this.viewModel.all);
+        rerender();
+        let lastPortCount = this.portCount;
+        this._register(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._register(this.table.onMouseClick(e => {
+            if (this.hasOpenLinkModifier(e.browserEvent)) {
+                const selection = this.table.getSelectedElements();
+                if ((selection.length === 0) ||
+                    ((selection.length === 1) && (selection[0] === e.element))) {
+                    this.commandService.executeCommand(OpenPortInBrowserAction.ID, e.element);
+                }
+            }
+        }));
+        this._register(this.table.onDidOpen(e => {
+            if (!e.element || (e.element.tunnelType !== TunnelType.Forwarded)) {
+                return;
+            }
+            if (e.browserEvent?.type === 'dblclick') {
+                this.commandService.executeCommand(LabelTunnelAction.ID);
+            }
+        }));
+        this._register(this.remoteExplorerService.onDidChangeEditable(e => {
+            this.isEditing = !!this.remoteExplorerService.getEditableData(e?.tunnel, e?.editId);
+            this._onDidChangeViewWelcomeState.fire();
+            if (!this.isEditing) {
+                widgetContainer.classList.remove('highlight');
+            }
+            rerender();
+            if (this.isEditing) {
+                widgetContainer.classList.add('highlight');
+                if (!e) {
+                    this.table.reveal(this.table.indexOf(this.viewModel.input));
+                }
+            }
+            else {
+                if (e && (e.tunnel.tunnelType !== TunnelType.Add)) {
+                    this.table.setFocus(this.lastFocus);
+                }
+                this.focus();
+            }
+        }));
+    }
+    shouldShowWelcome() {
+        return this.viewModel.isEmpty() && !this.isEditing;
+    }
+    focus() {
+        super.focus();
+        this.table.domFocus();
+    }
+    onFocusChanged(event) {
+        if (event.indexes.length > 0 && event.elements.length > 0) {
+            this.lastFocus = [...event.indexes];
+        }
+        const elements = event.elements;
+        const item = elements && elements.length ? elements[0] : undefined;
+        if (item) {
+            this.tunnelViewSelectionContext.set(makeAddress(item.remoteHost, item.remotePort));
+            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.portChangableContextKey.set(!!item.localPort);
+        }
+        else {
+            this.tunnelTypeContext.reset();
+            this.tunnelViewSelectionContext.reset();
+            this.tunnelCloseableContext.reset();
+            this.tunnelPrivacyContext.reset();
+            this.tunnelProtocolContext.reset();
+            this.portChangableContextKey.reset();
+        }
+    }
+    hasOpenLinkModifier(e) {
+        const editorConf = this.configurationService.getValue('editor');
+        let modifierKey = false;
+        if (editorConf.multiCursorModifier === 'ctrlCmd') {
+            modifierKey = e.altKey;
+        }
+        else {
+            if (isMacintosh) {
+                modifierKey = e.metaKey;
+            }
+            else {
+                modifierKey = e.ctrlKey;
+            }
+        }
+        return modifierKey;
+    }
+    onSelectionChanged(event) {
+        const elements = event.elements;
+        if (elements.length > 1) {
+            this.tunnelViewMultiSelectionContext.set(( (elements.map(element => makeAddress(element.remoteHost, element.remotePort)))));
+        }
+        else {
+            this.tunnelViewMultiSelectionContext.set(undefined);
+        }
+    }
+    onContextMenu(event, actionRunner) {
+        if ((event.element !== undefined) && !(event.element instanceof TunnelItem)) {
+            return;
+        }
+        event.browserEvent.preventDefault();
+        event.browserEvent.stopPropagation();
+        const node = event.element;
+        if (node) {
+            this.table.setFocus([this.table.indexOf(node)]);
+            this.tunnelTypeContext.set(node.tunnelType);
+            this.tunnelCloseableContext.set(!!node.closeable);
+            this.tunnelPrivacyContext.set(node.privacy.id);
+            this.tunnelProtocolContext.set(node.protocol);
+            this.portChangableContextKey.set(!!node.localPort);
+        }
+        else {
+            this.tunnelTypeContext.set(TunnelType.Add);
+            this.tunnelCloseableContext.set(false);
+            this.tunnelPrivacyContext.set(undefined);
+            this.tunnelProtocolContext.set(undefined);
+            this.portChangableContextKey.set(false);
+        }
+        this.contextMenuService.showContextMenu({
+            menuId: MenuId.TunnelContext,
+            menuActionOptions: { shouldForwardArgs: true },
+            contextKeyService: this.table.contextKeyService,
+            getAnchor: () => event.anchor,
+            getActionViewItem: (action) => {
+                const keybinding = this.keybindingService.lookupKeybinding(action.id);
+                if (keybinding) {
+                    return (
+                         (new ActionViewItem(action, action, { label: true, keybinding: keybinding.getLabel() }))
+                    );
+                }
+                return undefined;
+            },
+            onHide: (wasCancelled) => {
+                if (wasCancelled) {
+                    this.table.domFocus();
+                }
+            },
+            getActionsContext: () => node?.strip(),
+            actionRunner
+        });
+    }
+    onMouseDblClick(e) {
+        if (!e.element) {
+            this.commandService.executeCommand(ForwardPortAction.INLINE_ID);
+        }
+    }
+    layoutBody(height, width) {
+        super.layoutBody(height, width);
+        this.table.layout(height, width);
+    }
+};
+TunnelPanel.ID = TUNNEL_VIEW_ID;
+TunnelPanel.TITLE = ( (nls.localize('remote.tunnel', "Ports")));
+TunnelPanel = ( (__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) {
+    LabelTunnelAction.ID = 'remote.tunnel.label';
+    LabelTunnelAction.LABEL = ( (nls.localize('remote.tunnel.label', "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 {
+                const context = accessor.get(IContextKeyService).getContextKeyValue(TunnelViewSelectionKeyName);
+                const tunnel = context ? remoteExplorerService.tunnelModel.forwarded.get(context) : undefined;
+                if (tunnel) {
+                    const tunnelService = accessor.get(ITunnelService);
+                    tunnelContext = TunnelItem.createFromTunnel(remoteExplorerService, tunnelService, tunnel);
+                }
+            }
+            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 undefined;
+        };
+    }
+    LabelTunnelAction.handler = handler;
+})(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(
+    '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")));
+var 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(
+        '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) {
+            return { content: invalidPortString, severity: Severity.Error };
+        }
+        else if (parsed.port >= maxPortNumber) {
+            return { content: invalidPortNumberString, severity: Severity.Error };
+        }
+        else if (canElevate && tunnelService.isPortPrivileged(parsed.port)) {
+            return { content: requiresSudoString, severity: Severity.Info };
+        }
+        else if (mapHasAddressLocalhostOrAllInterfaces(remoteExplorerService.tunnelModel.forwarded, parsed.host, parsed.port)) {
+            return { content: alreadyForwarded, severity: Severity.Error };
+        }
+        return null;
+    }
+    function error(notificationService, tunnel, host, port) {
+        if (!tunnel) {
+            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
+            ))));
+        }
+    }
+    function inlineHandler() {
+        return async (accessor, arg) => {
+            const remoteExplorerService = accessor.get(IRemoteExplorerService);
+            const notificationService = accessor.get(INotificationService);
+            const tunnelService = accessor.get(ITunnelService);
+            remoteExplorerService.setEditable(undefined, TunnelEditId.New, {
+                onFinish: async (value, success) => {
+                    remoteExplorerService.setEditable(undefined, TunnelEditId.New, null);
+                    let parsed;
+                    if (success && (parsed = parseAddress(value))) {
+                        remoteExplorerService.forward({
+                            remote: { host: parsed.host, port: parsed.port },
+                            elevateIfNeeded: true
+                        }).then(tunnel => error(notificationService, tunnel, parsed.host, parsed.port));
+                    }
+                },
+                validationMessage: (value) => validateInput(remoteExplorerService, tunnelService, value, tunnelService.canElevate),
+                placeholder: forwardPrompt
+            });
+        };
+    }
+    ForwardPortAction.inlineHandler = inlineHandler;
+    function commandPaletteHandler() {
+        return async (accessor, arg) => {
+            const remoteExplorerService = accessor.get(IRemoteExplorerService);
+            const notificationService = accessor.get(INotificationService);
+            const viewsService = accessor.get(IViewsService);
+            const quickInputService = accessor.get(IQuickInputService);
+            const tunnelService = accessor.get(ITunnelService);
+            await viewsService.openView(TunnelPanel.ID, true);
+            const value = await quickInputService.input({
+                prompt: forwardPrompt,
+                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 },
+                    elevateIfNeeded: true
+                }).then(tunnel => error(notificationService, tunnel, parsed.host, parsed.port));
+            }
+        };
+    }
+    ForwardPortAction.commandPaletteHandler = commandPaletteHandler;
+})(ForwardPortAction || (ForwardPortAction = {}))));
+function makeTunnelPicks(tunnels, remoteExplorerService, tunnelService) {
+    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(
+                'remote.tunnel.closeNoPorts',
+                "No ports currently forwarded. Try running the {0} command",
+                ForwardPortAction.LABEL.value
+            )))
+        });
+    }
+    return picks;
+}
+var 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' };
+    function inlineHandler() {
+        return async (accessor, arg) => {
+            const contextKeyService = accessor.get(IContextKeyService);
+            const remoteExplorerService = accessor.get(IRemoteExplorerService);
+            let ports = [];
+            const multiSelectContext = contextKeyService.getContextKeyValue(TunnelViewMultiSelectionKeyName);
+            if (multiSelectContext) {
+                multiSelectContext.forEach(context => {
+                    const tunnel = remoteExplorerService.tunnelModel.forwarded.get(context);
+                    if (tunnel) {
+                        ports?.push(tunnel);
+                    }
+                });
+            }
+            else if (isITunnelItem(arg)) {
+                ports = [arg];
+            }
+            else {
+                const context = contextKeyService.getContextKeyValue(TunnelViewSelectionKeyName);
+                const tunnel = context ? remoteExplorerService.tunnelModel.forwarded.get(context) : undefined;
+                if (tunnel) {
+                    ports = [tunnel];
+                }
+            }
+            if (!ports || ports.length === 0) {
+                return;
+            }
+            return Promise.all(( (ports.map(
+                port => remoteExplorerService.close({ host: port.remoteHost, port: port.remotePort })
+            ))));
+        };
+    }
+    ClosePortAction.inlineHandler = inlineHandler;
+    function commandPaletteHandler() {
+        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: ( (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 });
+            }
+            else if (result) {
+                await commandService.executeCommand(ForwardPortAction.COMMANDPALETTE_ID);
+            }
+        };
+    }
+    ClosePortAction.commandPaletteHandler = commandPaletteHandler;
+})(ClosePortAction || (ClosePortAction = {}))));
+var OpenPortInBrowserAction;
+( ((function(OpenPortInBrowserAction) {
+    OpenPortInBrowserAction.ID = 'remote.tunnel.open';
+    OpenPortInBrowserAction.LABEL = ( (nls.localize('remote.tunnel.open', "Open in Browser")));
+    function handler() {
+        return async (accessor, arg) => {
+            let key;
+            if (isITunnelItem(arg)) {
+                key = makeAddress(arg.remoteHost, arg.remotePort);
+            }
+            else if (arg.tunnelRemoteHost && arg.tunnelRemotePort) {
+                key = makeAddress(arg.tunnelRemoteHost, arg.tunnelRemotePort);
+            }
+            if (key) {
+                const model = accessor.get(IRemoteExplorerService).tunnelModel;
+                const openerService = accessor.get(IOpenerService);
+                return run(model, openerService, key);
+            }
+        };
+    }
+    OpenPortInBrowserAction.handler = handler;
+    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 Promise.resolve();
+    }
+    OpenPortInBrowserAction.run = run;
+})(OpenPortInBrowserAction || (OpenPortInBrowserAction = {}))));
+var OpenPortInPreviewAction;
+( ((function(OpenPortInPreviewAction) {
+    OpenPortInPreviewAction.ID = 'remote.tunnel.openPreview';
+    OpenPortInPreviewAction.LABEL = ( (nls.localize('remote.tunnel.openPreview', "Preview in Editor")));
+    function handler() {
+        return async (accessor, arg) => {
+            let key;
+            if (isITunnelItem(arg)) {
+                key = makeAddress(arg.remoteHost, arg.remotePort);
+            }
+            else if (arg.tunnelRemoteHost && arg.tunnelRemotePort) {
+                key = makeAddress(arg.tunnelRemoteHost, arg.tunnelRemotePort);
+            }
+            if (key) {
+                const model = accessor.get(IRemoteExplorerService).tunnelModel;
+                const openerService = accessor.get(IOpenerService);
+                const externalOpenerService = accessor.get(IExternalUriOpenerService);
+                return run(model, openerService, externalOpenerService, key);
+            }
+        };
+    }
+    OpenPortInPreviewAction.handler = handler;
+    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 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 openerService.open(tunnel.localUri);
+        }
+        return Promise.resolve();
+    }
+    OpenPortInPreviewAction.run = run;
+})(OpenPortInPreviewAction || (OpenPortInPreviewAction = {}))));
+var OpenPortInBrowserCommandPaletteAction;
+( ((function(OpenPortInBrowserCommandPaletteAction) {
+    OpenPortInBrowserCommandPaletteAction.ID = 'remote.tunnel.openCommandPalette';
+    OpenPortInBrowserCommandPaletteAction.LABEL = ( (nls.localize('remote.tunnel.openCommandPalette', "Open Port in Browser")));
+    function handler() {
+        return async (accessor, arg) => {
+            const remoteExplorerService = accessor.get(IRemoteExplorerService);
+            const tunnelService = accessor.get(ITunnelService);
+            const model = remoteExplorerService.tunnelModel;
+            const quickPickService = accessor.get(IQuickInputService);
+            const openerService = accessor.get(IOpenerService);
+            const commandService = accessor.get(ICommandService);
+            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(
+                        '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...")))
+                });
+            }
+            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));
+            }
+            else if (picked) {
+                return commandService.executeCommand(`${TUNNEL_VIEW_ID}.focus`);
+            }
+        };
+    }
+    OpenPortInBrowserCommandPaletteAction.handler = handler;
+})(
+    OpenPortInBrowserCommandPaletteAction || (OpenPortInBrowserCommandPaletteAction = {})
+)));
+var 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")));
+    async function copyAddress(remoteExplorerService, clipboardService, tunnelItem) {
+        const address = remoteExplorerService.tunnelModel.address(tunnelItem.remoteHost, tunnelItem.remotePort);
+        if (address) {
+            await clipboardService.writeText(( (address.toString())));
+        }
+    }
+    function inlineHandler() {
+        return async (accessor, arg) => {
+            const remoteExplorerService = accessor.get(IRemoteExplorerService);
+            let tunnelItem;
+            if (isITunnelItem(arg)) {
+                tunnelItem = arg;
+            }
+            else {
+                const context = accessor.get(IContextKeyService).getContextKeyValue(TunnelViewSelectionKeyName);
+                tunnelItem = context ? remoteExplorerService.tunnelModel.forwarded.get(context) : undefined;
+            }
+            if (tunnelItem) {
+                return copyAddress(remoteExplorerService, accessor.get(IClipboardService), tunnelItem);
+            }
+        };
+    }
+    CopyAddressAction.inlineHandler = inlineHandler;
+    function commandPaletteHandler() {
+        return async (accessor, arg) => {
+            const quickInputService = accessor.get(IQuickInputService);
+            const remoteExplorerService = accessor.get(IRemoteExplorerService);
+            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"))) });
+            if (result && result.tunnel) {
+                await copyAddress(remoteExplorerService, clipboardService, result.tunnel);
+            }
+            else if (result) {
+                await commandService.executeCommand(ForwardPortAction.COMMANDPALETTE_ID);
+            }
+        };
+    }
+    CopyAddressAction.commandPaletteHandler = commandPaletteHandler;
+})(CopyAddressAction || (CopyAddressAction = {}))));
+var ChangeLocalPortAction;
+( ((function(ChangeLocalPortAction) {
+    ChangeLocalPortAction.ID = 'remote.tunnel.changeLocalPort';
+    ChangeLocalPortAction.LABEL = ( (nls.localize('remote.tunnel.changeLocalPort', "Change Local Address Port")));
+    function validateInput(tunnelService, value, canElevate) {
+        if (!value.match(/^[0-9]+$/)) {
+            return { content: invalidPortString, severity: Severity.Error };
+        }
+        else if (Number(value) >= maxPortNumber) {
+            return { content: invalidPortNumberString, severity: Severity.Error };
+        }
+        else if (canElevate && tunnelService.isPortPrivileged(Number(value))) {
+            return { content: requiresSudoString, severity: Severity.Info };
+        }
+        return null;
+    }
+    function handler() {
+        return async (accessor, arg) => {
+            const remoteExplorerService = accessor.get(IRemoteExplorerService);
+            const notificationService = accessor.get(INotificationService);
+            const tunnelService = accessor.get(ITunnelService);
+            let tunnelContext;
+            if (isITunnelItem(arg)) {
+                tunnelContext = arg;
+            }
+            else {
+                const context = accessor.get(IContextKeyService).getContextKeyValue(TunnelViewSelectionKeyName);
+                const tunnel = context ? remoteExplorerService.tunnelModel.forwarded.get(context) : undefined;
+                if (tunnel) {
+                    const tunnelService = accessor.get(ITunnelService);
+                    tunnelContext = TunnelItem.createFromTunnel(remoteExplorerService, tunnelService, tunnel);
+                }
+            }
+            if (tunnelContext) {
+                const tunnelItem = tunnelContext;
+                remoteExplorerService.setEditable(tunnelItem, TunnelEditId.LocalPort, {
+                    onFinish: async (value, success) => {
+                        remoteExplorerService.setEditable(tunnelItem, TunnelEditId.LocalPort, null);
+                        if (success) {
+                            await remoteExplorerService.close({ host: tunnelItem.remoteHost, port: tunnelItem.remotePort });
+                            const numberValue = Number(value);
+                            const newForward = await remoteExplorerService.forward({
+                                remote: { host: tunnelItem.remoteHost, port: tunnelItem.remotePort },
+                                local: numberValue,
+                                name: tunnelItem.name,
+                                elevateIfNeeded: true,
+                                source: tunnelItem.source
+                            });
+                            if (newForward && newForward.tunnelLocalPort !== numberValue) {
+                                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")))
+                });
+            }
+        };
+    }
+    ChangeLocalPortAction.handler = handler;
+})(ChangeLocalPortAction || (ChangeLocalPortAction = {}))));
+var 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 });
+                return remoteExplorerService.forward({
+                    remote: { host: arg.remoteHost, port: arg.remotePort },
+                    local: arg.localPort,
+                    name: arg.name,
+                    elevateIfNeeded: true,
+                    privacy: privacyId,
+                    source: arg.source
+                });
+            }
+            return undefined;
+        };
+    }
+    ChangeTunnelPrivacyAction.handler = handler;
+})(ChangeTunnelPrivacyAction || (ChangeTunnelPrivacyAction = {}))));
+var 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")));
+    async function handler(arg, protocol, remoteExplorerService) {
+        if (isITunnelItem(arg)) {
+            const attributes = {
+                protocol
+            };
+            return remoteExplorerService.tunnelModel.configPortsAttributes.addAttributes(arg.remotePort, attributes, 4 );
+        }
+    }
+    function handlerHttp() {
+        return async (accessor, arg) => {
+            return handler(arg, TunnelProtocol.Http, accessor.get(IRemoteExplorerService));
+        };
+    }
+    SetTunnelProtocolAction.handlerHttp = handlerHttp;
+    function handlerHttps() {
+        return async (accessor, arg) => {
+            return handler(arg, TunnelProtocol.Https, accessor.get(IRemoteExplorerService));
+        };
+    }
+    SetTunnelProtocolAction.handlerHttps = handlerHttps;
+})(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)));
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: LabelTunnelAction.ID,
+    weight: 200  + tunnelViewCommandsWeightBonus,
+    when: ( (ContextKeyExpr.and(TunnelViewFocusContextKey, isForwardedExpr, isNotMultiSelectionExpr))),
+    primary: 60 ,
+    mac: {
+        primary: 3
+    },
+    handler: LabelTunnelAction.handler()
+});
+CommandsRegistry.registerCommand(ForwardPortAction.INLINE_ID, ForwardPortAction.inlineHandler());
+CommandsRegistry.registerCommand(ForwardPortAction.COMMANDPALETTE_ID, ForwardPortAction.commandPaletteHandler());
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: ClosePortAction.INLINE_ID,
+    weight: 200  + tunnelViewCommandsWeightBonus,
+    when: ( (ContextKeyExpr.and(TunnelCloseableContextKey, TunnelViewFocusContextKey))),
+    primary: 20 ,
+    mac: {
+        primary: 2048  | 1 ,
+        secondary: [20 ]
+    },
+    handler: ClosePortAction.inlineHandler()
+});
+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());
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: CopyAddressAction.INLINE_ID,
+    weight: 200  + tunnelViewCommandsWeightBonus,
+    when: ( (ContextKeyExpr.and(
+        TunnelViewFocusContextKey,
+        isForwardedOrDetectedExpr,
+        isNotMultiSelectionExpr
+    ))),
+    primary: 2048  | 33 ,
+    handler: CopyAddressAction.inlineHandler()
+});
+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());
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, ({
+    command: {
+        id: ClosePortAction.COMMANDPALETTE_ID,
+        title: ClosePortAction.LABEL
+    },
+    when: forwardedPortsViewEnabled
+}));
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, ({
+    command: {
+        id: ForwardPortAction.COMMANDPALETTE_ID,
+        title: ForwardPortAction.LABEL
+    },
+    when: forwardedPortsViewEnabled
+}));
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, ({
+    command: {
+        id: CopyAddressAction.COMMANDPALETTE_ID,
+        title: CopyAddressAction.COMMANDPALETTE_LABEL
+    },
+    when: forwardedPortsViewEnabled
+}));
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, ({
+    command: {
+        id: OpenPortInBrowserCommandPaletteAction.ID,
+        title: OpenPortInBrowserCommandPaletteAction.LABEL
+    },
+    when: forwardedPortsViewEnabled
+}));
+MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
+    group: '._open',
+    order: 0,
+    command: {
+        id: OpenPortInBrowserAction.ID,
+        title: OpenPortInBrowserAction.LABEL,
+    },
+    when: ( (ContextKeyExpr.and(isForwardedOrDetectedExpr, isNotMultiSelectionExpr)))
+}));
+MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
+    group: '._open',
+    order: 1,
+    command: {
+        id: OpenPortInPreviewAction.ID,
+        title: OpenPortInPreviewAction.LABEL,
+    },
+    when: ( (ContextKeyExpr.and(isForwardedOrDetectedExpr, isNotMultiSelectionExpr)))
+}));
+MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
+    group: '0_manage',
+    order: 1,
+    command: {
+        id: LabelTunnelAction.ID,
+        title: LabelTunnelAction.LABEL,
+        icon: labelPortIcon
+    },
+    when: ( (ContextKeyExpr.and(isForwardedExpr, isNotMultiSelectionExpr)))
+}));
+MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
+    group: '2_localaddress',
+    order: 0,
+    command: {
+        id: CopyAddressAction.INLINE_ID,
+        title: CopyAddressAction.INLINE_LABEL,
+    },
+    when: ( (ContextKeyExpr.and(isForwardedOrDetectedExpr, isNotMultiSelectionExpr)))
+}));
+MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
+    group: '2_localaddress',
+    order: 1,
+    command: {
+        id: ChangeLocalPortAction.ID,
+        title: ChangeLocalPortAction.LABEL,
+    },
+    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)))
+}));
+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)))
+}));
+MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
+    group: '3_forward',
+    order: 0,
+    command: {
+        id: ClosePortAction.INLINE_ID,
+        title: ClosePortAction.LABEL,
+    },
+    when: TunnelCloseableContextKey
+}));
+MenuRegistry.appendMenuItem(MenuId.TunnelContext, ({
+    group: '3_forward',
+    order: 1,
+    command: {
+        id: ForwardPortAction.INLINE_ID,
+        title: ForwardPortAction.LABEL,
+    },
+}));
+MenuRegistry.appendMenuItem(MenuId.TunnelProtocol, ({
+    order: 0,
+    command: {
+        id: SetTunnelProtocolAction.ID_HTTP,
+        title: SetTunnelProtocolAction.LABEL_HTTP,
+        toggled: ( (TunnelProtocolContextKey.isEqualTo(TunnelProtocol.Http)))
+    }
+}));
+MenuRegistry.appendMenuItem(MenuId.TunnelProtocol, ({
+    order: 1,
+    command: {
+        id: SetTunnelProtocolAction.ID_HTTPS,
+        title: SetTunnelProtocolAction.LABEL_HTTPS,
+        toggled: ( (TunnelProtocolContextKey.isEqualTo(TunnelProtocol.Https)))
+    }
+}));
+MenuRegistry.appendMenuItem(MenuId.TunnelPortInline, ({
+    group: '0_manage',
+    order: 0,
+    command: {
+        id: ForwardPortAction.INLINE_ID,
+        title: ForwardPortAction.TREEITEM_LABEL,
+        icon: forwardPortIcon
+    },
+    when: ( (TunnelTypeContextKey.isEqualTo(TunnelType.Candidate)))
+}));
+MenuRegistry.appendMenuItem(MenuId.TunnelPortInline, ({
+    group: '0_manage',
+    order: 4,
+    command: {
+        id: LabelTunnelAction.ID,
+        title: LabelTunnelAction.LABEL,
+        icon: labelPortIcon
+    },
+    when: isForwardedExpr
+}));
+MenuRegistry.appendMenuItem(MenuId.TunnelPortInline, ({
+    group: '0_manage',
+    order: 5,
+    command: {
+        id: ClosePortAction.INLINE_ID,
+        title: ClosePortAction.LABEL,
+        icon: stopForwardIcon
+    },
+    when: TunnelCloseableContextKey
+}));
+MenuRegistry.appendMenuItem(MenuId.TunnelLocalAddressInline, ({
+    order: -1,
+    command: {
+        id: CopyAddressAction.INLINE_ID,
+        title: CopyAddressAction.INLINE_LABEL,
+        icon: copyAddressIcon
+    },
+    when: isForwardedOrDetectedExpr
+}));
+MenuRegistry.appendMenuItem(MenuId.TunnelLocalAddressInline, ({
+    order: 0,
+    command: {
+        id: OpenPortInBrowserAction.ID,
+        title: OpenPortInBrowserAction.LABEL,
+        icon: openBrowserIcon
+    },
+    when: isForwardedOrDetectedExpr
+}));
+MenuRegistry.appendMenuItem(MenuId.TunnelLocalAddressInline, ({
+    order: 1,
+    command: {
+        id: OpenPortInPreviewAction.ID,
+        title: OpenPortInPreviewAction.LABEL,
+        icon: openPreviewIcon
+    },
+    when: isForwardedOrDetectedExpr
+}));
+registerColor('ports.iconRunningProcessForeground', {
+    light: STATUS_BAR_HOST_NAME_BACKGROUND,
+    dark: STATUS_BAR_HOST_NAME_BACKGROUND,
+    hcDark: STATUS_BAR_HOST_NAME_BACKGROUND,
+    hcLight: STATUS_BAR_HOST_NAME_BACKGROUND
+}, ( (nls.localize(
+    'portWithRunningProcess.foreground',
+    "The color of the icon for a port that has an associated running process."
+))));
+export { ForwardPortAction, OpenPortInBrowserAction, OpenPortInPreviewAction, TunnelPanel, forwardedPortsViewEnabled, openPreviewEnabledContext };