@codingame/monaco-vscode-remote-agent-service-override 4.5.0 → 4.5.2

package/index.d.ts

@@ -1 +1,2 @@
-export { RemoteAgentServiceOverrideParams, default } from './remoteAgent.js';
+export * from 'vscode/service-override/remoteAgent';
+export { default } from 'vscode/service-override/remoteAgent';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-remote-agent-service-override",
-  "version": "4.5.0",
+  "version": "4.5.2",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -26,7 +26,7 @@
     }
   },
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@4.5.0",
-    "@codingame/monaco-vscode-environment-service-override": "4.5.0"
+    "vscode": "npm:@codingame/monaco-vscode-api@4.5.2",
+    "@codingame/monaco-vscode-environment-service-override": "4.5.2"
   }
 }

package/vscode/src/vs/platform/download/common/downloadIpc.js

@@ -5,13 +5,13 @@ class DownloadServiceChannel {
         this.service = service;
     }
     listen(_, event, arg) {
-        throw new Error('Invalid listen');
+        throw ( new Error('Invalid listen'));
     }
     call(context, command, args) {
         switch (command) {
             case 'download': return this.service.download(URI.revive(args[0]), URI.revive(args[1]));
         }
-        throw new Error('Invalid call');
+        throw ( new Error('Invalid call'));
     }
 }
 

package/vscode/src/vs/platform/remote/common/remoteSocketFactoryService.js

