@codingame/monaco-vscode-api 1.78.4 → 1.78.5-next.0

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

@@ -0,0 +1,1104 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { equals } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Delayer, Barrier, Queue, Promises, runWhenIdle } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Extensions as Extensions$2 } from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
+import { IWorkspaceContextService, isWorkspaceIdentifier, isSingleFolderWorkspaceIdentifier, isWorkspaceFolder, toWorkspaceFolder, Workspace as Workspace$1 } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { ConfigurationModel, mergeChanges, ConfigurationChangeEvent } from 'monaco-editor/esm/vs/platform/configuration/common/configurationModels.js';
+import { isConfigurationOverrides, isConfigurationUpdateOverrides, ConfigurationTargetToString } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { NullPolicyConfiguration, PolicyConfiguration } from 'monaco-editor/esm/vs/platform/configuration/common/configurations.js';
+import { Configuration } from '../common/configurationModels.js';
+import { defaultSettingsSchemaId, userSettingsSchemaId, profileSettingsSchemaId, machineSettingsSchemaId, workspaceSettingsSchemaId, folderSettingsSchemaId, FOLDER_CONFIG_FOLDER_NAME, LOCAL_MACHINE_SCOPES, LOCAL_MACHINE_PROFILE_SCOPES, PROFILE_SCOPES } from '../common/configuration.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { applicationSettings, windowSettings, resourceSettings, allSettings, machineSettings, machineOverridableSettings, configurationDefaultsSchemaId, OVERRIDE_PROPERTY_PATTERN, resourceLanguageSettingsSchemaId, Extensions as Extensions$1, keyFromOverrideIdentifiers } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { isStoredWorkspaceFolder, toWorkspaceFolders, getStoredWorkspaceFolder } from '../../../../platform/workspaces/common/workspaces.js';
+import { ConfigurationEditing } from '../common/configurationEditing.js';
+import { DefaultConfiguration, UserConfiguration, RemoteUserConfiguration, WorkspaceConfiguration, FolderConfiguration } from './configuration.js';
+import { mark } from '../../../../base/common/performance.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
+import { Extensions } from '../../../common/contributions.js';
+import { ILifecycleService } from '../../lifecycle/common/lifecycle.js';
+import { toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
+import { IWorkspaceTrustManagementService } from 'monaco-editor/esm/vs/platform/workspace/common/workspaceTrust.js';
+import { distinct, delta } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { IExtensionService } from '../../extensions/common/extensions.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { NullPolicyService } from 'monaco-editor/esm/vs/platform/policy/common/policy.js';
+import { updateIgnoredSettings } from '../../../../platform/userDataSync/common/settingsMerge.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { IJSONEditingService } from '../common/jsonEditing.js';
+function getLocalUserConfigurationScopes(userDataProfile, hasRemote) {
+    return userDataProfile.isDefault
+        ? hasRemote ? LOCAL_MACHINE_SCOPES : undefined
+        : hasRemote ? LOCAL_MACHINE_PROFILE_SCOPES : PROFILE_SCOPES;
+}
+class Workspace extends Workspace$1 {
+    constructor() {
+        super(...arguments);
+        this.initialized = false;
+    }
+}
+class WorkspaceService extends Disposable {
+    get restrictedSettings() { return this._restrictedSettings; }
+    constructor({ remoteAuthority, configurationCache }, environmentService, userDataProfileService, userDataProfilesService, fileService, remoteAgentService, uriIdentityService, logService, policyService) {
+        super();
+        this.userDataProfileService = userDataProfileService;
+        this.userDataProfilesService = userDataProfilesService;
+        this.fileService = fileService;
+        this.remoteAgentService = remoteAgentService;
+        this.uriIdentityService = uriIdentityService;
+        this.logService = logService;
+        this.initialized = false;
+        this.applicationConfiguration = null;
+        this.remoteUserConfiguration = null;
+        this._onDidChangeConfiguration = this._register(( (new Emitter())));
+        this.onDidChangeConfiguration = this._onDidChangeConfiguration.event;
+        this._onWillChangeWorkspaceFolders = this._register(( (new Emitter())));
+        this.onWillChangeWorkspaceFolders = this._onWillChangeWorkspaceFolders.event;
+        this._onDidChangeWorkspaceFolders = this._register(( (new Emitter())));
+        this.onDidChangeWorkspaceFolders = this._onDidChangeWorkspaceFolders.event;
+        this._onDidChangeWorkspaceName = this._register(( (new Emitter())));
+        this.onDidChangeWorkspaceName = this._onDidChangeWorkspaceName.event;
+        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._onDidChangeRestrictedSettings.event;
+        this.configurationRegistry = ( (Registry.as(Extensions$1.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.configurationCache = configurationCache;
+        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())));
+        this.createApplicationConfiguration();
+        this.localUserConfiguration = this._register(( (new UserConfiguration(
+            userDataProfileService.currentProfile.settingsResource,
+            userDataProfileService.currentProfile.tasksResource,
+            getLocalUserConfigurationScopes(userDataProfileService.currentProfile, !!remoteAuthority),
+            fileService,
+            uriIdentityService,
+            logService
+        ))));
+        this.cachedFolderConfigs = ( (new ResourceMap()));
+        this._register(this.localUserConfiguration.onDidChangeConfiguration(userConfiguration => this.onLocalUserConfigurationChanged(userConfiguration)));
+        if (remoteAuthority) {
+            const remoteUserConfiguration = this.remoteUserConfiguration = this._register(( (new RemoteUserConfiguration(
+                remoteAuthority,
+                configurationCache,
+                fileService,
+                uriIdentityService,
+                remoteAgentService
+            ))));
+            this._register(remoteUserConfiguration.onDidInitialize(remoteUserConfigurationModel => {
+                this._register(remoteUserConfiguration.onDidChangeConfiguration(remoteUserConfigurationModel => this.onRemoteUserConfigurationChanged(remoteUserConfigurationModel)));
+                this.onRemoteUserConfigurationChanged(remoteUserConfigurationModel);
+                this.initRemoteUserConfigurationBarrier.open();
+            }));
+        }
+        else {
+            this.initRemoteUserConfigurationBarrier.open();
+        }
+        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;
+                this.checkAndMarkWorkspaceComplete(fromCache);
+            });
+        }));
+        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()));
+    }
+    createApplicationConfiguration() {
+        this.applicationConfigurationDisposables.clear();
+        if (this.userDataProfileService.currentProfile.isDefault) {
+            this.applicationConfiguration = null;
+        }
+        else {
+            this.applicationConfiguration = this.applicationConfigurationDisposables.add(this._register(( (new UserConfiguration(
+                this.userDataProfilesService.defaultProfile.settingsResource,
+                undefined,
+                [1 ],
+                this.fileService,
+                this.uriIdentityService,
+                this.logService
+            )))));
+            this.applicationConfigurationDisposables.add(this.applicationConfiguration.onDidChangeConfiguration(configurationModel => this.onApplicationConfigurationChanged(configurationModel)));
+        }
+    }
+    async getCompleteWorkspace() {
+        await this.completeWorkspaceBarrier.wait();
+        return this.getWorkspace();
+    }
+    getWorkspace() {
+        return this.workspace;
+    }
+    getWorkbenchState() {
+        if (this.workspace.configuration) {
+            return 3 ;
+        }
+        if (this.workspace.folders.length === 1) {
+            return 2 ;
+        }
+        return 1 ;
+    }
+    getWorkspaceFolder(resource) {
+        return this.workspace.getFolder(resource);
+    }
+    addFolders(foldersToAdd, index) {
+        return this.updateFolders(foldersToAdd, [], index);
+    }
+    removeFolders(foldersToRemove) {
+        return this.updateFolders([], foldersToRemove);
+    }
+    async updateFolders(foldersToAdd, foldersToRemove, index) {
+        return this.workspaceEditingQueue.queue(() => this.doUpdateFolders(foldersToAdd, foldersToRemove, index));
+    }
+    isInsideWorkspace(resource) {
+        return !!this.getWorkspaceFolder(resource);
+    }
+    isCurrentWorkspace(workspaceIdOrFolder) {
+        switch (this.getWorkbenchState()) {
+            case 2 : {
+                let folderUri = undefined;
+                if (URI.isUri(workspaceIdOrFolder)) {
+                    folderUri = workspaceIdOrFolder;
+                }
+                else if (isSingleFolderWorkspaceIdentifier(workspaceIdOrFolder)) {
+                    folderUri = workspaceIdOrFolder.uri;
+                }
+                return URI.isUri(folderUri) && this.uriIdentityService.extUri.isEqual(folderUri, this.workspace.folders[0].uri);
+            }
+            case 3 :
+                return isWorkspaceIdentifier(workspaceIdOrFolder) && this.workspace.id === workspaceIdOrFolder.id;
+        }
+        return false;
+    }
+    async doUpdateFolders(foldersToAdd, foldersToRemove, index) {
+        if (this.getWorkbenchState() !== 3 ) {
+            return Promise.resolve(undefined);
+        }
+        if (foldersToAdd.length + foldersToRemove.length === 0) {
+            return Promise.resolve(undefined);
+        }
+        let foldersHaveChanged = false;
+        let currentWorkspaceFolders = this.getWorkspace().folders;
+        let newStoredFolders = ( (currentWorkspaceFolders.map(f => f.raw))).filter((folder, index) => {
+            if (!isStoredWorkspaceFolder(folder)) {
+                return true;
+            }
+            return !this.contains(foldersToRemove, currentWorkspaceFolders[index].uri);
+        });
+        foldersHaveChanged = currentWorkspaceFolders.length !== newStoredFolders.length;
+        if (foldersToAdd.length) {
+            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 storedFoldersToAdd = [];
+            for (const folderToAdd of foldersToAdd) {
+                const folderURI = folderToAdd.uri;
+                if (this.contains(currentWorkspaceFolderUris, folderURI)) {
+                    continue;
+                }
+                try {
+                    const result = await this.fileService.stat(folderURI);
+                    if (!result.isDirectory) {
+                        continue;
+                    }
+                }
+                catch (e) {  }
+                storedFoldersToAdd.push(getStoredWorkspaceFolder(folderURI, false, folderToAdd.name, workspaceConfigFolder, this.uriIdentityService.extUri));
+            }
+            if (storedFoldersToAdd.length > 0) {
+                foldersHaveChanged = true;
+                if (typeof index === 'number' && index >= 0 && index < newStoredFolders.length) {
+                    newStoredFolders = newStoredFolders.slice(0);
+                    newStoredFolders.splice(index, 0, ...storedFoldersToAdd);
+                }
+                else {
+                    newStoredFolders = [...newStoredFolders, ...storedFoldersToAdd];
+                }
+            }
+        }
+        if (foldersHaveChanged) {
+            return this.setFolders(newStoredFolders);
+        }
+        return Promise.resolve(undefined);
+    }
+    async setFolders(folders) {
+        if (!this.instantiationService) {
+            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)))
+        );
+    }
+    getConfigurationData() {
+        return this._configuration.toData();
+    }
+    getValue(arg1, arg2) {
+        const section = typeof arg1 === 'string' ? arg1 : undefined;
+        const overrides = isConfigurationOverrides(arg1) ? arg1 : isConfigurationOverrides(arg2) ? arg2 : undefined;
+        return this._configuration.getValue(section, overrides);
+    }
+    async updateValue(key, value, arg3, arg4, options) {
+        const overrides = isConfigurationUpdateOverrides(arg3) ? arg3
+            : isConfigurationOverrides(arg3) ? { resource: arg3.resource, overrideIdentifiers: arg3.overrideIdentifier ? [arg3.overrideIdentifier] : undefined } : undefined;
+        const target = overrides ? arg4 : arg3;
+        const targets = target ? [target] : [];
+        if (overrides?.overrideIdentifiers) {
+            overrides.overrideIdentifiers = distinct(overrides.overrideIdentifiers);
+            overrides.overrideIdentifiers = overrides.overrideIdentifiers.length ? overrides.overrideIdentifiers : undefined;
+        }
+        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');
+            }
+            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) )) {
+                value = undefined;
+            }
+        }
+        await Promises.settled(( (targets.map(
+            target => this.writeConfigurationValue(key, value, target, overrides, options)
+        ))));
+    }
+    async reloadConfiguration(target) {
+        if (target === undefined) {
+            this.reloadDefaultConfiguration();
+            const application = await this.reloadApplicationConfiguration(true);
+            const { local, remote } = await this.reloadUserConfiguration();
+            await this.reloadWorkspaceConfiguration();
+            await this.loadConfiguration(application, local, remote);
+            return;
+        }
+        if (isWorkspaceFolder(target)) {
+            await this.reloadWorkspaceFolderConfiguration(target);
+            return;
+        }
+        switch (target) {
+            case 7 :
+                this.reloadDefaultConfiguration();
+                return;
+            case 2 : {
+                const { local, remote } = await this.reloadUserConfiguration();
+                await this.loadConfiguration(this._configuration.applicationConfiguration, local, remote);
+                return;
+            }
+            case 3 :
+                await this.reloadLocalUserConfiguration();
+                return;
+            case 4 :
+                await this.reloadRemoteUserConfiguration();
+                return;
+            case 5 :
+            case 6 :
+                await this.reloadWorkspaceConfiguration();
+                return;
+        }
+    }
+    hasCachedConfigurationDefaultsOverrides() {
+        return this.defaultConfiguration.hasCachedConfigurationDefaultsOverrides();
+    }
+    inspect(key, overrides) {
+        return this._configuration.inspect(key, overrides);
+    }
+    keys() {
+        return (
+             (this._configuration.keys())
+        );
+    }
+    async whenRemoteConfigurationLoaded() {
+        await this.initRemoteUserConfigurationBarrier.wait();
+    }
+    async initialize(arg) {
+        mark('code/willInitWorkspaceService');
+        const workspace = await this.createWorkspace(arg);
+        await this.updateWorkspaceAndInitializeConfiguration(workspace);
+        this.checkAndMarkWorkspaceComplete(false);
+        mark('code/didInitWorkspaceService');
+    }
+    updateWorkspaceTrust(trusted) {
+        if (this.isWorkspaceTrusted !== trusted) {
+            this.isWorkspaceTrusted = trusted;
+            const data = this._configuration.toData();
+            const folderConfigurationModels = [];
+            for (const folder of this.workspace.folders) {
+                const folderConfiguration = this.cachedFolderConfigs.get(folder.uri);
+                let configurationModel;
+                if (folderConfiguration) {
+                    configurationModel = folderConfiguration.updateWorkspaceTrust(this.isWorkspaceTrusted);
+                    this._configuration.updateFolderConfiguration(folder.uri, configurationModel);
+                }
+                folderConfigurationModels.push(configurationModel);
+            }
+            if (this.getWorkbenchState() === 2 ) {
+                if (folderConfigurationModels[0]) {
+                    this._configuration.updateWorkspaceConfiguration(folderConfigurationModels[0]);
+                }
+            }
+            else {
+                this._configuration.updateWorkspaceConfiguration(this.workspaceConfiguration.updateWorkspaceTrust(this.isWorkspaceTrusted));
+            }
+            this.updateRestrictedSettings();
+            let keys = [];
+            if (this.restrictedSettings.userLocal) {
+                keys.push(...this.restrictedSettings.userLocal);
+            }
+            if (this.restrictedSettings.userRemote) {
+                keys.push(...this.restrictedSettings.userRemote);
+            }
+            if (this.restrictedSettings.workspace) {
+                keys.push(...this.restrictedSettings.workspace);
+            }
+            this.restrictedSettings.workspaceFolder?.forEach((value) => keys.push(...value));
+            keys = distinct(keys);
+            if (keys.length) {
+                this.triggerConfigurationChange({ keys, overrides: [] }, { data, workspace: this.workspace }, 5 );
+            }
+        }
+    }
+    acquireInstantiationService(instantiationService) {
+        this.instantiationService = instantiationService;
+    }
+    async createWorkspace(arg) {
+        if (isWorkspaceIdentifier(arg)) {
+            return this.createMultiFolderWorkspace(arg);
+        }
+        if (isSingleFolderWorkspaceIdentifier(arg)) {
+            return this.createSingleFolderWorkspace(arg);
+        }
+        return this.createEmptyWorkspace(arg);
+    }
+    async createMultiFolderWorkspace(workspaceIdentifier) {
+        await this.workspaceConfiguration.initialize({ id: workspaceIdentifier.id, configPath: workspaceIdentifier.configPath }, this.isWorkspaceTrusted);
+        const workspaceConfigPath = workspaceIdentifier.configPath;
+        const workspaceFolders = toWorkspaceFolders(this.workspaceConfiguration.getFolders(), workspaceConfigPath, this.uriIdentityService.extUri);
+        const workspaceId = workspaceIdentifier.id;
+        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(
+            singleFolderWorkspaceIdentifier.id,
+            [toWorkspaceFolder(singleFolderWorkspaceIdentifier.uri)],
+            false,
+            null,
+            uri => this.uriIdentityService.extUri.ignorePathCasing(uri)
+        )));
+        workspace.initialized = true;
+        return workspace;
+    }
+    createEmptyWorkspace(emptyWorkspaceIdentifier) {
+        const workspace = ( (new Workspace(
+            emptyWorkspaceIdentifier.id,
+            [],
+            false,
+            null,
+            uri => this.uriIdentityService.extUri.ignorePathCasing(uri)
+        )));
+        workspace.initialized = true;
+        return Promise.resolve(workspace);
+    }
+    checkAndMarkWorkspaceComplete(fromCache) {
+        if (!this.completeWorkspaceBarrier.isOpen() && this.workspace.initialized) {
+            this.completeWorkspaceBarrier.open();
+            this.validateWorkspaceFoldersAndReload(fromCache);
+        }
+    }
+    async updateWorkspaceAndInitializeConfiguration(workspace) {
+        const hasWorkspaceBefore = !!this.workspace;
+        let previousState;
+        let previousWorkspacePath;
+        let previousFolders = [];
+        if (hasWorkspaceBefore) {
+            previousState = this.getWorkbenchState();
+            previousWorkspacePath = this.workspace.configuration ? this.workspace.configuration.fsPath : undefined;
+            previousFolders = this.workspace.folders;
+            this.workspace.update(workspace);
+        }
+        else {
+            this.workspace = workspace;
+        }
+        await this.initializeConfiguration();
+        if (hasWorkspaceBefore) {
+            const newState = this.getWorkbenchState();
+            if (previousState && newState !== previousState) {
+                this._onDidChangeWorkbenchState.fire(newState);
+            }
+            const newWorkspacePath = this.workspace.configuration ? this.workspace.configuration.fsPath : undefined;
+            if (previousWorkspacePath && newWorkspacePath !== previousWorkspacePath || newState !== previousState) {
+                this._onDidChangeWorkspaceName.fire();
+            }
+            const folderChanges = this.compareFolders(previousFolders, this.workspace.folders);
+            if (folderChanges && (folderChanges.added.length || folderChanges.removed.length || folderChanges.changed.length)) {
+                await this.handleWillChangeWorkspaceFolders(folderChanges, false);
+                this._onDidChangeWorkspaceFolders.fire(folderChanges);
+            }
+        }
+        if (!this.localUserConfiguration.hasTasksLoaded) {
+            this._register(runWhenIdle(() => this.reloadLocalUserConfiguration()));
+        }
+    }
+    compareFolders(currentFolders, newFolders) {
+        const result = { added: [], removed: [], changed: [] };
+        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++) { }
+            if (newIndex < newFolders.length) {
+                if (currentIndex !== newIndex || currentFolder.name !== newFolders[newIndex].name) {
+                    result.changed.push(currentFolder);
+                }
+            }
+            else {
+                result.removed.push(currentFolder);
+            }
+        }
+        return result;
+    }
+    async initializeConfiguration() {
+        await this.defaultConfiguration.initialize();
+        const [, application, user] = await Promise.all([
+            this.policyConfiguration.initialize(),
+            this.initializeApplicationConfiguration(),
+            (async () => {
+                mark('code/willInitUserConfiguration');
+                const result = await this.initializeUserConfiguration();
+                mark('code/didInitUserConfiguration');
+                return result;
+            })()
+        ]);
+        mark('code/willInitWorkspaceConfiguration');
+        await this.loadConfiguration(application, user.local, user.remote);
+        mark('code/didInitWorkspaceConfiguration');
+    }
+    async initializeApplicationConfiguration() {
+        return this.applicationConfiguration ? this.applicationConfiguration.initialize() : Promise.resolve(( (new ConfigurationModel())));
+    }
+    async initializeUserConfiguration() {
+        const [local, remote] = await Promise.all([this.localUserConfiguration.initialize(), this.remoteUserConfiguration ? this.remoteUserConfiguration.initialize() : Promise.resolve(( (new ConfigurationModel())))]);
+        return { local, remote };
+    }
+    reloadDefaultConfiguration() {
+        this.onDefaultConfigurationChanged(this.defaultConfiguration.reload());
+    }
+    async reloadApplicationConfiguration(donotTrigger) {
+        if (!this.applicationConfiguration) {
+            return (
+                 (new ConfigurationModel())
+            );
+        }
+        const model = await this.applicationConfiguration.reload();
+        if (!donotTrigger) {
+            this.onApplicationConfigurationChanged(model);
+        }
+        return model;
+    }
+    async reloadUserConfiguration() {
+        const [local, remote] = await Promise.all([this.reloadLocalUserConfiguration(true), this.reloadRemoteUserConfiguration(true)]);
+        return { local, remote };
+    }
+    async reloadLocalUserConfiguration(donotTrigger) {
+        const model = await this.localUserConfiguration.reload();
+        if (!donotTrigger) {
+            this.onLocalUserConfigurationChanged(model);
+        }
+        return model;
+    }
+    async reloadRemoteUserConfiguration(donotTrigger) {
+        if (this.remoteUserConfiguration) {
+            const model = await this.remoteUserConfiguration.reload();
+            if (!donotTrigger) {
+                this.onRemoteUserConfigurationChanged(model);
+            }
+            return model;
+        }
+        return (
+             (new ConfigurationModel())
+        );
+    }
+    async reloadWorkspaceConfiguration() {
+        const workbenchState = this.getWorkbenchState();
+        if (workbenchState === 2 ) {
+            return this.onWorkspaceFolderConfigurationChanged(this.workspace.folders[0]);
+        }
+        if (workbenchState === 3 ) {
+            return this.workspaceConfiguration.reload().then(() => this.onWorkspaceConfigurationChanged(false));
+        }
+    }
+    reloadWorkspaceFolderConfiguration(folder) {
+        return this.onWorkspaceFolderConfigurationChanged(folder);
+    }
+    async loadConfiguration(applicationConfigurationModel, userConfigurationModel, remoteUserConfigurationModel) {
+        this.cachedFolderConfigs = ( (new ResourceMap()));
+        const folders = this.workspace.folders;
+        const folderConfigurations = await this.loadFolderConfigurations(folders);
+        const workspaceConfiguration = this.getWorkspaceConfigurationModel(folderConfigurations);
+        const folderConfigurationModels = ( (new ResourceMap()));
+        folderConfigurations.forEach((folderConfiguration, index) => folderConfigurationModels.set(folders[index].uri, folderConfiguration));
+        const currentConfiguration = this._configuration;
+        this._configuration = ( (new Configuration(
+            this.defaultConfiguration.configurationModel,
+            this.policyConfiguration.configurationModel,
+            applicationConfigurationModel,
+            userConfigurationModel,
+            remoteUserConfigurationModel,
+            workspaceConfiguration,
+            folderConfigurationModels,
+             (new ConfigurationModel()),
+             (new ResourceMap()),
+            this.workspace
+        )));
+        if (this.initialized) {
+            const change = this._configuration.compare(currentConfiguration);
+            this.triggerConfigurationChange(change, { data: currentConfiguration.toData(), workspace: this.workspace }, 5 );
+        }
+        else {
+            this.initialized = true;
+        }
+        this.updateRestrictedSettings();
+    }
+    getWorkspaceConfigurationModel(folderConfigurations) {
+        switch (this.getWorkbenchState()) {
+            case 2 :
+                return folderConfigurations[0];
+            case 3 :
+                return this.workspaceConfiguration.getConfiguration();
+            default:
+                return (
+                     (new ConfigurationModel())
+                );
+        }
+    }
+    onUserDataProfileChanged(e) {
+        e.join((async () => {
+            if (e.preserveData) {
+                await Promise.all([
+                    this.copyProfileSettings(e.previous.settingsResource, e.profile.settingsResource),
+                    this.copyProfileTasks(e.previous.tasksResource, e.profile.tasksResource)
+                ]);
+            }
+            const promises = [];
+            promises.push(this.localUserConfiguration.reset(e.profile.settingsResource, e.profile.tasksResource, getLocalUserConfigurationScopes(e.profile, !!this.remoteUserConfiguration)));
+            if (e.previous.isDefault !== e.profile.isDefault) {
+                this.createApplicationConfiguration();
+                if (this.applicationConfiguration) {
+                    promises.push(this.reloadApplicationConfiguration(true));
+                }
+            }
+            const [localUser, application] = await Promise.all(promises);
+            await this.loadConfiguration(application ?? this._configuration.applicationConfiguration, localUser, this._configuration.remoteUserConfiguration);
+        })());
+    }
+    async copyProfileSettings(from, to) {
+        let fromContent;
+        try {
+            fromContent = ( ((await this.fileService.readFile(from)).value.toString()));
+        }
+        catch (error) {
+            if (error.fileOperationResult !== 1 ) {
+                throw error;
+            }
+        }
+        if (!fromContent) {
+            return;
+        }
+        const allSettings = ( (Registry.as(Extensions$1.Configuration))).getConfigurationProperties();
+        const applicationSettings = ( (Object.keys(allSettings))).filter(key => allSettings[key]?.scope === 1 );
+        const toContent = updateIgnoredSettings(fromContent, '{}', applicationSettings, {});
+        await this.fileService.writeFile(to, VSBuffer.fromString(toContent));
+    }
+    async copyProfileTasks(from, to) {
+        if (await this.fileService.exists(from)) {
+            await this.fileService.copy(from, to);
+        }
+    }
+    onDefaultConfigurationChanged(configurationModel, properties) {
+        if (this.workspace) {
+            const previousData = this._configuration.toData();
+            const change = this._configuration.compareAndUpdateDefaultConfiguration(configurationModel, properties);
+            if (this.applicationConfiguration) {
+                this._configuration.updateApplicationConfiguration(this.applicationConfiguration.reparse());
+            }
+            if (this.remoteUserConfiguration) {
+                this._configuration.updateLocalUserConfiguration(this.localUserConfiguration.reparse());
+                this._configuration.updateRemoteUserConfiguration(this.remoteUserConfiguration.reparse());
+            }
+            if (this.getWorkbenchState() === 2 ) {
+                const folderConfiguration = this.cachedFolderConfigs.get(this.workspace.folders[0].uri);
+                if (folderConfiguration) {
+                    this._configuration.updateWorkspaceConfiguration(folderConfiguration.reparse());
+                    this._configuration.updateFolderConfiguration(this.workspace.folders[0].uri, folderConfiguration.reparse());
+                }
+            }
+            else {
+                this._configuration.updateWorkspaceConfiguration(this.workspaceConfiguration.reparseWorkspaceSettings());
+                for (const folder of this.workspace.folders) {
+                    const folderConfiguration = this.cachedFolderConfigs.get(folder.uri);
+                    if (folderConfiguration) {
+                        this._configuration.updateFolderConfiguration(folder.uri, folderConfiguration.reparse());
+                    }
+                }
+            }
+            this.triggerConfigurationChange(change, { data: previousData, workspace: this.workspace }, 7 );
+            this.updateRestrictedSettings();
+        }
+    }
+    onPolicyConfigurationChanged(policyConfiguration) {
+        const previous = { data: this._configuration.toData(), workspace: this.workspace };
+        const change = this._configuration.compareAndUpdatePolicyConfiguration(policyConfiguration);
+        this.triggerConfigurationChange(change, previous, 7 );
+    }
+    onApplicationConfigurationChanged(applicationConfiguration) {
+        const previous = { data: this._configuration.toData(), workspace: this.workspace };
+        const change = this._configuration.compareAndUpdateApplicationConfiguration(applicationConfiguration);
+        const configurationProperties = this.configurationRegistry.getConfigurationProperties();
+        change.keys = change.keys.filter(key => configurationProperties[key]?.scope === 1 );
+        this.triggerConfigurationChange(change, previous, 2 );
+    }
+    onLocalUserConfigurationChanged(userConfiguration) {
+        const previous = { data: this._configuration.toData(), workspace: this.workspace };
+        const change = this._configuration.compareAndUpdateLocalUserConfiguration(userConfiguration);
+        this.triggerConfigurationChange(change, previous, 2 );
+    }
+    onRemoteUserConfigurationChanged(userConfiguration) {
+        const previous = { data: this._configuration.toData(), workspace: this.workspace };
+        const change = this._configuration.compareAndUpdateRemoteUserConfiguration(userConfiguration);
+        this.triggerConfigurationChange(change, previous, 2 );
+    }
+    async onWorkspaceConfigurationChanged(fromCache) {
+        if (this.workspace && this.workspace.configuration) {
+            let newFolders = toWorkspaceFolders(this.workspaceConfiguration.getFolders(), this.workspace.configuration, this.uriIdentityService.extUri);
+            if (this.workspace.initialized) {
+                const { added, removed, changed } = this.compareFolders(this.workspace.folders, newFolders);
+                if (added.length || removed.length || changed.length) {
+                    newFolders = await this.toValidWorkspaceFolders(newFolders);
+                }
+                else {
+                    newFolders = this.workspace.folders;
+                }
+            }
+            await this.updateWorkspaceConfiguration(newFolders, this.workspaceConfiguration.getConfiguration(), fromCache);
+        }
+    }
+    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 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));
+        const applicationDelta = delta(application, this._restrictedSettings.application || [], (a, b) => a.localeCompare(b));
+        changed.push(...applicationDelta.added, ...applicationDelta.removed);
+        const userLocal = this.localUserConfiguration.getRestrictedSettings().sort((a, b) => a.localeCompare(b));
+        const userLocalDelta = delta(userLocal, this._restrictedSettings.userLocal || [], (a, b) => a.localeCompare(b));
+        changed.push(...userLocalDelta.added, ...userLocalDelta.removed);
+        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()));
+        for (const workspaceFolder of this.workspace.folders) {
+            const cachedFolderConfig = this.cachedFolderConfigs.get(workspaceFolder.uri);
+            const folderRestrictedSettings = (cachedFolderConfig?.getRestrictedSettings() || []).sort((a, b) => a.localeCompare(b));
+            if (folderRestrictedSettings.length) {
+                workspaceFolderMap.set(workspaceFolder.uri, folderRestrictedSettings);
+            }
+            const previous = this._restrictedSettings.workspaceFolder?.get(workspaceFolder.uri) || [];
+            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))
+            : 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);
+        if (changed.length) {
+            this._restrictedSettings = {
+                default: defaultRestrictedSettings,
+                application: application.length ? application : undefined,
+                userLocal: userLocal.length ? userLocal : undefined,
+                userRemote: userRemote.length ? userRemote : undefined,
+                workspace: workspace.length ? workspace : undefined,
+                workspaceFolder: workspaceFolderMap.size ? workspaceFolderMap : undefined,
+            };
+            this._onDidChangeRestrictedSettings.fire(this.restrictedSettings);
+        }
+    }
+    async updateWorkspaceConfiguration(workspaceFolders, configuration, fromCache) {
+        const previous = { data: this._configuration.toData(), workspace: this.workspace };
+        const change = this._configuration.compareAndUpdateWorkspaceConfiguration(configuration);
+        const changes = this.compareFolders(this.workspace.folders, workspaceFolders);
+        if (changes.added.length || changes.removed.length || changes.changed.length) {
+            this.workspace.folders = workspaceFolders;
+            const change = await this.onFoldersChanged();
+            await this.handleWillChangeWorkspaceFolders(changes, fromCache);
+            this.triggerConfigurationChange(change, previous, 6 );
+            this._onDidChangeWorkspaceFolders.fire(changes);
+        }
+        else {
+            this.triggerConfigurationChange(change, previous, 5 );
+        }
+        this.updateRestrictedSettings();
+    }
+    async handleWillChangeWorkspaceFolders(changes, fromCache) {
+        const joiners = [];
+        this._onWillChangeWorkspaceFolders.fire({
+            join(updateWorkspaceTrustStatePromise) {
+                joiners.push(updateWorkspaceTrustStatePromise);
+            },
+            changes,
+            fromCache
+        });
+        try {
+            await Promises.settled(joiners);
+        }
+        catch (error) {  }
+    }
+    async onWorkspaceFolderConfigurationChanged(folder) {
+        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 ) {
+            const workspaceConfigurationChange = this._configuration.compareAndUpdateWorkspaceConfiguration(folderConfiguration);
+            this.triggerConfigurationChange(mergeChanges(folderConfigurationChange, workspaceConfigurationChange), previous, 5 );
+        }
+        else {
+            this.triggerConfigurationChange(folderConfigurationChange, previous, 6 );
+        }
+        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]) {
+                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));
+        if (toInitialize.length) {
+            const folderConfigurations = await this.loadFolderConfigurations(toInitialize);
+            folderConfigurations.forEach((folderConfiguration, index) => {
+                changes.push(this._configuration.compareAndUpdateFolderConfiguration(toInitialize[index].uri, folderConfiguration));
+            });
+        }
+        return mergeChanges(...changes);
+    }
+    loadFolderConfigurations(folders) {
+        return Promise.all([...( (folders.map(folder => {
+                let folderConfiguration = this.cachedFolderConfigs.get(folder.uri);
+                if (!folderConfiguration) {
+                    folderConfiguration = ( (new FolderConfiguration(
+                        !this.initialized,
+                        folder,
+                        FOLDER_CONFIG_FOLDER_NAME,
+                        this.getWorkbenchState(),
+                        this.isWorkspaceTrusted,
+                        this.fileService,
+                        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);
+        const { removed } = this.compareFolders(this.workspace.folders, validWorkspaceFolders);
+        if (removed.length) {
+            await this.updateWorkspaceConfiguration(validWorkspaceFolders, this.workspaceConfiguration.getConfiguration(), fromCache);
+        }
+    }
+    async toValidWorkspaceFolders(workspaceFolders) {
+        const validWorkspaceFolders = [];
+        for (const workspaceFolder of workspaceFolders) {
+            try {
+                const result = await this.fileService.stat(workspaceFolder.uri);
+                if (!result.isDirectory) {
+                    continue;
+                }
+            }
+            catch (e) {
+                this.logService.warn(`Ignoring the error while validating workspace folder ${( ( workspaceFolder.uri.toString()))} - ${toErrorMessage(e)}`);
+            }
+            validWorkspaceFolders.push(workspaceFolder);
+        }
+        return validWorkspaceFolders;
+    }
+    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.');
+        }
+        if (target === 7 ) {
+            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);
+            return;
+        }
+        const editableConfigurationTarget = this.toEditableConfigurationTarget(target, key);
+        if (!editableConfigurationTarget) {
+            throw new Error('Invalid configuration target');
+        }
+        if (editableConfigurationTarget === 2  && !this.remoteUserConfiguration) {
+            throw new Error('Invalid configuration target');
+        }
+        this.configurationEditing = this.configurationEditing ?? this.instantiationService.createInstance(ConfigurationEditing, (await this.remoteAgentService.getEnvironment())?.settingsPath ?? null);
+        await this.configurationEditing.writeConfiguration(editableConfigurationTarget, { key, value }, { scopes: overrides, ...options });
+        switch (editableConfigurationTarget) {
+            case 1 :
+                if (this.applicationConfiguration && this.configurationRegistry.getConfigurationProperties()[key].scope === 1 ) {
+                    await this.reloadApplicationConfiguration();
+                }
+                else {
+                    await this.reloadLocalUserConfiguration();
+                }
+                return;
+            case 2 :
+                return this.reloadRemoteUserConfiguration().then(() => undefined);
+            case 3 :
+                return this.reloadWorkspaceConfiguration();
+            case 4 : {
+                const workspaceFolder = overrides && overrides.resource ? this.workspace.getFolder(overrides.resource) : null;
+                if (workspaceFolder) {
+                    return this.reloadWorkspaceFolderConfiguration(workspaceFolder);
+                }
+            }
+        }
+    }
+    deriveConfigurationTargets(key, value, inspect) {
+        if (equals(value, inspect.value)) {
+            return [];
+        }
+        const definedTargets = [];
+        if (inspect.workspaceFolderValue !== undefined) {
+            definedTargets.push(6 );
+        }
+        if (inspect.workspaceValue !== undefined) {
+            definedTargets.push(5 );
+        }
+        if (inspect.userRemoteValue !== undefined) {
+            definedTargets.push(4 );
+        }
+        if (inspect.userLocalValue !== undefined) {
+            definedTargets.push(3 );
+        }
+        if (value === undefined) {
+            return definedTargets;
+        }
+        return [definedTargets[0] || 2 ];
+    }
+    triggerConfigurationChange(change, previous, target) {
+        if (change.keys.length) {
+            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)));
+            configurationChangeEvent.source = target;
+            configurationChangeEvent.sourceConfig = this.getTargetConfiguration(target);
+            this._onDidChangeConfiguration.fire(configurationChangeEvent);
+        }
+    }
+    getTargetConfiguration(target) {
+        switch (target) {
+            case 7 :
+                return this._configuration.defaults.contents;
+            case 2 :
+                return this._configuration.userConfiguration.contents;
+            case 5 :
+                return this._configuration.workspaceConfiguration.contents;
+        }
+        return {};
+    }
+    toEditableConfigurationTarget(target, key) {
+        if (target === 2 ) {
+            if (this.remoteUserConfiguration) {
+                const scope = this.configurationRegistry.getConfigurationProperties()[key]?.scope;
+                if (scope === 2  || scope === 6 ) {
+                    return 2 ;
+                }
+                if (this.inspect(key).userRemoteValue !== undefined) {
+                    return 2 ;
+                }
+            }
+            return 1 ;
+        }
+        if (target === 3 ) {
+            return 1 ;
+        }
+        if (target === 4 ) {
+            return 2 ;
+        }
+        if (target === 5 ) {
+            return 3 ;
+        }
+        if (target === 6 ) {
+            return 4 ;
+        }
+        return null;
+    }
+}
+let RegisterConfigurationSchemasContribution = class RegisterConfigurationSchemasContribution extends Disposable {
+    constructor(workspaceContextService, environmentService, workspaceTrustManagementService, extensionService, lifecycleService) {
+        super();
+        this.workspaceContextService = workspaceContextService;
+        this.environmentService = environmentService;
+        this.workspaceTrustManagementService = workspaceTrustManagementService;
+        extensionService.whenInstalledExtensionsRegistered().then(() => {
+            this.registerConfigurationSchemas();
+            const configurationRegistry = ( (Registry.as(Extensions$1.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 )));
+        });
+    }
+    registerConfigurationSchemas() {
+        const jsonRegistry = ( (Registry.as(Extensions$2.JSONContribution)));
+        const allSettingsSchema = {
+            properties: allSettings.properties,
+            patternProperties: allSettings.patternProperties,
+            additionalProperties: true,
+            allowTrailingCommas: true,
+            allowComments: true
+        };
+        const userSettingsSchema = this.environmentService.remoteAuthority ?
+            {
+                properties: Object.assign({}, applicationSettings.properties, windowSettings.properties, resourceSettings.properties),
+                patternProperties: allSettings.patternProperties,
+                additionalProperties: true,
+                allowTrailingCommas: true,
+                allowComments: true
+            }
+            : allSettingsSchema;
+        const profileSettingsSchema = {
+            properties: Object.assign({}, machineSettings.properties, machineOverridableSettings.properties, windowSettings.properties, resourceSettings.properties),
+            patternProperties: allSettings.patternProperties,
+            additionalProperties: true,
+            allowTrailingCommas: true,
+            allowComments: true
+        };
+        const machineSettingsSchema = {
+            properties: Object.assign({}, machineSettings.properties, machineOverridableSettings.properties, windowSettings.properties, resourceSettings.properties),
+            patternProperties: allSettings.patternProperties,
+            additionalProperties: true,
+            allowTrailingCommas: true,
+            allowComments: true
+        };
+        const workspaceSettingsSchema = {
+            properties: Object.assign({}, this.checkAndFilterPropertiesRequiringTrust(machineOverridableSettings.properties), this.checkAndFilterPropertiesRequiringTrust(windowSettings.properties), this.checkAndFilterPropertiesRequiringTrust(resourceSettings.properties)),
+            patternProperties: allSettings.patternProperties,
+            additionalProperties: true,
+            allowTrailingCommas: true,
+            allowComments: true
+        };
+        jsonRegistry.registerSchema(defaultSettingsSchemaId, {
+            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) => {
+                result[key] = Object.assign({ deprecationMessage: undefined }, allSettings.patternProperties[key]);
+                return result;
+            }, {}),
+            additionalProperties: true,
+            allowTrailingCommas: true,
+            allowComments: true
+        });
+        jsonRegistry.registerSchema(userSettingsSchemaId, userSettingsSchema);
+        jsonRegistry.registerSchema(profileSettingsSchemaId, profileSettingsSchema);
+        jsonRegistry.registerSchema(machineSettingsSchemaId, machineSettingsSchema);
+        if (3  === this.workspaceContextService.getWorkbenchState()) {
+            const folderSettingsSchema = {
+                properties: Object.assign({}, this.checkAndFilterPropertiesRequiringTrust(machineOverridableSettings.properties), this.checkAndFilterPropertiesRequiringTrust(resourceSettings.properties)),
+                patternProperties: allSettings.patternProperties,
+                additionalProperties: true,
+                allowTrailingCommas: true,
+                allowComments: true
+            };
+            jsonRegistry.registerSchema(workspaceSettingsSchemaId, workspaceSettingsSchema);
+            jsonRegistry.registerSchema(folderSettingsSchemaId, folderSettingsSchema);
+        }
+        else {
+            jsonRegistry.registerSchema(workspaceSettingsSchemaId, workspaceSettingsSchema);
+            jsonRegistry.registerSchema(folderSettingsSchemaId, workspaceSettingsSchema);
+        }
+        jsonRegistry.registerSchema(configurationDefaultsSchemaId, {
+            type: 'object',
+            description: ( (localize(
+                'configurationDefaults.description',
+                'Contribute defaults for configurations'
+            ))),
+            properties: Object.assign({}, machineOverridableSettings.properties, windowSettings.properties, resourceSettings.properties),
+            patternProperties: {
+                [OVERRIDE_PROPERTY_PATTERN]: {
+                    type: 'object',
+                    default: {},
+                    $ref: resourceLanguageSettingsSchemaId,
+                }
+            },
+            additionalProperties: false
+        });
+    }
+    checkAndFilterPropertiesRequiringTrust(properties) {
+        if (this.workspaceTrustManagementService.isWorkspaceTrusted()) {
+            return properties;
+        }
+        const result = {};
+        Object.entries(properties).forEach(([key, value]) => {
+            if (!value.restricted) {
+                result[key] = value;
+            }
+        });
+        return result;
+    }
+};
+RegisterConfigurationSchemasContribution = ( (__decorate([
+    ( (__param(0, IWorkspaceContextService))),
+    ( (__param(1, IWorkbenchEnvironmentService))),
+    ( (__param(2, IWorkspaceTrustManagementService))),
+    ( (__param(3, IExtensionService))),
+    ( (__param(4, ILifecycleService)))
+], RegisterConfigurationSchemasContribution)));
+const workbenchContributionsRegistry = ( (Registry.as(Extensions.Workbench)));
+workbenchContributionsRegistry.registerWorkbenchContribution(RegisterConfigurationSchemasContribution, 3 );
+export { WorkspaceService };