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

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

@@ -6,20 +6,21 @@ import { raceCancellationError } from 'vscode/vscode/vs/base/common/async';
 import { IEditSessionIdentityService } from 'vscode/vscode/vs/platform/workspace/common/editSessions.service';
 import { ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 
+const _moduleId = "vs/workbench/api/browser/mainThreadEditSessionIdentityParticipant";
 class ExtHostEditSessionIdentityCreateParticipant {
     constructor(extHostContext) {
         this.timeout = 10000;
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostWorkspace));
+        this._proxy = ( (extHostContext.getProxy(ExtHostContext.ExtHostWorkspace)));
     }
     async participate(workspaceFolder, token) {
-        const p = ( new Promise((resolve, reject) => {
-            setTimeout(() => reject(( new Error(( localizeWithPath(
-                'vs/workbench/api/browser/mainThreadEditSessionIdentityParticipant',
-                'timeout.onWillCreateEditSessionIdentity',
+        const p = ( (new Promise((resolve, reject) => {
+            setTimeout(() => reject(( (new Error(( localizeWithPath(
+                _moduleId,
+                0,
                 "Aborted onWillCreateEditSessionIdentity-event after 10000ms"
-            ))))), this.timeout);
+            )))))), this.timeout);
             this._proxy.$onWillCreateEditSessionIdentity(workspaceFolder.uri, token, this.timeout).then(resolve, reject);
-        }));
+        })));
         return raceCancellationError(p, token);
     }
 }
@@ -34,8 +35,8 @@ let EditSessionIdentityCreateParticipant = class EditSessionIdentityCreatePartic
 };
 EditSessionIdentityCreateParticipant = __decorate([
     extHostCustomer,
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IEditSessionIdentityService))
+    ( (__param(1, IInstantiationService))),
+    ( (__param(2, IEditSessionIdentityService)))
 ], EditSessionIdentityCreateParticipant);
 
 export { EditSessionIdentityCreateParticipant };

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

@@ -35,7 +35,7 @@ class MainThreadTextEditorProperties {
                 return previousProperties.options;
             }
             else {
-                throw new Error('No valid properties');
+                throw ( new Error('No valid properties'));
             }
         }
         let cursorStyle;

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

