@codingame/monaco-vscode-configuration-service-override 11.1.2 → 12.0.0

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

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
 import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
@@ -6,22 +7,23 @@ import { equals } from 'vscode/vscode/vs/base/common/objects';
 import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
 import { Barrier, Queue, Promises, Delayer } from 'vscode/vscode/vs/base/common/async';
 import { Extensions as Extensions$1 } from 'vscode/vscode/vs/platform/jsonschemas/common/jsonContributionRegistry';
-import { Workspace as Workspace$1, isWorkspaceIdentifier, isSingleFolderWorkspaceIdentifier, isWorkspaceFolder, toWorkspaceFolder } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { Workspace as Workspace$1, WorkbenchState, isWorkspaceIdentifier, isSingleFolderWorkspaceIdentifier, isWorkspaceFolder, toWorkspaceFolder } from 'vscode/vscode/vs/platform/workspace/common/workspace';
 import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
 import { ConfigurationModel, mergeChanges, ConfigurationChangeEvent } from 'vscode/vscode/vs/platform/configuration/common/configurationModels';
-import { isConfigurationOverrides, isConfigurationUpdateOverrides, ConfigurationTargetToString } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { isConfigurationOverrides, isConfigurationUpdateOverrides, ConfigurationTarget, ConfigurationTargetToString } from 'vscode/vscode/vs/platform/configuration/common/configuration';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
 import { NullPolicyConfiguration, PolicyConfiguration } from 'vscode/vscode/vs/platform/configuration/common/configurations';
 import { Configuration } from '../common/configurationModels.js';
-import { LOCAL_MACHINE_SCOPES, LOCAL_MACHINE_PROFILE_SCOPES, PROFILE_SCOPES, APPLY_ALL_PROFILES_SETTING, FOLDER_CONFIG_FOLDER_NAME, defaultSettingsSchemaId, userSettingsSchemaId, profileSettingsSchemaId, machineSettingsSchemaId, workspaceSettingsSchemaId, folderSettingsSchemaId } from 'vscode/vscode/vs/workbench/services/configuration/common/configuration';
+import { LOCAL_MACHINE_SCOPES, LOCAL_MACHINE_PROFILE_SCOPES, PROFILE_SCOPES, APPLY_ALL_PROFILES_SETTING, FOLDER_CONFIG_FOLDER_NAME, defaultSettingsSchemaId, userSettingsSchemaId, profileSettingsSchemaId, machineSettingsSchemaId, workspaceSettingsSchemaId, folderSettingsSchemaId } from '@codingame/monaco-vscode-37e80bf5-92f5-5e4c-8b6d-98e0bb89dbef-common/vscode/vs/workbench/services/configuration/common/configuration';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { Extensions, keyFromOverrideIdentifiers, allSettings, applicationSettings, windowSettings, resourceSettings, machineSettings, machineOverridableSettings, OVERRIDE_PROPERTY_PATTERN, resourceLanguageSettingsSchemaId, configurationDefaultsSchemaId } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
-import { isStoredWorkspaceFolder, toWorkspaceFolders, getStoredWorkspaceFolder } from 'vscode/vscode/vs/platform/workspaces/common/workspaces';
-import { ConfigurationEditing } from '../common/configurationEditing.js';
+import { Extensions, ConfigurationScope, keyFromOverrideIdentifiers, allSettings, applicationSettings, windowSettings, resourceSettings, machineSettings, machineOverridableSettings, OVERRIDE_PROPERTY_PATTERN, resourceLanguageSettingsSchemaId, configurationDefaultsSchemaId } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+import { isStoredWorkspaceFolder, toWorkspaceFolders, getStoredWorkspaceFolder } from '@codingame/monaco-vscode-56402b83-4a60-5b15-86f9-71fe99c32744-common/vscode/vs/platform/workspaces/common/workspaces';
+import { EditableConfigurationTarget, ConfigurationEditing } from '../common/configurationEditing.js';
 import { DefaultConfiguration, UserConfiguration, RemoteUserConfiguration, WorkspaceConfiguration, ApplicationConfiguration, FolderConfiguration } from './configuration.js';
 import { mark } from 'vscode/vscode/vs/base/common/performance';
 import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
