@codingame/monaco-vscode-configuration-service-override 4.5.1 → 5.0.0

package/vscode/src/vs/workbench/services/configuration/browser/configurationService.js

@@ -36,6 +36,7 @@ import { workbenchConfigurationNodeBase } from 'vscode/vscode/vs/workbench/commo
 import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
 import { runWhenWindowIdle } from 'vscode/vscode/vs/base/browser/dom';
 
+const _moduleId = "vs/workbench/services/configuration/browser/configurationService";
 function getLocalUserConfigurationScopes(userDataProfile, hasRemote) {
     return (userDataProfile.isDefault || userDataProfile.useDefaultFlags?.settings)
         ? hasRemote ? LOCAL_MACHINE_SCOPES : undefined
@@ -60,58 +61,60 @@ class WorkspaceService extends Disposable {
         this.initialized = false;
         this.applicationConfiguration = null;
         this.remoteUserConfiguration = null;
-        this._onDidChangeConfiguration = this._register(( new Emitter()));
+        this._onDidChangeConfiguration = this._register(( (new Emitter())));
         this.onDidChangeConfiguration = this._onDidChangeConfiguration.event;
-        this._onWillChangeWorkspaceFolders = this._register(( new Emitter()));
+        this._onWillChangeWorkspaceFolders = this._register(( (new Emitter())));
         this.onWillChangeWorkspaceFolders = this._onWillChangeWorkspaceFolders.event;
-        this._onDidChangeWorkspaceFolders = this._register(( new Emitter()));
+        this._onDidChangeWorkspaceFolders = this._register(( (new Emitter())));
         this.onDidChangeWorkspaceFolders = this._onDidChangeWorkspaceFolders.event;
-        this._onDidChangeWorkspaceName = this._register(( new Emitter()));
+        this._onDidChangeWorkspaceName = this._register(( (new Emitter())));
         this.onDidChangeWorkspaceName = this._onDidChangeWorkspaceName.event;
-        this._onDidChangeWorkbenchState = this._register(( new Emitter()));
+        this._onDidChangeWorkbenchState = this._register(( (new Emitter())));
         this.onDidChangeWorkbenchState = this._onDidChangeWorkbenchState.event;
         this.isWorkspaceTrusted = true;
         this._restrictedSettings = { default: [] };
-        this._onDidChangeRestrictedSettings = this._register(( new Emitter()));
+        this._onDidChangeRestrictedSettings = this._register(( (new Emitter())));
         this.onDidChangeRestrictedSettings = this._onDidChangeRestrictedSettings.event;
-        this.configurationRegistry = ( Registry.as(Extensions.Configuration));
-        this.initRemoteUserConfigurationBarrier = ( new Barrier());
-        this.completeWorkspaceBarrier = ( new Barrier());
-        this.defaultConfiguration = this._register(( new DefaultConfiguration(configurationCache, environmentService)));
-        this.policyConfiguration = policyService instanceof NullPolicyService ? ( new NullPolicyConfiguration()) : this._register(( new PolicyConfiguration(this.defaultConfiguration, policyService, logService)));
+        this.configurationRegistry = ( (Registry.as(Extensions.Configuration)));
+        this.initRemoteUserConfigurationBarrier = ( (new Barrier()));
+        this.completeWorkspaceBarrier = ( (new Barrier()));
+        this.defaultConfiguration = this._register(( (new DefaultConfiguration(configurationCache, environmentService, logService))));
+        this.policyConfiguration = policyService instanceof NullPolicyService ? ( (new NullPolicyConfiguration())) : this._register(( (new PolicyConfiguration(this.defaultConfiguration, policyService, logService))));
         this.configurationCache = configurationCache;
-        this._configuration = ( new Configuration(
+        this._configuration = ( (new Configuration(
             this.defaultConfiguration.configurationModel,
             this.policyConfiguration.configurationModel,
-            ( new ConfigurationModel()),
-            ( new ConfigurationModel()),
-            ( new ConfigurationModel()),
-            ( new ConfigurationModel()),
-            ( new ResourceMap()),
-            ( new ConfigurationModel()),
-            ( new ResourceMap()),
-            this.workspace
-        ));
-        this.applicationConfigurationDisposables = this._register(( new DisposableStore()));
+            ConfigurationModel.createEmptyModel(logService),
+            ConfigurationModel.createEmptyModel(logService),
+            ConfigurationModel.createEmptyModel(logService),
+            ConfigurationModel.createEmptyModel(logService),
+             (new ResourceMap()),
+            ConfigurationModel.createEmptyModel(logService),
+             (new ResourceMap()),
+            this.workspace,
+            logService
+        )));
+        this.applicationConfigurationDisposables = this._register(( (new DisposableStore())));
         this.createApplicationConfiguration();
-        this.localUserConfiguration = this._register(( new UserConfiguration(
+        this.localUserConfiguration = this._register(( (new UserConfiguration(
             userDataProfileService.currentProfile.settingsResource,
             userDataProfileService.currentProfile.tasksResource,
             { scopes: getLocalUserConfigurationScopes(userDataProfileService.currentProfile, !!remoteAuthority) },
             fileService,
             uriIdentityService,
             logService
-        )));
-        this.cachedFolderConfigs = ( new ResourceMap());
+        ))));
+        this.cachedFolderConfigs = ( (new ResourceMap()));
         this._register(this.localUserConfiguration.onDidChangeConfiguration(userConfiguration => this.onLocalUserConfigurationChanged(userConfiguration)));
         if (remoteAuthority) {
-            const remoteUserConfiguration = this.remoteUserConfiguration = this._register(( new RemoteUserConfiguration(
+            const remoteUserConfiguration = this.remoteUserConfiguration = this._register(( (new RemoteUserConfiguration(
                 remoteAuthority,
                 configurationCache,
                 fileService,
                 uriIdentityService,
-                remoteAgentService
-            )));
+                remoteAgentService,
+                logService
+            ))));
             this._register(remoteUserConfiguration.onDidInitialize(remoteUserConfigurationModel => {
                 this._register(remoteUserConfiguration.onDidChangeConfiguration(remoteUserConfigurationModel => this.onRemoteUserConfigurationChanged(remoteUserConfigurationModel)));
                 this.onRemoteUserConfigurationChanged(remoteUserConfigurationModel);
@@ -121,7 +124,7 @@ class WorkspaceService extends Disposable {
         else {
             this.initRemoteUserConfigurationBarrier.open();
         }
-        this.workspaceConfiguration = this._register(( new WorkspaceConfiguration(configurationCache, fileService, uriIdentityService, logService)));
+        this.workspaceConfiguration = this._register(( (new WorkspaceConfiguration(configurationCache, fileService, uriIdentityService, logService))));
         this._register(this.workspaceConfiguration.onDidUpdateConfiguration(fromCache => {
             this.onWorkspaceConfigurationChanged(fromCache).then(() => {
                 this.workspace.initialized = this.workspaceConfiguration.initialized;
@@ -131,7 +134,7 @@ class WorkspaceService extends Disposable {
         this._register(this.defaultConfiguration.onDidChangeConfiguration(({ properties, defaults }) => this.onDefaultConfigurationChanged(defaults, properties)));
         this._register(this.policyConfiguration.onDidChangeConfiguration(configurationModel => this.onPolicyConfigurationChanged(configurationModel)));
         this._register(userDataProfileService.onDidChangeCurrentProfile(e => this.onUserDataProfileChanged(e)));
-        this.workspaceEditingQueue = ( new Queue());
+        this.workspaceEditingQueue = ( (new Queue()));
     }
     createApplicationConfiguration() {
         this.applicationConfigurationDisposables.clear();
@@ -139,7 +142,12 @@ class WorkspaceService extends Disposable {
             this.applicationConfiguration = null;
         }
         else {
-            this.applicationConfiguration = this.applicationConfigurationDisposables.add(this._register(( new ApplicationConfiguration(this.userDataProfilesService, this.fileService, this.uriIdentityService))));
+            this.applicationConfiguration = this.applicationConfigurationDisposables.add(this._register(( (new ApplicationConfiguration(
+                this.userDataProfilesService,
+                this.fileService,
+                this.uriIdentityService,
+                this.logService
+            )))));
             this.applicationConfigurationDisposables.add(this.applicationConfiguration.onDidChangeConfiguration(configurationModel => this.onApplicationConfigurationChanged(configurationModel)));
         }
     }
@@ -200,7 +208,7 @@ class WorkspaceService extends Disposable {
         }
         let foldersHaveChanged = false;
         let currentWorkspaceFolders = this.getWorkspace().folders;
-        let newStoredFolders = ( currentWorkspaceFolders.map(f => f.raw)).filter((folder, index) => {
+        let newStoredFolders = ( (currentWorkspaceFolders.map(f => f.raw))).filter((folder, index) => {
             if (!isStoredWorkspaceFolder(folder)) {
                 return true;
             }
@@ -211,7 +219,7 @@ class WorkspaceService extends Disposable {
             const workspaceConfigPath = this.getWorkspace().configuration;
             const workspaceConfigFolder = this.uriIdentityService.extUri.dirname(workspaceConfigPath);
             currentWorkspaceFolders = toWorkspaceFolders(newStoredFolders, workspaceConfigPath, this.uriIdentityService.extUri);
-            const currentWorkspaceFolderUris = ( currentWorkspaceFolders.map(folder => folder.uri));
+            const currentWorkspaceFolderUris = ( (currentWorkspaceFolders.map(folder => folder.uri)));
             const storedFoldersToAdd = [];
             for (const folderToAdd of foldersToAdd) {
                 const folderURI = folderToAdd.uri;
@@ -245,13 +253,17 @@ class WorkspaceService extends Disposable {
     }
     async setFolders(folders) {
         if (!this.instantiationService) {
-            throw new Error('Cannot update workspace folders because workspace service is not yet ready to accept writes.');
+            throw ( (new Error(
+                'Cannot update workspace folders because workspace service is not yet ready to accept writes.'
+            )));
         }
         await this.instantiationService.invokeFunction(accessor => this.workspaceConfiguration.setFolders(folders, accessor.get(IJSONEditingService)));
         return this.onWorkspaceConfigurationChanged(false);
     }
     contains(resources, toCheck) {
-        return ( resources.some(resource => this.uriIdentityService.extUri.isEqual(resource, toCheck)));
+        return (
+             (resources.some(resource => this.uriIdentityService.extUri.isEqual(resource, toCheck)))
+        );
     }
     getConfigurationData() {
         return this._configuration.toData();
@@ -272,7 +284,9 @@ class WorkspaceService extends Disposable {
         }
         if (!targets.length) {
             if (overrides?.overrideIdentifiers && overrides.overrideIdentifiers.length > 1) {
-                throw new Error('Configuration Target is required while updating the value for multiple override identifiers');
+                throw ( (new Error(
+                    'Configuration Target is required while updating the value for multiple override identifiers'
+                )));
             }
             const inspect = this.inspect(key, { resource: overrides?.resource, overrideIdentifier: overrides?.overrideIdentifiers ? overrides.overrideIdentifiers[0] : undefined });
             targets.push(...this.deriveConfigurationTargets(key, value, inspect));
@@ -280,9 +294,9 @@ class WorkspaceService extends Disposable {
                 value = undefined;
             }
         }
-        await Promises.settled(( targets.map(
+        await Promises.settled(( (targets.map(
             target => this.writeConfigurationValue(key, value, target, overrides, options)
-        )));
+        ))));
     }
     async reloadConfiguration(target) {
         if (target === undefined) {
@@ -325,7 +339,9 @@ class WorkspaceService extends Disposable {
         return this._configuration.inspect(key, overrides);
     }
     keys() {
-        return ( this._configuration.keys());
+        return (
+             (this._configuration.keys())
+        );
     }
     async whenRemoteConfigurationLoaded() {
         await this.initRemoteUserConfigurationBarrier.wait();
@@ -403,35 +419,35 @@ class WorkspaceService extends Disposable {
         const workspaceConfigPath = workspaceIdentifier.configPath;
         const workspaceFolders = toWorkspaceFolders(this.workspaceConfiguration.getFolders(), workspaceConfigPath, this.uriIdentityService.extUri);
         const workspaceId = workspaceIdentifier.id;
-        const workspace = ( new Workspace(
+        const workspace = ( (new Workspace(
             workspaceId,
             workspaceFolders,
             this.workspaceConfiguration.isTransient(),
             workspaceConfigPath,
             uri => this.uriIdentityService.extUri.ignorePathCasing(uri)
-        ));
+        )));
         workspace.initialized = this.workspaceConfiguration.initialized;
         return workspace;
     }
     createSingleFolderWorkspace(singleFolderWorkspaceIdentifier) {
-        const workspace = ( new Workspace(
+        const workspace = ( (new Workspace(
             singleFolderWorkspaceIdentifier.id,
             [toWorkspaceFolder(singleFolderWorkspaceIdentifier.uri)],
             false,
             null,
             uri => this.uriIdentityService.extUri.ignorePathCasing(uri)
-        ));
+        )));
         workspace.initialized = true;
         return workspace;
     }
     createEmptyWorkspace(emptyWorkspaceIdentifier) {
-        const workspace = ( new Workspace(
+        const workspace = ( (new Workspace(
             emptyWorkspaceIdentifier.id,
             [],
             false,
             null,
             uri => this.uriIdentityService.extUri.ignorePathCasing(uri)
-        ));
+        )));
         workspace.initialized = true;
         return Promise.resolve(workspace);
     }
@@ -477,11 +493,13 @@ class WorkspaceService extends Disposable {
     }
     compareFolders(currentFolders, newFolders) {
         const result = { added: [], removed: [], changed: [] };
-        result.added = newFolders.filter(newFolder => !( currentFolders.some(currentFolder => ( newFolder.uri.toString()) === ( currentFolder.uri.toString()))));
+        result.added = newFolders.filter(newFolder => !( (currentFolders.some(
+            currentFolder => ( (newFolder.uri.toString())) === ( (currentFolder.uri.toString()))
+        ))));
         for (let currentIndex = 0; currentIndex < currentFolders.length; currentIndex++) {
             const currentFolder = currentFolders[currentIndex];
             let newIndex = 0;
-            for (newIndex = 0; newIndex < newFolders.length && ( currentFolder.uri.toString()) !== ( newFolders[newIndex].uri.toString()); newIndex++) { }
+            for (newIndex = 0; newIndex < newFolders.length && ( (currentFolder.uri.toString())) !== ( (newFolders[newIndex].uri.toString())); newIndex++) { }
             if (newIndex < newFolders.length) {
                 if (currentIndex !== newIndex || currentFolder.name !== newFolders[newIndex].name) {
                     result.changed.push(currentFolder);
@@ -496,10 +514,10 @@ class WorkspaceService extends Disposable {
     async initializeConfiguration(trigger) {
         await this.defaultConfiguration.initialize();
         const initPolicyConfigurationPromise = this.policyConfiguration.initialize();
-        const initApplicationConfigurationPromise = this.applicationConfiguration ? this.applicationConfiguration.initialize() : Promise.resolve(( new ConfigurationModel()));
+        const initApplicationConfigurationPromise = this.applicationConfiguration ? this.applicationConfiguration.initialize() : Promise.resolve(ConfigurationModel.createEmptyModel(this.logService));
         const initUserConfiguration = async () => {
             mark('code/willInitUserConfiguration');
-            const result = await Promise.all([this.localUserConfiguration.initialize(), this.remoteUserConfiguration ? this.remoteUserConfiguration.initialize() : Promise.resolve(( new ConfigurationModel()))]);
+            const result = await Promise.all([this.localUserConfiguration.initialize(), this.remoteUserConfiguration ? this.remoteUserConfiguration.initialize() : Promise.resolve(ConfigurationModel.createEmptyModel(this.logService))]);
             if (this.applicationConfiguration) {
                 const applicationConfigurationModel = await initApplicationConfigurationPromise;
                 result[0] = this.localUserConfiguration.reparse({ exclude: applicationConfigurationModel.getValue(APPLY_ALL_PROFILES_SETTING) });
@@ -521,7 +539,7 @@ class WorkspaceService extends Disposable {
     }
     async reloadApplicationConfiguration(donotTrigger) {
         if (!this.applicationConfiguration) {
-            return ( new ConfigurationModel());
+            return ConfigurationModel.createEmptyModel(this.logService);
         }
         const model = await this.applicationConfiguration.loadConfiguration();
         if (!donotTrigger) {
@@ -548,7 +566,7 @@ class WorkspaceService extends Disposable {
             }
             return model;
         }
-        return ( new ConfigurationModel());
+        return ConfigurationModel.createEmptyModel(this.logService);
     }
     async reloadWorkspaceConfiguration() {
         const workbenchState = this.getWorkbenchState();
@@ -563,14 +581,14 @@ class WorkspaceService extends Disposable {
         return this.onWorkspaceFolderConfigurationChanged(folder);
     }
     async loadConfiguration(applicationConfigurationModel, userConfigurationModel, remoteUserConfigurationModel, trigger) {
-        this.cachedFolderConfigs = ( new ResourceMap());
+        this.cachedFolderConfigs = ( (new ResourceMap()));
         const folders = this.workspace.folders;
         const folderConfigurations = await this.loadFolderConfigurations(folders);
         const workspaceConfiguration = this.getWorkspaceConfigurationModel(folderConfigurations);
-        const folderConfigurationModels = ( new ResourceMap());
+        const folderConfigurationModels = ( (new ResourceMap()));
         folderConfigurations.forEach((folderConfiguration, index) => folderConfigurationModels.set(folders[index].uri, folderConfiguration));
         const currentConfiguration = this._configuration;
-        this._configuration = ( new Configuration(
+        this._configuration = ( (new Configuration(
             this.defaultConfiguration.configurationModel,
             this.policyConfiguration.configurationModel,
             applicationConfigurationModel,
@@ -578,10 +596,11 @@ class WorkspaceService extends Disposable {
             remoteUserConfigurationModel,
             workspaceConfiguration,
             folderConfigurationModels,
-            ( new ConfigurationModel()),
-            ( new ResourceMap()),
-            this.workspace
-        ));
+            ConfigurationModel.createEmptyModel(this.logService),
+             (new ResourceMap()),
+            this.workspace,
+            this.logService
+        )));
         this.initialized = true;
         if (trigger) {
             const change = this._configuration.compare(currentConfiguration);
@@ -596,7 +615,7 @@ class WorkspaceService extends Disposable {
             case 3 :
                 return this.workspaceConfiguration.getConfiguration();
             default:
-                return ( new ConfigurationModel());
+                return ConfigurationModel.createEmptyModel(this.logService);
         }
     }
     onUserDataProfileChanged(e) {
@@ -715,7 +734,7 @@ class WorkspaceService extends Disposable {
     updateRestrictedSettings() {
         const changed = [];
         const allProperties = this.configurationRegistry.getConfigurationProperties();
-        const defaultRestrictedSettings = ( Object.keys(allProperties)).filter(key => allProperties[key].restricted).sort((a, b) => a.localeCompare(b));
+        const defaultRestrictedSettings = ( (Object.keys(allProperties))).filter(key => allProperties[key].restricted).sort((a, b) => a.localeCompare(b));
         const defaultDelta = delta(defaultRestrictedSettings, this._restrictedSettings.default, (a, b) => a.localeCompare(b));
         changed.push(...defaultDelta.added, ...defaultDelta.removed);
         const application = (this.applicationConfiguration?.getRestrictedSettings() || []).sort((a, b) => a.localeCompare(b));
@@ -727,7 +746,7 @@ class WorkspaceService extends Disposable {
         const userRemote = (this.remoteUserConfiguration?.getRestrictedSettings() || []).sort((a, b) => a.localeCompare(b));
         const userRemoteDelta = delta(userRemote, this._restrictedSettings.userRemote || [], (a, b) => a.localeCompare(b));
         changed.push(...userRemoteDelta.added, ...userRemoteDelta.removed);
-        const workspaceFolderMap = ( new ResourceMap());
+        const workspaceFolderMap = ( (new ResourceMap()));
         for (const workspaceFolder of this.workspace.folders) {
             const cachedFolderConfig = this.cachedFolderConfigs.get(workspaceFolder.uri);
             const folderRestrictedSettings = (cachedFolderConfig?.getRestrictedSettings() || []).sort((a, b) => a.localeCompare(b));
@@ -799,15 +818,15 @@ class WorkspaceService extends Disposable {
     }
     async onFoldersChanged() {
         const changes = [];
-        for (const key of ( this.cachedFolderConfigs.keys())) {
-            if (!this.workspace.folders.filter(folder => ( folder.uri.toString()) === ( key.toString()))[0]) {
+        for (const key of ( (this.cachedFolderConfigs.keys()))) {
+            if (!this.workspace.folders.filter(folder => ( (folder.uri.toString())) === ( (key.toString())))[0]) {
                 const folderConfiguration = this.cachedFolderConfigs.get(key);
                 folderConfiguration.dispose();
                 this.cachedFolderConfigs.delete(key);
                 changes.push(this._configuration.compareAndDeleteFolderConfiguration(key));
             }
         }
-        const toInitialize = this.workspace.folders.filter(folder => !( this.cachedFolderConfigs.has(folder.uri)));
+        const toInitialize = this.workspace.folders.filter(folder => !( (this.cachedFolderConfigs.has(folder.uri))));
         if (toInitialize.length) {
             const folderConfigurations = await this.loadFolderConfigurations(toInitialize);
             folderConfigurations.forEach((folderConfiguration, index) => {
@@ -817,10 +836,10 @@ class WorkspaceService extends Disposable {
         return mergeChanges(...changes);
     }
     loadFolderConfigurations(folders) {
-        return Promise.all([...( folders.map(folder => {
+        return Promise.all([...( (folders.map(folder => {
                 let folderConfiguration = this.cachedFolderConfigs.get(folder.uri);
                 if (!folderConfiguration) {
-                    folderConfiguration = ( new FolderConfiguration(
+                    folderConfiguration = ( (new FolderConfiguration(
                         !this.initialized,
                         folder,
                         FOLDER_CONFIG_FOLDER_NAME,
@@ -830,12 +849,12 @@ class WorkspaceService extends Disposable {
                         this.uriIdentityService,
                         this.logService,
                         this.configurationCache
-                    ));
+                    )));
                     this._register(folderConfiguration.onDidChange(() => this.onWorkspaceFolderConfigurationChanged(folder)));
                     this.cachedFolderConfigs.set(folder.uri, this._register(folderConfiguration));
                 }
                 return folderConfiguration.loadConfiguration();
-            }))]);
+            })))]);
     }
     async validateWorkspaceFoldersAndReload(fromCache) {
         const validWorkspaceFolders = await this.toValidWorkspaceFolders(this.workspace.folders);
@@ -854,7 +873,7 @@ class WorkspaceService extends Disposable {
                 }
             }
             catch (e) {
-                this.logService.warn(`Ignoring the error while validating workspace folder ${( workspaceFolder.uri.toString())} - ${toErrorMessage(e)}`);
+                this.logService.warn(`Ignoring the error while validating workspace folder ${( (workspaceFolder.uri.toString()))} - ${toErrorMessage(e)}`);
             }
             validWorkspaceFolders.push(workspaceFolder);
         }
@@ -862,23 +881,25 @@ class WorkspaceService extends Disposable {
     }
     async writeConfigurationValue(key, value, target, overrides, options) {
         if (!this.instantiationService) {
-            throw new Error('Cannot write configuration because the configuration service is not yet ready to accept writes.');
+            throw ( (new Error(
+                'Cannot write configuration because the configuration service is not yet ready to accept writes.'
+            )));
         }
         if (target === 7 ) {
-            throw new Error('Invalid configuration target');
+            throw ( (new Error('Invalid configuration target')));
         }
         if (target === 8 ) {
             const previous = { data: this._configuration.toData(), workspace: this.workspace };
             this._configuration.updateValue(key, value, overrides);
-            this.triggerConfigurationChange({ keys: overrides?.overrideIdentifiers?.length ? [keyFromOverrideIdentifiers(overrides.overrideIdentifiers), key] : [key], overrides: overrides?.overrideIdentifiers?.length ? ( overrides.overrideIdentifiers.map(overrideIdentifier => ([overrideIdentifier, [key]]))) : [] }, previous, target);
+            this.triggerConfigurationChange({ keys: overrides?.overrideIdentifiers?.length ? [keyFromOverrideIdentifiers(overrides.overrideIdentifiers), key] : [key], overrides: overrides?.overrideIdentifiers?.length ? ( (overrides.overrideIdentifiers.map(overrideIdentifier => ([overrideIdentifier, [key]])))) : [] }, previous, target);
             return;
         }
         const editableConfigurationTarget = this.toEditableConfigurationTarget(target, key);
         if (!editableConfigurationTarget) {
-            throw new Error('Invalid configuration target');
+            throw ( (new Error('Invalid configuration target')));
         }
         if (editableConfigurationTarget === 2  && !this.remoteUserConfiguration) {
-            throw new Error('Invalid configuration target');
+            throw ( (new Error('Invalid configuration target')));
         }
         if (overrides?.overrideIdentifiers?.length && overrides.overrideIdentifiers.length > 1) {
             const configurationModel = this.getConfigurationModelForEditableConfigurationTarget(editableConfigurationTarget, overrides.resource);
@@ -961,7 +982,7 @@ class WorkspaceService extends Disposable {
             if (target !== 7 ) {
                 this.logService.debug(`Configuration keys changed in ${ConfigurationTargetToString(target)} target`, ...change.keys);
             }
-            const configurationChangeEvent = ( new ConfigurationChangeEvent(change, previous, this._configuration, this.workspace));
+            const configurationChangeEvent = ( (new ConfigurationChangeEvent(change, previous, this._configuration, this.workspace, this.logService)));
             configurationChangeEvent.source = target;
             this._onDidChangeConfiguration.fire(configurationChangeEvent);
         }
@@ -1002,8 +1023,8 @@ let RegisterConfigurationSchemasContribution = class RegisterConfigurationSchema
         this.workspaceTrustManagementService = workspaceTrustManagementService;
         extensionService.whenInstalledExtensionsRegistered().then(() => {
             this.registerConfigurationSchemas();
-            const configurationRegistry = ( Registry.as(Extensions.Configuration));
-            const delayer = this._register(( new Delayer(50)));
+            const configurationRegistry = ( (Registry.as(Extensions.Configuration)));
+            const delayer = this._register(( (new Delayer(50))));
             this._register(Event.any(configurationRegistry.onDidUpdateConfiguration, configurationRegistry.onDidSchemaChange, workspaceTrustManagementService.onDidChangeTrust)(() => delayer.trigger(() => this.registerConfigurationSchemas(), lifecycleService.phase === 4  ? undefined : 2500 )));
         });
     }
@@ -1046,11 +1067,11 @@ let RegisterConfigurationSchemasContribution = class RegisterConfigurationSchema
             allowComments: true
         };
         const defaultSettingsSchema = {
-            properties: ( Object.keys(allSettings.properties)).reduce((result, key) => {
+            properties: ( (Object.keys(allSettings.properties))).reduce((result, key) => {
                 result[key] = Object.assign({ deprecationMessage: undefined }, allSettings.properties[key]);
                 return result;
             }, {}),
-            patternProperties: ( Object.keys(allSettings.patternProperties)).reduce((result, key) => {
+            patternProperties: ( (Object.keys(allSettings.patternProperties))).reduce((result, key) => {
                 result[key] = Object.assign({ deprecationMessage: undefined }, allSettings.patternProperties[key]);
                 return result;
             }, {}),
@@ -1068,11 +1089,7 @@ let RegisterConfigurationSchemasContribution = class RegisterConfigurationSchema
             } : workspaceSettingsSchema;
         const configDefaultsSchema = {
             type: 'object',
-            description: ( localizeWithPath(
-                'vs/workbench/services/configuration/browser/configurationService',
-                'configurationDefaults.description',
-                'Contribute defaults for configurations'
-            )),
+            description: ( localizeWithPath(_moduleId, 0, 'Contribute defaults for configurations')),
             properties: Object.assign({}, machineOverridableSettings.properties, windowSettings.properties, resourceSettings.properties),
             patternProperties: {
                 [OVERRIDE_PROPERTY_PATTERN]: {
@@ -1094,7 +1111,7 @@ let RegisterConfigurationSchemasContribution = class RegisterConfigurationSchema
         });
     }
     registerSchemas(schemas) {
-        const jsonRegistry = ( Registry.as(Extensions$1.JSONContribution));
+        const jsonRegistry = ( (Registry.as(Extensions$1.JSONContribution)));
         jsonRegistry.registerSchema(defaultSettingsSchemaId, schemas.defaultSettingsSchema);
         jsonRegistry.registerSchema(userSettingsSchemaId, schemas.userSettingsSchema);
         jsonRegistry.registerSchema(profileSettingsSchemaId, schemas.profileSettingsSchema);
@@ -1116,13 +1133,13 @@ let RegisterConfigurationSchemasContribution = class RegisterConfigurationSchema
         return result;
     }
 };
-RegisterConfigurationSchemasContribution = ( __decorate([
-    ( __param(0, IWorkspaceContextService)),
-    ( __param(1, IWorkbenchEnvironmentService)),
-    ( __param(2, IWorkspaceTrustManagementService)),
-    ( __param(3, IExtensionService)),
-    ( __param(4, ILifecycleService))
-], RegisterConfigurationSchemasContribution));
+RegisterConfigurationSchemasContribution = ( (__decorate([
+    ( (__param(0, IWorkspaceContextService))),
+    ( (__param(1, IWorkbenchEnvironmentService))),
+    ( (__param(2, IWorkspaceTrustManagementService))),
+    ( (__param(3, IExtensionService))),
+    ( (__param(4, ILifecycleService)))
+], RegisterConfigurationSchemasContribution)));
 let ResetConfigurationDefaultsOverridesCache = class ResetConfigurationDefaultsOverridesCache extends Disposable {
     constructor(configurationService, extensionService) {
         super();
@@ -1131,18 +1148,18 @@ let ResetConfigurationDefaultsOverridesCache = class ResetConfigurationDefaultsO
         }
     }
 };
-ResetConfigurationDefaultsOverridesCache = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, IExtensionService))
-], ResetConfigurationDefaultsOverridesCache));
+ResetConfigurationDefaultsOverridesCache = ( (__decorate([
+    ( (__param(0, IConfigurationService))),
+    ( (__param(1, IExtensionService)))
+], ResetConfigurationDefaultsOverridesCache)));
 let UpdateExperimentalSettingsDefaults = class UpdateExperimentalSettingsDefaults extends Disposable {
     static { this.ID = 'workbench.contrib.updateExperimentalSettingsDefaults'; }
     constructor(workbenchAssignmentService) {
         super();
         this.workbenchAssignmentService = workbenchAssignmentService;
-        this.processedExperimentalSettings = ( new Set());
-        this.configurationRegistry = ( Registry.as(Extensions.Configuration));
-        this.processExperimentalSettings(( Object.keys(this.configurationRegistry.getConfigurationProperties())));
+        this.processedExperimentalSettings = ( (new Set()));
+        this.configurationRegistry = ( (Registry.as(Extensions.Configuration)));
+        this.processExperimentalSettings(( (Object.keys(this.configurationRegistry.getConfigurationProperties()))));
         this._register(this.configurationRegistry.onDidUpdateConfiguration(({ properties }) => this.processExperimentalSettings(properties)));
     }
     async processExperimentalSettings(properties) {
@@ -1153,7 +1170,7 @@ let UpdateExperimentalSettingsDefaults = class UpdateExperimentalSettingsDefault
             if (!schema?.tags?.includes('experimental')) {
                 continue;
             }
-            if (( this.processedExperimentalSettings.has(property))) {
+            if (( (this.processedExperimentalSettings.has(property)))) {
                 continue;
             }
             this.processedExperimentalSettings.add(property);
@@ -1165,33 +1182,25 @@ let UpdateExperimentalSettingsDefaults = class UpdateExperimentalSettingsDefault
             }
             catch (error) {  }
         }
-        if (( Object.keys(overrides)).length) {
-            this.configurationRegistry.registerDefaultConfigurations([{ overrides, source: ( localizeWithPath(
-                'vs/workbench/services/configuration/browser/configurationService',
-                'experimental',
-                "Experiments"
-            )) }]);
+        if (( (Object.keys(overrides))).length) {
+            this.configurationRegistry.registerDefaultConfigurations([{ overrides, source: ( localizeWithPath(_moduleId, 1, "Experiments")) }]);
         }
     }
 };
-UpdateExperimentalSettingsDefaults = ( __decorate([
-    ( __param(0, IWorkbenchAssignmentService))
-], UpdateExperimentalSettingsDefaults));
-const workbenchContributionsRegistry = ( Registry.as(Extensions$2.Workbench));
+UpdateExperimentalSettingsDefaults = ( (__decorate([
+    ( (__param(0, IWorkbenchAssignmentService)))
+], UpdateExperimentalSettingsDefaults)));
+const workbenchContributionsRegistry = ( (Registry.as(Extensions$2.Workbench)));
 workbenchContributionsRegistry.registerWorkbenchContribution(RegisterConfigurationSchemasContribution, 3 );
 workbenchContributionsRegistry.registerWorkbenchContribution(ResetConfigurationDefaultsOverridesCache, 4 );
 registerWorkbenchContribution2(UpdateExperimentalSettingsDefaults.ID, UpdateExperimentalSettingsDefaults, 2 );
-const configurationRegistry = ( Registry.as(Extensions.Configuration));
+const configurationRegistry = ( (Registry.as(Extensions.Configuration)));
 configurationRegistry.registerConfiguration({
     ...workbenchConfigurationNodeBase,
     properties: {
         [APPLY_ALL_PROFILES_SETTING]: {
             'type': 'array',
-            description: ( localizeWithPath(
-                'vs/workbench/services/configuration/browser/configurationService',
-                'setting description',
-                "Configure settings to be applied for all profiles."
-            )),
+            description: ( localizeWithPath(_moduleId, 2, "Configure settings to be applied for all profiles.")),
             'default': [],
             'scope': 1 ,
             additionalProperties: true,