@codingame/monaco-vscode-extensions-service-override 4.5.1 → 4.5.2

package/vscode/src/vs/workbench/api/browser/mainThreadTunnelService.js

@@ -19,6 +19,7 @@ import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/
 import { TunnelSource, TunnelCloseReason, makeAddress, forwardedPortsViewEnabled } from 'vscode/vscode/vs/workbench/services/remote/common/tunnelModel';
 import Severity$1 from 'vscode/vscode/vs/base/common/severity';
 
+const _moduleId = "vs/workbench/api/browser/mainThreadTunnelService";
 let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
     constructor(extHostContext, remoteExplorerService, tunnelService, notificationService, configurationService, logService, remoteAgentService, contextKeyService) {
         super();
@@ -30,9 +31,9 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
         this.remoteAgentService = remoteAgentService;
         this.contextKeyService = contextKeyService;
         this.elevateionRetry = false;
-        this.portsAttributesProviders = ( new Map());
+        this.portsAttributesProviders = ( (new Map()));
         this._alreadyRegistered = false;
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostTunnelService));
+        this._proxy = ( (extHostContext.getProxy(ExtHostContext.ExtHostTunnelService)));
         this._register(tunnelService.onTunnelOpened(() => this._proxy.$onDidTunnelsChange()));
         this._register(tunnelService.onTunnelClosed(() => this._proxy.$onDidTunnelsChange()));
     }
@@ -71,13 +72,13 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
         if (this.portsAttributesProviders.size === 0) {
             return [];
         }
-        const appropriateHandles = ( Array.from(this.portsAttributesProviders.entries()).filter(entry => {
+        const appropriateHandles = ( (Array.from(this.portsAttributesProviders.entries()).filter(entry => {
             const selector = entry[1];
             const portRange = (typeof selector.portRange === 'number') ? [selector.portRange, selector.portRange + 1] : selector.portRange;
-            const portInRange = portRange ? ( ports.some(port => portRange[0] <= port && port < portRange[1])) : true;
+            const portInRange = portRange ? ( (ports.some(port => portRange[0] <= port && port < portRange[1]))) : true;
             const commandMatches = !selector.commandPattern || (commandLine && (commandLine.match(selector.commandPattern)));
             return portInRange && commandMatches;
-        }).map(entry => entry[0]));
+        }).map(entry => entry[0])));
         if (appropriateHandles.length === 0) {
             return [];
         }
