@codingame/monaco-vscode-api 4.5.1 → 4.5.2

package/vscode/src/vs/platform/actions/browser/toolbar.js

@@ -17,6 +17,7 @@ import { IContextKeyService } from '../../contextkey/common/contextkey.service.j
 import { IContextMenuService } from '../../contextview/browser/contextView.service.js';
 import { IKeybindingService } from '../../keybinding/common/keybinding.service.js';
 import { ITelemetryService } from '../../telemetry/common/telemetry.service.js';
+const _moduleId = "vs/platform/actions/browser/toolbar";
 let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
     constructor(container, _options, _menuService, _contextKeyService, _contextMenuService, keybindingService, telemetryService) {
         super(container, _contextMenuService, {
@@ -29,7 +30,7 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
         this._menuService = _menuService;
         this._contextKeyService = _contextKeyService;
         this._contextMenuService = _contextMenuService;
-        this._sessionDisposables = this._store.add(( new DisposableStore()));
+        this._sessionDisposables = this._store.add(( (new DisposableStore())));
         const telemetrySource = _options?.telemetrySource;
         if (telemetrySource) {
             this._store.add(this.actionBar.onDidRun(e => telemetryService.publicLog2('workbenchActionExecuted', { id: e.action.id, from: telemetrySource })));
@@ -66,7 +67,7 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
             }
         }
         if (this._options?.overflowBehavior !== undefined) {
-            const exemptedIds = intersection(( new Set(this._options.overflowBehavior.exempted)), ( Iterable.map(primary, a => a?.id)));
+            const exemptedIds = intersection(( (new Set(this._options.overflowBehavior.exempted))), ( (Iterable.map(primary, a => a?.id))));
             const maxItems = this._options.overflowBehavior.maxItems - exemptedIds.size;
             let count = 0;
             for (let i = 0; i < primary.length; i++) {
@@ -75,7 +76,7 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
                     continue;
                 }
                 count++;
-                if (( exemptedIds.has(action.id))) {
+                if (( (exemptedIds.has(action.id)))) {
                     continue;
                 }
                 if (count >= maxItems) {
@@ -89,7 +90,7 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
         super.setActions(primary, Separator.join(extraSecondary, secondary));
         if (toggleActions.length > 0) {
             this._sessionDisposables.add(addDisposableListener(this.getElement(), 'contextmenu', e => {
-                const event = ( new StandardMouseEvent(getWindow(this.getElement()), e));
+                const event = ( (new StandardMouseEvent(getWindow(this.getElement()), e)));
                 const action = this.getItemAction(event.target);
                 if (!(action)) {
                     return;
@@ -122,7 +123,7 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
                 else {
                     hideAction = toAction({
                         id: 'label',
-                        label: ( localizeWithPath('vs/platform/actions/browser/toolbar', 'hide', "Hide")),
+                        label: ( localizeWithPath(_moduleId, 0, "Hide")),
                         enabled: false,
                         run() { }
                     });
@@ -132,10 +133,10 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
                     menuIds = [this._options.resetMenu];
                 }
                 if (someAreHidden && menuIds) {
-                    actions.push(( new Separator()));
+                    actions.push(( (new Separator())));
                     actions.push(toAction({
                         id: 'resetThisMenu',
-                        label: ( localizeWithPath('vs/platform/actions/browser/toolbar', 'resetThisMenu', "Reset Menu")),
+                        label: ( localizeWithPath(_moduleId, 1, "Reset Menu")),
                         run: () => this._menuService.resetHiddenStates(menuIds)
                     }));
                 }
@@ -151,17 +152,17 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
         }
     }
 };
-WorkbenchToolBar = ( __decorate([
-    ( __param(2, IMenuService)),
-    ( __param(3, IContextKeyService)),
-    ( __param(4, IContextMenuService)),
-    ( __param(5, IKeybindingService)),
-    ( __param(6, ITelemetryService))
-], WorkbenchToolBar));
+WorkbenchToolBar = ( (__decorate([
+    ( (__param(2, IMenuService))),
+    ( (__param(3, IContextKeyService))),
+    ( (__param(4, IContextMenuService))),
+    ( (__param(5, IKeybindingService))),
+    ( (__param(6, ITelemetryService)))
+], WorkbenchToolBar)));
 let MenuWorkbenchToolBar = class MenuWorkbenchToolBar extends WorkbenchToolBar {
     constructor(container, menuId, options, menuService, contextKeyService, contextMenuService, keybindingService, telemetryService) {
         super(container, { resetMenu: menuId, ...options }, menuService, contextKeyService, contextMenuService, keybindingService, telemetryService);
-        this._onDidChangeMenuItems = this._store.add(( new Emitter()));
+        this._onDidChangeMenuItems = this._store.add(( (new Emitter())));
         this.onDidChangeMenuItems = this._onDidChangeMenuItems.event;
         const menu = this._store.add(menuService.createMenu(menuId, contextKeyService, { emitEventsForSubmenuChanges: true }));
         const updateToolbar = () => {
@@ -178,14 +179,14 @@ let MenuWorkbenchToolBar = class MenuWorkbenchToolBar extends WorkbenchToolBar {
         updateToolbar();
     }
     setActions() {
-        throw new BugIndicatingError('This toolbar is populated from a menu.');
+        throw ( (new BugIndicatingError('This toolbar is populated from a menu.')));
     }
 };
-MenuWorkbenchToolBar = ( __decorate([
-    ( __param(3, IMenuService)),
-    ( __param(4, IContextKeyService)),
-    ( __param(5, IContextMenuService)),
-    ( __param(6, IKeybindingService)),
-    ( __param(7, ITelemetryService))
-], MenuWorkbenchToolBar));
+MenuWorkbenchToolBar = ( (__decorate([
+    ( (__param(3, IMenuService))),
+    ( (__param(4, IContextKeyService))),
+    ( (__param(5, IContextMenuService))),
+    ( (__param(6, IKeybindingService))),
+    ( (__param(7, ITelemetryService)))
+], MenuWorkbenchToolBar)));
 export { MenuWorkbenchToolBar, WorkbenchToolBar };

package/vscode/src/vs/platform/actions/common/actions.contribution.js

@@ -0,0 +1,5 @@
+import { registerAction2 } from './actions.js';
+import '../../instantiation/common/instantiation.js';
+import { MenuHiddenStatesReset } from './menuResetAction.js';
+import './menuService.js';
+registerAction2(MenuHiddenStatesReset);

package/vscode/src/vs/platform/actions/common/actions.js

@@ -200,7 +200,9 @@ class MenuId {
     }
     constructor(identifier) {
         if (( MenuId._instances.has(identifier))) {
-            throw new TypeError(`MenuId with identifier '${identifier}' already exists. Use MenuId.for(ident) or a unique identifier`);
+            throw ( new TypeError(
+                `MenuId with identifier '${identifier}' already exists. Use MenuId.for(ident) or a unique identifier`
+            ));
         }
         MenuId._instances.set(identifier, this);
         this.id = identifier;
@@ -374,7 +376,7 @@ function registerAction2(ctor) {
     const action = ( new ctor());
     const { f1, menu, keybinding, ...command } = action.desc;
     if (CommandsRegistry.getCommand(command.id)) {
-        throw new Error(`Cannot register two commands with the same id: ${command.id}`);
+        throw ( new Error(`Cannot register two commands with the same id: ${command.id}`));
     }
     disposables.add(CommandsRegistry.registerCommand({
         id: command.id,

package/vscode/src/vs/platform/actions/common/menuResetAction.js

@@ -0,0 +1,21 @@
+import { localize2WithPath } from '../../../nls.js';
+import { Categories } from '../../action/common/actionCommonCategories.js';
+import { Action2 } from './actions.js';
+import { IMenuService } from './actions.service.js';
+import { ILogService } from '../../log/common/log.service.js';
+const _moduleId = "vs/platform/actions/common/menuResetAction";
+class MenuHiddenStatesReset extends Action2 {
+    constructor() {
+        super({
+            id: 'menu.resetHiddenStates',
+            title: ( localize2WithPath(_moduleId, 0, "Reset All Menus")),
+            category: Categories.View,
+            f1: true
+        });
+    }
+    run(accessor) {
+        accessor.get(IMenuService).resetHiddenStates();
+        accessor.get(ILogService).info('did RESET all menu hidden states');
+    }
+}
+export { MenuHiddenStatesReset };

package/vscode/src/vs/platform/actions/common/menuService.js

@@ -10,38 +10,41 @@ import { IStorageService } from '../../storage/common/storage.service.js';
 import { removeFastWithoutKeepingOrder } from '../../../base/common/arrays.js';
 import { localizeWithPath } from '../../../nls.js';
 var PersistedMenuHideState_1, MenuInfo_1;
+const _moduleId = "vs/platform/actions/common/menuService";
 let MenuService = class MenuService {
     constructor(_commandService, storageService) {
         this._commandService = _commandService;
-        this._hiddenStates = ( new PersistedMenuHideState(storageService));
+        this._hiddenStates = ( (new PersistedMenuHideState(storageService)));
     }
     createMenu(id, contextKeyService, options) {
-        return ( new MenuImpl(
-            id,
-            this._hiddenStates,
-            { emitEventsForSubmenuChanges: false, eventDebounceDelay: 50, ...options },
-            this._commandService,
-            contextKeyService
-        ));
+        return (
+             (new MenuImpl(
+                id,
+                this._hiddenStates,
+                { emitEventsForSubmenuChanges: false, eventDebounceDelay: 50, ...options },
+                this._commandService,
+                contextKeyService
+            ))
+        );
     }
     resetHiddenStates(ids) {
         this._hiddenStates.reset(ids);
     }
 };
-MenuService = ( __decorate([
-    ( __param(0, ICommandService)),
-    ( __param(1, IStorageService))
-], MenuService));
+MenuService = ( (__decorate([
+    ( (__param(0, ICommandService))),
+    ( (__param(1, IStorageService)))
+], MenuService)));
 let PersistedMenuHideState = class PersistedMenuHideState {
     static { PersistedMenuHideState_1 = this; }
     static { this._key = 'menu.hiddenCommands'; }
     constructor(_storageService) {
         this._storageService = _storageService;
-        this._disposables = ( new DisposableStore());
-        this._onDidChange = ( new Emitter());
+        this._disposables = ( (new DisposableStore()));
+        this._onDidChange = ( (new Emitter()));
         this.onDidChange = this._onDidChange.event;
         this._ignoreChangeEvent = false;
-        this._hiddenByDefaultCache = ( new Map());
+        this._hiddenByDefaultCache = ( (new Map()));
         try {
             const raw = _storageService.get(PersistedMenuHideState_1._key, 0 , '{}');
             this._data = JSON.parse(raw);
@@ -132,9 +135,9 @@ let PersistedMenuHideState = class PersistedMenuHideState {
         }
     }
 };
-PersistedMenuHideState = PersistedMenuHideState_1 = ( __decorate([
-    ( __param(0, IStorageService))
-], PersistedMenuHideState));
+PersistedMenuHideState = PersistedMenuHideState_1 = ( (__decorate([
+    ( (__param(0, IStorageService)))
+], PersistedMenuHideState)));
 let MenuInfo = MenuInfo_1 = class MenuInfo {
     constructor(_id, _hiddenStates, _collectContextKeysForSubmenus, _commandService, _contextKeyService) {
         this._id = _id;
@@ -143,9 +146,9 @@ let MenuInfo = MenuInfo_1 = class MenuInfo {
         this._commandService = _commandService;
         this._contextKeyService = _contextKeyService;
         this._menuGroups = [];
-        this._structureContextKeys = ( new Set());
-        this._preconditionContextKeys = ( new Set());
-        this._toggledContextKeys = ( new Set());
+        this._structureContextKeys = ( (new Set()));
+        this._preconditionContextKeys = ( (new Set()));
+        this._toggledContextKeys = ( (new Set()));
         this.refresh();
     }
     get structureContextKeys() {
@@ -203,26 +206,26 @@ let MenuInfo = MenuInfo_1 = class MenuInfo {
                     }
                     const menuHide = createMenuHide(this._id, isMenuItem ? item.command : item, this._hiddenStates);
                     if (isMenuItem) {
-                        activeActions.push(( new MenuItemAction(
+                        activeActions.push(( (new MenuItemAction(
                             item.command,
                             item.alt,
                             options,
                             menuHide,
                             this._contextKeyService,
                             this._commandService
-                        )));
+                        ))));
                     }
                     else {
-                        const groups = ( new MenuInfo_1(
+                        const groups = ( (new MenuInfo_1(
                             item.submenu,
                             this._hiddenStates,
                             this._collectContextKeysForSubmenus,
                             this._commandService,
                             this._contextKeyService
-                        )).createActionGroups(options);
-                        const submenuActions = Separator.join(...( groups.map(g => g[1])));
+                        ))).createActionGroups(options);
+                        const submenuActions = Separator.join(...( (groups.map(g => g[1]))));
                         if (submenuActions.length > 0) {
-                            activeActions.push(( new SubmenuItemAction(item, menuHide, submenuActions)));
+                            activeActions.push(( (new SubmenuItemAction(item, menuHide, submenuActions))));
                         }
                     }
                 }
@@ -235,7 +238,7 @@ let MenuInfo = MenuInfo_1 = class MenuInfo {
     }
     static _fillInKbExprKeys(exp, set) {
         if (exp) {
-            for (const key of ( exp.keys())) {
+            for (const key of ( (exp.keys()))) {
                 set.add(key);
             }
         }
@@ -277,31 +280,31 @@ let MenuInfo = MenuInfo_1 = class MenuInfo {
         return aStr.localeCompare(bStr);
     }
 };
-MenuInfo = MenuInfo_1 = ( __decorate([
-    ( __param(3, ICommandService)),
-    ( __param(4, IContextKeyService))
-], MenuInfo));
+MenuInfo = MenuInfo_1 = ( (__decorate([
+    ( (__param(3, ICommandService))),
+    ( (__param(4, IContextKeyService)))
+], MenuInfo)));
 let MenuImpl = class MenuImpl {
     constructor(id, hiddenStates, options, commandService, contextKeyService) {
-        this._disposables = ( new DisposableStore());
-        this._menuInfo = ( new MenuInfo(
+        this._disposables = ( (new DisposableStore()));
+        this._menuInfo = ( (new MenuInfo(
             id,
             hiddenStates,
             options.emitEventsForSubmenuChanges,
             commandService,
             contextKeyService
-        ));
-        const rebuildMenuSoon = ( new RunOnceScheduler(() => {
+        )));
+        const rebuildMenuSoon = ( (new RunOnceScheduler(() => {
             this._menuInfo.refresh();
             this._onDidChange.fire({ menu: this, isStructuralChange: true, isEnablementChange: true, isToggleChange: true });
-        }, options.eventDebounceDelay));
+        }, options.eventDebounceDelay)));
         this._disposables.add(rebuildMenuSoon);
         this._disposables.add(MenuRegistry.onDidChangeMenu(e => {
-            if (( e.has(id))) {
+            if (( (e.has(id)))) {
                 rebuildMenuSoon.schedule();
             }
         }));
-        const lazyListener = this._disposables.add(( new DisposableStore()));
+        const lazyListener = this._disposables.add(( (new DisposableStore())));
         const merge = (events) => {
             let isStructuralChange = false;
             let isEnablementChange = false;
@@ -329,12 +332,12 @@ let MenuImpl = class MenuImpl {
                 this._onDidChange.fire({ menu: this, isStructuralChange: true, isEnablementChange: false, isToggleChange: false });
             }));
         };
-        this._onDidChange = ( new DebounceEmitter({
+        this._onDidChange = ( (new DebounceEmitter({
             onWillAddFirstListener: startLazyListener,
             onDidRemoveLastListener: lazyListener.clear.bind(lazyListener),
             delay: options.eventDebounceDelay,
             merge
-        }));
+        })));
         this.onDidChange = this._onDidChange.event;
     }
     getActions(options) {
@@ -345,21 +348,16 @@ let MenuImpl = class MenuImpl {
         this._onDidChange.dispose();
     }
 };
-MenuImpl = ( __decorate([
-    ( __param(3, ICommandService)),
-    ( __param(4, IContextKeyService))
-], MenuImpl));
+MenuImpl = ( (__decorate([
+    ( (__param(3, ICommandService))),
+    ( (__param(4, IContextKeyService)))
+], MenuImpl)));
 function createMenuHide(menu, command, states) {
     const id = isISubmenuItem(command) ? command.submenu.id : command.id;
     const title = typeof command.title === 'string' ? command.title : command.title.value;
     const hide = toAction({
         id: `hide/${menu.id}/${id}`,
-        label: ( localizeWithPath(
-            'vs/platform/actions/common/menuService',
-            'hide.label',
-            'Hide \'{0}\'',
-            title
-        )),
+        label: ( localizeWithPath(_moduleId, 0, 'Hide \'{0}\'', title)),
         run() { states.updateHidden(menu, id, true); }
     });
     const toggle = toAction({

package/vscode/src/vs/platform/commands/common/commands.js

@@ -12,11 +12,11 @@ const CommandsRegistry = new (class {
     }
     registerCommand(idOrCommand, handler) {
         if (!idOrCommand) {
-            throw new Error(`invalid command`);
+            throw ( new Error(`invalid command`));
         }
         if (typeof idOrCommand === 'string') {
             if (!handler) {
-                throw new Error(`invalid command`);
+                throw ( new Error(`invalid command`));
             }
             return this.registerCommand({ id: idOrCommand, handler });
         }

package/vscode/src/vs/platform/configuration/common/configurationModels.js

@@ -745,7 +745,7 @@ let Configuration$1 = class Configuration {
     compareAndDeleteFolderConfiguration(folder) {
         const folderConfig = this.folderConfigurations.get(folder);
         if (!folderConfig) {
-            throw new Error('Unknown folder');
+            throw ( new Error('Unknown folder'));
         }
         this.deleteFolderConfiguration(folder);
         const { added, updated, removed, overrides } = compare(folderConfig, undefined);

package/vscode/src/vs/platform/configuration/common/configurationRegistry.js

@@ -5,23 +5,24 @@ import { localizeWithPath } from '../../../nls.js';
 import { getLanguageTagSettingPlainKey } from './configuration.js';
 import { Extensions as Extensions$1 } from '../../jsonschemas/common/jsonContributionRegistry.js';
 import { Registry } from '../../registry/common/platform.js';
+const _moduleId = "vs/platform/configuration/common/configurationRegistry";
 var EditPresentationTypes;
-( (function(EditPresentationTypes) {
+( ((function(EditPresentationTypes) {
     EditPresentationTypes["Multiline"] = "multilineText";
     EditPresentationTypes["Singleline"] = "singlelineText";
-})(EditPresentationTypes || (EditPresentationTypes = {})));
+})(EditPresentationTypes || (EditPresentationTypes = {}))));
 const Extensions = {
     Configuration: 'base.contributions.configuration'
 };
 var ConfigurationScope;
-( (function(ConfigurationScope) {
+( ((function(ConfigurationScope) {
     ConfigurationScope[ConfigurationScope["APPLICATION"] = 1] = "APPLICATION";
     ConfigurationScope[ConfigurationScope["MACHINE"] = 2] = "MACHINE";
     ConfigurationScope[ConfigurationScope["WINDOW"] = 3] = "WINDOW";
     ConfigurationScope[ConfigurationScope["RESOURCE"] = 4] = "RESOURCE";
     ConfigurationScope[ConfigurationScope["LANGUAGE_OVERRIDABLE"] = 5] = "LANGUAGE_OVERRIDABLE";
     ConfigurationScope[ConfigurationScope["MACHINE_OVERRIDABLE"] = 6] = "MACHINE_OVERRIDABLE";
-})(ConfigurationScope || (ConfigurationScope = {})));
+})(ConfigurationScope || (ConfigurationScope = {}))));
 const allSettings = { properties: {}, patternProperties: {} };
 const applicationSettings = { properties: {}, patternProperties: {} };
 const machineSettings = { properties: {}, patternProperties: {} };
@@ -30,22 +31,18 @@ const windowSettings = { properties: {}, patternProperties: {} };
 const resourceSettings = { properties: {}, patternProperties: {} };
 const resourceLanguageSettingsSchemaId = 'vscode://schemas/settings/resourceLanguage';
 const configurationDefaultsSchemaId = 'vscode://schemas/settings/configurationDefaults';
-const contributionRegistry = ( Registry.as(Extensions$1.JSONContribution));
+const contributionRegistry = ( (Registry.as(Extensions$1.JSONContribution)));
 class ConfigurationRegistry {
     constructor() {
-        this.overrideIdentifiers = ( new Set());
-        this._onDidSchemaChange = ( new Emitter());
+        this.overrideIdentifiers = ( (new Set()));
+        this._onDidSchemaChange = ( (new Emitter()));
         this.onDidSchemaChange = this._onDidSchemaChange.event;
-        this._onDidUpdateConfiguration = ( new Emitter());
+        this._onDidUpdateConfiguration = ( (new Emitter()));
         this.onDidUpdateConfiguration = this._onDidUpdateConfiguration.event;
-        this.configurationDefaultsOverrides = ( new Map());
+        this.configurationDefaultsOverrides = ( (new Map()));
         this.defaultLanguageConfigurationOverridesNode = {
             id: 'defaultOverrides',
-            title: ( localizeWithPath(
-                'vs/platform/configuration/common/configurationRegistry',
-                'defaultLanguageConfigurationOverrides.title',
-                "Default Language Configuration Overrides"
-            )),
+            title: ( localizeWithPath(_moduleId, 0, "Default Language Configuration Overrides")),
             properties: {}
         };
         this.configurationContributors = [this.defaultLanguageConfigurationOverridesNode];
@@ -57,7 +54,7 @@ class ConfigurationRegistry {
             allowComments: true
         };
         this.configurationProperties = {};
-        this.policyConfigurations = ( new Map());
+        this.policyConfigurations = ( (new Map()));
         this.excludedConfigurationProperties = {};
         contributionRegistry.registerSchema(resourceLanguageSettingsSchemaId, this.resourceLanguageSettingsSchema);
         this.registerOverridePropertyPatternKey();
@@ -66,21 +63,21 @@ class ConfigurationRegistry {
         this.registerConfigurations([configuration], validate);
     }
     registerConfigurations(configurations, validate = true) {
-        const properties = ( new Set());
+        const properties = ( (new Set()));
         this.doRegisterConfigurations(configurations, validate, properties);
         contributionRegistry.registerSchema(resourceLanguageSettingsSchemaId, this.resourceLanguageSettingsSchema);
         this._onDidSchemaChange.fire();
         this._onDidUpdateConfiguration.fire({ properties });
     }
     deregisterConfigurations(configurations) {
-        const properties = ( new Set());
+        const properties = ( (new Set()));
         this.doDeregisterConfigurations(configurations, properties);
         contributionRegistry.registerSchema(resourceLanguageSettingsSchemaId, this.resourceLanguageSettingsSchema);
         this._onDidSchemaChange.fire();
         this._onDidUpdateConfiguration.fire({ properties });
     }
     updateConfigurations({ add, remove }) {
-        const properties = ( new Set());
+        const properties = ( (new Set()));
         this.doDeregisterConfigurations(remove, properties);
         this.doRegisterConfigurations(add, false, properties);
         contributionRegistry.registerSchema(resourceLanguageSettingsSchemaId, this.resourceLanguageSettingsSchema);
@@ -88,7 +85,7 @@ class ConfigurationRegistry {
         this._onDidUpdateConfiguration.fire({ properties });
     }
     registerDefaultConfigurations(configurationDefaults) {
-        const properties = ( new Set());
+        const properties = ( (new Set()));
         this.doRegisterDefaultConfigurations(configurationDefaults, properties);
         this._onDidSchemaChange.fire();
         this._onDidUpdateConfiguration.fire({ properties, defaultsOverrides: true });
@@ -100,9 +97,9 @@ class ConfigurationRegistry {
                 bucket.add(key);
                 if (OVERRIDE_PROPERTY_REGEX.test(key)) {
                     const configurationDefaultOverride = this.configurationDefaultsOverrides.get(key);
-                    const valuesSources = configurationDefaultOverride?.valuesSources ?? ( new Map());
+                    const valuesSources = configurationDefaultOverride?.valuesSources ?? ( (new Map()));
                     if (source) {
-                        for (const configuration of ( Object.keys(overrides[key]))) {
+                        for (const configuration of ( (Object.keys(overrides[key])))) {
                             valuesSources.set(configuration, source);
                         }
                     }
@@ -113,8 +110,8 @@ class ConfigurationRegistry {
                         type: 'object',
                         default: defaultValue,
                         description: ( localizeWithPath(
-                            'vs/platform/configuration/common/configurationRegistry',
-                            'defaultLanguageConfiguration.description',
+                            _moduleId,
+                            1,
                             "Configure settings to be overridden for the {0} language.",
                             plainKey
                         )),
@@ -140,7 +137,7 @@ class ConfigurationRegistry {
         this.doRegisterOverrideIdentifiers(overrideIdentifiers);
     }
     deregisterDefaultConfigurations(defaultConfigurations) {
-        const properties = ( new Set());
+        const properties = ( (new Set()));
         this.doDeregisterDefaultConfigurations(defaultConfigurations, properties);
         this._onDidSchemaChange.fire();
         this._onDidUpdateConfiguration.fire({ properties, defaultsOverrides: true });
@@ -173,7 +170,7 @@ class ConfigurationRegistry {
     }
     deltaConfiguration(delta) {
         let defaultsOverrides = false;
-        const properties = ( new Set());
+        const properties = ( (new Set()));
         if (delta.removedDefaults) {
             this.doDeregisterDefaultConfigurations(delta.removedDefaults, properties);
             defaultsOverrides = true;
@@ -353,20 +350,12 @@ class ConfigurationRegistry {
         }
     }
     updateOverridePropertyPatternKey() {
-        for (const overrideIdentifier of ( this.overrideIdentifiers.values())) {
+        for (const overrideIdentifier of ( (this.overrideIdentifiers.values()))) {
             const overrideIdentifierProperty = `[${overrideIdentifier}]`;
             const resourceLanguagePropertiesSchema = {
                 type: 'object',
-                description: ( localizeWithPath(
-                    'vs/platform/configuration/common/configurationRegistry',
-                    'overrideSettings.defaultDescription',
-                    "Configure editor settings to be overridden for a language."
-                )),
-                errorMessage: ( localizeWithPath(
-                    'vs/platform/configuration/common/configurationRegistry',
-                    'overrideSettings.errorMessage',
-                    "This setting does not support per-language configuration."
-                )),
+                description: ( localizeWithPath(_moduleId, 2, "Configure editor settings to be overridden for a language.")),
+                errorMessage: ( localizeWithPath(_moduleId, 3, "This setting does not support per-language configuration.")),
                 $ref: resourceLanguageSettingsSchemaId,
             };
             this.updatePropertyDefaultValue(overrideIdentifierProperty, resourceLanguagePropertiesSchema);
@@ -381,16 +370,8 @@ class ConfigurationRegistry {
     registerOverridePropertyPatternKey() {
         const resourceLanguagePropertiesSchema = {
             type: 'object',
-            description: ( localizeWithPath(
-                'vs/platform/configuration/common/configurationRegistry',
-                'overrideSettings.defaultDescription',
-                "Configure editor settings to be overridden for a language."
-            )),
-            errorMessage: ( localizeWithPath(
-                'vs/platform/configuration/common/configurationRegistry',
-                'overrideSettings.errorMessage',
-                "This setting does not support per-language configuration."
-            )),
+            description: ( localizeWithPath(_moduleId, 2, "Configure editor settings to be overridden for a language.")),
+            errorMessage: ( localizeWithPath(_moduleId, 3, "This setting does not support per-language configuration.")),
             $ref: resourceLanguageSettingsSchemaId,
         };
         allSettings.patternProperties[OVERRIDE_PROPERTY_PATTERN] = resourceLanguagePropertiesSchema;
@@ -417,9 +398,9 @@ class ConfigurationRegistry {
     }
 }
 const OVERRIDE_IDENTIFIER_PATTERN = `\\[([^\\]]+)\\]`;
-const OVERRIDE_IDENTIFIER_REGEX = ( new RegExp(OVERRIDE_IDENTIFIER_PATTERN, 'g'));
+const OVERRIDE_IDENTIFIER_REGEX = ( (new RegExp(OVERRIDE_IDENTIFIER_PATTERN, 'g')));
 const OVERRIDE_PROPERTY_PATTERN = `^(${OVERRIDE_IDENTIFIER_PATTERN})+$`;
-const OVERRIDE_PROPERTY_REGEX = ( new RegExp(OVERRIDE_PROPERTY_PATTERN));
+const OVERRIDE_PROPERTY_REGEX = ( (new RegExp(OVERRIDE_PROPERTY_PATTERN)));
 function overrideIdentifiersFromKey(key) {
     const identifiers = [];
     if (OVERRIDE_PROPERTY_REGEX.test(key)) {
@@ -455,36 +436,32 @@ function getDefaultValue(type) {
             return null;
     }
 }
-const configurationRegistry = ( new ConfigurationRegistry());
+const configurationRegistry = ( (new ConfigurationRegistry()));
 Registry.add(Extensions.Configuration, configurationRegistry);
 function validateProperty(property, schema) {
     if (!property.trim()) {
-        return ( localizeWithPath(
-            'vs/platform/configuration/common/configurationRegistry',
-            'config.property.empty',
-            "Cannot register an empty property"
-        ));
+        return ( localizeWithPath(_moduleId, 4, "Cannot register an empty property"));
     }
     if (OVERRIDE_PROPERTY_REGEX.test(property)) {
         return ( localizeWithPath(
-            'vs/platform/configuration/common/configurationRegistry',
-            'config.property.languageDefault',
+            _moduleId,
+            5,
             "Cannot register '{0}'. This matches property pattern '\\\\[.*\\\\]$' for describing language specific editor settings. Use 'configurationDefaults' contribution.",
             property
         ));
     }
     if (configurationRegistry.getConfigurationProperties()[property] !== undefined) {
         return ( localizeWithPath(
-            'vs/platform/configuration/common/configurationRegistry',
-            'config.property.duplicate',
+            _moduleId,
+            6,
             "Cannot register '{0}'. This property is already registered.",
             property
         ));
     }
     if (schema.policy?.name && configurationRegistry.getPolicyConfigurations().get(schema.policy?.name) !== undefined) {
         return ( localizeWithPath(
-            'vs/platform/configuration/common/configurationRegistry',
-            'config.policy.duplicate',
+            _moduleId,
+            7,
             "Cannot register '{0}'. The associated policy {1} is already registered with {2}.",
             property,
             schema.policy?.name,
@@ -496,7 +473,7 @@ function validateProperty(property, schema) {
 function getScopes() {
     const scopes = [];
     const configurationProperties = configurationRegistry.getConfigurationProperties();
-    for (const key of ( Object.keys(configurationProperties))) {
+    for (const key of ( (Object.keys(configurationProperties)))) {
         scopes.push([key, configurationProperties[key].scope]);
     }
     scopes.push(['launch', 4 ]);