@@ -21,7 +21,7 @@ class RemoteSocketFactoryService {
     connect(connectTo, path, query, debugLabel) {
         const socketFactory = this.getSocketFactory(connectTo);
         if (!socketFactory) {
-            throw new Error(`No socket factory found for ${connectTo}`);
+            throw ( new Error(`No socket factory found for ${connectTo}`));
         }
         return socketFactory.connect(connectTo, path, query, debugLabel);
     }

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

@@ -13,7 +13,8 @@ import { getVirtualWorkspaceLocation } from 'vscode/vscode/vs/platform/workspace
 import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
 import { Disposable, DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
 
-const SELECTED_REMOTE_IN_EXPLORER = ( new RawContextKey('selectedRemoteInExplorer', ''));
+const _moduleId = "vs/workbench/contrib/remote/browser/explorerViewItems";
+const SELECTED_REMOTE_IN_EXPLORER = ( (new RawContextKey('selectedRemoteInExplorer', '')));
 let SwitchRemoteViewItem = class SwitchRemoteViewItem extends Disposable {
     constructor(contextKeyService, remoteExplorerService, environmentService, storageService, workspaceContextService) {
         super();
@@ -22,18 +23,14 @@ let SwitchRemoteViewItem = class SwitchRemoteViewItem extends Disposable {
         this.environmentService = environmentService;
         this.storageService = storageService;
         this.workspaceContextService = workspaceContextService;
-        this.completedRemotes = this._register(( new DisposableMap()));
+        this.completedRemotes = this._register(( (new DisposableMap())));
         this.selectedRemoteContext = SELECTED_REMOTE_IN_EXPLORER.bindTo(contextKeyService);
         this.switchRemoteMenu = MenuId.for('workbench.remote.menu.switchRemoteMenu');
         this._register(MenuRegistry.appendMenuItem(MenuId.ViewContainerTitle, {
             submenu: this.switchRemoteMenu,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/remote/browser/explorerViewItems',
-                'switchRemote.label',
-                "Switch Remote"
-            )),
+            title: ( localizeWithPath(_moduleId, 0, "Switch Remote")),
             group: 'navigation',
-            when: ( ContextKeyExpr.equals('viewContainer', VIEWLET_ID)),
+            when: ( (ContextKeyExpr.equals('viewContainer', VIEWLET_ID))),
             order: 1,
             isSelection: true
         }));
@@ -99,7 +96,7 @@ let SwitchRemoteViewItem = class SwitchRemoteViewItem extends Disposable {
             if (view.group && view.group.startsWith('targets') && view.remoteAuthority && (!view.when || this.contextKeyService.contextMatchesRules(view.when))) {
                 const text = view.name;
                 const authority = isStringArray(view.remoteAuthority) ? view.remoteAuthority : [view.remoteAuthority];
-                if (( this.completedRemotes.has(authority[0]))) {
+                if (( (this.completedRemotes.has(authority[0])))) {
                     continue;
                 }
                 const thisCapture = this;
@@ -108,7 +105,7 @@ let SwitchRemoteViewItem = class SwitchRemoteViewItem extends Disposable {
                         super({
                             id: `workbench.action.remoteExplorer.show.${authority[0]}`,
                             title: text,
-                            toggled: ( SELECTED_REMOTE_IN_EXPLORER.isEqualTo(authority[0])),
+                            toggled: ( (SELECTED_REMOTE_IN_EXPLORER.isEqualTo(authority[0]))),
                             menu: {
                                 id: thisCapture.switchRemoteMenu
                             }
@@ -126,12 +123,12 @@ let SwitchRemoteViewItem = class SwitchRemoteViewItem extends Disposable {
         }
     }
 };
-SwitchRemoteViewItem = ( __decorate([
-    ( __param(0, IContextKeyService)),
-    ( __param(1, IRemoteExplorerService)),
-    ( __param(2, IWorkbenchEnvironmentService)),
-    ( __param(3, IStorageService)),
-    ( __param(4, IWorkspaceContextService))
-], SwitchRemoteViewItem));
+SwitchRemoteViewItem = ( (__decorate([
+    ( (__param(0, IContextKeyService))),
+    ( (__param(1, IRemoteExplorerService))),
+    ( (__param(2, IWorkbenchEnvironmentService))),
+    ( (__param(3, IStorageService))),
+    ( (__param(4, IWorkspaceContextService)))
+], SwitchRemoteViewItem)));
 
 export { SELECTED_REMOTE_IN_EXPLORER, SwitchRemoteViewItem };

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

@@ -47,6 +47,7 @@ import { IWalkthroughsService } from 'vscode/vscode/vs/workbench/contrib/welcome
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
 import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
 
+const _moduleId = "vs/workbench/contrib/remote/browser/remote";
 class HelpTreeVirtualDelegate {
     getHeight(element) {
         return 22;
@@ -100,57 +101,43 @@ class HelpModel {
         viewModel.onDidChangeHelpInformation(() => this.updateItems());
     }
     createHelpItemValue(info, infoKey) {
-        return ( new HelpItemValue(
-            this.commandService,
-            this.walkthroughsService,
-            info.extensionDescription,
-            (typeof info.remoteName === 'string') ? [info.remoteName] : info.remoteName,
-            info.virtualWorkspace,
-            info[infoKey]
-        ));
+        return (
+             (new HelpItemValue(
+                this.commandService,
+                this.walkthroughsService,
+                info.extensionDescription,
+                (typeof info.remoteName === 'string') ? [info.remoteName] : info.remoteName,
+                info.virtualWorkspace,
+                info[infoKey]
+            ))
+        );
     }
     updateItems() {
         const helpItems = [];
         const getStarted = this.viewModel.helpInformation.filter(info => info.getStarted);
         if (getStarted.length) {
-            const helpItemValues = ( getStarted.map((info) => this.createHelpItemValue(info, 'getStarted')));
-            const getStartedHelpItem = this.items?.find(item => item.icon === getStartedIcon) ?? ( new GetStartedHelpItem(getStartedIcon, ( localizeWithPath(
-                'vs/workbench/contrib/remote/browser/remote',
-                'remote.help.getStarted',
-                "Get Started"
-            )), helpItemValues, this.quickInputService, this.environmentService, this.openerService, this.remoteExplorerService, this.workspaceContextService, this.commandService));
+            const helpItemValues = ( (getStarted.map((info) => this.createHelpItemValue(info, 'getStarted'))));
+            const getStartedHelpItem = this.items?.find(item => item.icon === getStartedIcon) ?? ( (new GetStartedHelpItem(getStartedIcon, ( localizeWithPath(_moduleId, 0, "Get Started")), helpItemValues, this.quickInputService, this.environmentService, this.openerService, this.remoteExplorerService, this.workspaceContextService, this.commandService)));
             getStartedHelpItem.values = helpItemValues;
             helpItems.push(getStartedHelpItem);
         }
         const documentation = this.viewModel.helpInformation.filter(info => info.documentation);
         if (documentation.length) {
-            const helpItemValues = ( documentation.map((info) => this.createHelpItemValue(info, 'documentation')));
-            const documentationHelpItem = this.items?.find(item => item.icon === documentationIcon) ?? ( new HelpItem(documentationIcon, ( localizeWithPath(
-                'vs/workbench/contrib/remote/browser/remote',
-                'remote.help.documentation',
-                "Read Documentation"
-            )), helpItemValues, this.quickInputService, this.environmentService, this.openerService, this.remoteExplorerService, this.workspaceContextService));
+            const helpItemValues = ( (documentation.map((info) => this.createHelpItemValue(info, 'documentation'))));
+            const documentationHelpItem = this.items?.find(item => item.icon === documentationIcon) ?? ( (new HelpItem(documentationIcon, ( localizeWithPath(_moduleId, 1, "Read Documentation")), helpItemValues, this.quickInputService, this.environmentService, this.openerService, this.remoteExplorerService, this.workspaceContextService)));
             documentationHelpItem.values = helpItemValues;
             helpItems.push(documentationHelpItem);
         }
         const issues = this.viewModel.helpInformation.filter(info => info.issues);
         if (issues.length) {
-            const helpItemValues = ( issues.map((info) => this.createHelpItemValue(info, 'issues')));
-            const reviewIssuesHelpItem = this.items?.find(item => item.icon === reviewIssuesIcon) ?? ( new HelpItem(reviewIssuesIcon, ( localizeWithPath(
-                'vs/workbench/contrib/remote/browser/remote',
-                'remote.help.issues',
-                "Review Issues"
-            )), helpItemValues, this.quickInputService, this.environmentService, this.openerService, this.remoteExplorerService, this.workspaceContextService));
+            const helpItemValues = ( (issues.map((info) => this.createHelpItemValue(info, 'issues'))));
+            const reviewIssuesHelpItem = this.items?.find(item => item.icon === reviewIssuesIcon) ?? ( (new HelpItem(reviewIssuesIcon, ( localizeWithPath(_moduleId, 2, "Review Issues")), helpItemValues, this.quickInputService, this.environmentService, this.openerService, this.remoteExplorerService, this.workspaceContextService)));
             reviewIssuesHelpItem.values = helpItemValues;
             helpItems.push(reviewIssuesHelpItem);
         }
         if (helpItems.length) {
-            const helpItemValues = ( this.viewModel.helpInformation.map(info => this.createHelpItemValue(info, 'reportIssue')));
-            const issueReporterItem = this.items?.find(item => item.icon === reportIssuesIcon) ?? ( new IssueReporterItem(reportIssuesIcon, ( localizeWithPath(
-                'vs/workbench/contrib/remote/browser/remote',
-                'remote.help.report',
-                "Report Issue"
-            )), helpItemValues, this.quickInputService, this.environmentService, this.commandService, this.openerService, this.remoteExplorerService, this.workspaceContextService));
+            const helpItemValues = ( (this.viewModel.helpInformation.map(info => this.createHelpItemValue(info, 'reportIssue'))));
+            const issueReporterItem = this.items?.find(item => item.icon === reportIssuesIcon) ?? ( (new IssueReporterItem(reportIssuesIcon, ( localizeWithPath(_moduleId, 3, "Report Issue")), helpItemValues, this.quickInputService, this.environmentService, this.commandService, this.openerService, this.remoteExplorerService, this.workspaceContextService)));
             issueReporterItem.values = helpItemValues;
             helpItems.push(issueReporterItem);
         }
@@ -177,7 +164,7 @@ class HelpItemValue {
     async getUrl() {
         if (this._url === undefined) {
             if (typeof this.urlOrCommandOrId === 'string') {
-                const url = ( URI.parse(this.urlOrCommandOrId));
+                const url = ( (URI.parse(this.urlOrCommandOrId)));
                 if (url.authority) {
                     this._url = this.urlOrCommandOrId;
                 }
@@ -186,7 +173,7 @@ class HelpItemValue {
                         this._url = result;
                         return this._url;
                     });
-                    const emptyString = ( new Promise(resolve => setTimeout(() => resolve(''), 500)));
+                    const emptyString = ( (new Promise(resolve => setTimeout(() => resolve(''), 500))));
                     this._url = await Promise.race([urlCommand, emptyString]);
                 }
             }
@@ -220,14 +207,14 @@ class HelpItemBase {
         this.iconClasses.push('remote-help-tree-node-item-icon');
     }
     async getActions() {
-        return (await Promise.all(( this.values.map(async (value) => {
+        return (await Promise.all(( (this.values.map(async (value) => {
             return {
                 label: value.extensionDescription.displayName || value.extensionDescription.identifier.value,
                 description: (await value.description) ?? (await value.url),
                 url: await value.url,
                 extensionDescription: value.extensionDescription
             };
-        })))).filter(item => item.description);
+        }))))).filter(item => item.description);
     }
     async handleClick() {
         const remoteAuthority = this.environmentService.remoteAuthority;
@@ -267,11 +254,7 @@ class HelpItemBase {
         if (this.values.length > 1) {
             const actions = await this.getActions();
             if (actions.length) {
-                const action = await this.quickInputService.pick(actions, { placeHolder: ( localizeWithPath(
-                    'vs/workbench/contrib/remote/browser/remote',
-                    'pickRemoteExtension',
-                    "Select url to open"
-                )) });
+                const action = await this.quickInputService.pick(actions, { placeHolder: ( localizeWithPath(_moduleId, 4, "Select url to open")) });
                 if (action) {
                     await this.takeAction(action.extensionDescription, action.url);
                 }
@@ -289,7 +272,7 @@ class GetStartedHelpItem extends HelpItemBase {
         this.commandService = commandService;
     }
     async takeAction(extensionDescription, urlOrWalkthroughId) {
-        if ([Schemas.http, Schemas.https].includes(( URI.parse(urlOrWalkthroughId)).scheme)) {
+        if ([Schemas.http, Schemas.https].includes(( (URI.parse(urlOrWalkthroughId))).scheme)) {
             this.openerService.open(urlOrWalkthroughId, { allowCommands: true });
             return;
         }
@@ -302,7 +285,7 @@ class HelpItem extends HelpItemBase {
         this.openerService = openerService;
     }
     async takeAction(extensionDescription, url) {
-        await this.openerService.open(( URI.parse(url)), { allowCommands: true });
+        await this.openerService.open(( (URI.parse(url))), { allowCommands: true });
     }
 }
 class IssueReporterItem extends HelpItemBase {
@@ -312,31 +295,27 @@ class IssueReporterItem extends HelpItemBase {
         this.openerService = openerService;
     }
     async getActions() {
-        return Promise.all(( this.values.map(async (value) => {
+        return Promise.all(( (this.values.map(async (value) => {
             return {
                 label: value.extensionDescription.displayName || value.extensionDescription.identifier.value,
                 description: '',
                 url: await value.url,
                 extensionDescription: value.extensionDescription
             };
-        })));
+        }))));
     }
     async takeAction(extensionDescription, url) {
         if (!url) {
             await this.commandService.executeCommand('workbench.action.openIssueReporter', [extensionDescription.identifier.value]);
         }
         else {
-            await this.openerService.open(( URI.parse(url)));
+            await this.openerService.open(( (URI.parse(url))));
         }
     }
 }
 let HelpPanel = class HelpPanel extends ViewPane {
     static { this.ID = '~remote.helpPanel'; }
-    static { this.TITLE = ( localize2WithPath(
-        'vs/workbench/contrib/remote/browser/remote',
-        'remote.help',
-        "Help and feedback"
-    )); }
+    static { this.TITLE = ( localize2WithPath(_moduleId, 5, "Help and feedback")); }
     constructor(viewModel, options, keybindingService, contextMenuService, contextKeyService, configurationService, instantiationService, viewDescriptorService, openerService, quickInputService, commandService, remoteExplorerService, environmentService, themeService, telemetryService, workspaceContextService, walkthroughsService) {
         super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
         this.viewModel = viewModel;
@@ -353,15 +332,15 @@ let HelpPanel = class HelpPanel extends ViewPane {
         const treeContainer = document.createElement('div');
         treeContainer.classList.add('remote-help-content');
         container.appendChild(treeContainer);
-        this.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'RemoteHelp', treeContainer, ( new HelpTreeVirtualDelegate()), [( new HelpTreeRenderer())], ( new HelpDataSource()), {
+        this.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'RemoteHelp', treeContainer, ( (new HelpTreeVirtualDelegate())), [( (new HelpTreeRenderer()))], ( (new HelpDataSource())), {
             accessibilityProvider: {
                 getAriaLabel: (item) => {
                     return item.label;
                 },
-                getWidgetAriaLabel: () => ( localizeWithPath('vs/workbench/contrib/remote/browser/remote', 'remotehelp', "Remote Help"))
+                getWidgetAriaLabel: () => ( localizeWithPath(_moduleId, 6, "Remote Help"))
             }
         });
-        const model = ( new HelpModel(
+        const model = ( (new HelpModel(
             this.viewModel,
             this.openerService,
             this.quickInputService,
@@ -370,7 +349,7 @@ let HelpPanel = class HelpPanel extends ViewPane {
             this.environmentService,
             this.workspaceContextService,
             this.walkthroughsService
-        ));
+        )));
         this.tree.setInput(model);
         this._register(Event.debounce(this.tree.onDidOpen, (last, event) => event, 75, true)(e => {
             e.element?.handleClick();
@@ -381,23 +360,23 @@ let HelpPanel = class HelpPanel extends ViewPane {
         this.tree.layout(height, width);
     }
 };
-HelpPanel = ( __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, IRemoteExplorerService)),
-    ( __param(12, IWorkbenchEnvironmentService)),
-    ( __param(13, IThemeService)),
-    ( __param(14, ITelemetryService)),
-    ( __param(15, IWorkspaceContextService)),
-    ( __param(16, IWalkthroughsService))
-], HelpPanel));
+HelpPanel = ( (__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, IRemoteExplorerService))),
+    ( (__param(12, IWorkbenchEnvironmentService))),
+    ( (__param(13, IThemeService))),
+    ( (__param(14, ITelemetryService))),
+    ( (__param(15, IWorkspaceContextService))),
+    ( (__param(16, IWalkthroughsService)))
+], HelpPanel)));
 class HelpPanelDescriptor {
     constructor(viewModel) {
         this.id = HelpPanel.ID;
@@ -406,16 +385,16 @@ class HelpPanelDescriptor {
         this.hideByDefault = false;
         this.group = 'help@50';
         this.order = -10;
-        this.ctorDescriptor = ( new SyncDescriptor(HelpPanel, [viewModel]));
+        this.ctorDescriptor = ( (new SyncDescriptor(HelpPanel, [viewModel])));
     }
 }
 let RemoteViewPaneContainer = class RemoteViewPaneContainer extends FilterViewPaneContainer {
     constructor(layoutService, telemetryService, contextService, storageService, configurationService, instantiationService, themeService, contextMenuService, extensionService, remoteExplorerService, viewDescriptorService) {
         super(VIEWLET_ID, remoteExplorerService.onDidChangeTargetType, configurationService, layoutService, telemetryService, storageService, instantiationService, themeService, contextMenuService, extensionService, contextService, viewDescriptorService);
         this.remoteExplorerService = remoteExplorerService;
-        this.helpPanelDescriptor = ( new HelpPanelDescriptor(this));
+        this.helpPanelDescriptor = ( (new HelpPanelDescriptor(this)));
         this.helpInformation = [];
-        this._onDidChangeHelpInformation = ( new Emitter());
+        this._onDidChangeHelpInformation = ( (new Emitter()));
         this.onDidChangeHelpInformation = this._onDidChangeHelpInformation.event;
         this.hasRegisteredHelpView = false;
         this.addConstantViewDescriptors([this.helpPanelDescriptor]);
@@ -424,7 +403,7 @@ let RemoteViewPaneContainer = class RemoteViewPaneContainer extends FilterViewPa
             this._setHelpInformation(extensions);
         });
         this._setHelpInformation(this.remoteExplorerService.helpInformation);
-        const viewsRegistry = ( Registry.as(Extensions.ViewsRegistry));
+        const viewsRegistry = ( (Registry.as(Extensions.ViewsRegistry)));
         this.remoteSwitcher.createOptionItems(viewsRegistry.getViews(this.viewContainer));
         this._register(viewsRegistry.onViewsRegistered(e => {
             const remoteViews = [];
@@ -450,7 +429,7 @@ let RemoteViewPaneContainer = class RemoteViewPaneContainer extends FilterViewPa
         }
         this.helpInformation = helpInformation;
         this._onDidChangeHelpInformation.fire();
-        const viewsRegistry = ( Registry.as(Extensions.ViewsRegistry));
+        const viewsRegistry = ( (Registry.as(Extensions.ViewsRegistry)));
         if (this.helpInformation.length && !this.hasRegisteredHelpView) {
             const view = viewsRegistry.getView(this.helpPanelDescriptor.id);
             if (!view) {
@@ -487,35 +466,27 @@ let RemoteViewPaneContainer = class RemoteViewPaneContainer extends FilterViewPa
         this.remoteExplorerService.targetType = isStringArray(viewDescriptor.remoteAuthority) ? viewDescriptor.remoteAuthority : [viewDescriptor.remoteAuthority];
     }
     getTitle() {
-        const title = ( localizeWithPath(
-            'vs/workbench/contrib/remote/browser/remote',
-            'remote.explorer',
-            "Remote Explorer"
-        ));
+        const title = ( localizeWithPath(_moduleId, 7, "Remote Explorer"));
         return title;
     }
 };
-RemoteViewPaneContainer = ( __decorate([
-    ( __param(0, IWorkbenchLayoutService)),
-    ( __param(1, ITelemetryService)),
-    ( __param(2, IWorkspaceContextService)),
-    ( __param(3, IStorageService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IInstantiationService)),
-    ( __param(6, IThemeService)),
-    ( __param(7, IContextMenuService)),
-    ( __param(8, IExtensionService)),
-    ( __param(9, IRemoteExplorerService)),
-    ( __param(10, IViewDescriptorService))
-], RemoteViewPaneContainer));
-( Registry.as(Extensions.ViewContainersRegistry)).registerViewContainer({
+RemoteViewPaneContainer = ( (__decorate([
+    ( (__param(0, IWorkbenchLayoutService))),
+    ( (__param(1, ITelemetryService))),
+    ( (__param(2, IWorkspaceContextService))),
+    ( (__param(3, IStorageService))),
+    ( (__param(4, IConfigurationService))),
+    ( (__param(5, IInstantiationService))),
+    ( (__param(6, IThemeService))),
+    ( (__param(7, IContextMenuService))),
+    ( (__param(8, IExtensionService))),
+    ( (__param(9, IRemoteExplorerService))),
+    ( (__param(10, IViewDescriptorService)))
+], RemoteViewPaneContainer)));
+( (Registry.as(Extensions.ViewContainersRegistry))).registerViewContainer({
     id: VIEWLET_ID,
-    title: ( localize2WithPath(
-        'vs/workbench/contrib/remote/browser/remote',
-        'remote.explorer',
-        "Remote Explorer"
-    )),
-    ctorDescriptor: ( new SyncDescriptor(RemoteViewPaneContainer)),
+    title: ( localize2WithPath(_moduleId, 7, "Remote Explorer")),
+    ctorDescriptor: ( (new SyncDescriptor(RemoteViewPaneContainer))),
     hideIfEmpty: true,
     viewOrderDelegate: {
         getOrder: (group) => {
@@ -549,10 +520,10 @@ let RemoteMarkers = class RemoteMarkers {
         });
     }
 };
-RemoteMarkers = ( __decorate([
-    ( __param(0, IRemoteAgentService)),
-    ( __param(1, ITimerService))
-], RemoteMarkers));
+RemoteMarkers = ( (__decorate([
+    ( (__param(0, IRemoteAgentService))),
+    ( (__param(1, ITimerService)))
+], RemoteMarkers)));
 class VisibleProgress {
     get lastReport() {
         return this._lastReport;
@@ -564,7 +535,7 @@ class VisibleProgress {
         this._currentProgressPromiseResolve = null;
         this._currentProgress = null;
         this._currentTimer = null;
-        const promise = ( new Promise((resolve) => this._currentProgressPromiseResolve = resolve));
+        const promise = ( (new Promise((resolve) => this._currentProgressPromiseResolve = resolve)));
         progressService.withProgress({ location: location, buttons: buttons }, (progress) => { if (!this._isDisposed) {
             this._currentProgress = progress;
         } return promise; }, (choice) => onDidCancel(choice, this._lastReport));
@@ -594,7 +565,7 @@ class VisibleProgress {
     }
     startTimer(completionTime) {
         this.stopTimer();
-        this._currentTimer = ( new ReconnectionTimer(this, completionTime));
+        this._currentTimer = ( (new ReconnectionTimer(this, completionTime)));
     }
     stopTimer() {
         if (this._currentTimer) {
@@ -620,20 +591,10 @@ class ReconnectionTimer {
         }
         const remainingTime = Math.ceil(remainingTimeMs / 1000);
         if (remainingTime === 1) {
-            this._parent.report(( localizeWithPath(
-                'vs/workbench/contrib/remote/browser/remote',
-                'reconnectionWaitOne',
-                "Attempting to reconnect in {0} second...",
-                remainingTime
-            )));
+            this._parent.report(( localizeWithPath(_moduleId, 8, "Attempting to reconnect in {0} second...", remainingTime)));
         }
         else {
-            this._parent.report(( localizeWithPath(
-                'vs/workbench/contrib/remote/browser/remote',
-                'reconnectionWaitMany',
-                "Attempting to reconnect in {0} seconds...",
-                remainingTime
-            )));
+            this._parent.report(( localizeWithPath(_moduleId, 9, "Attempting to reconnect in {0} seconds...", remainingTime)));
         }
     }
 }
@@ -658,19 +619,27 @@ let RemoteAgentConnectionStatusListener = class RemoteAgentConnectionStatusListe
                 if (!location) {
                     location = quickInputVisible ? 15  : 20 ;
                 }
-                return ( new VisibleProgress(progressService, location, initialReport, ( buttons.map(button => button.label)), (choice, lastReport) => {
-                    if (typeof choice !== 'undefined' && buttons[choice]) {
-                        buttons[choice].callback();
-                    }
-                    else {
-                        if (location === 20 ) {
-                            visibleProgress = showProgress(15 , buttons, lastReport);
-                        }
-                        else {
-                            hideProgress();
+                return (
+                     (new VisibleProgress(
+                        progressService,
+                        location,
+                        initialReport,
+                         (buttons.map(button => button.label)),
+                        (choice, lastReport) => {
+                            if (typeof choice !== 'undefined' && buttons[choice]) {
+                                buttons[choice].callback();
+                            }
+                            else {
+                                if (location === 20 ) {
+                                    visibleProgress = showProgress(15 , buttons, lastReport);
+                                }
+                                else {
+                                    hideProgress();
+                                }
+                            }
                         }
-                    }
-                }));
+                    ))
+                );
             }
             function hideProgress() {
                 if (visibleProgress) {
@@ -682,21 +651,13 @@ let RemoteAgentConnectionStatusListener = class RemoteAgentConnectionStatusListe
             let lastIncomingDataTime = 0;
             let reconnectionAttempts = 0;
             const reconnectButton = {
-                label: ( localizeWithPath(
-                    'vs/workbench/contrib/remote/browser/remote',
-                    'reconnectNow',
-                    "Reconnect Now"
-                )),
+                label: ( localizeWithPath(_moduleId, 10, "Reconnect Now")),
                 callback: () => {
                     reconnectWaitEvent?.skipWait();
                 }
             };
             const reloadButton = {
-                label: ( localizeWithPath(
-                    'vs/workbench/contrib/remote/browser/remote',
-                    'reloadWindow',
-                    "Reload Window"
-                )),
+                label: ( localizeWithPath(_moduleId, 11, "Reload Window")),
                 callback: () => {
                     telemetryService.publicLog2('remoteReconnectionReload', {
                         remoteName: getRemoteName(environmentService.remoteAuthority),
@@ -726,11 +687,7 @@ let RemoteAgentConnectionStatusListener = class RemoteAgentConnectionStatusListe
                             if (!visibleProgress) {
                                 visibleProgress = showProgress(null, [reconnectButton, reloadButton]);
                             }
-                            visibleProgress.report(( localizeWithPath(
-                                'vs/workbench/contrib/remote/browser/remote',
-                                'connectionLost',
-                                "Connection Lost"
-                            )));
+                            visibleProgress.report(( localizeWithPath(_moduleId, 12, "Connection Lost")));
                         }
                         break;
                     case 1 :
@@ -752,11 +709,7 @@ let RemoteAgentConnectionStatusListener = class RemoteAgentConnectionStatusListe
                         });
                         if (visibleProgress || e.millisSinceLastIncomingData > DISCONNECT_PROMPT_TIME) {
                             visibleProgress = showProgress(null, [reloadButton]);
-                            visibleProgress.report(( localizeWithPath(
-                                'vs/workbench/contrib/remote/browser/remote',
-                                'reconnectionRunning',
-                                "Disconnected. Attempting to reconnect..."
-                            )));
+                            visibleProgress.report(( localizeWithPath(_moduleId, 13, "Disconnected. Attempting to reconnect...")));
                             disposableListener = quickInputService.onShow(() => {
                                 if (visibleProgress && visibleProgress.location === 20 ) {
                                     visibleProgress = showProgress(15 , [reloadButton], visibleProgress.lastReport);
@@ -784,16 +737,8 @@ let RemoteAgentConnectionStatusListener = class RemoteAgentConnectionStatusListe
                             this._reloadWindowShown = true;
                             dialogService.confirm({
                                 type: Severity$1.Error,
-                                message: ( localizeWithPath(
-                                    'vs/workbench/contrib/remote/browser/remote',
-                                    'reconnectionPermanentFailure',
-                                    "Cannot reconnect. Please reload the window."
-                                )),
-                                primaryButton: ( localizeWithPath(
-                                    'vs/workbench/contrib/remote/browser/remote',
-                                    { key: 'reloadWindow.dialog', comment: ['&& denotes a mnemonic'] },
-                                    "&&Reload Window"
-                                ))
+                                message: ( localizeWithPath(_moduleId, 14, "Cannot reconnect. Please reload the window.")),
+                                primaryButton: ( localizeWithPath(_moduleId, 15, "&&Reload Window"))
                             }).then(result => {
                                 if (result.confirmed) {
                                     commandService.executeCommand(ReloadWindowAction.ID);
@@ -818,15 +763,15 @@ let RemoteAgentConnectionStatusListener = class RemoteAgentConnectionStatusListe
         }
     }
 };
-RemoteAgentConnectionStatusListener = ( __decorate([
-    ( __param(0, IRemoteAgentService)),
-    ( __param(1, IProgressService)),
-    ( __param(2, IDialogService)),
-    ( __param(3, ICommandService)),
-    ( __param(4, IQuickInputService)),
-    ( __param(5, ILogService)),
-    ( __param(6, IWorkbenchEnvironmentService)),
-    ( __param(7, ITelemetryService))
-], RemoteAgentConnectionStatusListener));
+RemoteAgentConnectionStatusListener = ( (__decorate([
+    ( (__param(0, IRemoteAgentService))),
+    ( (__param(1, IProgressService))),
+    ( (__param(2, IDialogService))),
+    ( (__param(3, ICommandService))),
+    ( (__param(4, IQuickInputService))),
+    ( (__param(5, ILogService))),
+    ( (__param(6, IWorkbenchEnvironmentService))),
+    ( (__param(7, ITelemetryService)))
+], RemoteAgentConnectionStatusListener)));
 
 export { RemoteAgentConnectionStatusListener, RemoteMarkers };