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

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';
@@ -13,22 +13,22 @@ import { SerializableObjectWithBuffers } from '../../services/extensions/common/
 var MainThreadWebviews_1;
 let MainThreadWebviews = class MainThreadWebviews extends Disposable {
     static { MainThreadWebviews_1 = this; }
-    static { this.standardSupportedLinkSchemes = ( (new Set([
+    static { this.standardSupportedLinkSchemes = ( new Set([
         Schemas.http,
         Schemas.https,
         Schemas.mailto,
         Schemas.vscode,
         'vscode-insider',
-    ]))); }
+    ])); }
     constructor(context, _openerService, _productService) {
         super();
         this._openerService = _openerService;
         this._productService = _productService;
-        this._webviews = ( (new Map()));
-        this._proxy = ( (context.getProxy(ExtHostContext.ExtHostWebviews)));
+        this._webviews = ( new Map());
+        this._proxy = ( context.getProxy(ExtHostContext.ExtHostWebviews));
     }
     addWebview(handle, webview, options) {
-        if (( (this._webviews.has(handle)))) {
+        if (( this._webviews.has(handle))) {
             throw new Error('Webview already registered');
         }
         this._webviews.set(handle, webview);
@@ -52,11 +52,11 @@ let MainThreadWebviews = class MainThreadWebviews extends Disposable {
         return webview.postMessage(message, arrayBuffers);
     }
     hookupWebviewEventDelegate(handle, webview, options) {
-        const disposables = ( (new DisposableStore()));
+        const disposables = ( new DisposableStore());
         disposables.add(webview.onDidClickLink((uri) => this.onDidClickLink(handle, uri)));
         disposables.add(webview.onMessage((message) => {
             const serialized = serializeWebviewMessage(message.message, options);
-            this._proxy.$onMessage(handle, serialized.message, ( (new SerializableObjectWithBuffers(serialized.buffers))));
+            this._proxy.$onMessage(handle, serialized.message, ( new SerializableObjectWithBuffers(serialized.buffers)));
         }));
         disposables.add(webview.onMissingCsp((extension) => this._proxy.$onMissingCsp(handle, extension.value)));
         disposables.add(webview.onDidDispose(() => {
@@ -66,12 +66,12 @@ let MainThreadWebviews = class MainThreadWebviews extends Disposable {
     }
     onDidClickLink(handle, link) {
         const webview = this.getWebview(handle);
-        if (this.isSupportedLink(webview, ( (URI.parse(link))))) {
+        if (this.isSupportedLink(webview, ( URI.parse(link)))) {
             this._openerService.open(link, { fromUserGesture: true, allowContributedOpeners: true, allowCommands: Array.isArray(webview.contentOptions.enableCommandUris) || webview.contentOptions.enableCommandUris === true, fromWorkspace: true });
         }
     }
     isSupportedLink(webview, link) {
-        if (( (MainThreadWebviews_1.standardSupportedLinkSchemes.has(link.scheme)))) {
+        if (( MainThreadWebviews_1.standardSupportedLinkSchemes.has(link.scheme))) {
             return true;
         }
         if (!isWeb && this._productService.urlProtocol === link.scheme) {
@@ -102,18 +102,14 @@ 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>`;
     }
 };
-MainThreadWebviews = MainThreadWebviews_1 = ( (__decorate([
-    ( (__param(1, IOpenerService))),
-    ( (__param(2, IProductService)))
-], MainThreadWebviews)));
+MainThreadWebviews = MainThreadWebviews_1 = ( __decorate([
+    ( __param(1, IOpenerService)),
+    ( __param(2, IProductService))
+], MainThreadWebviews));
 function reviveWebviewExtension(extensionData) {
     return {
         id: extensionData.id,
@@ -125,7 +121,7 @@ function reviveWebviewContentOptions(webviewOptions) {
         allowScripts: webviewOptions.enableScripts,
         allowForms: webviewOptions.enableForms,
         enableCommandUris: webviewOptions.enableCommandUris,
-        localResourceRoots: Array.isArray(webviewOptions.localResourceRoots) ? ( (webviewOptions.localResourceRoots.map(r => URI.revive(r)))) : undefined,
+        localResourceRoots: Array.isArray(webviewOptions.localResourceRoots) ? ( webviewOptions.localResourceRoots.map(r => URI.revive(r))) : undefined,
         portMapping: webviewOptions.portMapping,
     };
 }

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

@@ -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 };

package/vscode/src/vs/workbench/api/common/extHostChat.js

@@ -3,7 +3,7 @@ import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
 import { toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { MainContext } from './extHost.protocol.js';
 import { ChatReplyFollowup, ChatFollowup, CompletionItemKind, ChatVariable, MarkdownString, Range } from './extHostTypeConverters.js';
 class ChatProviderWrapper {
@@ -201,11 +201,11 @@ class ExtHostChat {
         try {
             result = await entry.provider.provideResponseWithProgress(requestObj, progressObj, token);
             if (!result) {
-                result = { errorDetails: { message: ( localize('emptyResponse', "Provider returned null response")) } };
+                result = { errorDetails: { message: localizeWithPath('vs/workbench/api/common/extHostChat', 'emptyResponse', "Provider returned null response") } };
             }
         }
         catch (err) {
-            result = { errorDetails: { message: ( localize('errorResponse', "Error from provider: {0}", err.message)), responseIsIncomplete: true } };
+            result = { errorDetails: { message: localizeWithPath('vs/workbench/api/common/extHostChat', 'errorResponse', "Error from provider: {0}", err.message), responseIsIncomplete: true } };
             this.logService.error(err);
         }
         try {

package/vscode/src/vs/workbench/api/common/extHostCommands.js

@@ -25,17 +25,17 @@ let ExtHostCommands = class ExtHostCommands {
     #telemetry;
     #extHostTelemetry;
     constructor(extHostRpc, logService, extHostTelemetry) {
-        this._commands = ( (new Map()));
-        this._apiCommands = ( (new Map()));
-        this.#proxy = ( (extHostRpc.getProxy(MainContext.MainThreadCommands)));
+        this._commands = ( new Map());
+        this._apiCommands = ( new Map());
+        this.#proxy = ( extHostRpc.getProxy(MainContext.MainThreadCommands));
         this._logService = logService;
         this.#extHostTelemetry = extHostTelemetry;
-        this.#telemetry = ( (extHostRpc.getProxy(MainContext.MainThreadTelemetry)));
-        this.converter = ( (new CommandsConverter(this, id => {
+        this.#telemetry = ( extHostRpc.getProxy(MainContext.MainThreadTelemetry));
+        this.converter = ( new CommandsConverter(this, id => {
             const candidate = this._apiCommands.get(id);
             return candidate?.result === ApiCommandResult.Void
                 ? candidate : undefined;
-        }, logService)));
+        }, logService));
         this._argumentProcessors = [
             {
                 processArgument(a) {
@@ -70,12 +70,12 @@ let ExtHostCommands = class ExtHostCommands {
     }
     registerApiCommand(apiCommand) {
         const registration = this.registerCommand(false, apiCommand.id, async (...apiArgs) => {
-            const internalArgs = ( (apiCommand.args.map((arg, i) => {
+            const internalArgs = ( apiCommand.args.map((arg, i) => {
                 if (!arg.validate(apiArgs[i])) {
                     throw new Error(`Invalid argument '${arg.name}' when running '${apiCommand.id}', received: ${typeof apiArgs[i] === 'object' ? JSON.stringify(apiArgs[i], null, '\t') : apiArgs[i]} `);
                 }
                 return arg.convert(apiArgs[i]);
-            })));
+            }));
             const internalResult = await this.executeCommand(apiCommand.internalId, ...internalArgs);
             return apiCommand.result.convert(internalResult, apiArgs, this.converter);
         }, undefined, {
@@ -94,7 +94,7 @@ let ExtHostCommands = class ExtHostCommands {
         if (!id.trim().length) {
             throw new Error('invalid id');
         }
-        if (( (this._commands.has(id)))) {
+        if (( this._commands.has(id))) {
             throw new Error(`command '${id}' already exists`);
         }
         this._commands.set(id, { callback, thisArg, description, extension });
@@ -114,7 +114,7 @@ let ExtHostCommands = class ExtHostCommands {
         return this._doExecuteCommand(id, args, true);
     }
     async _doExecuteCommand(id, args, retry) {
-        if (( (this._commands.has(id)))) {
+        if (( this._commands.has(id))) {
             this.#proxy.$fireCommandActivationEvent(id);
             return this._executeContributedCommand(id, args, false);
         }
@@ -135,7 +135,7 @@ let ExtHostCommands = class ExtHostCommands {
                 }
                 else if (value instanceof ArrayBuffer) {
                     hasBuffers = true;
-                    return VSBuffer.wrap(( (new Uint8Array(value))));
+                    return VSBuffer.wrap(( new Uint8Array(value)));
                 }
                 else if (value instanceof Uint8Array) {
                     hasBuffers = true;
@@ -150,7 +150,7 @@ let ExtHostCommands = class ExtHostCommands {
                 }
             });
             try {
-                const result = await this.#proxy.$executeCommand(id, hasBuffers ? ( (new SerializableObjectWithBuffers(toArgs))) : toArgs, retry);
+                const result = await this.#proxy.$executeCommand(id, hasBuffers ? ( new SerializableObjectWithBuffers(toArgs)) : toArgs, retry);
                 return revive(result);
             }
             catch (e) {
@@ -216,7 +216,7 @@ let ExtHostCommands = class ExtHostCommands {
         }
         this.#telemetry.$publicLog2('Extension:ActionExecuted', {
             extensionId: command.extension.identifier.value,
-            id: ( (new TelemetryTrustedValue(id))),
+            id: ( new TelemetryTrustedValue(id)),
             duration: duration,
         });
     }
@@ -224,12 +224,12 @@ let ExtHostCommands = class ExtHostCommands {
         this._logService.trace('ExtHostCommands#$executeContributedCommand', id);
         const cmdHandler = this._commands.get(id);
         if (!cmdHandler) {
-            return Promise.reject(( (new Error(`Contributed command '${id}' does not exist.`))));
+            return Promise.reject(( new Error(`Contributed command '${id}' does not exist.`)));
         }
         else {
-            args = ( (args.map(
+            args = ( args.map(
                 arg => this._argumentProcessors.reduce((r, p) => p.processArgument(r, cmdHandler.extension?.identifier), arg)
-            )));
+            ));
             return this._executeContributedCommand(id, args, true);
         }
     }
@@ -253,19 +253,19 @@ let ExtHostCommands = class ExtHostCommands {
         return Promise.resolve(result);
     }
 };
-ExtHostCommands = ( (__decorate([
-    ( (__param(0, IExtHostRpcService))),
-    ( (__param(1, ILogService))),
-    ( (__param(2, IExtHostTelemetry)))
-], ExtHostCommands)));
-const IExtHostCommands = ( (createDecorator('IExtHostCommands')));
+ExtHostCommands = ( __decorate([
+    ( __param(0, IExtHostRpcService)),
+    ( __param(1, ILogService)),
+    ( __param(2, IExtHostTelemetry))
+], ExtHostCommands));
+const IExtHostCommands = ( createDecorator('IExtHostCommands'));
 class CommandsConverter {
     constructor(_commands, _lookupApiCommand, _logService) {
         this._commands = _commands;
         this._lookupApiCommand = _lookupApiCommand;
         this._logService = _logService;
-        this.delegatingCommandId = `__vsc${( ( Date.now().toString(36)))} `;
-        this._cache = ( (new Map()));
+        this.delegatingCommandId = `__vsc${( Date.now().toString(36))} `;
+        this._cache = ( new Map());
         this._cachIdPool = 0;
         this._commands.registerCommand(true, this.delegatingCommandId, this._executeConvertedCommand, this);
     }
@@ -285,7 +285,7 @@ class CommandsConverter {
         const apiCommand = this._lookupApiCommand(command.command);
         if (apiCommand) {
             result.id = apiCommand.internalId;
-            result.arguments = ( (apiCommand.args.map((arg, i) => arg.convert(command.arguments && command.arguments[i]))));
+            result.arguments = ( apiCommand.args.map((arg, i) => arg.convert(command.arguments && command.arguments[i])));
         }
         else if (isNonEmptyArray(command.arguments)) {
             const id = `${command.command} /${++this._cachIdPool}`;
@@ -326,56 +326,54 @@ class CommandsConverter {
     }
 }
 class ApiCommandArgument {
-    static { this.Uri = ( (new ApiCommandArgument('uri', 'Uri of a text document', v => URI.isUri(v), v => v))); }
-    static { this.Position = ( (new ApiCommandArgument(
+    static { this.Uri = ( new ApiCommandArgument('uri', 'Uri of a text document', v => URI.isUri(v), v => v)); }
+    static { this.Position = ( new ApiCommandArgument(
         'position',
         'A position in a text document',
         v => Position.isPosition(v),
         Position$1.from
-    ))); }
-    static { this.Range = ( (new ApiCommandArgument(
+    )); }
+    static { this.Range = ( new ApiCommandArgument(
         'range',
         'A range in a text document',
         v => Range.isRange(v),
         Range$1.from
-    ))); }
-    static { this.Selection = ( (new ApiCommandArgument(
+    )); }
+    static { this.Selection = ( new ApiCommandArgument(
         'selection',
         'A selection in a text document',
         v => Selection.isSelection(v),
         Selection$1.from
-    ))); }
-    static { this.Number = ( (new ApiCommandArgument('number', '', v => typeof v === 'number', v => v))); }
-    static { this.String = ( (new ApiCommandArgument('string', '', v => typeof v === 'string', v => v))); }
+    )); }
+    static { this.Number = ( new ApiCommandArgument('number', '', v => typeof v === 'number', v => v)); }
+    static { this.String = ( new ApiCommandArgument('string', '', v => typeof v === 'string', v => v)); }
     static { this.StringArray = ApiCommandArgument.Arr(ApiCommandArgument.String); }
     static Arr(element) {
-        return (
-             (new ApiCommandArgument(
-                `${element.name}_array`,
-                `Array of ${element.name}, ${element.description}`,
-                (v) => Array.isArray(v) && v.every(e => element.validate(e)),
-                (v) => ( (v.map(e => element.convert(e))))
-            ))
-        );
+        return ( new ApiCommandArgument(
+            `${element.name}_array`,
+            `Array of ${element.name}, ${element.description}`,
+            (v) => Array.isArray(v) && v.every(e => element.validate(e)),
+            (v) => ( v.map(e => element.convert(e)))
+        ));
     }
-    static { this.CallHierarchyItem = ( (new ApiCommandArgument(
+    static { this.CallHierarchyItem = ( new ApiCommandArgument(
         'item',
         'A call hierarchy item',
         v => v instanceof CallHierarchyItem,
         CallHierarchyItem$1.from
-    ))); }
-    static { this.TypeHierarchyItem = ( (new ApiCommandArgument(
+    )); }
+    static { this.TypeHierarchyItem = ( new ApiCommandArgument(
         'item',
         'A type hierarchy item',
         v => v instanceof TypeHierarchyItem,
         TypeHierarchyItem$1.from
-    ))); }
-    static { this.TestItem = ( (new ApiCommandArgument(
+    )); }
+    static { this.TestItem = ( new ApiCommandArgument(
         'testItem',
         'A VS Code TestItem',
         v => v instanceof TestItemImpl,
         TestItem.from
-    ))); }
+    )); }
     constructor(name, description, validate, convert) {
         this.name = name;
         this.description = description;
@@ -383,28 +381,24 @@ class ApiCommandArgument {
         this.convert = convert;
     }
     optional() {
-        return (
-             (new ApiCommandArgument(
-                this.name,
-                `(optional) ${this.description}`,
-                value => value === undefined || value === null || this.validate(value),
-                value => value === undefined ? undefined : value === null ? null : this.convert(value)
-            ))
-        );
+        return ( new ApiCommandArgument(
+            this.name,
+            `(optional) ${this.description}`,
+            value => value === undefined || value === null || this.validate(value),
+            value => value === undefined ? undefined : value === null ? null : this.convert(value)
+        ));
     }
     with(name, description) {
-        return (
-             (new ApiCommandArgument(
-                name ?? this.name,
-                description ?? this.description,
-                this.validate,
-                this.convert
-            ))
-        );
+        return ( new ApiCommandArgument(
+            name ?? this.name,
+            description ?? this.description,
+            this.validate,
+            this.convert
+        ));
     }
 }
 class ApiCommandResult {
-    static { this.Void = ( (new ApiCommandResult('no result', v => v))); }
+    static { this.Void = ( new ApiCommandResult('no result', v => v)); }
     constructor(description, convert) {
         this.description = description;
         this.convert = convert;

package/vscode/src/vs/workbench/api/common/extHostConsoleForwarder.js

@@ -5,7 +5,7 @@ import { IExtHostInitDataService } from './extHostInitDataService.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
 let AbstractExtHostConsoleForwarder = class AbstractExtHostConsoleForwarder {
     constructor(extHostRpc, initData) {
-        this._mainThreadConsole = ( (extHostRpc.getProxy(MainContext.MainThreadConsole)));
+        this._mainThreadConsole = ( extHostRpc.getProxy(MainContext.MainThreadConsole));
         this._includeStack = initData.consoleForward.includeStack;
         this._logNative = initData.consoleForward.logNative;
         this._wrapConsoleMethod('info', 'log');
@@ -34,10 +34,10 @@ let AbstractExtHostConsoleForwarder = class AbstractExtHostConsoleForwarder {
         }
     }
 };
-AbstractExtHostConsoleForwarder = ( (__decorate([
-    ( (__param(0, IExtHostRpcService))),
-    ( (__param(1, IExtHostInitDataService)))
-], AbstractExtHostConsoleForwarder)));
+AbstractExtHostConsoleForwarder = ( __decorate([
+    ( __param(0, IExtHostRpcService)),
+    ( __param(1, IExtHostInitDataService))
+], AbstractExtHostConsoleForwarder));
 const MAX_LENGTH = 100000;
 function safeStringifyArgumentsToArray(args, includeStack) {
     const argsArray = [];
@@ -53,14 +53,14 @@ function safeStringifyArgumentsToArray(args, includeStack) {
                     arg = errorObj.stack;
                 }
                 else {
-                    arg = ( (errorObj.toString()));
+                    arg = ( errorObj.toString());
                 }
             }
             argsArray.push(arg);
         }
     }
     if (includeStack) {
-        const stack = ( (new Error())).stack;
+        const stack = ( new Error()).stack;
         if (stack) {
             argsArray.push({ __$stack: stack.split('\n').slice(3).join('\n') });
         }
@@ -73,7 +73,7 @@ function safeStringifyArgumentsToArray(args, includeStack) {
         return res;
     }
     catch (error) {
-        return `Output omitted for an object that cannot be inspected ('${( ( error.toString()))}')`;
+        return `Output omitted for an object that cannot be inspected ('${( error.toString())}')`;
     }
 }
 export { AbstractExtHostConsoleForwarder };

package/vscode/src/vs/workbench/api/common/extHostDiagnostics.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 { MarkerSeverity } from 'monaco-editor/esm/vs/platform/markers/common/markers.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { MainContext } from './extHost.protocol.js';
@@ -104,11 +104,7 @@ class DiagnosticCollection {
                     }
                     marker.push({
                         severity: MarkerSeverity.Info,
-                        message: ( localize(
-                            { key: 'limitHit', comment: ['amount of errors/warning skipped due to limits'] },
-                            "Not showing {0} further errors and warnings.",
-                            diagnostics.length - this._maxDiagnosticsPerFile
-                        )),
+                        message: localizeWithPath('vs/workbench/api/common/extHostDiagnostics', { key: 'limitHit', comment: ['amount of errors/warning skipped due to limits'] }, "Not showing {0} further errors and warnings.", diagnostics.length - this._maxDiagnosticsPerFile),
                         startLineNumber: marker[marker.length - 1].startLineNumber,
                         startColumn: marker[marker.length - 1].startColumn,
                         endLineNumber: marker[marker.length - 1].endLineNumber,

package/vscode/src/vs/workbench/api/common/extHostExtensionService.js

@@ -523,11 +523,11 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
     async _doHandleExtensionTests() {
         const { extensionDevelopmentLocationURI, extensionTestsLocationURI } = this._initData.environment;
         if (!extensionDevelopmentLocationURI || !extensionTestsLocationURI) {
-            throw new Error(nls.localize('extensionTestError1', "Cannot load test runner."));
+            throw new Error(nls.localizeWithPath('vs/workbench/api/common/extHostExtensionService', 'extensionTestError1', "Cannot load test runner."));
         }
         const testRunner = await this._loadCommonJSModule(null, extensionTestsLocationURI, ( new ExtensionActivationTimesBuilder(false)));
         if (!testRunner || typeof testRunner.run !== 'function') {
-            throw new Error(nls.localize('extensionTestError', "Path {0} does not point to a valid extension test runner.", extensionTestsLocationURI.toString()));
+            throw new Error(nls.localizeWithPath('vs/workbench/api/common/extHostExtensionService', 'extensionTestError', "Path {0} does not point to a valid extension test runner.", extensionTestsLocationURI.toString()));
         }
         return ( new Promise((resolve, reject) => {
             const oldTestRunnerCallback = (error, failures) => {