@codingame/monaco-vscode-api 1.83.1 → 1.83.3-next.0

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

@@ -4,7 +4,7 @@ import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation
 import { FileAccess } from 'monaco-editor/esm/vs/base/common/network.js';
 import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
 import { areSameExtensions } from '../../../platform/extensionManagement/common/extensionManagementUtil.js';
 import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
@@ -89,14 +89,15 @@ let MainThreadExtensionService = class MainThreadExtensionService {
         if (this._extensionEnablementService.isEnabled(missingInstalledDependency)) {
             this._notificationService.notify({
                 severity: Severity.Error,
-                message: ( localize(
-                    'reload window',
-                    "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
-                )),
+                message: localizeWithPath('vs/workbench/api/browser/mainThreadExtensionService', 'reload window', "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', ( localize('reload', "Reload Window")), '', true, () => this._hostService.reload()))]
+                    primary: [( new Action(
+                        'reload',
+                        localizeWithPath('vs/workbench/api/browser/mainThreadExtensionService', 'reload', "Reload Window"),
+                        '',
+                        true,
+                        () => this._hostService.reload()
+                    ))]
                 }
             });
         }
@@ -105,52 +106,44 @@ let MainThreadExtensionService = class MainThreadExtensionService {
             if (enablementState === 4 ) {
                 this._notificationService.notify({
                     severity: Severity.Error,
-                    message: ( localize(
-                        'notSupportedInWorkspace',
-                        "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
-                    )),
+                    message: localizeWithPath('vs/workbench/api/browser/mainThreadExtensionService', 'notSupportedInWorkspace', "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),
                 });
             }
             else if (enablementState === 0 ) {
                 this._notificationService.notify({
                     severity: Severity.Error,
-                    message: ( localize(
-                        'restrictedMode',
-                        "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
-                    )),
+                    message: localizeWithPath('vs/workbench/api/browser/mainThreadExtensionService', 'restrictedMode', "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', ( localize('manageWorkspaceTrust', "Manage Workspace Trust")), '', true, () => this._commandService.executeCommand('workbench.trust.manage')))]
+                        primary: [( new Action(
+                            'manageWorkspaceTrust',
+                            localizeWithPath('vs/workbench/api/browser/mainThreadExtensionService', 'manageWorkspaceTrust', "Manage Workspace Trust"),
+                            '',
+                            true,
+                            () => this._commandService.executeCommand('workbench.trust.manage')
+                        ))]
                     }
                 });
             }
             else if (this._extensionEnablementService.canChangeEnablement(missingInstalledDependency)) {
                 this._notificationService.notify({
                     severity: Severity.Error,
-                    message: ( localize(
-                        'disabledDep',
-                        "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
-                    )),
+                    message: localizeWithPath('vs/workbench/api/browser/mainThreadExtensionService', 'disabledDep', "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', ( localize('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('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))
+                        ))]
                     }
                 });
             }
             else {
                 this._notificationService.notify({
                     severity: Severity.Error,
-                    message: ( localize(
-                        'disabledDepNoAction',
-                        "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is disabled.",
-                        extName,
-                        missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
-                    )),
+                    message: localizeWithPath('vs/workbench/api/browser/mainThreadExtensionService', 'disabledDepNoAction', "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is disabled.", extName, missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name),
                 });
             }
         }