@@ -424,7 +424,7 @@ let MainThreadEditorTabs = class MainThreadEditorTabs {
         const tabInfo = this._tabInfoLookup.get(tabId);
         const tab = tabInfo?.tab;
         if (!tab) {
-            throw new Error(`Attempted to close tab with id ${tabId} which does not exist`);
+            throw ( new Error(`Attempted to close tab with id ${tabId} which does not exist`));
         }
         let targetGroup;
         const sourceGroup = this._editorGroupsService.getGroup(tabInfo.group.id);

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

@@ -216,7 +216,7 @@ MainThreadTextEditors = MainThreadTextEditors_1 = ( __decorate([
 CommandsRegistry.registerCommand('_workbench.revertAllDirty', async function (accessor) {
     const environmentService = accessor.get(IEnvironmentService);
     if (!environmentService.extensionTestsLocationURI) {
-        throw new Error('Command is only available when running extension tests.');
+        throw ( new Error('Command is only available when running extension tests.'));
     }
     const workingCopyService = accessor.get(IWorkingCopyService);
     for (const workingCopy of workingCopyService.dirtyWorkingCopies) {

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

@@ -18,6 +18,7 @@ import { extHostNamedCustomer } from '../../services/extensions/common/extHostCu
 import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host.service';
 import { ITimerService } from 'vscode/vscode/vs/workbench/services/timer/browser/timerService.service';
 
+const _moduleId = "vs/workbench/api/browser/mainThreadExtensionService";
 let MainThreadExtensionService = class MainThreadExtensionService {
     constructor(extHostContext, _extensionService, _notificationService, _extensionsWorkbenchService, _hostService, _extensionEnablementService, _timerService, _commandService, _environmentService) {
         this._extensionService = _extensionService;
@@ -31,8 +32,10 @@ let MainThreadExtensionService = class MainThreadExtensionService {
         this._extensionHostKind = extHostContext.extensionHostKind;
         const internalExtHostContext = extHostContext;
         this._internalExtensionService = internalExtHostContext.internalExtensionService;
-        internalExtHostContext._setExtensionHostProxy(( new ExtensionHostProxy(( extHostContext.getProxy(ExtHostContext.ExtHostExtensionService)))));
-        internalExtHostContext._setAllMainProxyIdentifiers(( ( Object.keys(MainContext)).map((key) => MainContext[key])));
+        internalExtHostContext._setExtensionHostProxy(( (new ExtensionHostProxy(
+             (extHostContext.getProxy(ExtHostContext.ExtHostExtensionService))
+        ))));
+        internalExtHostContext._setAllMainProxyIdentifiers(( (( (Object.keys(MainContext))).map((key) => MainContext[key]))));
     }
     dispose() {
     }
@@ -49,7 +52,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
         this._internalExtensionService._onDidActivateExtension(extensionId, codeLoadingTime, activateCallTime, activateResolvedTime, activationReason);
     }
     $onExtensionRuntimeError(extensionId, data) {
-        const error = ( new Error());
+        const error = ( (new Error()));
         error.name = data.name;
         error.message = data.message;
         error.stack = data.stack;
@@ -58,7 +61,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
         console.error(error.stack);
     }
     async $onExtensionActivationError(extensionId, data, missingExtensionDependency) {
-        const error = ( new Error());
+        const error = ( (new Error()));
         error.name = data.name;
         error.message = data.message;
         error.stack = data.stack;
@@ -91,18 +94,14 @@ let MainThreadExtensionService = class MainThreadExtensionService {
             this._notificationService.notify({
                 severity: Severity$1.Error,
                 message: ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadExtensionService',
-                    'reload window',
+                    _moduleId,
+                    0,
                     "Cannot activate the '{0}' extension because it depends on the '{1}' extension, which is not loaded. Would you like to reload the window to load the extension?",
                     extName,
                     missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
                 )),
                 actions: {
-                    primary: [( new Action('reload', ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadExtensionService',
-                        'reload',
-                        "Reload Window"
-                    )), '', true, () => this._hostService.reload()))]
+                    primary: [( (new Action('reload', ( localizeWithPath(_moduleId, 1, "Reload Window")), '', true, () => this._hostService.reload())))]
                 }
             });
         }
@@ -112,8 +111,8 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity$1.Error,
                     message: ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadExtensionService',
-                        'notSupportedInWorkspace',
+                        _moduleId,
+                        2,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is not supported in the current workspace",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -124,18 +123,14 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity$1.Error,
                     message: ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadExtensionService',
-                        'restrictedMode',
+                        _moduleId,
+                        3,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is not supported in Restricted Mode",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
                     )),
                     actions: {
-                        primary: [( new Action('manageWorkspaceTrust', ( localizeWithPath(
-                            'vs/workbench/api/browser/mainThreadExtensionService',
-                            'manageWorkspaceTrust',
-                            "Manage Workspace Trust"
-                        )), '', true, () => this._commandService.executeCommand('workbench.trust.manage')))]
+                        primary: [( (new Action('manageWorkspaceTrust', ( localizeWithPath(_moduleId, 4, "Manage Workspace Trust")), '', true, () => this._commandService.executeCommand('workbench.trust.manage'))))]
                     }
                 });
             }
@@ -143,19 +138,15 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity$1.Error,
                     message: ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadExtensionService',
-                        'disabledDep',
+                        _moduleId,
+                        5,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is disabled. Would you like to enable the extension and reload the window?",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
                     )),
                     actions: {
-                        primary: [( new Action('enable', ( localizeWithPath(
-                            'vs/workbench/api/browser/mainThreadExtensionService',
-                            'enable dep',
-                            "Enable and Reload"
-                        )), '', true, () => this._extensionEnablementService.setEnablement([missingInstalledDependency], enablementState === 6  ? 8  : 9 )
-                                .then(() => this._hostService.reload(), e => this._notificationService.error(e))))]
+                        primary: [( (new Action('enable', ( localizeWithPath(_moduleId, 6, "Enable and Reload")), '', true, () => this._extensionEnablementService.setEnablement([missingInstalledDependency], enablementState === 6  ? 8  : 9 )
+                                .then(() => this._hostService.reload(), e => this._notificationService.error(e)))))]
                     }
                 });
             }
@@ -163,8 +154,8 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity$1.Error,
                     message: ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadExtensionService',
