@codingame/monaco-vscode-api 4.5.0 → 4.5.2

package/vscode/src/vs/workbench/contrib/webviewPanel/browser/webviewEditor.js

@@ -18,14 +18,11 @@ import { IEditorService } from '../../../services/editor/common/editorService.se
 import { IHostService } from '../../../services/host/browser/host.service.js';
 import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.service.js';
 var WebviewEditor_1;
-const CONTEXT_ACTIVE_WEBVIEW_PANEL_ID = ( new RawContextKey('activeWebviewPanelId', '', {
+const _moduleId = "vs/workbench/contrib/webviewPanel/browser/webviewEditor";
+const CONTEXT_ACTIVE_WEBVIEW_PANEL_ID = ( (new RawContextKey('activeWebviewPanelId', '', {
     type: 'string',
-    description: ( localizeWithPath(
-        'vs/workbench/contrib/webviewPanel/browser/webviewEditor',
-        'context.activeWebviewId',
-        "The viewType of the currently active webview panel."
-    )),
-}));
+    description: ( localizeWithPath(_moduleId, 0, "The viewType of the currently active webview panel.")),
+})));
 let WebviewEditor = class WebviewEditor extends EditorPane {
     static { WebviewEditor_1 = this; }
     static { this.ID = 'WebviewEditor'; }
@@ -39,10 +36,10 @@ let WebviewEditor = class WebviewEditor extends EditorPane {
         this._contextKeyService = _contextKeyService;
         this._visible = false;
         this._isDisposed = false;
-        this._webviewVisibleDisposables = this._register(( new DisposableStore()));
-        this._onFocusWindowHandler = this._register(( new MutableDisposable()));
-        this._onDidFocusWebview = this._register(( new Emitter()));
-        this._scopedContextKeyService = this._register(( new MutableDisposable()));
+        this._webviewVisibleDisposables = this._register(( (new DisposableStore())));
+        this._onFocusWindowHandler = this._register(( (new MutableDisposable())));
+        this._onDidFocusWebview = this._register(( (new Emitter())));
+        this._scopedContextKeyService = this._register(( (new MutableDisposable())));
         const part = _editorGroupsService.getPart(group);
         this._register(Event.any(part.onDidScroll, part.onDidAddGroup, part.onDidRemoveGroup, part.onDidMoveGroup)(() => {
             if (this.webview && this._visible) {
@@ -138,7 +135,7 @@ let WebviewEditor = class WebviewEditor extends EditorPane {
         this._webviewVisibleDisposables.add(this._editorGroupsService.createEditorDropTarget(input.webview.container, {
             containsGroup: (group) => this.group.id === group.id
         }));
-        this._webviewVisibleDisposables.add(( new WebviewWindowDragMonitor(this.window, () => this.webview)));
+        this._webviewVisibleDisposables.add(( (new WebviewWindowDragMonitor(this.window, () => this.webview))));
         this.synchronizeWebviewContainerDimensions(input.webview);
         this._webviewVisibleDisposables.add(this.trackFocus(input.webview));
     }
@@ -150,7 +147,7 @@ let WebviewEditor = class WebviewEditor extends EditorPane {
         webview.layoutWebviewOverElement(this._element.parentElement, dimension, rootContainer);
     }
     trackFocus(webview) {
-        const store = ( new DisposableStore());
+        const store = ( (new DisposableStore()));
         const webviewContentFocusTracker = trackFocus(webview.container);
         store.add(webviewContentFocusTracker);
         store.add(webviewContentFocusTracker.onDidFocus(() => this._onDidFocusWebview.fire()));
@@ -158,14 +155,14 @@ let WebviewEditor = class WebviewEditor extends EditorPane {
         return store;
     }
 };
-WebviewEditor = WebviewEditor_1 = ( __decorate([
-    ( __param(1, ITelemetryService)),
-    ( __param(2, IThemeService)),
-    ( __param(3, IStorageService)),
-    ( __param(4, IEditorGroupsService)),
-    ( __param(5, IEditorService)),
-    ( __param(6, IWorkbenchLayoutService)),
-    ( __param(7, IHostService)),
-    ( __param(8, IContextKeyService))
-], WebviewEditor));
+WebviewEditor = WebviewEditor_1 = ( (__decorate([
+    ( (__param(1, ITelemetryService))),
+    ( (__param(2, IThemeService))),
+    ( (__param(3, IStorageService))),
+    ( (__param(4, IEditorGroupsService))),
+    ( (__param(5, IEditorService))),
+    ( (__param(6, IWorkbenchLayoutService))),
+    ( (__param(7, IHostService))),
+    ( (__param(8, IContextKeyService)))
+], WebviewEditor)));
 export { CONTEXT_ACTIVE_WEBVIEW_PANEL_ID, WebviewEditor };

package/vscode/src/vs/workbench/contrib/workspace/common/workspace.js

@@ -1,16 +1,13 @@
 import { localizeWithPath } from '../../../../nls.js';
 import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
+const _moduleId = "vs/workbench/contrib/workspace/common/workspace";
 const WorkspaceTrustContext = {
-    IsEnabled: ( new RawContextKey('isWorkspaceTrustEnabled', false, ( localizeWithPath(
-     'vs/workbench/contrib/workspace/common/workspace',
-     'workspaceTrustEnabledCtx',
-     "Whether the workspace trust feature is enabled."
-    )))),
-    IsTrusted: ( new RawContextKey('isWorkspaceTrusted', false, ( localizeWithPath(
-     'vs/workbench/contrib/workspace/common/workspace',
-     'workspaceTrustedCtx',
+    IsEnabled: ( (new RawContextKey('isWorkspaceTrustEnabled', false, ( localizeWithPath(_moduleId, 0, "Whether the workspace trust feature is enabled."))))),
+    IsTrusted: ( (new RawContextKey('isWorkspaceTrusted', false, ( localizeWithPath(
+     _moduleId,
+     1,
      "Whether the current workspace has been trusted by the user."
-    ))))
+    )))))
 };
 const MANAGE_TRUST_COMMAND_ID = 'workbench.trust.manage';
 export { MANAGE_TRUST_COMMAND_ID, WorkspaceTrustContext };

package/vscode/src/vs/workbench/services/activity/browser/activityService.d.ts

@@ -0,0 +1,28 @@
+import { IActivity } from '../common/activity.js';
+import { IActivityService } from '../common/activity.service.js';
+import { Disposable, IDisposable } from '../../../../base/common/lifecycle.js';
+import { ViewContainer } from '../../../common/views.js';
+import { IViewDescriptorService } from '../../../common/views.service.js';
+import { Event } from '../../../../base/common/event.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+
+declare class ActivityService extends Disposable implements IActivityService {
+    private readonly viewDescriptorService;
+    private readonly instantiationService;
+    _serviceBrand: undefined;
+    private readonly viewActivities;
+    private readonly _onDidChangeActivity;
+    readonly onDidChangeActivity: Event<string | ViewContainer>;
+    private readonly viewContainerActivities;
+    private readonly globalActivities;
+    constructor(viewDescriptorService: IViewDescriptorService, instantiationService: IInstantiationService);
+    showViewContainerActivity(viewContainerId: string, activity: IActivity): IDisposable;
+    getViewContainerActivities(viewContainerId: string): IActivity[];
+    showViewActivity(viewId: string, activity: IActivity): IDisposable;
+    showAccountsActivity(activity: IActivity): IDisposable;
+    showGlobalActivity(activity: IActivity): IDisposable;
+    getActivity(id: string): IActivity[];
+    private showActivity;
+}
+
+export { ActivityService };

package/vscode/src/vs/workbench/services/authentication/browser/authenticationService.js

@@ -7,6 +7,7 @@ import { localizeWithPath } from '../../../../nls.js';
 import { IAuthenticationAccessService } from './authenticationAccessService.service.js';
 import '../../../../platform/instantiation/common/instantiation.js';
 import { IExtensionService } from '../../extensions/common/extensions.service.js';
+const _moduleId = "vs/workbench/services/authentication/browser/authenticationService";
 function getAuthenticationProviderActivationEvent(id) { return `onAuthenticationRequest:${id}`; }
 async function getCurrentAuthenticationSessionInfo(secretStorageService, productService) {
     const authenticationSessionValue = await secretStorageService.get(`${productService.urlProtocol}.loginAccount`);
@@ -58,13 +59,22 @@ let AuthenticationService = class AuthenticationService extends Disposable {
     }
     registerDeclaredAuthenticationProvider(provider) {
         if (isFalsyOrWhitespace(provider.id)) {
-            throw new Error(localizeWithPath('vs/workbench/services/authentication/browser/authenticationService', 'authentication.missingId', 'An authentication contribution must specify an id.'));
+            throw ( new Error(
+                localizeWithPath(_moduleId, 0, 'An authentication contribution must specify an id.')
+            ));
         }
         if (isFalsyOrWhitespace(provider.label)) {
-            throw new Error(localizeWithPath('vs/workbench/services/authentication/browser/authenticationService', 'authentication.missingLabel', 'An authentication contribution must specify a label.'));
+            throw ( new Error(
+                localizeWithPath(_moduleId, 1, 'An authentication contribution must specify a label.')
+            ));
         }
         if (( this.declaredProviders.some(p => p.id === provider.id))) {
-            throw new Error(localizeWithPath('vs/workbench/services/authentication/browser/authenticationService', 'authentication.idConflict', "This authentication id '{0}' has already been registered", provider.id));
+            throw ( new Error(localizeWithPath(
+                _moduleId,
+                2,
+                "This authentication id '{0}' has already been registered",
+                provider.id
+            )));
         }
         this._declaredProviders.push(provider);
         this._onDidChangeDeclaredProviders.fire();
@@ -112,7 +122,7 @@ let AuthenticationService = class AuthenticationService extends Disposable {
         if (( this._authenticationProviders.has(id))) {
             return this._authenticationProviders.get(id);
         }
-        throw new Error(`No authentication provider '${id}' is currently registered.`);
+        throw ( new Error(`No authentication provider '${id}' is currently registered.`));
     }
     async getSessions(id, scopes, activateImmediate = false) {
         const authProvider = this._authenticationProviders.get(id) || (await this.tryActivateProvider(id, activateImmediate));
@@ -120,7 +130,7 @@ let AuthenticationService = class AuthenticationService extends Disposable {
             return await authProvider.getSessions(scopes);
         }
         else {
-            throw new Error(`No authentication provider '${id}' is currently registered.`);
+            throw ( new Error(`No authentication provider '${id}' is currently registered.`));
         }
     }
     async createSession(id, scopes, options) {
@@ -131,7 +141,7 @@ let AuthenticationService = class AuthenticationService extends Disposable {
             });
         }
         else {
-            throw new Error(`No authentication provider '${id}' is currently registered.`);
+            throw ( new Error(`No authentication provider '${id}' is currently registered.`));
         }
     }
     async removeSession(id, sessionId) {
@@ -140,7 +150,7 @@ let AuthenticationService = class AuthenticationService extends Disposable {
             return authProvider.removeSession(sessionId);
         }
         else {
-            throw new Error(`No authentication provider '${id}' is currently registered.`);
+            throw ( new Error(`No authentication provider '${id}' is currently registered.`));
         }
     }
     async tryActivateProvider(providerId, activateImmediate) {
@@ -157,7 +167,7 @@ let AuthenticationService = class AuthenticationService extends Disposable {
                         resolve(provider);
                     }
                     else {
-                        throw new Error(`No authentication provider '${providerId}' is currently registered.`);
+                        throw ( new Error(`No authentication provider '${providerId}' is currently registered.`));
                     }
                 }
             });

package/vscode/src/vs/workbench/services/configurationResolver/common/configurationResolverSchema.js

@@ -1,31 +1,24 @@
 import { localizeWithPath } from '../../../../nls.js';
+const _moduleId = "vs/workbench/services/configurationResolver/common/configurationResolverSchema";
 const idDescription = ( localizeWithPath(
-    'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-    'JsonSchema.input.id',
+    _moduleId,
+    0,
     "The input's id is used to associate an input with a variable of the form ${input:id}."
 ));
-const typeDescription = ( localizeWithPath(
-    'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-    'JsonSchema.input.type',
-    "The type of user input prompt to use."
-));
+const typeDescription = ( localizeWithPath(_moduleId, 1, "The type of user input prompt to use."));
 const descriptionDescription = ( localizeWithPath(
-    'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-    'JsonSchema.input.description',
+    _moduleId,
+    2,
     "The description is shown when the user is prompted for input."
 ));
-const defaultDescription = ( localizeWithPath(
-    'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-    'JsonSchema.input.default',
-    "The default value for the input."
-));
+const defaultDescription = ( localizeWithPath(_moduleId, 3, "The default value for the input."));
 const inputsSchema = {
     definitions: {
         inputs: {
             type: 'array',
             description: ( localizeWithPath(
-                'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-                'JsonSchema.inputs',
+                _moduleId,
+                4,
                 'User inputs. Used for defining user input prompts, such as free string input or a choice from several options.'
             )),
             items: {
@@ -45,8 +38,8 @@ const inputsSchema = {
                                 enum: ['promptString'],
                                 enumDescriptions: [
                                     ( localizeWithPath(
-                                        'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-                                        'JsonSchema.input.type.promptString',
+                                        _moduleId,
+                                        5,
                                         "The 'promptString' type opens an input box to ask the user for input."
                                     )),
                                 ]
@@ -62,8 +55,8 @@ const inputsSchema = {
                             password: {
                                 type: 'boolean',
                                 description: ( localizeWithPath(
-                                    'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-                                    'JsonSchema.input.password',
+                                    _moduleId,
+                                    6,
                                     "Controls if a password input is shown. Password input hides the typed text."
                                 )),
                             },
@@ -83,11 +76,7 @@ const inputsSchema = {
                                 description: typeDescription,
                                 enum: ['pickString'],
                                 enumDescriptions: [
-                                    ( localizeWithPath(
-                                        'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-                                        'JsonSchema.input.type.pickString',
-                                        "The 'pickString' type shows a selection list."
-                                    )),
+                                    ( localizeWithPath(_moduleId, 7, "The 'pickString' type shows a selection list.")),
                                 ]
                             },
                             description: {
@@ -101,8 +90,8 @@ const inputsSchema = {
                             options: {
                                 type: 'array',
                                 description: ( localizeWithPath(
-                                    'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-                                    'JsonSchema.input.options',
+                                    _moduleId,
+                                    8,
                                     "An array of strings that defines the options for a quick pick."
                                 )),
                                 items: {
@@ -117,19 +106,11 @@ const inputsSchema = {
                                             properties: {
                                                 label: {
                                                     type: 'string',
-                                                    description: ( localizeWithPath(
-                                                        'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-                                                        'JsonSchema.input.pickString.optionLabel',
-                                                        "Label for the option."
-                                                    ))
+                                                    description: ( localizeWithPath(_moduleId, 9, "Label for the option."))
                                                 },
                                                 value: {
                                                     type: 'string',
-                                                    description: ( localizeWithPath(
-                                                        'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-                                                        'JsonSchema.input.pickString.optionValue',
-                                                        "Value for the option."
-                                                    ))
+                                                    description: ( localizeWithPath(_moduleId, 10, "Value for the option."))
                                                 }
                                             }
                                         }
@@ -152,46 +133,26 @@ const inputsSchema = {
                                 description: typeDescription,
                                 enum: ['command'],
                                 enumDescriptions: [
-                                    ( localizeWithPath(
-                                        'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-                                        'JsonSchema.input.type.command',
-                                        "The 'command' type executes a command."
-                                    )),
+                                    ( localizeWithPath(_moduleId, 11, "The 'command' type executes a command.")),
                                 ]
                             },
                             command: {
                                 type: 'string',
-                                description: ( localizeWithPath(
-                                    'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-                                    'JsonSchema.input.command.command',
-                                    "The command to execute for this input variable."
-                                ))
+                                description: ( localizeWithPath(_moduleId, 12, "The command to execute for this input variable."))
                             },
                             args: {
                                 oneOf: [
                                     {
                                         type: 'object',
-                                        description: ( localizeWithPath(
-                                            'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-                                            'JsonSchema.input.command.args',
-                                            "Optional arguments passed to the command."
-                                        ))
+                                        description: ( localizeWithPath(_moduleId, 13, "Optional arguments passed to the command."))
                                     },
                                     {
                                         type: 'array',
-                                        description: ( localizeWithPath(
-                                            'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-                                            'JsonSchema.input.command.args',
-                                            "Optional arguments passed to the command."
-                                        ))
+                                        description: ( localizeWithPath(_moduleId, 13, "Optional arguments passed to the command."))
                                     },
                                     {
                                         type: 'string',
-                                        description: ( localizeWithPath(
-                                            'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-                                            'JsonSchema.input.command.args',
-                                            "Optional arguments passed to the command."
-                                        ))
+                                        description: ( localizeWithPath(_moduleId, 13, "Optional arguments passed to the command."))
                                     }
                                 ]
                             }

package/vscode/src/vs/workbench/services/configurationResolver/common/configurationResolverUtils.js

@@ -1,10 +1,11 @@
 import { localizeWithPath } from '../../../../nls.js';
+const _moduleId = "vs/workbench/services/configurationResolver/common/configurationResolverUtils";
 function applyDeprecatedVariableMessage(schema) {
     schema.pattern = schema.pattern || '^(?!.*\\$\\{(env|config|command)\\.)';
     schema.patternErrorMessage = schema.patternErrorMessage ||
         ( localizeWithPath(
-         'vs/workbench/services/configurationResolver/common/configurationResolverUtils',
-         'deprecatedVariables',
+         _moduleId,
+         0,
          "'env.', 'config.' and 'command.' are deprecated, use 'env:', 'config:' and 'command:' instead."
         ));
 }

package/vscode/src/vs/workbench/services/configurationResolver/common/variableResolver.js

@@ -7,6 +7,7 @@ import { normalizeDriveLetter } from '../../../../base/common/labels.js';
 import { localizeWithPath } from '../../../../nls.js';
 import { VariableKind, VariableError } from './configurationResolver.js';
 import { replaceAsync } from '../../../../base/common/strings.js';
+const _moduleId = "vs/workbench/services/configurationResolver/common/variableResolver";
 class AbstractVariableResolverService {
     static { this.VARIABLE_LHS = '${'; }
     static { this.VARIABLE_REGEXP = /\$\{(.*?)\}/g; }
@@ -70,14 +71,14 @@ class AbstractVariableResolverService {
         return { newConfig, resolvedVariables };
     }
     resolveWithInteractionReplace(folder, config, section, variables) {
-        throw new Error('resolveWithInteractionReplace not implemented.');
+        throw ( new Error('resolveWithInteractionReplace not implemented.'));
     }
     resolveWithInteraction(folder, config, section, variables) {
-        throw new Error('resolveWithInteraction not implemented.');
+        throw ( new Error('resolveWithInteraction not implemented.'));
     }
     contributeVariable(variable, resolution) {
         if (( this._contributedVariables.has(variable))) {
-            throw new Error('Variable ' + variable + ' is contributed twice.');
+            throw ( new Error('Variable ' + variable + ' is contributed twice.'));
         }
         else {
             this._contributedVariables.set(variable, resolution);
@@ -133,7 +134,12 @@ class AbstractVariableResolverService {
             if (filePath) {
                 return normalizeDriveLetter(filePath);
             }
-            throw new VariableError(variableKind, (localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveFile', "Variable {0} can not be resolved. Please open an editor.", match)));
+            throw ( new VariableError(variableKind, localizeWithPath(
+                _moduleId,
+                0,
+                "Variable {0} can not be resolved. Please open an editor.",
+                match
+            )));
         };
         const getFolderPathForFile = (variableKind) => {
             const filePath = getFilePath(variableKind);
@@ -143,7 +149,13 @@ class AbstractVariableResolverService {
                     return normalizeDriveLetter(folderPath);
                 }
             }
-            throw new VariableError(variableKind, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveFolderForFile', "Variable {0}: can not find workspace folder of '{1}'.", match, basename(filePath)));
+            throw ( new VariableError(variableKind, localizeWithPath(
+                _moduleId,
+                1,
+                "Variable {0}: can not find workspace folder of '{1}'.",
+                match,
+                basename(filePath)
+            )));
         };
         const getFolderUri = (variableKind) => {
             if (argument) {
@@ -151,15 +163,31 @@ class AbstractVariableResolverService {
                 if (folder) {
                     return folder;
                 }
-                throw new VariableError(variableKind, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotFindFolder', "Variable {0} can not be resolved. No such folder '{1}'.", match, argument));
+                throw ( new VariableError(variableKind, localizeWithPath(
+                    _moduleId,
+                    2,
+                    "Variable {0} can not be resolved. No such folder '{1}'.",
+                    match,
+                    argument
+                )));
             }
             if (folderUri) {
                 return folderUri;
             }
             if (this._context.getWorkspaceFolderCount() > 1) {
-                throw new VariableError(variableKind, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveWorkspaceFolderMultiRoot', "Variable {0} can not be resolved in a multi folder workspace. Scope this variable using ':' and a workspace folder name.", match));
+                throw ( new VariableError(variableKind, localizeWithPath(
+                    _moduleId,
+                    3,
+                    "Variable {0} can not be resolved in a multi folder workspace. Scope this variable using ':' and a workspace folder name.",
+                    match
+                )));
             }
-            throw new VariableError(variableKind, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveWorkspaceFolder', "Variable {0} can not be resolved. Please open a folder.", match));
+            throw ( new VariableError(variableKind, localizeWithPath(
+                _moduleId,
+                4,
+                "Variable {0} can not be resolved. Please open a folder.",
+                match
+            )));
         };
         switch (variable) {
             case 'env':
@@ -172,19 +200,41 @@ class AbstractVariableResolverService {
                     }
                     return '';
                 }
-                throw new VariableError(VariableKind.Env, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'missingEnvVarName', "Variable {0} can not be resolved because no environment variable name is given.", match));
+                throw ( new VariableError(VariableKind.Env, localizeWithPath(
+                    _moduleId,
+                    5,
+                    "Variable {0} can not be resolved because no environment variable name is given.",
+                    match
+                )));
             case 'config':
                 if (argument) {
                     const config = this._context.getConfigurationValue(folderUri, argument);
                     if (isUndefinedOrNull(config)) {
-                        throw new VariableError(VariableKind.Config, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'configNotFound', "Variable {0} can not be resolved because setting '{1}' not found.", match, argument));
+                        throw ( new VariableError(VariableKind.Config, localizeWithPath(
+                            _moduleId,
+                            6,
+                            "Variable {0} can not be resolved because setting '{1}' not found.",
+                            match,
+                            argument
+                        )));
                     }
                     if (isObject(config)) {
-                        throw new VariableError(VariableKind.Config, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'configNoString', "Variable {0} can not be resolved because '{1}' is a structured value.", match, argument));
+                        throw ( new VariableError(VariableKind.Config, localizeWithPath(
+                            _moduleId,
+                            7,
+                            "Variable {0} can not be resolved because '{1}' is a structured value.",
+                            match,
+                            argument
+                        )));
                     }
                     return config;
                 }
-                throw new VariableError(VariableKind.Config, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'missingConfigName', "Variable {0} can not be resolved because no settings name is given.", match));
+                throw ( new VariableError(VariableKind.Config, localizeWithPath(
+                    _moduleId,
+                    8,
+                    "Variable {0} can not be resolved because no settings name is given.",
+                    match
+                )));
             case 'command':
                 return this.resolveFromMap(VariableKind.Command, match, argument, commandValueMapping, 'command');
             case 'input':
@@ -193,11 +243,22 @@ class AbstractVariableResolverService {
                 if (argument) {
                     const ext = await this._context.getExtension(argument);
                     if (!ext) {
-                        throw new VariableError(VariableKind.ExtensionInstallFolder, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'extensionNotInstalled', "Variable {0} can not be resolved because the extension {1} is not installed.", match, argument));
+                        throw ( new VariableError(VariableKind.ExtensionInstallFolder, localizeWithPath(
+                            _moduleId,
+                            9,
+                            "Variable {0} can not be resolved because the extension {1} is not installed.",
+                            match,
+                            argument
+                        )));
                     }
                     return this.fsPath(ext.extensionLocation);
                 }
-                throw new VariableError(VariableKind.ExtensionInstallFolder, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'missingExtensionName', "Variable {0} can not be resolved because no extension name is given.", match));
+                throw ( new VariableError(VariableKind.ExtensionInstallFolder, localizeWithPath(
+                    _moduleId,
+                    10,
+                    "Variable {0} can not be resolved because no extension name is given.",
+                    match
+                )));
             default: {
                 switch (variable) {
                     case 'workspaceRoot':
@@ -212,21 +273,36 @@ class AbstractVariableResolverService {
                         if (environment.userHome) {
                             return environment.userHome;
                         }
-                        throw new VariableError(VariableKind.UserHome, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveUserHome', "Variable {0} can not be resolved. UserHome path is not defined", match));
+                        throw ( new VariableError(VariableKind.UserHome, localizeWithPath(
+                            _moduleId,
+                            11,
+                            "Variable {0} can not be resolved. UserHome path is not defined",
+                            match
+                        )));
                     }
                     case 'lineNumber': {
                         const lineNumber = this._context.getLineNumber();
                         if (lineNumber) {
                             return lineNumber;
                         }
-                        throw new VariableError(VariableKind.LineNumber, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveLineNumber', "Variable {0} can not be resolved. Make sure to have a line selected in the active editor.", match));
+                        throw ( new VariableError(VariableKind.LineNumber, localizeWithPath(
+                            _moduleId,
+                            12,
+                            "Variable {0} can not be resolved. Make sure to have a line selected in the active editor.",
+                            match
+                        )));
                     }
                     case 'selectedText': {
                         const selectedText = this._context.getSelectedText();
                         if (selectedText) {
                             return selectedText;
                         }
-                        throw new VariableError(VariableKind.SelectedText, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveSelectedText', "Variable {0} can not be resolved. Make sure to have some text selected in the active editor.", match));
+                        throw ( new VariableError(VariableKind.SelectedText, localizeWithPath(
+                            _moduleId,
+                            13,
+                            "Variable {0} can not be resolved. Make sure to have some text selected in the active editor.",
+                            match
+                        )));
                     }
                     case 'file':
                         return getFilePath(VariableKind.File);
@@ -294,7 +370,12 @@ class AbstractVariableResolverService {
             if (typeof v === 'string') {
                 return v;
             }
-            throw new VariableError(variableKind, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'noValueForCommand', "Variable {0} can not be resolved because the command has no value.", match));
+            throw ( new VariableError(variableKind, localizeWithPath(
+                _moduleId,
+                14,
+                "Variable {0} can not be resolved because the command has no value.",
+                match
+            )));
         }
         return match;
     }