@codingame/monaco-vscode-api 4.5.0 → 4.5.2

package/vscode/src/vs/workbench/services/remote/common/tunnelModel.d.ts

@@ -0,0 +1,185 @@
+import { Event } from '../../../../base/common/event.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { URI } from '../../../../base/common/uri.js';
+import { ConfigurationTarget } from '../../../../platform/configuration/common/configuration.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.service.js';
+import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { TunnelDescription } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
+import { IRemoteAuthorityResolverService } from '../../../../platform/remote/common/remoteAuthorityResolver.service.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.service.js';
+import { TunnelProtocol, RemoteTunnel, PortAttributesProvider, TunnelPrivacyId, ProvidedOnAutoForward } from '../../../../platform/tunnel/common/tunnel.js';
+import { ITunnelService } from '../../../../platform/tunnel/common/tunnel.service.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.service.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.service.js';
+import { IExtensionService } from '../../extensions/common/extensions.service.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
+
+interface Tunnel {
+    remoteHost: string;
+    remotePort: number;
+    localAddress: string;
+    localUri: URI;
+    protocol: TunnelProtocol;
+    localPort?: number;
+    name?: string;
+    closeable?: boolean;
+    privacy: TunnelPrivacyId | string;
+    runningProcess: string | undefined;
+    hasRunningProcess?: boolean;
+    pid: number | undefined;
+    source: {
+        source: TunnelSource;
+        description: string;
+    };
+}
+declare enum TunnelCloseReason {
+    Other = "Other",
+    User = "User",
+    AutoForwardEnd = "AutoForwardEnd"
+}
+declare enum TunnelSource {
+    User = 0,
+    Auto = 1,
+    Extension = 2
+}
+interface TunnelProperties {
+    remote: {
+        host: string;
+        port: number;
+    };
+    local?: number;
+    name?: string;
+    source?: {
+        source: TunnelSource;
+        description: string;
+    };
+    elevateIfNeeded?: boolean;
+    privacy?: string;
+}
+interface CandidatePort {
+    host: string;
+    port: number;
+    detail?: string;
+    pid?: number;
+}
+declare enum OnPortForward {
+    Notify = "notify",
+    OpenBrowser = "openBrowser",
+    OpenBrowserOnce = "openBrowserOnce",
+    OpenPreview = "openPreview",
+    Silent = "silent",
+    Ignore = "ignore"
+}
+interface Attributes {
+    label: string | undefined;
+    onAutoForward: OnPortForward | undefined;
+    elevateIfNeeded: boolean | undefined;
+    requireLocalPort: boolean | undefined;
+    protocol: TunnelProtocol | undefined;
+}
+declare class PortsAttributes extends Disposable {
+    private readonly configurationService;
+    private static SETTING;
+    private static DEFAULTS;
+    private static RANGE;
+    private static HOST_AND_PORT;
+    private portsAttributes;
+    private defaultPortAttributes;
+    private _onDidChangeAttributes;
+    readonly onDidChangeAttributes: Event<void>;
+    constructor(configurationService: IConfigurationService);
+    private updateAttributes;
+    getAttributes(port: number, host: string, commandLine?: string): Attributes | undefined;
+    private hasStartEnd;
+    private hasHostAndPort;
+    private findNextIndex;
+    private readSetting;
+    private sortAttributes;
+    private getOtherAttributes;
+    static providedActionToAction(providedAction: ProvidedOnAutoForward | undefined): OnPortForward | undefined;
+    addAttributes(port: number, attributes: Partial<Attributes>, target: ConfigurationTarget): Promise<void>;
+}
+declare class TunnelModel extends Disposable {
+    private readonly tunnelService;
+    private readonly storageService;
+    private readonly configurationService;
+    private readonly environmentService;
+    private readonly remoteAuthorityResolverService;
+    private readonly workspaceContextService;
+    private readonly logService;
+    private readonly dialogService;
+    private readonly extensionService;
+    private readonly contextKeyService;
+    readonly forwarded: Map<string, Tunnel>;
+    private readonly inProgress;
+    readonly detected: Map<string, Tunnel>;
+    private remoteTunnels;
+    private _onForwardPort;
+    onForwardPort: Event<Tunnel | void>;
+    private _onClosePort;
+    onClosePort: Event<{
+        host: string;
+        port: number;
+    }>;
+    private _onPortName;
+    onPortName: Event<{
+        host: string;
+        port: number;
+    }>;
+    private _candidates;
+    private _onCandidatesChanged;
+    onCandidatesChanged: Event<Map<string, {
+        host: string;
+        port: number;
+    }>>;
+    private _candidateFilter;
+    private tunnelRestoreValue;
+    private _onEnvironmentTunnelsSet;
+    onEnvironmentTunnelsSet: Event<void>;
+    private _environmentTunnelsSet;
+    readonly configPortsAttributes: PortsAttributes;
+    private restoreListener;
+    private knownPortsRestoreValue;
+    private restoreComplete;
+    private onRestoreComplete;
+    private unrestoredExtensionTunnels;
+    private sessionCachedProperties;
+    private portAttributesProviders;
+    constructor(tunnelService: ITunnelService, storageService: IStorageService, configurationService: IConfigurationService, environmentService: IWorkbenchEnvironmentService, remoteAuthorityResolverService: IRemoteAuthorityResolverService, workspaceContextService: IWorkspaceContextService, logService: ILogService, dialogService: IDialogService, extensionService: IExtensionService, contextKeyService: IContextKeyService);
+    private extensionHasActivationEvent;
+    private checkExtensionActivationEvents;
+    private onTunnelClosed;
+    private makeLocalUri;
+    private addStorageKeyPostfix;
+    private getTunnelRestoreStorageKey;
+    private getRestoreExpirationStorageKey;
+    private getTunnelRestoreValue;
+    restoreForwarded(): Promise<void>;
+    private cleanupExpiredTunnelsForRestore;
+    private storeForwarded;
+    private mismatchCooldown;
+    private showPortMismatchModalIfNeeded;
+    forward(tunnelProperties: TunnelProperties, attributes?: Attributes | null): Promise<RemoteTunnel | string | undefined>;
+    private doForward;
+    private mergeCachedAndUnrestoredProperties;
+    private mergeAttributesIntoExistingTunnel;
+    name(host: string, port: number, name: string): Promise<void>;
+    close(host: string, port: number, reason: TunnelCloseReason): Promise<void>;
+    address(host: string, port: number): string | undefined;
+    get environmentTunnelsSet(): boolean;
+    addEnvironmentTunnels(tunnels: TunnelDescription[] | undefined): void;
+    setCandidateFilter(filter: ((candidates: CandidatePort[]) => Promise<CandidatePort[]>) | undefined): void;
+    setCandidates(candidates: CandidatePort[]): Promise<void>;
+    private updateInResponseToCandidates;
+    get candidates(): CandidatePort[];
+    get candidatesOrUndefined(): CandidatePort[] | undefined;
+    private updateAttributes;
+    getAttributes(forwardedPorts: {
+        host: string;
+        port: number;
+    }[], checkProviders?: boolean): Promise<Map<number, Attributes> | undefined>;
+    addAttributesProvider(provider: PortAttributesProvider): void;
+}
+
+export { type Attributes, type CandidatePort, OnPortForward, PortsAttributes, type Tunnel, TunnelCloseReason, TunnelModel, type TunnelProperties, TunnelSource };