@@ -166,26 +159,21 @@ let MainThreadExtensionService = class MainThreadExtensionService {
         if (dependencyExtension) {
             this._notificationService.notify({
                 severity: Severity.Error,
-                message: ( localize(
-                    'uninstalledDep',
-                    "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
-                )),
+                message: localizeWithPath('vs/workbench/api/browser/mainThreadExtensionService', 'uninstalledDep', "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', ( localize('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('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))
+                    ))]
                 }
             });
         }
         else {
-            this._notificationService.error(( localize(
-                'unknownDep',
-                "Cannot activate the '{0}' extension because it depends on an unknown '{1}' extension.",
-                extName,
-                missingDependency
-            )));
+            this._notificationService.error(localizeWithPath('vs/workbench/api/browser/mainThreadExtensionService', 'unknownDep', "Cannot activate the '{0}' extension because it depends on an unknown '{1}' extension.", extName, missingDependency));
         }
     }
     async $setPerformanceMarks(marks) {

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

@@ -20,16 +20,16 @@ let MainThreadFileSystem = MainThreadFileSystem_1 = class MainThreadFileSystem {
         this._contextService = _contextService;
         this._logService = _logService;
         this._configurationService = _configurationService;
-        this._fileProvider = ( (new DisposableMap()));
-        this._disposables = ( (new DisposableStore()));
-        this._watches = ( (new DisposableMap()));
-        this._proxy = ( (extHostContext.getProxy(ExtHostContext.ExtHostFileSystem)));
-        const infoProxy = ( (extHostContext.getProxy(ExtHostContext.ExtHostFileSystemInfo)));
+        this._fileProvider = ( new DisposableMap());
+        this._disposables = ( new DisposableStore());
+        this._watches = ( new DisposableMap());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostFileSystem));
+        const infoProxy = ( extHostContext.getProxy(ExtHostContext.ExtHostFileSystemInfo));
         for (const entry of _fileService.listCapabilities()) {
-            infoProxy.$acceptProviderInfos(( (URI.from({ scheme: entry.scheme, path: '/dummy' }))), entry.capabilities);
+            infoProxy.$acceptProviderInfos(( URI.from({ scheme: entry.scheme, path: '/dummy' })), entry.capabilities);
         }