@@ -109,19 +110,14 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
     }
     async elevationPrompt(tunnelOptions, tunnel, source) {
         return this.notificationService.prompt(Severity$1.Info, ( localizeWithPath(
-            'vs/workbench/api/browser/mainThreadTunnelService',
-            'remote.tunnel.openTunnel',
+            _moduleId,
+            0,
             "The extension {0} has forwarded port {1}. You'll need to run as superuser to use port {2} locally.",
             source,
             tunnelOptions.remoteAddress.port,
             tunnelOptions.localAddressPort
         )), [{
-                label: ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadTunnelService',
-                    'remote.tunnelsView.elevationButton',
-                    "Use Port {0} as Sudo...",
-                    tunnel.tunnelRemotePort
-                )),
+                label: ( localizeWithPath(_moduleId, 1, "Use Port {0} as Sudo...", tunnel.tunnelRemotePort)),
                 run: async () => {
                     this.elevateionRetry = true;
                     await this.remoteExplorerService.close({ host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort }, TunnelCloseReason.Other);
@@ -143,14 +139,16 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
         return this.remoteExplorerService.close(remote, TunnelCloseReason.Other);
     }
     async $getTunnels() {
-        return ( (await this.tunnelService.tunnels).map(tunnel => {
-            return {
-                remoteAddress: { port: tunnel.tunnelRemotePort, host: tunnel.tunnelRemoteHost },
-                localAddress: tunnel.localAddress,
-                privacy: tunnel.privacy,
-                protocol: tunnel.protocol
-            };
-        }));
+        return (
+             ((await this.tunnelService.tunnels).map(tunnel => {
+                return {
+                    remoteAddress: { port: tunnel.tunnelRemotePort, host: tunnel.tunnelRemoteHost },
+                    localAddress: tunnel.localAddress,
+                    privacy: tunnel.privacy,
+                    protocol: tunnel.protocol
+                };
+            }))
+        );
     }
     async $onFoundNewCandidates(candidates) {
         this.remoteExplorerService.onFoundNewCandidates(candidates);
@@ -199,12 +197,12 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
         this.remoteAgentService.getEnvironment().then(() => {
             switch (source) {
                 case CandidatePortSource.None: {
-                    ( Registry.as(Extensions.Configuration))
+                    ( (Registry.as(Extensions.Configuration)))
                         .registerDefaultConfigurations([{ overrides: { 'remote.autoForwardPorts': false } }]);
                     break;
                 }
                 case CandidatePortSource.Output: {
-                    ( Registry.as(Extensions.Configuration))
+                    ( (Registry.as(Extensions.Configuration)))
                         .registerDefaultConfigurations([{ overrides: { 'remote.autoForwardPortsSource': PORT_AUTO_SOURCE_SETTING_OUTPUT } }]);
                     break;
                 }
@@ -215,13 +213,13 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
 };
 MainThreadTunnelService = __decorate([
     extHostNamedCustomer(MainContext.MainThreadTunnelService),
-    ( __param(1, IRemoteExplorerService)),
-    ( __param(2, ITunnelService)),
-    ( __param(3, INotificationService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, ILogService)),
-    ( __param(6, IRemoteAgentService)),
-    ( __param(7, IContextKeyService))
+    ( (__param(1, IRemoteExplorerService))),
+    ( (__param(2, ITunnelService))),
+    ( (__param(3, INotificationService))),
+    ( (__param(4, IConfigurationService))),
+    ( (__param(5, ILogService))),
+    ( (__param(6, IRemoteAgentService))),
+    ( (__param(7, IContextKeyService)))
 ], MainThreadTunnelService);
 
 export { MainThreadTunnelService };

package/vscode/src/vs/workbench/api/browser/mainThreadUriOpeners.js

@@ -16,16 +16,17 @@ import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extension
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import Severity$1 from 'vscode/vscode/vs/base/common/severity';
 
+const _moduleId = "vs/workbench/api/browser/mainThreadUriOpeners";
 let MainThreadUriOpeners = class MainThreadUriOpeners extends Disposable {
     constructor(context, storageService, externalUriOpenerService, extensionService, openerService, notificationService) {
         super();
         this.extensionService = extensionService;
         this.openerService = openerService;
         this.notificationService = notificationService;
-        this._registeredOpeners = ( new Map());
-        this.proxy = ( context.getProxy(ExtHostContext.ExtHostUriOpeners));
+        this._registeredOpeners = ( (new Map()));
+        this.proxy = ( (context.getProxy(ExtHostContext.ExtHostUriOpeners)));
         this._register(externalUriOpenerService.registerExternalOpenerProvider(this));
-        this._contributedExternalUriOpenersStore = this._register(( new ContributedExternalUriOpenersStore(storageService, extensionService)));
+        this._contributedExternalUriOpenersStore = this._register(( (new ContributedExternalUriOpenersStore(storageService, extensionService))));
     }
     async *getOpeners(targetUri) {
         if (targetUri.scheme !== Schemas.http && targetUri.scheme !== Schemas.https) {
@@ -33,7 +34,7 @@ let MainThreadUriOpeners = class MainThreadUriOpeners extends Disposable {
         }
         await this.extensionService.activateByEvent(`onOpenExternalUri:${targetUri.scheme}`);
         for (const [id, openerMetadata] of this._registeredOpeners) {
-            if (( openerMetadata.schemes.has(targetUri.scheme))) {
+            if (( (openerMetadata.schemes.has(targetUri.scheme)))) {
                 yield this.createOpener(id, openerMetadata);
             }
         }
@@ -51,23 +52,22 @@ let MainThreadUriOpeners = class MainThreadUriOpeners extends Disposable {
                 }
                 catch (e) {
                     if (!isCancellationError(e)) {
-                        const openDefaultAction = ( new Action('default', ( localizeWithPath(
-                            'vs/workbench/api/browser/mainThreadUriOpeners',
-                            'openerFailedUseDefault',
-                            "Open using default opener"
-                        )), undefined, undefined, async () => {
+                        const openDefaultAction = ( (new Action('default', ( localizeWithPath(_moduleId, 0, "Open using default opener")), undefined, undefined, async () => {
                             await this.openerService.open(uri, {
                                 allowTunneling: false,
                                 allowContributedOpeners: defaultExternalUriOpenerId,
                             });
-                        }));
-                        openDefaultAction.tooltip = ( uri.toString());
+                        })));
+                        openDefaultAction.tooltip = ( (uri.toString()));
                         this.notificationService.notify({
                             severity: Severity$1.Error,
-                            message: ( localizeWithPath('vs/workbench/api/browser/mainThreadUriOpeners', {
-                                key: 'openerFailedMessage',
-                                comment: ['{0} is the id of the opener. {1} is the url being opened.'],
-                            }, 'Could not open uri with \'{0}\': {1}', id, ( e.toString()))),
+                            message: ( localizeWithPath(
+                                _moduleId,
+                                1,
+                                'Could not open uri with \'{0}\': {1}',
+                                id,
+                                 (e.toString())
+                            )),
                             actions: {
                                 primary: [
                                     openDefaultAction
@@ -81,11 +81,11 @@ let MainThreadUriOpeners = class MainThreadUriOpeners extends Disposable {
         };
     }
     async $registerUriOpener(id, schemes, extensionId, label) {
-        if (( this._registeredOpeners.has(id))) {
-            throw new Error(`Opener with id '${id}' already registered`);
+        if (( (this._registeredOpeners.has(id)))) {
+            throw ( (new Error(`Opener with id '${id}' already registered`)));
         }
         this._registeredOpeners.set(id, {
-            schemes: ( new Set(schemes)),
+            schemes: ( (new Set(schemes))),
             label,
             extensionId,
         });
@@ -102,11 +102,11 @@ let MainThreadUriOpeners = class MainThreadUriOpeners extends Disposable {
 };
 MainThreadUriOpeners = __decorate([
     extHostNamedCustomer(MainContext.MainThreadUriOpeners),
-    ( __param(1, IStorageService)),
-    ( __param(2, IExternalUriOpenerService)),
-    ( __param(3, IExtensionService)),
-    ( __param(4, IOpenerService)),
-    ( __param(5, INotificationService))
+    ( (__param(1, IStorageService))),
+    ( (__param(2, IExternalUriOpenerService))),
+    ( (__param(3, IExtensionService))),
+    ( (__param(4, IOpenerService))),
+    ( (__param(5, INotificationService)))
 ], MainThreadUriOpeners);
 
 export { MainThreadUriOpeners };

package/vscode/src/vs/workbench/api/browser/mainThreadWebviewPanels.js

@@ -90,7 +90,7 @@ let MainThreadWebviewPanels = class MainThreadWebviewPanels extends Disposable {
                 }
                 return false;
             },
-            resolveWebview: () => { throw new Error('not implemented'); }
+            resolveWebview: () => { throw ( new Error('not implemented')); }
         }));
     }
     get webviewInputs() { return this._webviewInputs; }
@@ -174,7 +174,7 @@ let MainThreadWebviewPanels = class MainThreadWebviewPanels extends Disposable {
     }
     $registerSerializer(viewType, options) {
         if (( this._revivers.has(viewType))) {
-            throw new Error(`Reviver for ${viewType} already registered`);
+            throw ( new Error(`Reviver for ${viewType} already registered`));
         }
         this._revivers.set(viewType, this._webviewWorkbenchService.registerResolver({
             canResolve: (webviewInput) => {
@@ -215,7 +215,7 @@ let MainThreadWebviewPanels = class MainThreadWebviewPanels extends Disposable {
     }
     $unregisterSerializer(viewType) {
         if (!( this._revivers.has(viewType))) {
-            throw new Error(`No reviver for ${viewType} registered`);
+            throw ( new Error(`No reviver for ${viewType} registered`));
         }
         this._revivers.deleteAndDispose(viewType);
     }

package/vscode/src/vs/workbench/api/browser/mainThreadWebviewViews.js

@@ -35,7 +35,7 @@ let MainThreadWebviewsViews = class MainThreadWebviewsViews extends Disposable {
     }
     $registerWebviewViewProvider(extensionData, viewType, options) {
         if (( this._webviewViewProviders.has(viewType))) {
-            throw new Error(`View provider for ${viewType} already registered`);
+            throw ( new Error(`View provider for ${viewType} already registered`));
         }
         const extension = reviveWebviewExtension(extensionData);
         const registration = this._webviewViewService.register(viewType, {
@@ -80,14 +80,14 @@ let MainThreadWebviewsViews = class MainThreadWebviewsViews extends Disposable {
     }
     $unregisterWebviewViewProvider(viewType) {
         if (!( this._webviewViewProviders.has(viewType))) {
-            throw new Error(`No view provider for ${viewType} registered`);
+            throw ( new Error(`No view provider for ${viewType} registered`));
         }
         this._webviewViewProviders.deleteAndDispose(viewType);
     }
     getWebviewView(handle) {
         const webviewView = this._webviewViews.get(handle);
         if (!webviewView) {
-            throw new Error('unknown webview view');
+            throw ( new Error('unknown webview view'));
         }
         return webviewView;
     }

package/vscode/src/vs/workbench/api/browser/mainThreadWebviews.js

@@ -12,25 +12,26 @@ import { deserializeWebviewMessage, serializeWebviewMessage } from 'vscode/vscod
 import { SerializableObjectWithBuffers } from 'vscode/vscode/vs/workbench/services/extensions/common/proxyIdentifier';
 
 var MainThreadWebviews_1;
+const _moduleId = "vs/workbench/api/browser/mainThreadWebviews";
 let MainThreadWebviews = class MainThreadWebviews extends Disposable {
     static { MainThreadWebviews_1 = this; }
-    static { this.standardSupportedLinkSchemes = ( new Set([
+    static { this.standardSupportedLinkSchemes = ( (new Set([
         Schemas.http,
         Schemas.https,
         Schemas.mailto,
         Schemas.vscode,
         'vscode-insider',
-    ])); }
+    ]))); }
     constructor(context, _openerService, _productService) {
         super();
         this._openerService = _openerService;
         this._productService = _productService;
-        this._webviews = ( new Map());
-        this._proxy = ( context.getProxy(ExtHostContext.ExtHostWebviews));
+        this._webviews = ( (new Map()));
+        this._proxy = ( (context.getProxy(ExtHostContext.ExtHostWebviews)));
     }
     addWebview(handle, webview, options) {
-        if (( this._webviews.has(handle))) {
-            throw new Error('Webview already registered');
+        if (( (this._webviews.has(handle)))) {
+            throw ( (new Error('Webview already registered')));
         }
         this._webviews.set(handle, webview);
         this.hookupWebviewEventDelegate(handle, webview, options);
@@ -53,11 +54,11 @@ let MainThreadWebviews = class MainThreadWebviews extends Disposable {
         return webview.postMessage(message, arrayBuffers);
     }
     hookupWebviewEventDelegate(handle, webview, options) {
-        const disposables = ( new DisposableStore());
+        const disposables = ( (new DisposableStore()));
         disposables.add(webview.onDidClickLink((uri) => this.onDidClickLink(handle, uri)));
         disposables.add(webview.onMessage((message) => {
             const serialized = serializeWebviewMessage(message.message, options);
-            this._proxy.$onMessage(handle, serialized.message, ( new SerializableObjectWithBuffers(serialized.buffers)));
+            this._proxy.$onMessage(handle, serialized.message, ( (new SerializableObjectWithBuffers(serialized.buffers))));
         }));
         disposables.add(webview.onMissingCsp((extension) => this._proxy.$onMissingCsp(handle, extension.value)));
         disposables.add(webview.onDidDispose(() => {
@@ -67,12 +68,12 @@ let MainThreadWebviews = class MainThreadWebviews extends Disposable {
     }
     onDidClickLink(handle, link) {
         const webview = this.getWebview(handle);
-        if (this.isSupportedLink(webview, ( URI.parse(link)))) {
+        if (this.isSupportedLink(webview, ( (URI.parse(link))))) {
             this._openerService.open(link, { fromUserGesture: true, allowContributedOpeners: true, allowCommands: Array.isArray(webview.contentOptions.enableCommandUris) || webview.contentOptions.enableCommandUris === true, fromWorkspace: true });
         }
     }
     isSupportedLink(webview, link) {
-        if (( MainThreadWebviews_1.standardSupportedLinkSchemes.has(link.scheme))) {
+        if (( (MainThreadWebviews_1.standardSupportedLinkSchemes.has(link.scheme)))) {
             return true;
         }
         if (!isWeb && this._productService.urlProtocol === link.scheme) {
@@ -92,7 +93,7 @@ let MainThreadWebviews = class MainThreadWebviews extends Disposable {
     getWebview(handle) {
         const webview = this.tryGetWebview(handle);
         if (!webview) {
-            throw new Error(`Unknown webview handle:${handle}`);
+            throw ( (new Error(`Unknown webview handle:${handle}`)));
         }
         return webview;
     }
@@ -104,18 +105,18 @@ let MainThreadWebviews = class MainThreadWebviews extends Disposable {
 				<meta http-equiv="Content-Security-Policy" content="default-src 'none';">
 			</head>
 			<body>${( localizeWithPath(
-            'vs/workbench/api/browser/mainThreadWebviews',
-            'errorMessage',
+            _moduleId,
+            0,
             "An error occurred while loading view: {0}",
             escape(viewType)
         ))}</body>
 		</html>`;
     }
 };
-MainThreadWebviews = MainThreadWebviews_1 = ( __decorate([
-    ( __param(1, IOpenerService)),
-    ( __param(2, IProductService))
-], MainThreadWebviews));
+MainThreadWebviews = MainThreadWebviews_1 = ( (__decorate([
+    ( (__param(1, IOpenerService))),
+    ( (__param(2, IProductService)))
+], MainThreadWebviews)));
 function reviveWebviewExtension(extensionData) {
     return {
         id: extensionData.id,
@@ -127,7 +128,7 @@ function reviveWebviewContentOptions(webviewOptions) {
         allowScripts: webviewOptions.enableScripts,
         allowForms: webviewOptions.enableForms,
         enableCommandUris: webviewOptions.enableCommandUris,
-        localResourceRoots: Array.isArray(webviewOptions.localResourceRoots) ? ( webviewOptions.localResourceRoots.map(r => URI.revive(r))) : undefined,
+        localResourceRoots: Array.isArray(webviewOptions.localResourceRoots) ? ( (webviewOptions.localResourceRoots.map(r => URI.revive(r)))) : undefined,
         portMapping: webviewOptions.portMapping,
     };
 }

package/vscode/src/vs/workbench/api/browser/mainThreadWorkspace.js

@@ -25,6 +25,7 @@ import { SideBySideEditor, EditorResourceAccessor } from 'vscode/vscode/vs/workb
 import { firstOrDefault, coalesce } from 'vscode/vscode/vs/base/common/arrays';
 import { ICanonicalUriService } from 'vscode/vscode/vs/platform/workspace/common/canonicalUri.service';
 
+const _moduleId = "vs/workbench/api/browser/mainThreadWorkspace";
 let MainThreadWorkspace = class MainThreadWorkspace {
     constructor(extHostContext, _searchService, _contextService, _editSessionIdentityService, _canonicalUriService, _editorService, _workspaceEditingService, _notificationService, _requestService, _instantiationService, _labelService, _environmentService, fileService, _workspaceTrustManagementService, _workspaceTrustRequestService) {
         this._searchService = _searchService;
@@ -40,12 +41,12 @@ let MainThreadWorkspace = class MainThreadWorkspace {
         this._environmentService = _environmentService;
         this._workspaceTrustManagementService = _workspaceTrustManagementService;
         this._workspaceTrustRequestService = _workspaceTrustRequestService;
-        this._toDispose = ( new DisposableStore());
+        this._toDispose = ( (new DisposableStore()));
         this._activeCancelTokens = Object.create(null);
         this._queryBuilder = this._instantiationService.createInstance(QueryBuilder);
-        this.registeredEditSessionProviders = ( new Map());
-        this.registeredCanonicalUriProviders = ( new Map());
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostWorkspace));
+        this.registeredEditSessionProviders = ( (new Map()));
+        this.registeredCanonicalUriProviders = ( (new Map()));
+        this._proxy = ( (extHostContext.getProxy(ExtHostContext.ExtHostWorkspace)));
         const workspace = this._contextService.getWorkspace();
         if (workspace.configuration && !isNative && !fileService.hasProvider(workspace.configuration)) {
             this._proxy.$initializeWorkspace(this.getWorkspaceData(workspace), this.isWorkspaceTrusted());
@@ -65,7 +66,7 @@ let MainThreadWorkspace = class MainThreadWorkspace {
         }
     }
     $updateWorkspaceFolders(extensionName, index, deleteCount, foldersToAdd) {
-        const workspaceFoldersToAdd = ( foldersToAdd.map(f => ({ uri: URI.revive(f.uri), name: f.name })));
+        const workspaceFoldersToAdd = ( (foldersToAdd.map(f => ({ uri: URI.revive(f.uri), name: f.name }))));
         this._notificationService.status(this.getStatusMessage(extensionName, workspaceFoldersToAdd.length, deleteCount), { hideAfter: 10 * 1000  });
         return this._workspaceEditingService.updateFolders(index, deleteCount, workspaceFoldersToAdd, true);
     }
@@ -76,16 +77,16 @@ let MainThreadWorkspace = class MainThreadWorkspace {
         if (wantsToAdd && !wantsToDelete) {
             if (addCount === 1) {
                 message = ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadWorkspace',
-                    'folderStatusMessageAddSingleFolder',
+                    _moduleId,
+                    0,
                     "Extension '{0}' added 1 folder to the workspace",
                     extensionName
                 ));
             }
             else {
                 message = ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadWorkspace',
-                    'folderStatusMessageAddMultipleFolders',
+                    _moduleId,
+                    1,
                     "Extension '{0}' added {1} folders to the workspace",
                     extensionName,
                     addCount
@@ -95,16 +96,16 @@ let MainThreadWorkspace = class MainThreadWorkspace {
         else if (wantsToDelete && !wantsToAdd) {
             if (removeCount === 1) {
                 message = ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadWorkspace',
-                    'folderStatusMessageRemoveSingleFolder',
+                    _moduleId,
+                    2,
                     "Extension '{0}' removed 1 folder from the workspace",
                     extensionName
                 ));
             }
             else {
                 message = ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadWorkspace',
-                    'folderStatusMessageRemoveMultipleFolders',
+                    _moduleId,
+                    3,
                     "Extension '{0}' removed {1} folders from the workspace",
                     extensionName,
                     removeCount
@@ -113,8 +114,8 @@ let MainThreadWorkspace = class MainThreadWorkspace {
         }
         else {
             message = ( localizeWithPath(
-                'vs/workbench/api/browser/mainThreadWorkspace',
-                'folderStatusChangeFolder',
+                _moduleId,
+                4,
                 "Extension '{0}' changed folders of the workspace",
                 extensionName
             ));
@@ -142,7 +143,9 @@ let MainThreadWorkspace = class MainThreadWorkspace {
         const workspace = this._contextService.getWorkspace();
         const query = this._queryBuilder.file(includeFolder ? [includeFolder] : workspace.folders, options);
         return this._searchService.fileSearch(query, token).then(result => {
-            return ( result.results.map(m => m.resource));
+            return (
+                 (result.results.map(m => m.resource))
+            );
         }, err => {
             if (!isCancellationError(err)) {
                 return Promise.reject(err);
@@ -153,7 +156,7 @@ let MainThreadWorkspace = class MainThreadWorkspace {
     $startTextSearch(pattern, _folder, options, requestId, token) {
         const folder = URI.revive(_folder);
         const workspace = this._contextService.getWorkspace();
-        const folders = folder ? [folder] : ( workspace.folders.map(folder => folder.uri));
+        const folders = folder ? [folder] : ( (workspace.folders.map(folder => folder.uri)));
         const query = this._queryBuilder.text(pattern, folders, options);
         query._reason = 'startTextSearch';
         const onProgress = (p) => {
@@ -188,9 +191,9 @@ let MainThreadWorkspace = class MainThreadWorkspace {
         if (!result.success) {
             return [];
         }
-        return coalesce(( result.editors.map(
+        return coalesce(( (result.editors.map(
             editor => EditorResourceAccessor.getCanonicalUri(editor, { supportSideBySide: SideBySideEditor.PRIMARY })
-        )));
+        ))));
     }
     $saveAll(includeUntitled) {
         return this._editorService.saveAll({ includeUntitled }).then(res => res.success);
@@ -250,20 +253,20 @@ let MainThreadWorkspace = class MainThreadWorkspace {
 };
 MainThreadWorkspace = __decorate([
     extHostNamedCustomer(MainContext.MainThreadWorkspace),
-    ( __param(1, ISearchService)),
-    ( __param(2, IWorkspaceContextService)),
-    ( __param(3, IEditSessionIdentityService)),
-    ( __param(4, ICanonicalUriService)),
-    ( __param(5, IEditorService)),
-    ( __param(6, IWorkspaceEditingService)),
-    ( __param(7, INotificationService)),
-    ( __param(8, IRequestService)),
-    ( __param(9, IInstantiationService)),
-    ( __param(10, ILabelService)),
-    ( __param(11, IEnvironmentService)),
-    ( __param(12, IFileService)),
-    ( __param(13, IWorkspaceTrustManagementService)),
-    ( __param(14, IWorkspaceTrustRequestService))
+    ( (__param(1, ISearchService))),
+    ( (__param(2, IWorkspaceContextService))),
+    ( (__param(3, IEditSessionIdentityService))),
+    ( (__param(4, ICanonicalUriService))),
+    ( (__param(5, IEditorService))),
+    ( (__param(6, IWorkspaceEditingService))),
+    ( (__param(7, INotificationService))),
+    ( (__param(8, IRequestService))),
+    ( (__param(9, IInstantiationService))),
+    ( (__param(10, ILabelService))),
+    ( (__param(11, IEnvironmentService))),
+    ( (__param(12, IFileService))),
+    ( (__param(13, IWorkspaceTrustManagementService))),
+    ( (__param(14, IWorkspaceTrustRequestService)))
 ], MainThreadWorkspace);
 
 export { MainThreadWorkspace };

package/vscode/src/vs/workbench/api/common/shared/dataTransferCache.js

@@ -19,11 +19,11 @@ class DataTransferFileCache {
     async resolveFileData(requestId, dataItemId) {
         const files = this.dataTransferFiles.get(requestId);
         if (!files) {
-            throw new Error('No data transfer found');
+            throw ( new Error('No data transfer found'));
         }
         const file = files.find(file => file.id === dataItemId);
         if (!file) {
-            throw new Error('No matching file found in data transfer');
+            throw ( new Error('No matching file found in data transfer'));
         }
         return VSBuffer.wrap(await file.data());
     }