package/vscode/src/vs/workbench/services/remote/common/tunnelModel.js

@@ -21,16 +21,13 @@ import { isString, isNumber, isObject } from '../../../../base/common/types.js';
 import { deepClone } from '../../../../base/common/objects.js';
 import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
 import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
+const _moduleId = "vs/workbench/services/remote/common/tunnelModel";
 const MISMATCH_LOCAL_PORT_COOLDOWN = 10 * 1000;
 const TUNNELS_TO_RESTORE = 'remote.tunnels.toRestore';
 const TUNNELS_TO_RESTORE_EXPIRATION = 'remote.tunnels.toRestoreExpiration';
 const RESTORE_EXPIRATION_TIME = 1000 * 60 * 60 * 24 * 14;
 const ACTIVATION_EVENT = 'onTunnel';
-const forwardedPortsViewEnabled = ( new RawContextKey('forwardedPortsViewEnabled', false, ( localizeWithPath(
-    'vs/workbench/services/remote/common/tunnelModel',
-    'tunnel.forwardedPortsViewEnabled',
-    "Whether the Ports view is enabled."
-))));
+const forwardedPortsViewEnabled = ( (new RawContextKey('forwardedPortsViewEnabled', false, ( localizeWithPath(_moduleId, 0, "Whether the Ports view is enabled.")))));
 function parseAddress(address) {
     const matches = address.match(/^([a-zA-Z0-9_-]+(?:\.[a-zA-Z0-9_-]+)*:)?([0-9]+)$/);
     if (!matches) {
@@ -39,32 +36,24 @@ function parseAddress(address) {
     return { host: matches[1]?.substring(0, matches[1].length - 1) || 'localhost', port: Number(matches[2]) };
 }
 var TunnelCloseReason;
-( (function(TunnelCloseReason) {
+( ((function(TunnelCloseReason) {
     TunnelCloseReason["Other"] = "Other";
     TunnelCloseReason["User"] = "User";
     TunnelCloseReason["AutoForwardEnd"] = "AutoForwardEnd";
-})(TunnelCloseReason || (TunnelCloseReason = {})));
+})(TunnelCloseReason || (TunnelCloseReason = {}))));
 var TunnelSource;
-( (function(TunnelSource) {
+( ((function(TunnelSource) {
     TunnelSource[TunnelSource["User"] = 0] = "User";
     TunnelSource[TunnelSource["Auto"] = 1] = "Auto";
     TunnelSource[TunnelSource["Extension"] = 2] = "Extension";
-})(TunnelSource || (TunnelSource = {})));
+})(TunnelSource || (TunnelSource = {}))));
 const UserTunnelSource = {
     source: TunnelSource.User,
-    description: ( localizeWithPath(
-        'vs/workbench/services/remote/common/tunnelModel',
-        'tunnel.source.user',
-        "User Forwarded"
-    ))
+    description: ( localizeWithPath(_moduleId, 1, "User Forwarded"))
 };
 const AutoTunnelSource = {
     source: TunnelSource.Auto,
-    description: ( localizeWithPath(
-        'vs/workbench/services/remote/common/tunnelModel',
-        'tunnel.source.auto',
-        "Auto Forwarded"
-    ))
+    description: ( localizeWithPath(_moduleId, 2, "Auto Forwarded"))
 };
 function mapHasAddress(map, host, port) {
     const initialAddress = map.get(makeAddress(host, port));
@@ -74,7 +63,7 @@ function mapHasAddress(map, host, port) {
     if (isLocalhost(host)) {
         for (const testHost of LOCALHOST_ADDRESSES) {
             const testAddress = makeAddress(testHost, port);
-            if (( map.has(testAddress))) {
+            if (( (map.has(testAddress)))) {
                 return map.get(testAddress);
             }
         }
@@ -82,7 +71,7 @@ function mapHasAddress(map, host, port) {
     else if (isAllInterfaces(host)) {
         for (const testHost of ALL_INTERFACES_ADDRESSES) {
             const testAddress = makeAddress(testHost, port);
-            if (( map.has(testAddress))) {
+            if (( (map.has(testAddress)))) {
                 return map.get(testAddress);
             }
         }
@@ -104,14 +93,14 @@ function makeAddress(host, port) {
     return host + ':' + port;
 }
 var OnPortForward;
-( (function(OnPortForward) {
+( ((function(OnPortForward) {
     OnPortForward["Notify"] = "notify";
     OnPortForward["OpenBrowser"] = "openBrowser";
     OnPortForward["OpenBrowserOnce"] = "openBrowserOnce";
     OnPortForward["OpenPreview"] = "openPreview";
     OnPortForward["Silent"] = "silent";
     OnPortForward["Ignore"] = "ignore";
-})(OnPortForward || (OnPortForward = {})));
+})(OnPortForward || (OnPortForward = {}))));
 function isCandidatePort(candidate) {
     return candidate && 'host' in candidate && typeof candidate.host === 'string'
         && 'port' in candidate && typeof candidate.port === 'number'
@@ -127,7 +116,7 @@ class PortsAttributes extends Disposable {
         super();
         this.configurationService = configurationService;
         this.portsAttributes = [];
-        this._onDidChangeAttributes = ( new Emitter());
+        this._onDidChangeAttributes = ( (new Emitter()));
         this.onDidChangeAttributes = this._onDidChangeAttributes.event;
         this._register(configurationService.onDidChangeConfiguration(e => {
             if (e.affectsConfiguration(PortsAttributes.SETTING) || e.affectsConfiguration(PortsAttributes.DEFAULTS)) {
@@ -328,38 +317,38 @@ let TunnelModel = class TunnelModel extends Disposable {
         this.dialogService = dialogService;
         this.extensionService = extensionService;
         this.contextKeyService = contextKeyService;
-        this.inProgress = ( new Map());
-        this._onForwardPort = ( new Emitter());
+        this.inProgress = ( (new Map()));
+        this._onForwardPort = ( (new Emitter()));
         this.onForwardPort = this._onForwardPort.event;
-        this._onClosePort = ( new Emitter());
+        this._onClosePort = ( (new Emitter()));
         this.onClosePort = this._onClosePort.event;
-        this._onPortName = ( new Emitter());
+        this._onPortName = ( (new Emitter()));
         this.onPortName = this._onPortName.event;
-        this._onCandidatesChanged = ( new Emitter());
+        this._onCandidatesChanged = ( (new Emitter()));
         this.onCandidatesChanged = this._onCandidatesChanged.event;
-        this._onEnvironmentTunnelsSet = ( new Emitter());
+        this._onEnvironmentTunnelsSet = ( (new Emitter()));
         this.onEnvironmentTunnelsSet = this._onEnvironmentTunnelsSet.event;
         this._environmentTunnelsSet = false;
         this.restoreListener = undefined;
         this.restoreComplete = false;
-        this.onRestoreComplete = ( new Emitter());
-        this.unrestoredExtensionTunnels = ( new Map());
-        this.sessionCachedProperties = ( new Map());
+        this.onRestoreComplete = ( (new Emitter()));
+        this.unrestoredExtensionTunnels = ( (new Map()));
+        this.sessionCachedProperties = ( (new Map()));
         this.portAttributesProviders = [];
-        this.mismatchCooldown = ( new Date());
-        this.configPortsAttributes = ( new PortsAttributes(configurationService));
+        this.mismatchCooldown = ( (new Date()));
+        this.configPortsAttributes = ( (new PortsAttributes(configurationService)));
         this.tunnelRestoreValue = this.getTunnelRestoreValue();
         this._register(this.configPortsAttributes.onDidChangeAttributes(this.updateAttributes, this));
-        this.forwarded = ( new Map());
-        this.remoteTunnels = ( new Map());
+        this.forwarded = ( (new Map()));
+        this.remoteTunnels = ( (new Map()));
         this.tunnelService.tunnels.then(async (tunnels) => {
-            const attributes = await this.getAttributes(( tunnels.map(tunnel => {
+            const attributes = await this.getAttributes(( (tunnels.map(tunnel => {
                 return { port: tunnel.tunnelRemotePort, host: tunnel.tunnelRemoteHost };
-            })));
+            }))));
             for (const tunnel of tunnels) {
                 if (tunnel.localAddress) {
                     const key = makeAddress(tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort);
-                    const matchingCandidate = mapHasAddressLocalhostOrAllInterfaces(this._candidates ?? ( new Map()), tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort);
+                    const matchingCandidate = mapHasAddressLocalhostOrAllInterfaces(this._candidates ?? ( (new Map())), tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort);
                     this.forwarded.set(key, {
                         remotePort: tunnel.tunnelRemotePort,
                         remoteHost: tunnel.tunnelRemoteHost,
@@ -377,14 +366,14 @@ let TunnelModel = class TunnelModel extends Disposable {
                 }
             }
         });
-        this.detected = ( new Map());
+        this.detected = ( (new Map()));
         this._register(this.tunnelService.onTunnelOpened(async (tunnel) => {
             const key = makeAddress(tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort);
             if (!mapHasAddressLocalhostOrAllInterfaces(this.forwarded, tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort)
                 && !mapHasAddressLocalhostOrAllInterfaces(this.detected, tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort)
                 && !mapHasAddressLocalhostOrAllInterfaces(this.inProgress, tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort)
                 && tunnel.localAddress) {
-                const matchingCandidate = mapHasAddressLocalhostOrAllInterfaces(this._candidates ?? ( new Map()), tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort);
+                const matchingCandidate = mapHasAddressLocalhostOrAllInterfaces(this._candidates ?? ( (new Map())), tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort);
                 const attributes = (await this.getAttributes([{ port: tunnel.tunnelRemotePort, host: tunnel.tunnelRemoteHost }]))?.get(tunnel.tunnelRemotePort);
                 this.forwarded.set(key, {
                     remoteHost: tunnel.tunnelRemoteHost,
@@ -429,7 +418,7 @@ let TunnelModel = class TunnelModel extends Disposable {
     }
     async onTunnelClosed(address, reason) {
         const key = makeAddress(address.host, address.port);
-        if (( this.forwarded.has(key))) {
+        if (( (this.forwarded.has(key)))) {
             this.forwarded.delete(key);
             await this.storeForwarded();
             this._onClosePort.fire(address);
@@ -437,10 +426,14 @@ let TunnelModel = class TunnelModel extends Disposable {
     }
     makeLocalUri(localAddress, attributes) {
         if (localAddress.startsWith('http')) {
-            return ( URI.parse(localAddress));
+            return (
+                 (URI.parse(localAddress))
+            );
         }
         const protocol = attributes?.protocol ?? 'http';
-        return ( URI.parse(`${protocol}://${localAddress}`));
+        return (
+             (URI.parse(`${protocol}://${localAddress}`))
+        );
     }
     async addStorageKeyPostfix(prefix) {
         const workspace = this.workspaceContextService.getWorkspace();
@@ -476,7 +469,7 @@ let TunnelModel = class TunnelModel extends Disposable {
             const tunnelRestoreValue = await this.tunnelRestoreValue;
             if (tunnelRestoreValue && (tunnelRestoreValue !== this.knownPortsRestoreValue)) {
                 const tunnels = JSON.parse(tunnelRestoreValue) ?? [];
-                this.logService.trace(`ForwardedPorts: (TunnelModel) restoring ports ${( tunnels.map(tunnel => tunnel.remotePort)).join(', ')}`);
+                this.logService.trace(`ForwardedPorts: (TunnelModel) restoring ports ${( (tunnels.map(tunnel => tunnel.remotePort))).join(', ')}`);
                 for (const tunnel of tunnels) {
                     const alreadyForwarded = mapHasAddressLocalhostOrAllInterfaces(this.detected, tunnel.remoteHost, tunnel.remotePort);
                     if ((tunnel.source.source !== TunnelSource.Extension && !alreadyForwarded) || (tunnel.source.source === TunnelSource.Extension && alreadyForwarded)) {
@@ -498,7 +491,7 @@ let TunnelModel = class TunnelModel extends Disposable {
         this.onRestoreComplete.fire();
         if (!this.restoreListener) {
             const key = await this.getTunnelRestoreStorageKey();
-            this.restoreListener = this._register(( new DisposableStore()));
+            this.restoreListener = this._register(( (new DisposableStore())));
             this.restoreListener.add(this.storageService.onDidChangeValue(0 , undefined, this.restoreListener)(async (e) => {
                 if (e.key === key) {
                     this.tunnelRestoreValue = Promise.resolve(this.storageService.get(key, 0 ));
@@ -508,7 +501,7 @@ let TunnelModel = class TunnelModel extends Disposable {
         }
     }
     cleanupExpiredTunnelsForRestore() {
-        const keys = ( this.storageService.keys(0, 0 )).filter(key => key.startsWith(TUNNELS_TO_RESTORE_EXPIRATION));
+        const keys = ( (this.storageService.keys(0, 0 ))).filter(key => key.startsWith(TUNNELS_TO_RESTORE_EXPIRATION));
         for (const key of keys) {
             const expiration = this.storageService.getNumber(key, 0 );
             if (expiration && expiration < Date.now()) {
@@ -521,8 +514,8 @@ let TunnelModel = class TunnelModel extends Disposable {
     }
     async storeForwarded() {
         if (this.configurationService.getValue('remote.restoreForwardedPorts')) {
-            const forwarded = Array.from(( this.forwarded.values()));
-            const restorableTunnels = ( forwarded.map(tunnel => {
+            const forwarded = Array.from(( (this.forwarded.values())));
+            const restorableTunnels = ( (forwarded.map(tunnel => {
                 return {
                     remoteHost: tunnel.remoteHost,
                     remotePort: tunnel.remotePort,
@@ -533,7 +526,7 @@ let TunnelModel = class TunnelModel extends Disposable {
                     protocol: tunnel.protocol,
                     source: tunnel.source,
                 };
-            }));
+            })));
             let valueToStore;
             if (forwarded.length > 0) {
                 valueToStore = JSON.stringify(restorableTunnels);
@@ -558,14 +551,14 @@ let TunnelModel = class TunnelModel extends Disposable {
         if (tunnel.tunnelLocalPort === expectedLocal) {
             return;
         }
-        const newCooldown = ( new Date());
+        const newCooldown = ( (new Date()));
         if ((this.mismatchCooldown.getTime() + MISMATCH_LOCAL_PORT_COOLDOWN) > newCooldown.getTime()) {
             return;
         }
         this.mismatchCooldown = newCooldown;
         const mismatchString = ( localizeWithPath(
-            'vs/workbench/services/remote/common/tunnelModel',
-            'remote.localPortMismatch.single',
+            _moduleId,
+            3,
             "Local port {0} could not be used for forwarding to remote port {1}.\n\nThis usually happens when there is already another process using local port {0}.\n\nPort number {2} has been used instead.",
             expectedLocal,
             tunnel.tunnelRemotePort,
@@ -601,7 +594,7 @@ let TunnelModel = class TunnelModel extends Disposable {
                 noTunnelValue = tunnel;
             }
             else if (tunnel && tunnel.localAddress) {
-                const matchingCandidate = mapHasAddressLocalhostOrAllInterfaces(this._candidates ?? ( new Map()), tunnelProperties.remote.host, tunnelProperties.remote.port);
+                const matchingCandidate = mapHasAddressLocalhostOrAllInterfaces(this._candidates ?? ( (new Map())), tunnelProperties.remote.host, tunnelProperties.remote.port);
                 const protocol = (tunnel.protocol ?
                     ((tunnel.protocol === TunnelProtocol.Https) ? TunnelProtocol.Https : TunnelProtocol.Http)
                     : (attributes?.protocol ?? TunnelProtocol.Http));
@@ -636,7 +629,7 @@ let TunnelModel = class TunnelModel extends Disposable {
         return noTunnelValue;
     }
     mergeCachedAndUnrestoredProperties(key, tunnelProperties) {
-        const map = ( this.unrestoredExtensionTunnels.has(key)) ? this.unrestoredExtensionTunnels : (( this.sessionCachedProperties.has(key)) ? this.sessionCachedProperties : undefined);
+        const map = ( (this.unrestoredExtensionTunnels.has(key))) ? this.unrestoredExtensionTunnels : (( (this.sessionCachedProperties.has(key))) ? this.sessionCachedProperties : undefined);
         if (map) {
             const updateProps = map.get(key);
             map.delete(key);
@@ -651,11 +644,11 @@ let TunnelModel = class TunnelModel extends Disposable {
     async mergeAttributesIntoExistingTunnel(existingTunnel, tunnelProperties, attributes) {
         const newName = attributes?.label ?? tunnelProperties.name;
         let MergedAttributeAction;
-        ( (function(MergedAttributeAction) {
+        ( ((function(MergedAttributeAction) {
             MergedAttributeAction[MergedAttributeAction["None"] = 0] = "None";
             MergedAttributeAction[MergedAttributeAction["Fire"] = 1] = "Fire";
             MergedAttributeAction[MergedAttributeAction["Reopen"] = 2] = "Reopen";
-        })(MergedAttributeAction || (MergedAttributeAction = {})));
+        })(MergedAttributeAction || (MergedAttributeAction = {}))));
         let mergedAction = MergedAttributeAction.None;
         if (newName !== existingTunnel.name) {
             existingTunnel.name = newName;
@@ -689,7 +682,7 @@ let TunnelModel = class TunnelModel extends Disposable {
             this._onPortName.fire({ host, port });
             return;
         }
-        else if (( this.detected.has(key))) {
+        else if (( (this.detected.has(key)))) {
             this.detected.get(key).name = name;
             this._onPortName.fire({ host, port });
         }
@@ -717,7 +710,7 @@ let TunnelModel = class TunnelModel extends Disposable {
     addEnvironmentTunnels(tunnels) {
         if (tunnels) {
             for (const tunnel of tunnels) {
-                const matchingCandidate = mapHasAddressLocalhostOrAllInterfaces(this._candidates ?? ( new Map()), tunnel.remoteAddress.host, tunnel.remoteAddress.port);
+                const matchingCandidate = mapHasAddressLocalhostOrAllInterfaces(this._candidates ?? ( (new Map())), tunnel.remoteAddress.host, tunnel.remoteAddress.port);
                 const localAddress = typeof tunnel.localAddress === 'string' ? tunnel.localAddress : makeAddress(tunnel.localAddress.host, tunnel.localAddress.port);
                 this.detected.set(makeAddress(tunnel.remoteAddress.host, tunnel.remoteAddress.port), {
                     remoteHost: tunnel.remoteAddress.host,
@@ -732,11 +725,7 @@ let TunnelModel = class TunnelModel extends Disposable {
                     privacy: TunnelPrivacyId.ConstantPrivate,
                     source: {
                         source: TunnelSource.Extension,
-                        description: ( localizeWithPath(
-                            'vs/workbench/services/remote/common/tunnelModel',
-                            'tunnel.staticallyForwarded',
-                            "Statically Forwarded"
-                        ))
+                        description: ( localizeWithPath(_moduleId, 4, "Statically Forwarded"))
                     }
                 });
                 this.tunnelService.setEnvironmentTunnel(tunnel.remoteAddress.host, tunnel.remoteAddress.port, localAddress, TunnelPrivacyId.ConstantPrivate, TunnelProtocol.Http);
@@ -755,12 +744,12 @@ let TunnelModel = class TunnelModel extends Disposable {
             processedCandidates = await this._candidateFilter(candidates);
         }
         const removedCandidates = this.updateInResponseToCandidates(processedCandidates);
-        this.logService.trace(`ForwardedPorts: (TunnelModel) removed candidates ${( Array.from(( removedCandidates.values())).map(candidate => candidate.port)).join(', ')}`);
+        this.logService.trace(`ForwardedPorts: (TunnelModel) removed candidates ${( (Array.from(( (removedCandidates.values()))).map(candidate => candidate.port))).join(', ')}`);
         this._onCandidatesChanged.fire(removedCandidates);
     }
     updateInResponseToCandidates(candidates) {
-        const removedCandidates = this._candidates ?? ( new Map());
-        const candidatesMap = ( new Map());
+        const removedCandidates = this._candidates ?? ( (new Map()));
+        const candidatesMap = ( (new Map()));
         this._candidates = candidatesMap;
         candidates.forEach(value => {
             const addressKey = makeAddress(value.host, value.port);
@@ -770,7 +759,7 @@ let TunnelModel = class TunnelModel extends Disposable {
                 detail: value.detail,
                 pid: value.pid
             });
-            if (( removedCandidates.has(addressKey))) {
+            if (( (removedCandidates.has(addressKey)))) {
                 removedCandidates.delete(addressKey);
             }
             const forwardedValue = mapHasAddressLocalhostOrAllInterfaces(this.forwarded, value.host, value.port);
@@ -801,16 +790,16 @@ let TunnelModel = class TunnelModel extends Disposable {
         return removedCandidates;
     }
     get candidates() {
-        return this._candidates ? Array.from(( this._candidates.values())) : [];
+        return this._candidates ? Array.from(( (this._candidates.values()))) : [];
     }
     get candidatesOrUndefined() {
         return this._candidates ? this.candidates : undefined;
     }
     async updateAttributes() {
-        const tunnels = Array.from(( this.forwarded.values()));
-        const allAttributes = await this.getAttributes(( tunnels.map(tunnel => {
+        const tunnels = Array.from(( (this.forwarded.values())));
+        const allAttributes = await this.getAttributes(( (tunnels.map(tunnel => {
             return { port: tunnel.remotePort, host: tunnel.remoteHost };
-        })), false);
+        }))), false);
         if (!allAttributes) {
             return;
         }
@@ -833,20 +822,20 @@ let TunnelModel = class TunnelModel extends Disposable {
         }
     }
     async getAttributes(forwardedPorts, checkProviders = true) {
-        const matchingCandidates = ( new Map());
-        const pidToPortsMapping = ( new Map());
+        const matchingCandidates = ( (new Map()));
+        const pidToPortsMapping = ( (new Map()));
         forwardedPorts.forEach(forwardedPort => {
-            const matchingCandidate = mapHasAddressLocalhostOrAllInterfaces(this._candidates ?? ( new Map()), LOCALHOST_ADDRESSES[0], forwardedPort.port) ?? forwardedPort;
+            const matchingCandidate = mapHasAddressLocalhostOrAllInterfaces(this._candidates ?? ( (new Map())), LOCALHOST_ADDRESSES[0], forwardedPort.port) ?? forwardedPort;
             if (matchingCandidate) {
                 matchingCandidates.set(forwardedPort.port, matchingCandidate);
                 const pid = isCandidatePort(matchingCandidate) ? matchingCandidate.pid : undefined;
-                if (!( pidToPortsMapping.has(pid))) {
+                if (!( (pidToPortsMapping.has(pid)))) {
                     pidToPortsMapping.set(pid, []);
                 }
                 pidToPortsMapping.get(pid)?.push(forwardedPort.port);
             }
         });
-        const configAttributes = ( new Map());
+        const configAttributes = ( (new Map()));
         forwardedPorts.forEach(forwardedPort => {
             const attributes = this.configPortsAttributes.getAttributes(forwardedPort.port, forwardedPort.host, matchingCandidates.get(forwardedPort.port)?.detail);
             if (attributes) {
@@ -856,14 +845,16 @@ let TunnelModel = class TunnelModel extends Disposable {
         if ((this.portAttributesProviders.length === 0) || !checkProviders) {
             return (configAttributes.size > 0) ? configAttributes : undefined;
         }
-        const allProviderResults = await Promise.all(flatten(( this.portAttributesProviders.map(provider => {
-            return ( Array.from(pidToPortsMapping.entries()).map(entry => {
-                const portGroup = entry[1];
-                const matchingCandidate = matchingCandidates.get(portGroup[0]);
-                return provider.providePortAttributes(portGroup, matchingCandidate?.pid, matchingCandidate?.detail, CancellationToken.None);
-            }));
-        }))));
-        const providedAttributes = ( new Map());
+        const allProviderResults = await Promise.all(flatten(( (this.portAttributesProviders.map(provider => {
+            return (
+                 (Array.from(pidToPortsMapping.entries()).map(entry => {
+                    const portGroup = entry[1];
+                    const matchingCandidate = matchingCandidates.get(portGroup[0]);
+                    return provider.providePortAttributes(portGroup, matchingCandidate?.pid, matchingCandidate?.detail, CancellationToken.None);
+                }))
+            );
+        })))));
+        const providedAttributes = ( (new Map()));
         allProviderResults.forEach(attributes => attributes.forEach(attribute => {
             if (attribute) {
                 providedAttributes.set(attribute.port, attribute);
@@ -872,7 +863,7 @@ let TunnelModel = class TunnelModel extends Disposable {
         if (!configAttributes && !providedAttributes) {
             return undefined;
         }
-        const mergedAttributes = ( new Map());
+        const mergedAttributes = ( (new Map()));
         forwardedPorts.forEach(forwardedPorts => {
             const config = configAttributes.get(forwardedPorts.port);
             const provider = providedAttributes.get(forwardedPorts.port);
@@ -890,19 +881,19 @@ let TunnelModel = class TunnelModel extends Disposable {
         this.portAttributesProviders.push(provider);
     }
 };
-TunnelModel.__decorator = ( __decorate([
+TunnelModel.__decorator = ( (__decorate([
     debounce(1000)
-], TunnelModel.prototype, "storeForwarded", null));
-TunnelModel = ( __decorate([
-    ( __param(0, ITunnelService)),
-    ( __param(1, IStorageService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IWorkbenchEnvironmentService)),
-    ( __param(4, IRemoteAuthorityResolverService)),
-    ( __param(5, IWorkspaceContextService)),
-    ( __param(6, ILogService)),
-    ( __param(7, IDialogService)),
-    ( __param(8, IExtensionService)),
-    ( __param(9, IContextKeyService))
-], TunnelModel));
+], TunnelModel.prototype, "storeForwarded", null)));
+TunnelModel = ( (__decorate([
+    ( (__param(0, ITunnelService))),
+    ( (__param(1, IStorageService))),
+    ( (__param(2, IConfigurationService))),
+    ( (__param(3, IWorkbenchEnvironmentService))),
+    ( (__param(4, IRemoteAuthorityResolverService))),
+    ( (__param(5, IWorkspaceContextService))),
+    ( (__param(6, ILogService))),
+    ( (__param(7, IDialogService))),
+    ( (__param(8, IExtensionService))),
+    ( (__param(9, IContextKeyService)))
+], TunnelModel)));
 export { ACTIVATION_EVENT, AutoTunnelSource, OnPortForward, PortsAttributes, TunnelCloseReason, TunnelModel, TunnelSource, UserTunnelSource, forwardedPortsViewEnabled, isCandidatePort, makeAddress, mapHasAddress, mapHasAddressLocalhostOrAllInterfaces, parseAddress };