-                        'disabledDepNoAction',
+                        _moduleId,
+                        7,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is disabled.",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -185,27 +176,23 @@ let MainThreadExtensionService = class MainThreadExtensionService {
             this._notificationService.notify({
                 severity: Severity$1.Error,
                 message: ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadExtensionService',
-                    'uninstalledDep',
+                    _moduleId,
+                    8,
                     "Cannot activate the '{0}' extension because it depends on the '{1}' extension from '{2}', which is not installed. Would you like to install the extension and reload the window?",
                     extName,
                     dependencyExtension.displayName,
                     dependencyExtension.publisherDisplayName
                 )),
                 actions: {
-                    primary: [( new Action('install', ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadExtensionService',
-                        'install missing dep',
-                        "Install and Reload"
-                    )), '', true, () => this._extensionsWorkbenchService.install(dependencyExtension)
-                            .then(() => this._hostService.reload(), e => this._notificationService.error(e))))]
+                    primary: [( (new Action('install', ( localizeWithPath(_moduleId, 9, "Install and Reload")), '', true, () => this._extensionsWorkbenchService.install(dependencyExtension)
+                            .then(() => this._hostService.reload(), e => this._notificationService.error(e)))))]
                 }
             });
         }
         else {
             this._notificationService.error(( localizeWithPath(
-                'vs/workbench/api/browser/mainThreadExtensionService',
-                'unknownDep',
+                _moduleId,
+                10,
                 "Cannot activate the '{0}' extension because it depends on an unknown '{1}' extension.",
                 extName,
                 missingDependency
@@ -235,14 +222,14 @@ let MainThreadExtensionService = class MainThreadExtensionService {
 };
 MainThreadExtensionService = __decorate([
     extHostNamedCustomer(MainContext.MainThreadExtensionService),
-    ( __param(1, IExtensionService)),
-    ( __param(2, INotificationService)),
-    ( __param(3, IExtensionsWorkbenchService)),
-    ( __param(4, IHostService)),
-    ( __param(5, IWorkbenchExtensionEnablementService)),
-    ( __param(6, ITimerService)),
-    ( __param(7, ICommandService)),
-    ( __param(8, IWorkbenchEnvironmentService))
+    ( (__param(1, IExtensionService))),
+    ( (__param(2, INotificationService))),
+    ( (__param(3, IExtensionsWorkbenchService))),
+    ( (__param(4, IHostService))),
+    ( (__param(5, IWorkbenchExtensionEnablementService))),
+    ( (__param(6, ITimerService))),
+    ( (__param(7, ICommandService))),
+    ( (__param(8, IWorkbenchEnvironmentService)))
 ], MainThreadExtensionService);
 class ExtensionHostProxy {
     constructor(_actual) {
@@ -309,9 +296,13 @@ function reviveResolvedAuthority(resolvedAuthority) {
 }
 function reviveConnection(connection) {
     if (connection.type === 0 ) {
-        return ( new WebSocketRemoteConnection(connection.host, connection.port));
+        return (
+             (new WebSocketRemoteConnection(connection.host, connection.port))
+        );
     }
-    return ( new ManagedRemoteConnection(connection.id));
+    return (
+         (new ManagedRemoteConnection(connection.id))
+    );
 }
 
 export { MainThreadExtensionService };

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

@@ -42,7 +42,7 @@ let MainThreadFileSystem = MainThreadFileSystem_1 = class MainThreadFileSystem {
     $onFileSystemChange(handle, changes) {
         const fileProvider = this._fileProvider.get(handle);
         if (!fileProvider) {
-            throw new Error('Unknown file provider');
+            throw ( new Error('Unknown file provider'));
         }
         fileProvider.$onFileSystemChange(changes);
     }

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

@@ -25,6 +25,7 @@ import { normalizeWatcherPattern } from 'vscode/vscode/vs/platform/files/common/
 import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
 
 var MainThreadFileSystemEventService_1;
+const _moduleId = "vs/workbench/api/browser/mainThreadFileSystemEventService";
 let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
     static { MainThreadFileSystemEventService_1 = this; }
     static { this.MementoKeyAdditionalEdits = `file.particpants.additionalEdits`; }
@@ -33,9 +34,9 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
         this._contextService = _contextService;
         this._logService = _logService;
         this._configurationService = _configurationService;
-        this._listener = ( new DisposableStore());
-        this._watches = ( new DisposableMap());
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostFileSystemEventService));
+        this._listener = ( (new DisposableStore()));
+        this._watches = ( (new DisposableMap()));
+        this._proxy = ( (extHostContext.getProxy(ExtHostContext.ExtHostFileSystemEventService)));
         this._listener.add(_fileService.onDidFilesChange(event => {
             this._proxy.$onFileEvent({
                 created: event.rawAdded,
@@ -49,7 +50,7 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                 if (undoInfo?.isUndoing) {
                     return;
                 }
-                const cts = ( new CancellationTokenSource(token));
+                const cts = ( (new CancellationTokenSource(token)));
                 const timer = setTimeout(() => cts.cancel(), timeout);
                 const data = await progressService.withProgress({
                     location: 15 ,
@@ -68,7 +69,7 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                 if (!data || data.edit.edits.length === 0) {
                     return;
                 }
-                const needsConfirmation = ( data.edit.edits.some(edit => edit.metadata?.needsConfirmation));
+                const needsConfirmation = ( (data.edit.edits.some(edit => edit.metadata?.needsConfirmation)));
                 let showPreview = storageService.getBoolean(MainThreadFileSystemEventService_1.MementoKeyAdditionalEdits, 0 );
                 if (envService.extensionTestsLocationURI) {
                     showPreview = false;
@@ -78,32 +79,32 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                     if (data.extensionNames.length === 1) {
                         if (operation === 0 ) {
                             message = ( localizeWithPath(
-                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                'ask.1.create',
+                                _moduleId,
+                                0,
                                 "Extension '{0}' wants to make refactoring changes with this file creation",
                                 data.extensionNames[0]
                             ));
                         }
                         else if (operation === 3 ) {
                             message = ( localizeWithPath(
-                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                'ask.1.copy',
+                                _moduleId,
+                                1,
                                 "Extension '{0}' wants to make refactoring changes with this file copy",
                                 data.extensionNames[0]
                             ));
                         }
                         else if (operation === 2 ) {
                             message = ( localizeWithPath(
-                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                'ask.1.move',
+                                _moduleId,
+                                2,
                                 "Extension '{0}' wants to make refactoring changes with this file move",
                                 data.extensionNames[0]
                             ));
                         }
                         else  {
                             message = ( localizeWithPath(
-                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                'ask.1.delete',
+                                _moduleId,
+                                3,
                                 "Extension '{0}' wants to make refactoring changes with this file deletion",
                                 data.extensionNames[0]
                             ));
@@ -112,32 +113,32 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                     else {
                         if (operation === 0 ) {
                             message = ( localizeWithPath(
-                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                { key: 'ask.N.create', comment: ['{0} is a number, e.g "3 extensions want..."'] },
+                                _moduleId,
+                                4,
                                 "{0} extensions want to make refactoring changes with this file creation",
                                 data.extensionNames.length
                             ));
                         }
                         else if (operation === 3 ) {
                             message = ( localizeWithPath(
-                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                { key: 'ask.N.copy', comment: ['{0} is a number, e.g "3 extensions want..."'] },
+                                _moduleId,
+                                5,
                                 "{0} extensions want to make refactoring changes with this file copy",
                                 data.extensionNames.length
                             ));
                         }
                         else if (operation === 2 ) {
                             message = ( localizeWithPath(
-                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                { key: 'ask.N.move', comment: ['{0} is a number, e.g "3 extensions want..."'] },
+                                _moduleId,
+                                6,
                                 "{0} extensions want to make refactoring changes with this file move",
                                 data.extensionNames.length
                             ));
                         }
                         else  {
                             message = ( localizeWithPath(
-                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                { key: 'ask.N.delete', comment: ['{0} is a number, e.g "3 extensions want..."'] },
+                                _moduleId,
+                                7,
                                 "{0} extensions want to make refactoring changes with this file deletion",
                                 data.extensionNames.length
                             ));
@@ -147,16 +148,8 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                         const { confirmed } = await dialogService.confirm({
                             type: Severity$1.Info,
                             message,
-                            primaryButton: ( localizeWithPath(
-                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                'preview',
-                                "Show &&Preview"
-                            )),
-                            cancelButton: ( localizeWithPath(
-                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                'cancel',
-                                "Skip Changes"
-                            ))
+                            primaryButton: ( localizeWithPath(_moduleId, 8, "Show &&Preview")),
+                            cancelButton: ( localizeWithPath(_moduleId, 9, "Skip Changes"))
                         });
                         showPreview = true;
                         if (!confirmed) {
@@ -165,45 +158,29 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                     }
                     else {
                         let Choice;
-                        ( (function(Choice) {
+                        ( ((function(Choice) {
                             Choice[Choice["OK"] = 0] = "OK";
                             Choice[Choice["Preview"] = 1] = "Preview";
                             Choice[Choice["Cancel"] = 2] = "Cancel";
-                        })(Choice || (Choice = {})));
+                        })(Choice || (Choice = {}))));
                         const { result, checkboxChecked } = await dialogService.prompt({
                             type: Severity$1.Info,
                             message,
                             buttons: [
                                 {
-                                    label: ( localizeWithPath(
-                                        'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                        { key: 'ok', comment: ['&& denotes a mnemonic'] },
-                                        "&&OK"
-                                    )),
+                                    label: ( localizeWithPath(_moduleId, 10, "&&OK")),
                                     run: () => Choice.OK
                                 },
                                 {
-                                    label: ( localizeWithPath(
-                                        'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                        { key: 'preview', comment: ['&& denotes a mnemonic'] },
-                                        "Show &&Preview"
-                                    )),
+                                    label: ( localizeWithPath(_moduleId, 8, "Show &&Preview")),
                                     run: () => Choice.Preview
                                 }
                             ],
                             cancelButton: {
-                                label: ( localizeWithPath(
-                                    'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                    'cancel',
-                                    "Skip Changes"
-                                )),
+                                label: ( localizeWithPath(_moduleId, 9, "Skip Changes")),
                                 run: () => Choice.Cancel
                             },
-                            checkbox: { label: ( localizeWithPath(
-                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                                'again',
-                                "Do not ask me again"
-                            )) }
+                            checkbox: { label: ( localizeWithPath(_moduleId, 11, "Do not ask me again")) }
                         });
                         if (result === Choice.Cancel) {
                             return;
@@ -220,35 +197,15 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
             _progressLabel(operation) {
                 switch (operation) {
                     case 0 :
-                        return ( localizeWithPath(
-                            'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                            'msg-create',
-                            "Running 'File Create' participants..."
-                        ));
+                        return ( localizeWithPath(_moduleId, 12, "Running 'File Create' participants..."));
                     case 2 :
-                        return ( localizeWithPath(
-                            'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                            'msg-rename',
-                            "Running 'File Rename' participants..."
-                        ));
+                        return ( localizeWithPath(_moduleId, 13, "Running 'File Rename' participants..."));
                     case 3 :
-                        return ( localizeWithPath(
-                            'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                            'msg-copy',
-                            "Running 'File Copy' participants..."
-                        ));
+                        return ( localizeWithPath(_moduleId, 14, "Running 'File Copy' participants..."));
                     case 1 :
-                        return ( localizeWithPath(
-                            'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                            'msg-delete',
-                            "Running 'File Delete' participants..."
-                        ));
+                        return ( localizeWithPath(_moduleId, 15, "Running 'File Delete' participants..."));
                     case 4 :
-                        return ( localizeWithPath(
-                            'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                            'msg-write',
-                            "Running 'File Write' participants..."
-                        ));
+                        return ( localizeWithPath(_moduleId, 16, "Running 'File Write' participants..."));
                 }
             }
         });
@@ -271,8 +228,8 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
             }
         }
         if (correlate) {
-            this._logService.trace(`MainThreadFileSystemEventService#$watch(): request to start watching correlated (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session})`);
-            const watcherDisposables = ( new DisposableStore());
+            this._logService.trace(`MainThreadFileSystemEventService#$watch(): request to start watching correlated (extension: ${extensionId}, path: ${( (uri.toString(true)))}, recursive: ${opts.recursive}, session: ${session})`);
+            const watcherDisposables = ( (new DisposableStore()));
             const subscription = watcherDisposables.add(this._fileService.createWatcher(uri, opts));
             watcherDisposables.add(subscription.onDidChange(event => {
                 this._proxy.$onFileEvent({
@@ -285,7 +242,7 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
             this._watches.set(session, watcherDisposables);
         }
         else {
-            this._logService.trace(`MainThreadFileSystemEventService#$watch(): request to start watching uncorrelated (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session})`);
+            this._logService.trace(`MainThreadFileSystemEventService#$watch(): request to start watching uncorrelated (extension: ${extensionId}, path: ${( (uri.toString(true)))}, recursive: ${opts.recursive}, session: ${session})`);
             const workspaceFolder = this._contextService.getWorkspaceFolder(uri);
             if (opts.recursive && opts.excludes.length === 0) {
                 const config = this._configurationService.getValue();
@@ -311,7 +268,7 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                     }
                 }
                 if (!opts.includes || opts.includes.length === 0) {
-                    this._logService.trace(`MainThreadFileSystemEventService#$watch(): ignoring request to start watching because path is inside workspace and no excludes are configured (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session})`);
+                    this._logService.trace(`MainThreadFileSystemEventService#$watch(): ignoring request to start watching because path is inside workspace and no excludes are configured (extension: ${extensionId}, path: ${( (uri.toString(true)))}, recursive: ${opts.recursive}, session: ${session})`);
                     return;
                 }
             }
@@ -320,7 +277,7 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
         }
     }
     $unwatch(session) {
-        if (( this._watches.has(session))) {
+        if (( (this._watches.has(session)))) {
             this._logService.trace(`MainThreadFileSystemEventService#$unwatch(): request to stop watching (session: ${session})`);
             this._watches.deleteAndDispose(session);
         }
@@ -332,29 +289,25 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
 };
 MainThreadFileSystemEventService = MainThreadFileSystemEventService_1 = __decorate([
     extHostNamedCustomer(MainContext.MainThreadFileSystemEventService),
-    ( __param(1, IFileService)),
-    ( __param(2, IWorkingCopyFileService)),
-    ( __param(3, IBulkEditService)),
-    ( __param(4, IProgressService)),
-    ( __param(5, IDialogService)),
-    ( __param(6, IStorageService)),
-    ( __param(7, ILogService)),
-    ( __param(8, IEnvironmentService)),
-    ( __param(9, IUriIdentityService)),
-    ( __param(10, IWorkspaceContextService)),
-    ( __param(11, ILogService)),
-    ( __param(12, IConfigurationService))
+    ( (__param(1, IFileService))),
+    ( (__param(2, IWorkingCopyFileService))),
+    ( (__param(3, IBulkEditService))),
+    ( (__param(4, IProgressService))),
+    ( (__param(5, IDialogService))),
+    ( (__param(6, IStorageService))),
+    ( (__param(7, ILogService))),
+    ( (__param(8, IEnvironmentService))),
+    ( (__param(9, IUriIdentityService))),
+    ( (__param(10, IWorkspaceContextService))),
+    ( (__param(11, ILogService))),
+    ( (__param(12, IConfigurationService)))
 ], MainThreadFileSystemEventService);
 registerAction2(class ResetMemento extends Action2 {
     constructor() {
         super({
             id: 'files.participants.resetChoice',
             title: {
-                value: ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadFileSystemEventService',
-                    'label',
-                    "Reset choice for 'File operation needs preview'"
-                )),
+                value: ( localizeWithPath(_moduleId, 17, "Reset choice for 'File operation needs preview'")),
                 original: `Reset choice for 'File operation needs preview'`
             },
             f1: true

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

@@ -326,7 +326,7 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
     $resolvePasteFileData(handle, requestId, dataId) {
         const provider = this._pasteEditProviders.get(handle);
         if (!provider) {
-            throw new Error('Could not find provider');
+            throw ( new Error('Could not find provider'));
         }
         return provider.resolveFileData(requestId, dataId);
     }
@@ -563,7 +563,7 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
                 }
                 const result = await this._proxy.$resolveInlayHint(handle, dto.cacheId, token);
                 if (token.isCancellationRequested) {
-                    throw new CancellationError();
+                    throw ( new CancellationError());
                 }
                 if (!result) {
                     return hint;
@@ -805,7 +805,7 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
     async $resolveDocumentOnDropFileData(handle, requestId, dataId) {
         const provider = this._documentOnDropEditProviders.get(handle);
         if (!provider) {
-            throw new Error('Could not find provider');
+            throw ( new Error('Could not find provider'));
         }
         return provider.resolveDocumentOnDropFileData(requestId, dataId);
     }
@@ -998,7 +998,7 @@ class MainThreadDocumentRangeSemanticTokensProvider {
                 data: dto.data
             };
         }
-        throw new Error(`Unexpected`);
+        throw ( new Error(`Unexpected`));
     }
 }
 class MainThreadMappedEditsProvider {