@codingame/monaco-vscode-api 1.83.2 → 1.83.3

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/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

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

@@ -4,7 +4,7 @@ import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
 import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
 import { escape } from 'monaco-editor/esm/vs/base/common/strings.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 { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
 import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
 import { ExtHostContext } from '../common/extHost.protocol.js';
@@ -102,11 +102,7 @@ let MainThreadWebviews = class MainThreadWebviews extends Disposable {
 				<meta http-equiv="Content-type" content="text/html;charset=UTF-8">
 				<meta http-equiv="Content-Security-Policy" content="default-src 'none';">
 			</head>
-			<body>${( localize(
-            'errorMessage',
-            "An error occurred while loading view: {0}",
-            escape(viewType)
-        ))}</body>
+			<body>${localizeWithPath('vs/workbench/api/browser/mainThreadWebviews', 'errorMessage', "An error occurred while loading view: {0}", escape(viewType))}</body>
 		</html>`;
     }
 };

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

@@ -3,7 +3,7 @@ import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js'
 import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { isNative } from 'monaco-editor/esm/vs/base/common/platform.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 { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
 import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
@@ -73,44 +73,22 @@ let MainThreadWorkspace = class MainThreadWorkspace {
         const wantsToDelete = removeCount > 0;
         if (wantsToAdd && !wantsToDelete) {
             if (addCount === 1) {
-                message = ( localize(
-                    'folderStatusMessageAddSingleFolder',
-                    "Extension '{0}' added 1 folder to the workspace",
-                    extensionName
-                ));
+                message = localizeWithPath('vs/workbench/api/browser/mainThreadWorkspace', 'folderStatusMessageAddSingleFolder', "Extension '{0}' added 1 folder to the workspace", extensionName);
             }
             else {
-                message = ( localize(
-                    'folderStatusMessageAddMultipleFolders',
-                    "Extension '{0}' added {1} folders to the workspace",
-                    extensionName,
-                    addCount
-                ));
+                message = localizeWithPath('vs/workbench/api/browser/mainThreadWorkspace', 'folderStatusMessageAddMultipleFolders', "Extension '{0}' added {1} folders to the workspace", extensionName, addCount);
             }
         }
         else if (wantsToDelete && !wantsToAdd) {
             if (removeCount === 1) {
-                message = ( localize(
-                    'folderStatusMessageRemoveSingleFolder',
-                    "Extension '{0}' removed 1 folder from the workspace",
-                    extensionName
-                ));
+                message = localizeWithPath('vs/workbench/api/browser/mainThreadWorkspace', 'folderStatusMessageRemoveSingleFolder', "Extension '{0}' removed 1 folder from the workspace", extensionName);
             }
             else {
-                message = ( localize(
-                    'folderStatusMessageRemoveMultipleFolders',
-                    "Extension '{0}' removed {1} folders from the workspace",
-                    extensionName,
-                    removeCount
-                ));
+                message = localizeWithPath('vs/workbench/api/browser/mainThreadWorkspace', 'folderStatusMessageRemoveMultipleFolders', "Extension '{0}' removed {1} folders from the workspace", extensionName, removeCount);
             }
         }
         else {
-            message = ( localize(
-                'folderStatusChangeFolder',
-                "Extension '{0}' changed folders of the workspace",
-                extensionName
-            ));
+            message = localizeWithPath('vs/workbench/api/browser/mainThreadWorkspace', 'folderStatusChangeFolder', "Extension '{0}' changed folders of the workspace", extensionName);
         }
         return message;
     }

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

@@ -1,5 +1,6 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { IStatusbarService } from '../../services/statusbar/browser/statusbar.js';
 import { getCodiconAriaLabel } from 'monaco-editor/esm/vs/base/common/iconLabels.js';
@@ -93,4 +94,63 @@ ExtensionStatusBarItemService = ( __decorate([
     ( __param(0, IStatusbarService))
 ], ExtensionStatusBarItemService));
 registerSingleton(IExtensionStatusBarItemService, ExtensionStatusBarItemService, 1 );
+const statusBarItemSchema = {
+    type: 'object',
+    required: ['id', 'text', 'alignment', 'name'],
+    properties: {
+        id: {
+            type: 'string',
+            markdownDescription: localizeWithPath('vs/workbench/api/browser/statusBarExtensionPoint', 'id', 'The identifier of the status bar entry. Must be unique within the extension. The same value must be used when calling the `vscode.window.createStatusBarItem(id, ...)`-API')
+        },
+        name: {
+            type: 'string',
+            description: localizeWithPath('vs/workbench/api/browser/statusBarExtensionPoint', 'name', 'The name of the entry, like \'Python Language Indicator\', \'Git Status\' etc. Try to keep the length of the name short, yet descriptive enough that users can understand what the status bar item is about.')
+        },
+        text: {
+            type: 'string',
+            description: localizeWithPath('vs/workbench/api/browser/statusBarExtensionPoint', 'text', 'The text to show for the entry. You can embed icons in the text by leveraging the `$(<name>)`-syntax, like \'Hello $(globe)!\'')
+        },
+        tooltip: {
+            type: 'string',
+            description: localizeWithPath('vs/workbench/api/browser/statusBarExtensionPoint', 'tooltip', 'The tooltip text for the entry.')
+        },
+        command: {
+            type: 'string',
+            description: localizeWithPath('vs/workbench/api/browser/statusBarExtensionPoint', 'command', 'The command to execute when the status bar entry is clicked.')
+        },
+        alignment: {
+            type: 'string',
+            enum: ['left', 'right'],
+            description: localizeWithPath('vs/workbench/api/browser/statusBarExtensionPoint', 'alignment', 'The alignment of the status bar entry.')
+        },
+        priority: {
+            type: 'number',
+            description: localizeWithPath('vs/workbench/api/browser/statusBarExtensionPoint', 'priority', 'The priority of the status bar entry. Higher value means the item should be shown more to the left.')
+        },
+        accessibilityInformation: {
+            type: 'object',
+            description: localizeWithPath('vs/workbench/api/browser/statusBarExtensionPoint', 'accessibilityInformation', 'Defines the role and aria label to be used when the status bar entry is focused.'),
+            properties: {
+                role: {
+                    type: 'string',
+                    description: localizeWithPath('vs/workbench/api/browser/statusBarExtensionPoint', 'accessibilityInformation.role', 'The role of the status bar entry which defines how a screen reader interacts with it. More about aria roles can be found here https://w3c.github.io/aria/#widget_roles')
+                },
+                label: {
+                    type: 'string',
+                    description: localizeWithPath('vs/workbench/api/browser/statusBarExtensionPoint', 'accessibilityInformation.label', 'The aria label of the status bar entry. Defaults to the entry\'s text.')
+                }
+            }
+        }
+    }
+};
+({
+    description: localizeWithPath('vs/workbench/api/browser/statusBarExtensionPoint', 'vscode.extension.contributes.statusBarItems', "Contributes items to the status bar."),
+    oneOf: [
+        statusBarItemSchema,
+        {
+            type: 'array',
+            items: statusBarItemSchema
+        }
+    ]
+});
 export { ExtensionStatusBarItemService, IExtensionStatusBarItemService };