-import { Extensions as Extensions$2, registerWorkbenchContribution2 } from 'vscode/vscode/vs/workbench/common/contributions';
+import { Extensions as Extensions$2, registerWorkbenchContribution2, WorkbenchPhase } from 'vscode/vscode/vs/workbench/common/contributions';
+import { LifecyclePhase } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
 import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
 import { toErrorMessage } from 'vscode/vscode/vs/base/common/errorMessage';
 import { IWorkspaceTrustManagementService } from 'vscode/vscode/vs/platform/workspace/common/workspaceTrust.service';
@@ -60,60 +62,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, logService))));
-        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,
             ConfigurationModel.createEmptyModel(logService),
             ConfigurationModel.createEmptyModel(logService),
             ConfigurationModel.createEmptyModel(logService),
             ConfigurationModel.createEmptyModel(logService),
-             (new ResourceMap()),
+            ( new ResourceMap()),
             ConfigurationModel.createEmptyModel(logService),
-             (new ResourceMap()),
+            ( new ResourceMap()),
             this.workspace,
             logService
-        )));
-        this.applicationConfigurationDisposables = this._register(( (new DisposableStore())));
+        ));
+        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,
                 logService
-            ))));
+            )));
             this._register(remoteUserConfiguration.onDidInitialize(remoteUserConfigurationModel => {
                 this._register(remoteUserConfiguration.onDidChangeConfiguration(remoteUserConfigurationModel => this.onRemoteUserConfigurationChanged(remoteUserConfigurationModel)));
                 this.onRemoteUserConfigurationChanged(remoteUserConfigurationModel);
@@ -123,7 +125,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;
@@ -133,7 +135,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();
@@ -141,12 +143,12 @@ class WorkspaceService extends Disposable {
             this.applicationConfiguration = null;
         }
         else {
-            this.applicationConfiguration = this.applicationConfigurationDisposables.add(this._register(( (new ApplicationConfiguration(
+            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)));
         }
     }
@@ -159,12 +161,12 @@ class WorkspaceService extends Disposable {
     }
     getWorkbenchState() {
         if (this.workspace.configuration) {
-            return 3 ;
+            return WorkbenchState.WORKSPACE;
         }
         if (this.workspace.folders.length === 1) {
-            return 2 ;
+            return WorkbenchState.FOLDER;
         }
-        return 1 ;
+        return WorkbenchState.EMPTY;
     }
     getWorkspaceFolder(resource) {
         return this.workspace.getFolder(resource);
@@ -183,7 +185,7 @@ class WorkspaceService extends Disposable {
     }
     isCurrentWorkspace(workspaceIdOrFolder) {
         switch (this.getWorkbenchState()) {
-            case 2 : {
+            case WorkbenchState.FOLDER: {
                 let folderUri = undefined;
                 if (URI.isUri(workspaceIdOrFolder)) {
                     folderUri = workspaceIdOrFolder;
@@ -193,13 +195,13 @@ class WorkspaceService extends Disposable {
                 }
                 return URI.isUri(folderUri) && this.uriIdentityService.extUri.isEqual(folderUri, this.workspace.folders[0].uri);
             }
-            case 3 :
+            case WorkbenchState.WORKSPACE:
                 return isWorkspaceIdentifier(workspaceIdOrFolder) && this.workspace.id === workspaceIdOrFolder.id;
         }
         return false;
     }
     async doUpdateFolders(foldersToAdd, foldersToRemove, index) {
-        if (this.getWorkbenchState() !== 3 ) {
+        if (this.getWorkbenchState() !== WorkbenchState.WORKSPACE) {
             return Promise.resolve(undefined);
         }
         if (foldersToAdd.length + foldersToRemove.length === 0) {
@@ -207,7 +209,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;
             }
@@ -218,7 +220,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;
@@ -252,17 +254,15 @@ class WorkspaceService extends Disposable {
     }
     async setFolders(folders) {
         if (!this.instantiationService) {
-            throw ( (new Error(
+            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();
@@ -283,19 +283,19 @@ class WorkspaceService extends Disposable {
         }
         if (!targets.length) {
             if (overrides?.overrideIdentifiers && overrides.overrideIdentifiers.length > 1) {
-                throw ( (new Error(
+                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));
-            if (equals(value, inspect.defaultValue) && targets.length === 1 && ((targets[0] === 2  || targets[0] === 3) )) {
+            if (equals(value, inspect.defaultValue) && targets.length === 1 && (targets[0] === ConfigurationTarget.USER || targets[0] === ConfigurationTarget.USER_LOCAL)) {
                 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) {
@@ -311,22 +311,22 @@ class WorkspaceService extends Disposable {
             return;
         }
         switch (target) {
-            case 7 :
+            case ConfigurationTarget.DEFAULT:
                 this.reloadDefaultConfiguration();
                 return;
-            case 2 : {
+            case ConfigurationTarget.USER: {
                 const { local, remote } = await this.reloadUserConfiguration();
                 await this.loadConfiguration(this._configuration.applicationConfiguration, local, remote, true);
                 return;
             }
-            case 3 :
+            case ConfigurationTarget.USER_LOCAL:
                 await this.reloadLocalUserConfiguration();
                 return;
-            case 4 :
+            case ConfigurationTarget.USER_REMOTE:
                 await this.reloadRemoteUserConfiguration();
                 return;
-            case 5 :
-            case 6 :
+            case ConfigurationTarget.WORKSPACE:
+            case ConfigurationTarget.WORKSPACE_FOLDER:
                 await this.reloadWorkspaceConfiguration();
                 return;
         }
@@ -338,9 +338,7 @@ 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();
@@ -368,7 +366,7 @@ class WorkspaceService extends Disposable {
                 }
                 folderConfigurationModels.push(configurationModel);
             }
-            if (this.getWorkbenchState() === 2 ) {
+            if (this.getWorkbenchState() === WorkbenchState.FOLDER) {
                 if (folderConfigurationModels[0]) {
                     this._configuration.updateWorkspaceConfiguration(folderConfigurationModels[0]);
                 }
@@ -390,7 +388,7 @@ class WorkspaceService extends Disposable {
             this.restrictedSettings.workspaceFolder?.forEach((value) => keys.push(...value));
             keys = distinct(keys);
             if (keys.length) {
-                this.triggerConfigurationChange({ keys, overrides: [] }, { data, workspace: this.workspace }, 5 );
+                this.triggerConfigurationChange({ keys, overrides: [] }, { data, workspace: this.workspace }, ConfigurationTarget.WORKSPACE);
             }
         }
     }
@@ -398,7 +396,7 @@ class WorkspaceService extends Disposable {
         this.instantiationService = instantiationService;
     }
     isSettingAppliedForAllProfiles(key) {
-        if (this.configurationRegistry.getConfigurationProperties()[key]?.scope === 1 ) {
+        if (this.configurationRegistry.getConfigurationProperties()[key]?.scope === ConfigurationScope.APPLICATION) {
             return true;
         }
         const allProfilesSettings = this.getValue(APPLY_ALL_PROFILES_SETTING) ?? [];
@@ -418,35 +416,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);
     }
@@ -492,13 +490,11 @@ 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);
@@ -569,10 +565,10 @@ class WorkspaceService extends Disposable {
     }
     async reloadWorkspaceConfiguration() {
         const workbenchState = this.getWorkbenchState();
-        if (workbenchState === 2 ) {
+        if (workbenchState === WorkbenchState.FOLDER) {
             return this.onWorkspaceFolderConfigurationChanged(this.workspace.folders[0]);
         }
-        if (workbenchState === 3 ) {
+        if (workbenchState === WorkbenchState.WORKSPACE) {
             return this.workspaceConfiguration.reload().then(() => this.onWorkspaceConfigurationChanged(false));
         }
     }
@@ -580,14 +576,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,
@@ -596,22 +592,22 @@ class WorkspaceService extends Disposable {
             workspaceConfiguration,
             folderConfigurationModels,
             ConfigurationModel.createEmptyModel(this.logService),
-             (new ResourceMap()),
+            ( new ResourceMap()),
             this.workspace,
             this.logService
-        )));
+        ));
         this.initialized = true;
         if (trigger) {
             const change = this._configuration.compare(currentConfiguration);
-            this.triggerConfigurationChange(change, { data: currentConfiguration.toData(), workspace: this.workspace }, 5 );
+            this.triggerConfigurationChange(change, { data: currentConfiguration.toData(), workspace: this.workspace }, ConfigurationTarget.WORKSPACE);
         }
         this.updateRestrictedSettings();
     }
     getWorkspaceConfigurationModel(folderConfigurations) {
         switch (this.getWorkbenchState()) {
-            case 2 :
+            case WorkbenchState.FOLDER:
                 return folderConfigurations[0];
-            case 3 :
+            case WorkbenchState.WORKSPACE:
                 return this.workspaceConfiguration.getConfiguration();
             default:
                 return ConfigurationModel.createEmptyModel(this.logService);
@@ -647,7 +643,7 @@ class WorkspaceService extends Disposable {
                 this._configuration.updateLocalUserConfiguration(this.localUserConfiguration.reparse());
                 this._configuration.updateRemoteUserConfiguration(this.remoteUserConfiguration.reparse());
             }
-            if (this.getWorkbenchState() === 2 ) {
+            if (this.getWorkbenchState() === WorkbenchState.FOLDER) {
                 const folderConfiguration = this.cachedFolderConfigs.get(this.workspace.folders[0].uri);
                 if (folderConfiguration) {
                     this._configuration.updateWorkspaceConfiguration(folderConfiguration.reparse());
@@ -663,14 +659,14 @@ class WorkspaceService extends Disposable {
                     }
                 }
             }
-            this.triggerConfigurationChange(change, { data: previousData, workspace: this.workspace }, 7 );
+            this.triggerConfigurationChange(change, { data: previousData, workspace: this.workspace }, ConfigurationTarget.DEFAULT);
             this.updateRestrictedSettings();
         }
     }
     onPolicyConfigurationChanged(policyConfiguration) {
         const previous = { data: this._configuration.toData(), workspace: this.workspace };
         const change = this._configuration.compareAndUpdatePolicyConfiguration(policyConfiguration);
-        this.triggerConfigurationChange(change, previous, 7 );
+        this.triggerConfigurationChange(change, previous, ConfigurationTarget.DEFAULT);
     }
     onApplicationConfigurationChanged(applicationConfiguration) {
         const previous = { data: this._configuration.toData(), workspace: this.workspace };
@@ -680,7 +676,7 @@ class WorkspaceService extends Disposable {
         const configurationProperties = this.configurationRegistry.getConfigurationProperties();
         const changedKeys = [];
         for (const changedKey of change.keys) {
-            if (configurationProperties[changedKey]?.scope === 1 ) {
+            if (configurationProperties[changedKey]?.scope === ConfigurationScope.APPLICATION) {
                 changedKeys.push(changedKey);
                 if (changedKey === APPLY_ALL_PROFILES_SETTING) {
                     for (const previousAllProfileSetting of previousAllProfilesSettings) {
@@ -703,17 +699,17 @@ class WorkspaceService extends Disposable {
         if (change.keys.includes(APPLY_ALL_PROFILES_SETTING)) {
             this._configuration.updateLocalUserConfiguration(this.localUserConfiguration.reparse({ exclude: currentAllProfilesSettings }));
         }
-        this.triggerConfigurationChange(change, previous, 2 );
+        this.triggerConfigurationChange(change, previous, ConfigurationTarget.USER);
     }
     onLocalUserConfigurationChanged(userConfiguration) {
         const previous = { data: this._configuration.toData(), workspace: this.workspace };
         const change = this._configuration.compareAndUpdateLocalUserConfiguration(userConfiguration);
-        this.triggerConfigurationChange(change, previous, 2 );
+        this.triggerConfigurationChange(change, previous, ConfigurationTarget.USER);
     }
     onRemoteUserConfigurationChanged(userConfiguration) {
         const previous = { data: this._configuration.toData(), workspace: this.workspace };
         const change = this._configuration.compareAndUpdateRemoteUserConfiguration(userConfiguration);
-        this.triggerConfigurationChange(change, previous, 2 );
+        this.triggerConfigurationChange(change, previous, ConfigurationTarget.USER);
     }
     async onWorkspaceConfigurationChanged(fromCache) {
         if (this.workspace && this.workspace.configuration) {
@@ -733,7 +729,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));
@@ -745,7 +741,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));
@@ -756,7 +752,7 @@ class WorkspaceService extends Disposable {
             const workspaceFolderDelta = delta(folderRestrictedSettings, previous, (a, b) => a.localeCompare(b));
             changed.push(...workspaceFolderDelta.added, ...workspaceFolderDelta.removed);
         }
-        const workspace = this.getWorkbenchState() === 3  ? this.workspaceConfiguration.getRestrictedSettings().sort((a, b) => a.localeCompare(b))
+        const workspace = this.getWorkbenchState() === WorkbenchState.WORKSPACE ? this.workspaceConfiguration.getRestrictedSettings().sort((a, b) => a.localeCompare(b))
             : this.workspace.folders[0] ? (workspaceFolderMap.get(this.workspace.folders[0].uri) || []) : [];
         const workspaceDelta = delta(workspace, this._restrictedSettings.workspace || [], (a, b) => a.localeCompare(b));
         changed.push(...workspaceDelta.added, ...workspaceDelta.removed);
@@ -780,11 +776,11 @@ class WorkspaceService extends Disposable {
             this.workspace.folders = workspaceFolders;
             const change = await this.onFoldersChanged();
             await this.handleWillChangeWorkspaceFolders(changes, fromCache);
-            this.triggerConfigurationChange(change, previous, 6 );
+            this.triggerConfigurationChange(change, previous, ConfigurationTarget.WORKSPACE_FOLDER);
             this._onDidChangeWorkspaceFolders.fire(changes);
         }
         else {
-            this.triggerConfigurationChange(change, previous, 5 );
+            this.triggerConfigurationChange(change, previous, ConfigurationTarget.WORKSPACE);
         }
         this.updateRestrictedSettings();
     }
@@ -806,26 +802,26 @@ class WorkspaceService extends Disposable {
         const [folderConfiguration] = await this.loadFolderConfigurations([folder]);
         const previous = { data: this._configuration.toData(), workspace: this.workspace };
         const folderConfigurationChange = this._configuration.compareAndUpdateFolderConfiguration(folder.uri, folderConfiguration);
-        if (this.getWorkbenchState() === 2 ) {
+        if (this.getWorkbenchState() === WorkbenchState.FOLDER) {
             const workspaceConfigurationChange = this._configuration.compareAndUpdateWorkspaceConfiguration(folderConfiguration);
-            this.triggerConfigurationChange(mergeChanges(folderConfigurationChange, workspaceConfigurationChange), previous, 5 );
+            this.triggerConfigurationChange(mergeChanges(folderConfigurationChange, workspaceConfigurationChange), previous, ConfigurationTarget.WORKSPACE);
         }
         else {
-            this.triggerConfigurationChange(folderConfigurationChange, previous, 6 );
+            this.triggerConfigurationChange(folderConfigurationChange, previous, ConfigurationTarget.WORKSPACE_FOLDER);
         }
         this.updateRestrictedSettings();
     }
     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) => {
@@ -835,10 +831,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,
@@ -848,12 +844,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);
@@ -872,7 +868,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);
         }
@@ -880,25 +876,25 @@ class WorkspaceService extends Disposable {
     }
     async writeConfigurationValue(key, value, target, overrides, options) {
         if (!this.instantiationService) {
-            throw ( (new Error(
+            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')));
+        if (target === ConfigurationTarget.DEFAULT) {
+            throw ( new Error('Invalid configuration target'));
         }
-        if (target === 8 ) {
+        if (target === ConfigurationTarget.MEMORY) {
             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')));
+        if (editableConfigurationTarget === EditableConfigurationTarget.USER_REMOTE && !this.remoteUserConfiguration) {
+            throw ( new Error('Invalid configuration target'));
         }
         if (overrides?.overrideIdentifiers?.length && overrides.overrideIdentifiers.length > 1) {
             const configurationModel = this.getConfigurationModelForEditableConfigurationTarget(editableConfigurationTarget, overrides.resource);
@@ -913,7 +909,7 @@ class WorkspaceService extends Disposable {
         this.configurationEditing = this.configurationEditing ?? this.createConfigurationEditingService(this.instantiationService);
         await (await this.configurationEditing).writeConfiguration(editableConfigurationTarget, { key, value }, { scopes: overrides, ...options });
         switch (editableConfigurationTarget) {
-            case 1 :
+            case EditableConfigurationTarget.USER_LOCAL:
                 if (this.applicationConfiguration && this.isSettingAppliedForAllProfiles(key)) {
                     await this.reloadApplicationConfiguration();
                 }
@@ -921,11 +917,11 @@ class WorkspaceService extends Disposable {
                     await this.reloadLocalUserConfiguration();
                 }
                 return;
-            case 2 :
+            case EditableConfigurationTarget.USER_REMOTE:
                 return this.reloadRemoteUserConfiguration().then(() => undefined);
-            case 3 :
+            case EditableConfigurationTarget.WORKSPACE:
                 return this.reloadWorkspaceConfiguration();
-            case 4 : {
+            case EditableConfigurationTarget.WORKSPACE_FOLDER: {
                 const workspaceFolder = overrides && overrides.resource ? this.workspace.getFolder(overrides.resource) : null;
                 if (workspaceFolder) {
                     return this.reloadWorkspaceFolderConfiguration(workspaceFolder);
@@ -939,18 +935,18 @@ class WorkspaceService extends Disposable {
     }
     getConfigurationModelForEditableConfigurationTarget(target, resource) {
         switch (target) {
-            case 1 : return this._configuration.localUserConfiguration;
-            case 2 : return this._configuration.remoteUserConfiguration;
-            case 3 : return this._configuration.workspaceConfiguration;
-            case 4 : return resource ? this._configuration.folderConfigurations.get(resource) : undefined;
+            case EditableConfigurationTarget.USER_LOCAL: return this._configuration.localUserConfiguration;
+            case EditableConfigurationTarget.USER_REMOTE: return this._configuration.remoteUserConfiguration;
+            case EditableConfigurationTarget.WORKSPACE: return this._configuration.workspaceConfiguration;
+            case EditableConfigurationTarget.WORKSPACE_FOLDER: return resource ? this._configuration.folderConfigurations.get(resource) : undefined;
         }
     }
     getConfigurationModel(target, resource) {
         switch (target) {
-            case 3 : return this._configuration.localUserConfiguration;
-            case 4 : return this._configuration.remoteUserConfiguration;
-            case 5 : return this._configuration.workspaceConfiguration;
-            case 6 : return resource ? this._configuration.folderConfigurations.get(resource) : undefined;
+            case ConfigurationTarget.USER_LOCAL: return this._configuration.localUserConfiguration;
+            case ConfigurationTarget.USER_REMOTE: return this._configuration.remoteUserConfiguration;
+            case ConfigurationTarget.WORKSPACE: return this._configuration.workspaceConfiguration;
+            case ConfigurationTarget.WORKSPACE_FOLDER: return resource ? this._configuration.folderConfigurations.get(resource) : undefined;
             default: return undefined;
         }
     }
@@ -960,62 +956,62 @@ class WorkspaceService extends Disposable {
         }
         const definedTargets = [];
         if (inspect.workspaceFolderValue !== undefined) {
-            definedTargets.push(6 );
+            definedTargets.push(ConfigurationTarget.WORKSPACE_FOLDER);
         }
         if (inspect.workspaceValue !== undefined) {
-            definedTargets.push(5 );
+            definedTargets.push(ConfigurationTarget.WORKSPACE);
         }
         if (inspect.userRemoteValue !== undefined) {
-            definedTargets.push(4 );
+            definedTargets.push(ConfigurationTarget.USER_REMOTE);
         }
         if (inspect.userLocalValue !== undefined) {
-            definedTargets.push(3 );
+            definedTargets.push(ConfigurationTarget.USER_LOCAL);
         }
         if (inspect.applicationValue !== undefined) {
-            definedTargets.push(1 );
+            definedTargets.push(ConfigurationTarget.APPLICATION);
         }
         if (value === undefined) {
             return definedTargets;
         }
-        return [definedTargets[0] || 2 ];
+        return [definedTargets[0] || ConfigurationTarget.USER];
     }
     triggerConfigurationChange(change, previous, target) {
         if (change.keys.length) {
-            if (target !== 7 ) {
+            if (target !== ConfigurationTarget.DEFAULT) {
                 this.logService.debug(`Configuration keys changed in ${ConfigurationTargetToString(target)} target`, ...change.keys);
             }
-            const configurationChangeEvent = ( (new ConfigurationChangeEvent(change, previous, this._configuration, this.workspace, this.logService)));
+            const configurationChangeEvent = ( new ConfigurationChangeEvent(change, previous, this._configuration, this.workspace, this.logService));
             configurationChangeEvent.source = target;
             this._onDidChangeConfiguration.fire(configurationChangeEvent);
         }
     }
     toEditableConfigurationTarget(target, key) {
-        if (target === 1 ) {
-            return 1 ;
+        if (target === ConfigurationTarget.APPLICATION) {
+            return EditableConfigurationTarget.USER_LOCAL;
         }
-        if (target === 2 ) {
+        if (target === ConfigurationTarget.USER) {
             if (this.remoteUserConfiguration) {
                 const scope = this.configurationRegistry.getConfigurationProperties()[key]?.scope;
-                if (scope === 2  || scope === 6 ) {
-                    return 2 ;
+                if (scope === ConfigurationScope.MACHINE || scope === ConfigurationScope.MACHINE_OVERRIDABLE) {
+                    return EditableConfigurationTarget.USER_REMOTE;
                 }
                 if (this.inspect(key).userRemoteValue !== undefined) {
-                    return 2 ;
+                    return EditableConfigurationTarget.USER_REMOTE;
                 }
             }
-            return 1 ;
+            return EditableConfigurationTarget.USER_LOCAL;
         }
-        if (target === 3 ) {
-            return 1 ;
+        if (target === ConfigurationTarget.USER_LOCAL) {
+            return EditableConfigurationTarget.USER_LOCAL;
         }
-        if (target === 4 ) {
-            return 2 ;
+        if (target === ConfigurationTarget.USER_REMOTE) {
+            return EditableConfigurationTarget.USER_REMOTE;
         }
-        if (target === 5 ) {
-            return 3 ;
+        if (target === ConfigurationTarget.WORKSPACE) {
+            return EditableConfigurationTarget.WORKSPACE;
         }
-        if (target === 6 ) {
-            return 4 ;
+        if (target === ConfigurationTarget.WORKSPACE_FOLDER) {
+            return EditableConfigurationTarget.WORKSPACE_FOLDER;
         }
         return null;
     }
@@ -1028,9 +1024,9 @@ 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))));
-            this._register(Event.any(configurationRegistry.onDidUpdateConfiguration, configurationRegistry.onDidSchemaChange, workspaceTrustManagementService.onDidChangeTrust)(() => delayer.trigger(() => this.registerConfigurationSchemas(), lifecycleService.phase === 4  ? undefined : 2500 )));
+            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 === LifecyclePhase.Eventually ? undefined : 2500 )));
         });
     }
     registerConfigurationSchemas() {
@@ -1072,11 +1068,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;
             }, {}),
@@ -1084,7 +1080,7 @@ let RegisterConfigurationSchemasContribution = class RegisterConfigurationSchema
             allowTrailingCommas: true,
             allowComments: true
         };
-        const folderSettingsSchema = 3  === this.workspaceContextService.getWorkbenchState() ?
+        const folderSettingsSchema = WorkbenchState.WORKSPACE === this.workspaceContextService.getWorkbenchState() ?
             {
                 properties: Object.assign({}, this.checkAndFilterPropertiesRequiringTrust(machineOverridableSettings.properties), this.checkAndFilterPropertiesRequiringTrust(resourceSettings.properties)),
                 patternProperties: allSettings.patternProperties,
@@ -1094,7 +1090,7 @@ let RegisterConfigurationSchemasContribution = class RegisterConfigurationSchema
             } : workspaceSettingsSchema;
         const configDefaultsSchema = {
             type: 'object',
-            description: ( localize(3679, 'Contribute defaults for configurations')),
+            description: ( localize(11264, 'Contribute defaults for configurations')),
             properties: Object.assign({}, this.filterDefaultOverridableProperties(machineOverridableSettings.properties), this.filterDefaultOverridableProperties(windowSettings.properties), this.filterDefaultOverridableProperties(resourceSettings.properties)),
             patternProperties: {
                 [OVERRIDE_PROPERTY_PATTERN]: {
@@ -1116,7 +1112,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);
@@ -1147,33 +1143,33 @@ 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();
         if (configurationService.hasCachedConfigurationDefaultsOverrides()) {
-            extensionService.whenInstalledExtensionsRegistered().then(() => configurationService.reloadConfiguration(7 ));
+            extensionService.whenInstalledExtensionsRegistered().then(() => configurationService.reloadConfiguration(ConfigurationTarget.DEFAULT));
         }
     }
 };
-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) {
@@ -1182,10 +1178,10 @@ let UpdateExperimentalSettingsDefaults = class UpdateExperimentalSettingsDefault
         for (const property of properties) {
             const schema = allProperties[property];
             const tags = schema?.tags;
-            if (!tags || (!tags.includes('experimental') && !tags.includes('onExP'))) {
+            if (!tags || !( tags.some(tag => tag.toLowerCase() === 'onexp'))) {
                 continue;
             }
-            if (( (this.processedExperimentalSettings.has(property)))) {
+            if (( this.processedExperimentalSettings.has(property))) {
                 continue;
             }
             this.processedExperimentalSettings.add(property);
@@ -1197,27 +1193,27 @@ let UpdateExperimentalSettingsDefaults = class UpdateExperimentalSettingsDefault
             }
             catch (error) {  }
         }
-        if (( (Object.keys(overrides))).length) {
+        if (( Object.keys(overrides)).length) {
             this.configurationRegistry.registerDefaultConfigurations([{ overrides }]);
         }
     }
 };
-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)));
+UpdateExperimentalSettingsDefaults = ( __decorate([
+    ( __param(0, IWorkbenchAssignmentService))
+], UpdateExperimentalSettingsDefaults));
+const workbenchContributionsRegistry = ( Registry.as(Extensions$2.Workbench));
+workbenchContributionsRegistry.registerWorkbenchContribution(RegisterConfigurationSchemasContribution, LifecyclePhase.Restored);
+workbenchContributionsRegistry.registerWorkbenchContribution(ResetConfigurationDefaultsOverridesCache, LifecyclePhase.Eventually);
+registerWorkbenchContribution2(UpdateExperimentalSettingsDefaults.ID, UpdateExperimentalSettingsDefaults, WorkbenchPhase.BlockRestore);
+const configurationRegistry = ( Registry.as(Extensions.Configuration));
 configurationRegistry.registerConfiguration({
     ...workbenchConfigurationNodeBase,
     properties: {
         [APPLY_ALL_PROFILES_SETTING]: {
             'type': 'array',
-            description: ( localize(3680, "Configure settings to be applied for all profiles.")),
+            description: ( localize(11265, "Configure settings to be applied for all profiles.")),
             'default': [],
-            'scope': 1 ,
+            'scope': ConfigurationScope.APPLICATION,
             additionalProperties: true,
             uniqueItems: true,
         }