-        this._disposables.add(_fileService.onDidChangeFileSystemProviderRegistrations(e => infoProxy.$acceptProviderInfos(( (URI.from({ scheme: e.scheme, path: '/dummy' }))), e.provider?.capabilities ?? null)));
-        this._disposables.add(_fileService.onDidChangeFileSystemProviderCapabilities(e => infoProxy.$acceptProviderInfos(( (URI.from({ scheme: e.scheme, path: '/dummy' }))), e.provider.capabilities)));
+        this._disposables.add(_fileService.onDidChangeFileSystemProviderRegistrations(e => infoProxy.$acceptProviderInfos(( URI.from({ scheme: e.scheme, path: '/dummy' })), e.provider?.capabilities ?? null)));
+        this._disposables.add(_fileService.onDidChangeFileSystemProviderCapabilities(e => infoProxy.$acceptProviderInfos(( URI.from({ scheme: e.scheme, path: '/dummy' })), e.provider.capabilities)));
     }
     dispose() {
         this._disposables.dispose();
@@ -37,14 +37,14 @@ let MainThreadFileSystem = MainThreadFileSystem_1 = class MainThreadFileSystem {
         this._watches.dispose();
     }
     async $registerFileSystemProvider(handle, scheme, capabilities, readonlyMessage) {
-        this._fileProvider.set(handle, ( (new RemoteFileSystemProvider(
+        this._fileProvider.set(handle, ( new RemoteFileSystemProvider(
             this._fileService,
             scheme,
             capabilities,
             readonlyMessage,
             handle,
             this._proxy
-        ))));
+        )));
     }
     $unregisterProvider(handle) {
         this._fileProvider.deleteAndDispose(handle);
@@ -70,11 +70,11 @@ let MainThreadFileSystem = MainThreadFileSystem_1 = class MainThreadFileSystem {
     $readdir(uri) {
         return this._fileService.resolve(URI.revive(uri), { resolveMetadata: false }).then(stat => {
             if (!stat.isDirectory) {
-                const err = ( (new Error(stat.name)));
+                const err = ( new Error(stat.name));
                 err.name = FileSystemProviderErrorCode.FileNotADirectory;
                 throw err;
             }
-            return !stat.children ? [] : ( (stat.children.map(child => [child.name, MainThreadFileSystem_1._asFileType(child)])));
+            return !stat.children ? [] : ( stat.children.map(child => [child.name, MainThreadFileSystem_1._asFileType(child)]));
         }).catch(MainThreadFileSystem_1._handleError);
     }
     static _asFileType(stat) {
@@ -152,14 +152,14 @@ let MainThreadFileSystem = MainThreadFileSystem_1 = class MainThreadFileSystem {
                 }
             }
             catch (error) {
-                this._logService.error(`MainThreadFileSystem#$watch(): failed to stat a resource for file watching (extension: ${extensionId}, path: ${( ( uri.toString(true)))}, recursive: ${opts.recursive}, session: ${session}): ${error}`);
+                this._logService.error(`MainThreadFileSystem#$watch(): failed to stat a resource for file watching (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session}): ${error}`);
             }
         }
         if (workspaceFolder && opts.recursive) {
-            this._logService.trace(`MainThreadFileSystem#$watch(): ignoring request to start watching because path is inside workspace (extension: ${extensionId}, path: ${( ( uri.toString(true)))}, recursive: ${opts.recursive}, session: ${session})`);
+            this._logService.trace(`MainThreadFileSystem#$watch(): ignoring request to start watching because path is inside workspace (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session})`);
             return;
         }
-        this._logService.trace(`MainThreadFileSystem#$watch(): request to start watching (extension: ${extensionId}, path: ${( ( uri.toString(true)))}, recursive: ${opts.recursive}, session: ${session})`);
+        this._logService.trace(`MainThreadFileSystem#$watch(): request to start watching (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session})`);
         if (opts.recursive) {
             const config = this._configurationService.getValue();
             if (config.files?.watcherExclude) {
@@ -184,7 +184,7 @@ let MainThreadFileSystem = MainThreadFileSystem_1 = class MainThreadFileSystem {
                 }
             }
             if (!opts.includes || opts.includes.length === 0) {
-                this._logService.trace(`MainThreadFileSystem#$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(`MainThreadFileSystem#$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;
             }
         }
@@ -192,7 +192,7 @@ let MainThreadFileSystem = MainThreadFileSystem_1 = class MainThreadFileSystem {
         this._watches.set(session, subscription);
     }
     $unwatch(session) {
-        if (( (this._watches.has(session)))) {
+        if (( this._watches.has(session))) {
             this._logService.trace(`MainThreadFileSystem#$unwatch(): request to stop watching (session: ${session})`);
             this._watches.deleteAndDispose(session);
         }
@@ -200,17 +200,17 @@ let MainThreadFileSystem = MainThreadFileSystem_1 = class MainThreadFileSystem {
 };
 MainThreadFileSystem = MainThreadFileSystem_1 = __decorate([
     extHostNamedCustomer(MainContext.MainThreadFileSystem),
-    ( (__param(1, IWorkbenchFileService))),
-    ( (__param(2, IWorkspaceContextService))),
-    ( (__param(3, ILogService))),
-    ( (__param(4, IConfigurationService)))
+    ( __param(1, IWorkbenchFileService)),
+    ( __param(2, IWorkspaceContextService)),
+    ( __param(3, ILogService)),
+    ( __param(4, IConfigurationService))
 ], MainThreadFileSystem);
 class RemoteFileSystemProvider {
     constructor(fileService, scheme, capabilities, readOnlyMessage, _handle, _proxy) {
         this.readOnlyMessage = readOnlyMessage;
         this._handle = _handle;
         this._proxy = _proxy;
-        this._onDidChange = ( (new Emitter()));
+        this._onDidChange = ( new Emitter());
         this.onDidChangeFile = this._onDidChange.event;
         this.onDidChangeCapabilities = Event.None;
         this.capabilities = capabilities;
@@ -228,7 +228,7 @@ class RemoteFileSystemProvider {
         });
     }
     $onFileSystemChange(changes) {
-        this._onDidChange.fire(( (changes.map(RemoteFileSystemProvider._createFileChange))));
+        this._onDidChange.fire(( changes.map(RemoteFileSystemProvider._createFileChange)));
     }
     static _createFileChange(dto) {
         return { resource: URI.revive(dto.resource), type: dto.type };

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

@@ -3,7 +3,7 @@ import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import { extHostCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { ExtHostContext } from '../common/extHost.protocol.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { IWorkingCopyFileService } from '../../services/workingCopy/common/workingCopyFileService.js';
 import { IBulkEditService } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
 import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
@@ -65,70 +65,38 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                     let message;
                     if (data.extensionNames.length === 1) {
                         if (operation === 0 ) {
-                            message = ( localize(
-                                'ask.1.create',
-                                "Extension '{0}' wants to make refactoring changes with this file creation",
-                                data.extensionNames[0]
-                            ));
+                            message = localizeWithPath('vs/workbench/api/browser/mainThreadFileSystemEventService', 'ask.1.create', "Extension '{0}' wants to make refactoring changes with this file creation", data.extensionNames[0]);
                         }
                         else if (operation === 3 ) {
-                            message = ( localize(
-                                'ask.1.copy',
-                                "Extension '{0}' wants to make refactoring changes with this file copy",
-                                data.extensionNames[0]
-                            ));
+                            message = localizeWithPath('vs/workbench/api/browser/mainThreadFileSystemEventService', 'ask.1.copy', "Extension '{0}' wants to make refactoring changes with this file copy", data.extensionNames[0]);
                         }
                         else if (operation === 2 ) {
-                            message = ( localize(
-                                'ask.1.move',
-                                "Extension '{0}' wants to make refactoring changes with this file move",
-                                data.extensionNames[0]
-                            ));
+                            message = localizeWithPath('vs/workbench/api/browser/mainThreadFileSystemEventService', 'ask.1.move', "Extension '{0}' wants to make refactoring changes with this file move", data.extensionNames[0]);
                         }
                         else  {
-                            message = ( localize(
-                                'ask.1.delete',
-                                "Extension '{0}' wants to make refactoring changes with this file deletion",
-                                data.extensionNames[0]
-                            ));
+                            message = localizeWithPath('vs/workbench/api/browser/mainThreadFileSystemEventService', 'ask.1.delete', "Extension '{0}' wants to make refactoring changes with this file deletion", data.extensionNames[0]);
                         }
                     }
                     else {
                         if (operation === 0 ) {
-                            message = ( localize(
-                                { key: 'ask.N.create', comment: ['{0} is a number, e.g "3 extensions want..."'] },
-                                "{0} extensions want to make refactoring changes with this file creation",
-                                data.extensionNames.length
-                            ));
+                            message = localizeWithPath('vs/workbench/api/browser/mainThreadFileSystemEventService', { key: 'ask.N.create', comment: ['{0} is a number, e.g "3 extensions want..."'] }, "{0} extensions want to make refactoring changes with this file creation", data.extensionNames.length);
                         }
                         else if (operation === 3 ) {
-                            message = ( localize(
-                                { key: 'ask.N.copy', comment: ['{0} is a number, e.g "3 extensions want..."'] },
-                                "{0} extensions want to make refactoring changes with this file copy",
-                                data.extensionNames.length
-                            ));
+                            message = localizeWithPath('vs/workbench/api/browser/mainThreadFileSystemEventService', { key: 'ask.N.copy', comment: ['{0} is a number, e.g "3 extensions want..."'] }, "{0} extensions want to make refactoring changes with this file copy", data.extensionNames.length);
                         }
                         else if (operation === 2 ) {
-                            message = ( localize(
-                                { key: 'ask.N.move', comment: ['{0} is a number, e.g "3 extensions want..."'] },
-                                "{0} extensions want to make refactoring changes with this file move",
-                                data.extensionNames.length
-                            ));
+                            message = localizeWithPath('vs/workbench/api/browser/mainThreadFileSystemEventService', { key: 'ask.N.move', comment: ['{0} is a number, e.g "3 extensions want..."'] }, "{0} extensions want to make refactoring changes with this file move", data.extensionNames.length);
                         }
                         else  {
-                            message = ( localize(
-                                { key: 'ask.N.delete', comment: ['{0} is a number, e.g "3 extensions want..."'] },
-                                "{0} extensions want to make refactoring changes with this file deletion",
-                                data.extensionNames.length
-                            ));
+                            message = localizeWithPath('vs/workbench/api/browser/mainThreadFileSystemEventService', { key: 'ask.N.delete', comment: ['{0} is a number, e.g "3 extensions want..."'] }, "{0} extensions want to make refactoring changes with this file deletion", data.extensionNames.length);
                         }
                     }
                     if (needsConfirmation) {
                         const { confirmed } = await dialogService.confirm({
                             type: Severity.Info,
                             message,
-                            primaryButton: ( localize('preview', "Show &&Preview")),
-                            cancelButton: ( localize('cancel', "Skip Changes"))
+                            primaryButton: localizeWithPath('vs/workbench/api/browser/mainThreadFileSystemEventService', 'preview', "Show &&Preview"),
+                            cancelButton: localizeWithPath('vs/workbench/api/browser/mainThreadFileSystemEventService', 'cancel', "Skip Changes")
                         });
                         showPreview = true;
                         if (!confirmed) {
@@ -147,19 +115,19 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                             message,
                             buttons: [
                                 {
-                                    label: ( localize({ key: 'ok', comment: ['&& denotes a mnemonic'] }, "&&OK")),
+                                    label: localizeWithPath('vs/workbench/api/browser/mainThreadFileSystemEventService', { key: 'ok', comment: ['&& denotes a mnemonic'] }, "&&OK"),
                                     run: () => Choice.OK
                                 },
                                 {
-                                    label: ( localize({ key: 'preview', comment: ['&& denotes a mnemonic'] }, "Show &&Preview")),
+                                    label: localizeWithPath('vs/workbench/api/browser/mainThreadFileSystemEventService', { key: 'preview', comment: ['&& denotes a mnemonic'] }, "Show &&Preview"),
                                     run: () => Choice.Preview
                                 }
                             ],
                             cancelButton: {
-                                label: ( localize('cancel', "Skip Changes")),
+                                label: localizeWithPath('vs/workbench/api/browser/mainThreadFileSystemEventService', 'cancel', "Skip Changes"),
                                 run: () => Choice.Cancel
                             },
-                            checkbox: { label: ( localize('again', "Don't ask again")) }
+                            checkbox: { label: localizeWithPath('vs/workbench/api/browser/mainThreadFileSystemEventService', 'again', "Don't ask again") }
                         });
                         if (result === Choice.Cancel) {
                             return;
@@ -176,15 +144,15 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
             _progressLabel(operation) {
                 switch (operation) {
                     case 0 :
-                        return ( localize('msg-create', "Running 'File Create' participants..."));
+                        return localizeWithPath('vs/workbench/api/browser/mainThreadFileSystemEventService', 'msg-create', "Running 'File Create' participants...");
                     case 2 :
-                        return ( localize('msg-rename', "Running 'File Rename' participants..."));
+                        return localizeWithPath('vs/workbench/api/browser/mainThreadFileSystemEventService', 'msg-rename', "Running 'File Rename' participants...");
                     case 3 :
-                        return ( localize('msg-copy', "Running 'File Copy' participants..."));
+                        return localizeWithPath('vs/workbench/api/browser/mainThreadFileSystemEventService', 'msg-copy', "Running 'File Copy' participants...");
                     case 1 :
-                        return ( localize('msg-delete', "Running 'File Delete' participants..."));
+                        return localizeWithPath('vs/workbench/api/browser/mainThreadFileSystemEventService', 'msg-delete', "Running 'File Delete' participants...");
                     case 4 :
-                        return ( localize('msg-write', "Running 'File Write' participants..."));
+                        return localizeWithPath('vs/workbench/api/browser/mainThreadFileSystemEventService', 'msg-write', "Running 'File Write' participants...");
                 }
             }
         });
@@ -212,7 +180,7 @@ registerAction2(class ResetMemento extends Action2 {
         super({
             id: 'files.participants.resetChoice',
             title: {
-                value: ( localize('label', "Reset choice for 'File operation needs preview'")),
+                value: localizeWithPath('vs/workbench/api/browser/mainThreadFileSystemEventService', 'label', "Reset choice for 'File operation needs preview'"),
                 original: `Reset choice for 'File operation needs preview'`
             },
             f1: true

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

@@ -36,12 +36,12 @@ let MainThreadMessageService = class MainThreadMessageService {
             let source;
             if (options.source) {
                 source = {
-                    label: ( nls.localize('extensionSource', "{0} (Extension)", options.source.label)),
+                    label: nls.localizeWithPath('vs/workbench/api/browser/mainThreadMessageService', 'extensionSource', "{0} (Extension)", options.source.label),
                     id: options.source.identifier.value
                 };
             }
             if (!source) {
-                source = ( nls.localize('defaultSource', "Extension"));
+                source = nls.localizeWithPath('vs/workbench/api/browser/mainThreadMessageService', 'defaultSource', "Extension");
             }
             const secondaryActions = [];
             const messageHandle = this._notificationService.notify({
@@ -73,13 +73,13 @@ let MainThreadMessageService = class MainThreadMessageService {
         if (!cancelButton) {
             if (buttons.length > 0) {
                 cancelButton = {
-                    label: ( nls.localize('cancel', "Cancel")),
+                    label: nls.localizeWithPath('vs/workbench/api/browser/mainThreadMessageService', 'cancel', "Cancel"),
                     run: () => undefined
                 };
             }
             else {
                 cancelButton = {
-                    label: ( nls.localize({ key: 'ok', comment: ['&& denotes a mnemonic'] }, "&&OK")),
+                    label: nls.localizeWithPath('vs/workbench/api/browser/mainThreadMessageService', { key: 'ok', comment: ['&& denotes a mnemonic'] }, "&&OK"),
                     run: () => undefined
                 };
             }

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

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { extHostCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { ExtHostContext } from '../common/extHost.protocol.js';
@@ -16,10 +16,9 @@ class ExtHostNotebookDocumentSaveParticipant {
         }
         let _warningTimeout;
         const p = ( new Promise((resolve, reject) => {
-            _warningTimeout = setTimeout(() => reject(( new Error(( localize(
-                'timeout.onWillSave',
-                "Aborted onWillSaveNotebookDocument-event after 1750ms"
-            ))))), 1750);
+            _warningTimeout = setTimeout(() => reject(( new Error(
+                localizeWithPath('vs/workbench/api/browser/mainThreadNotebookSaveParticipant', 'timeout.onWillSave', "Aborted onWillSaveNotebookDocument-event after 1750ms")
+            ))), 1750);
             this._proxy.$participateInSave(workingCopy.resource, env.reason, token).then(_ => {
                 clearTimeout(_warningTimeout);
                 return undefined;

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

@@ -4,7 +4,7 @@ import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
 import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 class ManageExtensionAction extends Action {
     constructor(extensionId, label, commandService) {
         super(extensionId, label, undefined, true, () => {
@@ -29,7 +29,11 @@ let MainThreadProgress = class MainThreadProgress {
             const notificationOptions = {
                 ...options,
                 location: 15 ,
-                secondaryActions: [( new ManageExtensionAction(extensionId, ( localize('manageExtension', "Manage Extension")), this._commandService))]
+                secondaryActions: [( new ManageExtensionAction(
+                    extensionId,
+                    localizeWithPath('vs/workbench/api/browser/mainThreadProgress', 'manageExtension', "Manage Extension"),
+                    this._commandService
+                ))]
             };
             options = notificationOptions;
         }

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

@@ -1,6 +1,6 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { shouldSynchronizeModel } from 'monaco-editor/esm/vs/editor/common/model.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { extHostCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { ITextFileService } from '../../services/textfile/common/textfiles.js';
@@ -15,7 +15,9 @@ class ExtHostSaveParticipant {
             return undefined;
         }
         const p = ( new Promise((resolve, reject) => {
-            setTimeout(() => reject(( new Error(( localize('timeout.onWillSave', "Aborted onWillSaveTextDocument-event after 1750ms"))))), 1750);
+            setTimeout(() => reject(( new Error(
+                localizeWithPath('vs/workbench/api/browser/mainThreadSaveParticipant', 'timeout.onWillSave', "Aborted onWillSaveTextDocument-event after 1750ms")
+            ))), 1750);
             this._proxy.$participateInSave(editorModel.resource, env.reason).then(values => {
                 if (!values.every(success => success)) {
                     return Promise.reject(( new Error('listener failed')));

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

@@ -375,7 +375,7 @@ var TaskDTO;
         }
         command.presentation = TaskPresentationOptionsDTO.to(task.presentationOptions);
         const source = TaskSourceDTO.to(task.source, workspace);
-        const label = ( nls.localize('task.label', '{0}: {1}', source.label, task.name));
+        const label = nls.localizeWithPath('vs/workbench/api/browser/mainThreadTask', 'task.label', '{0}: {1}', source.label, task.name);
         const definition = TaskDefinitionDTO.to(task.definition, executeOnly);
         const id = (CustomExecutionDTO.is(task.execution) && task._id) ? task._id : `${task.source.extensionId}.${definition._key}`;
         const result = ( new ContributedTask(

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

@@ -103,18 +103,8 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
         return TunnelDtoConverter.fromServiceTunnel(tunnel);
     }
     async elevationPrompt(tunnelOptions, tunnel, source) {
-        return this.notificationService.prompt(Severity.Info, ( nls.localize(
-            'remote.tunnel.openTunnel',
-            "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: ( nls.localize(
-                    'remote.tunnelsView.elevationButton',
-                    "Use Port {0} as Sudo...",
-                    tunnel.tunnelRemotePort
-                )),
+        return this.notificationService.prompt(Severity.Info, nls.localizeWithPath('vs/workbench/api/browser/mainThreadTunnelService', 'remote.tunnel.openTunnel', "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: nls.localizeWithPath('vs/workbench/api/browser/mainThreadTunnelService', 'remote.tunnelsView.elevationButton', "Use Port {0} as Sudo...", tunnel.tunnelRemotePort),
                 run: async () => {
                     this.elevateionRetry = true;
                     await this.remoteExplorerService.close({ host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort }, TunnelCloseReason.Other);

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

@@ -3,7 +3,7 @@ import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
 import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { Severity, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
 import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
 import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
@@ -48,19 +48,25 @@ let MainThreadUriOpeners = class MainThreadUriOpeners extends Disposable {
                 }
                 catch (e) {
                     if (!isCancellationError(e)) {
-                        const openDefaultAction = ( new Action('default', ( localize('openerFailedUseDefault', "Open using default opener")), undefined, undefined, async () => {
-                            await this.openerService.open(uri, {
-                                allowTunneling: false,
-                                allowContributedOpeners: defaultExternalUriOpenerId,
-                            });
-                        }));
+                        const openDefaultAction = ( new Action(
+                            'default',
+                            localizeWithPath('vs/workbench/api/browser/mainThreadUriOpeners', 'openerFailedUseDefault', "Open using default opener"),
+                            undefined,
+                            undefined,
+                            async () => {
+                                await this.openerService.open(uri, {
+                                    allowTunneling: false,
+                                    allowContributedOpeners: defaultExternalUriOpenerId,
+                                });
+                            }
+                        ));
                         openDefaultAction.tooltip = ( uri.toString());
                         this.notificationService.notify({
                             severity: Severity.Error,
-                            message: ( localize({
+                            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()))),
+                            }, 'Could not open uri with \'{0}\': {1}', id, ( e.toString())),
                             actions: {
                                 primary: [
                                     openDefaultAction