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

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

@@ -0,0 +1,847 @@
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import * as errors from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Disposable, MutableDisposable, combinedDisposable, toDisposable, DisposableStore, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { whenProviderRegistered } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { UserSettings, ConfigurationModelParser, ConfigurationModel } from 'monaco-editor/esm/vs/platform/configuration/common/configurationModels.js';
+import { WorkspaceConfigurationModelParser, StandaloneConfigurationModelParser } from '../common/configurationModels.js';
+import { REMOTE_MACHINE_SCOPES, WORKSPACE_SCOPES, FOLDER_SCOPES, FOLDER_SETTINGS_NAME, TASKS_CONFIGURATION_KEY, LAUNCH_CONFIGURATION_KEY } from '../common/configuration.js';
+import { Extensions, OVERRIDE_PROPERTY_REGEX } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { equals } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
+import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { isEmptyObject, isObject } from 'monaco-editor/esm/vs/base/common/types.js';
+import { DefaultConfiguration as DefaultConfiguration$1 } from 'monaco-editor/esm/vs/platform/configuration/common/configurations.js';
+class DefaultConfiguration extends DefaultConfiguration$1 {
+    constructor(configurationCache, environmentService) {
+        super();
+        this.configurationCache = configurationCache;
+        this.configurationRegistry = ( (Registry.as(Extensions.Configuration)));
+        this.cachedConfigurationDefaultsOverrides = {};
+        this.cacheKey = { type: 'defaults', key: 'configurationDefaultsOverrides' };
+        this.updateCache = false;
+        if (environmentService.options?.configurationDefaults) {
+            this.configurationRegistry.registerDefaultConfigurations([{ overrides: environmentService.options.configurationDefaults }]);
+        }
+    }
+    getConfigurationDefaultOverrides() {
+        return this.cachedConfigurationDefaultsOverrides;
+    }
+    async initialize() {
+        await this.initializeCachedConfigurationDefaultsOverrides();
+        return super.initialize();
+    }
+    reload() {
+        this.updateCache = true;
+        this.cachedConfigurationDefaultsOverrides = {};
+        this.updateCachedConfigurationDefaultsOverrides();
+        return super.reload();
+    }
+    hasCachedConfigurationDefaultsOverrides() {
+        return !isEmptyObject(this.cachedConfigurationDefaultsOverrides);
+    }
+    initializeCachedConfigurationDefaultsOverrides() {
+        if (!this.initiaizeCachedConfigurationDefaultsOverridesPromise) {
+            this.initiaizeCachedConfigurationDefaultsOverridesPromise = (async () => {
+                try {
+                    if (window.localStorage.getItem(DefaultConfiguration.DEFAULT_OVERRIDES_CACHE_EXISTS_KEY)) {
+                        const content = await this.configurationCache.read(this.cacheKey);
+                        if (content) {
+                            this.cachedConfigurationDefaultsOverrides = JSON.parse(content);
+                        }
+                    }
+                }
+                catch (error) {  }
+                this.cachedConfigurationDefaultsOverrides = isObject(this.cachedConfigurationDefaultsOverrides) ? this.cachedConfigurationDefaultsOverrides : {};
+            })();
+        }
+        return this.initiaizeCachedConfigurationDefaultsOverridesPromise;
+    }
+    onDidUpdateConfiguration(properties, defaultsOverrides) {
+        super.onDidUpdateConfiguration(properties, defaultsOverrides);
+        if (defaultsOverrides) {
+            this.updateCachedConfigurationDefaultsOverrides();
+        }
+    }
+    async updateCachedConfigurationDefaultsOverrides() {
+        if (!this.updateCache) {
+            return;
+        }
+        const cachedConfigurationDefaultsOverrides = {};
+        const configurationDefaultsOverrides = this.configurationRegistry.getConfigurationDefaultsOverrides();
+        for (const [key, value] of configurationDefaultsOverrides) {
+            if (!OVERRIDE_PROPERTY_REGEX.test(key) && value.value !== undefined) {
+                cachedConfigurationDefaultsOverrides[key] = value.value;
+            }
+        }
+        try {
+            if (( (Object.keys(cachedConfigurationDefaultsOverrides))).length) {
+                window.localStorage.setItem(DefaultConfiguration.DEFAULT_OVERRIDES_CACHE_EXISTS_KEY, 'yes');
+                await this.configurationCache.write(this.cacheKey, JSON.stringify(cachedConfigurationDefaultsOverrides));
+            }
+            else {
+                window.localStorage.removeItem(DefaultConfiguration.DEFAULT_OVERRIDES_CACHE_EXISTS_KEY);
+                await this.configurationCache.remove(this.cacheKey);
+            }
+        }
+        catch (error) {  }
+    }
+}
+DefaultConfiguration.DEFAULT_OVERRIDES_CACHE_EXISTS_KEY = 'DefaultOverridesCacheExists';
+class UserConfiguration extends Disposable {
+    get hasTasksLoaded() { return this.userConfiguration.value instanceof FileServiceBasedConfiguration; }
+    constructor(settingsResource, tasksResource, scopes, fileService, uriIdentityService, logService) {
+        super();
+        this.settingsResource = settingsResource;
+        this.tasksResource = tasksResource;
+        this.fileService = fileService;
+        this.uriIdentityService = uriIdentityService;
+        this.logService = logService;
+        this._onDidChangeConfiguration = this._register(( (new Emitter())));
+        this.onDidChangeConfiguration = this._onDidChangeConfiguration.event;
+        this.userConfiguration = this._register(( (new MutableDisposable())));
+        this.userConfigurationChangeDisposable = this._register(( (new MutableDisposable())));
+        this.configurationParseOptions = { scopes, skipRestricted: false };
+        this.userConfiguration.value = ( (new UserSettings(settingsResource, scopes, uriIdentityService.extUri, this.fileService)));
+        this.userConfigurationChangeDisposable.value = this.userConfiguration.value.onDidChange(() => this.reloadConfigurationScheduler.schedule());
+        this.reloadConfigurationScheduler = this._register(( (new RunOnceScheduler(
+            () => this.userConfiguration.value.loadConfiguration().then(configurationModel => this._onDidChangeConfiguration.fire(configurationModel)),
+            50
+        ))));
+    }
+    async reset(settingsResource, tasksResource, scopes) {
+        this.settingsResource = settingsResource;
+        this.tasksResource = tasksResource;
+        this.configurationParseOptions = { scopes, skipRestricted: false };
+        const folder = this.uriIdentityService.extUri.dirname(this.settingsResource);
+        const standAloneConfigurationResources = this.tasksResource ? [[TASKS_CONFIGURATION_KEY, this.tasksResource]] : [];
+        const fileServiceBasedConfiguration = ( (new FileServiceBasedConfiguration(
+             (folder.toString()),
+            this.settingsResource,
+            standAloneConfigurationResources,
+            this.configurationParseOptions,
+            this.fileService,
+            this.uriIdentityService,
+            this.logService
+        )));
+        const configurationModel = await fileServiceBasedConfiguration.loadConfiguration();
+        this.userConfiguration.value = fileServiceBasedConfiguration;
+        if (this.userConfigurationChangeDisposable.value) {
+            this.userConfigurationChangeDisposable.value = this.userConfiguration.value.onDidChange(() => this.reloadConfigurationScheduler.schedule());
+        }
+        return configurationModel;
+    }
+    async initialize() {
+        return this.userConfiguration.value.loadConfiguration();
+    }
+    async reload() {
+        if (this.hasTasksLoaded) {
+            return this.userConfiguration.value.loadConfiguration();
+        }
+        return this.reset(this.settingsResource, this.tasksResource, this.configurationParseOptions.scopes);
+    }
+    reparse() {
+        return this.userConfiguration.value.reparse(this.configurationParseOptions);
+    }
+    getRestrictedSettings() {
+        return this.userConfiguration.value.getRestrictedSettings();
+    }
+}
+class FileServiceBasedConfiguration extends Disposable {
+    constructor(name, settingsResource, standAloneConfigurationResources, configurationParseOptions, fileService, uriIdentityService, logService) {
+        super();
+        this.settingsResource = settingsResource;
+        this.standAloneConfigurationResources = standAloneConfigurationResources;
+        this.fileService = fileService;
+        this.uriIdentityService = uriIdentityService;
+        this.logService = logService;
+        this._onDidChange = this._register(( (new Emitter())));
+        this.onDidChange = this._onDidChange.event;
+        this.allResources = [this.settingsResource, ...( (this.standAloneConfigurationResources.map(([, resource]) => resource)))];
+        this._register(combinedDisposable(...( (this.allResources.map(
+            resource => combinedDisposable(this.fileService.watch(uriIdentityService.extUri.dirname(resource)),
+            this.fileService.watch(resource))
+        )))));
+        this._folderSettingsModelParser = ( (new ConfigurationModelParser(name)));
+        this._folderSettingsParseOptions = configurationParseOptions;
+        this._standAloneConfigurations = [];
+        this._cache = ( (new ConfigurationModel()));
+        this._register(Event.debounce(Event.any(Event.filter(this.fileService.onDidFilesChange, e => this.handleFileChangesEvent(e)), Event.filter(this.fileService.onDidRunOperation, e => this.handleFileOperationEvent(e))), () => undefined, 100)(() => this._onDidChange.fire()));
+    }
+    async resolveContents() {
+        const resolveContents = async (resources) => {
+            return Promise.all(( (resources.map(async (resource) => {
+                try {
+                    const content = ( ((await this.fileService.readFile(resource)).value.toString()));
+                    return content;
+                }
+                catch (error) {
+                    this.logService.trace(`Error while resolving configuration file '${( ( resource.toString()))}': ${errors.getErrorMessage(error)}`);
+                    if (error.fileOperationResult !== 1
+                        && error.fileOperationResult !== 10 ) {
+                        this.logService.error(error);
+                    }
+                }
+                return '{}';
+            }))));
+        };
+        const [[settingsContent], standAloneConfigurationContents] = await Promise.all([
+            resolveContents([this.settingsResource]),
+            resolveContents(( (this.standAloneConfigurationResources.map(([, resource]) => resource)))),
+        ]);
+        return [settingsContent, ( (standAloneConfigurationContents.map(
+            (content, index) => ([this.standAloneConfigurationResources[index][0], content])
+        )))];
+    }
+    async loadConfiguration() {
+        const [settingsContent, standAloneConfigurationContents] = await this.resolveContents();
+        this._standAloneConfigurations = [];
+        this._folderSettingsModelParser.parse('', this._folderSettingsParseOptions);
+        if (settingsContent !== undefined) {
+            this._folderSettingsModelParser.parse(settingsContent, this._folderSettingsParseOptions);
+        }
+        for (let index = 0; index < standAloneConfigurationContents.length; index++) {
+            const contents = standAloneConfigurationContents[index][1];
+            if (contents !== undefined) {
+                const standAloneConfigurationModelParser = ( (new StandaloneConfigurationModelParser(
+                     (this.standAloneConfigurationResources[index][1].toString()),
+                    this.standAloneConfigurationResources[index][0]
+                )));
+                standAloneConfigurationModelParser.parse(contents);
+                this._standAloneConfigurations.push(standAloneConfigurationModelParser.configurationModel);
+            }
+        }
+        this.consolidate();
+        return this._cache;
+    }
+    getRestrictedSettings() {
+        return this._folderSettingsModelParser.restrictedConfigurations;
+    }
+    reparse(configurationParseOptions) {
+        const oldContents = this._folderSettingsModelParser.configurationModel.contents;
+        this._folderSettingsParseOptions = configurationParseOptions;
+        this._folderSettingsModelParser.reparse(this._folderSettingsParseOptions);
+        if (!equals(oldContents, this._folderSettingsModelParser.configurationModel.contents)) {
+            this.consolidate();
+        }
+        return this._cache;
+    }
+    consolidate() {
+        this._cache = this._folderSettingsModelParser.configurationModel.merge(...this._standAloneConfigurations);
+    }
+    handleFileChangesEvent(event) {
+        if (( (this.allResources.some(resource => event.contains(resource))))) {
+            return true;
+        }
+        if (( (this.allResources.some(
+            resource => event.contains(this.uriIdentityService.extUri.dirname(resource), 2 )
+        )))) {
+            return true;
+        }
+        return false;
+    }
+    handleFileOperationEvent(event) {
+        if ((event.isOperation(0 ) || event.isOperation(3 ) || event.isOperation(1 ) || event.isOperation(4 ))
+            && ( (this.allResources.some(
+            resource => this.uriIdentityService.extUri.isEqual(event.resource, resource)
+        )))) {
+            return true;
+        }
+        if (event.isOperation(1 ) && ( (this.allResources.some(
+            resource => this.uriIdentityService.extUri.isEqual(event.resource, this.uriIdentityService.extUri.dirname(resource))
+        )))) {
+            return true;
+        }
+        return false;
+    }
+}
+class RemoteUserConfiguration extends Disposable {
+    constructor(remoteAuthority, configurationCache, fileService, uriIdentityService, remoteAgentService) {
+        super();
+        this._userConfigurationInitializationPromise = null;
+        this._onDidChangeConfiguration = this._register(( (new Emitter())));
+        this.onDidChangeConfiguration = this._onDidChangeConfiguration.event;
+        this._onDidInitialize = this._register(( (new Emitter())));
+        this.onDidInitialize = this._onDidInitialize.event;
+        this._fileService = fileService;
+        this._userConfiguration = this._cachedConfiguration = ( (new CachedRemoteUserConfiguration(remoteAuthority, configurationCache, { scopes: REMOTE_MACHINE_SCOPES })));
+        remoteAgentService.getEnvironment().then(async (environment) => {
+            if (environment) {
+                const userConfiguration = this._register(( (new FileServiceBasedRemoteUserConfiguration(
+                    environment.settingsPath,
+                    { scopes: REMOTE_MACHINE_SCOPES },
+                    this._fileService,
+                    uriIdentityService
+                ))));
+                this._register(userConfiguration.onDidChangeConfiguration(configurationModel => this.onDidUserConfigurationChange(configurationModel)));
+                this._userConfigurationInitializationPromise = userConfiguration.initialize();
+                const configurationModel = await this._userConfigurationInitializationPromise;
+                this._userConfiguration.dispose();
+                this._userConfiguration = userConfiguration;
+                this.onDidUserConfigurationChange(configurationModel);
+                this._onDidInitialize.fire(configurationModel);
+            }
+        });
+    }
+    async initialize() {
+        if (this._userConfiguration instanceof FileServiceBasedRemoteUserConfiguration) {
+            return this._userConfiguration.initialize();
+        }
+        let configurationModel = await this._userConfiguration.initialize();
+        if (this._userConfigurationInitializationPromise) {
+            configurationModel = await this._userConfigurationInitializationPromise;
+            this._userConfigurationInitializationPromise = null;
+        }
+        return configurationModel;
+    }
+    reload() {
+        return this._userConfiguration.reload();
+    }
+    reparse() {
+        return this._userConfiguration.reparse({ scopes: REMOTE_MACHINE_SCOPES });
+    }
+    getRestrictedSettings() {
+        return this._userConfiguration.getRestrictedSettings();
+    }
+    onDidUserConfigurationChange(configurationModel) {
+        this.updateCache();
+        this._onDidChangeConfiguration.fire(configurationModel);
+    }
+    async updateCache() {
+        if (this._userConfiguration instanceof FileServiceBasedRemoteUserConfiguration) {
+            let content;
+            try {
+                content = await this._userConfiguration.resolveContent();
+            }
+            catch (error) {
+                if (error.fileOperationResult !== 1 ) {
+                    return;
+                }
+            }
+            await this._cachedConfiguration.updateConfiguration(content);
+        }
+    }
+}
+class FileServiceBasedRemoteUserConfiguration extends Disposable {
+    constructor(configurationResource, configurationParseOptions, fileService, uriIdentityService) {
+        super();
+        this.configurationResource = configurationResource;
+        this.fileService = fileService;
+        this.uriIdentityService = uriIdentityService;
+        this._onDidChangeConfiguration = this._register(( (new Emitter())));
+        this.onDidChangeConfiguration = this._onDidChangeConfiguration.event;
+        this.fileWatcherDisposable = Disposable.None;
+        this.directoryWatcherDisposable = Disposable.None;
+        this.parser = ( (new ConfigurationModelParser( (this.configurationResource.toString()))));
+        this.parseOptions = configurationParseOptions;
+        this._register(fileService.onDidFilesChange(e => this.handleFileChangesEvent(e)));
+        this._register(fileService.onDidRunOperation(e => this.handleFileOperationEvent(e)));
+        this.reloadConfigurationScheduler = this._register(( (new RunOnceScheduler(
+            () => this.reload().then(configurationModel => this._onDidChangeConfiguration.fire(configurationModel)),
+            50
+        ))));
+        this._register(toDisposable(() => {
+            this.stopWatchingResource();
+            this.stopWatchingDirectory();
+        }));
+    }
+    watchResource() {
+        this.fileWatcherDisposable = this.fileService.watch(this.configurationResource);
+    }
+    stopWatchingResource() {
+        this.fileWatcherDisposable.dispose();
+        this.fileWatcherDisposable = Disposable.None;
+    }
+    watchDirectory() {
+        const directory = this.uriIdentityService.extUri.dirname(this.configurationResource);
+        this.directoryWatcherDisposable = this.fileService.watch(directory);
+    }
+    stopWatchingDirectory() {
+        this.directoryWatcherDisposable.dispose();
+        this.directoryWatcherDisposable = Disposable.None;
+    }
+    async initialize() {
+        const exists = await this.fileService.exists(this.configurationResource);
+        this.onResourceExists(exists);
+        return this.reload();
+    }
+    async resolveContent() {
+        const content = await this.fileService.readFile(this.configurationResource);
+        return (
+             (content.value.toString())
+        );
+    }
+    async reload() {
+        try {
+            const content = await this.resolveContent();
+            this.parser.parse(content, this.parseOptions);
+            return this.parser.configurationModel;
+        }
+        catch (e) {
+            return (
+                 (new ConfigurationModel())
+            );
+        }
+    }
+    reparse(configurationParseOptions) {
+        this.parseOptions = configurationParseOptions;
+        this.parser.reparse(this.parseOptions);
+        return this.parser.configurationModel;
+    }
+    getRestrictedSettings() {
+        return this.parser.restrictedConfigurations;
+    }
+    handleFileChangesEvent(event) {
+        let affectedByChanges = event.contains(this.configurationResource, 0 );
+        if (event.contains(this.configurationResource, 1 )) {
+            affectedByChanges = true;
+            this.onResourceExists(true);
+        }
+        else if (event.contains(this.configurationResource, 2 )) {
+            affectedByChanges = true;
+            this.onResourceExists(false);
+        }
+        if (affectedByChanges) {
+            this.reloadConfigurationScheduler.schedule();
+        }
+    }
+    handleFileOperationEvent(event) {
+        if ((event.isOperation(0 ) || event.isOperation(3 ) || event.isOperation(1 ) || event.isOperation(4 ))
+            && this.uriIdentityService.extUri.isEqual(event.resource, this.configurationResource)) {
+            this.reloadConfigurationScheduler.schedule();
+        }
+    }
+    onResourceExists(exists) {
+        if (exists) {
+            this.stopWatchingDirectory();
+            this.watchResource();
+        }
+        else {
+            this.stopWatchingResource();
+            this.watchDirectory();
+        }
+    }
+}
+class CachedRemoteUserConfiguration extends Disposable {
+    constructor(remoteAuthority, configurationCache, configurationParseOptions) {
+        super();
+        this.configurationCache = configurationCache;
+        this._onDidChange = this._register(( (new Emitter())));
+        this.onDidChange = this._onDidChange.event;
+        this.key = { type: 'user', key: remoteAuthority };
+        this.parser = ( (new ConfigurationModelParser('CachedRemoteUserConfiguration')));
+        this.parseOptions = configurationParseOptions;
+        this.configurationModel = ( (new ConfigurationModel()));
+    }
+    getConfigurationModel() {
+        return this.configurationModel;
+    }
+    initialize() {
+        return this.reload();
+    }
+    reparse(configurationParseOptions) {
+        this.parseOptions = configurationParseOptions;
+        this.parser.reparse(this.parseOptions);
+        this.configurationModel = this.parser.configurationModel;
+        return this.configurationModel;
+    }
+    getRestrictedSettings() {
+        return this.parser.restrictedConfigurations;
+    }
+    async reload() {
+        try {
+            const content = await this.configurationCache.read(this.key);
+            const parsed = JSON.parse(content);
+            if (parsed.content) {
+                this.parser.parse(parsed.content, this.parseOptions);
+                this.configurationModel = this.parser.configurationModel;
+            }
+        }
+        catch (e) {  }
+        return this.configurationModel;
+    }
+    async updateConfiguration(content) {
+        if (content) {
+            return this.configurationCache.write(this.key, JSON.stringify({ content }));
+        }
+        else {
+            return this.configurationCache.remove(this.key);
+        }
+    }
+}
+class WorkspaceConfiguration extends Disposable {
+    get initialized() { return this._initialized; }
+    constructor(configurationCache, fileService, uriIdentityService, logService) {
+        super();
+        this.configurationCache = configurationCache;
+        this.fileService = fileService;
+        this.uriIdentityService = uriIdentityService;
+        this.logService = logService;
+        this._workspaceConfigurationDisposables = this._register(( (new DisposableStore())));
+        this._workspaceIdentifier = null;
+        this._isWorkspaceTrusted = false;
+        this._onDidUpdateConfiguration = this._register(( (new Emitter())));
+        this.onDidUpdateConfiguration = this._onDidUpdateConfiguration.event;
+        this._initialized = false;
+        this.fileService = fileService;
+        this._workspaceConfiguration = this._cachedConfiguration = ( (new CachedWorkspaceConfiguration(configurationCache)));
+    }
+    async initialize(workspaceIdentifier, workspaceTrusted) {
+        this._workspaceIdentifier = workspaceIdentifier;
+        this._isWorkspaceTrusted = workspaceTrusted;
+        if (!this._initialized) {
+            if (this.configurationCache.needsCaching(this._workspaceIdentifier.configPath)) {
+                this._workspaceConfiguration = this._cachedConfiguration;
+                this.waitAndInitialize(this._workspaceIdentifier);
+            }
+            else {
+                this.doInitialize(( (new FileServiceBasedWorkspaceConfiguration(this.fileService, this.uriIdentityService, this.logService))));
+            }
+        }
+        await this.reload();
+    }
+    async reload() {
+        if (this._workspaceIdentifier) {
+            await this._workspaceConfiguration.load(this._workspaceIdentifier, { scopes: WORKSPACE_SCOPES, skipRestricted: this.isUntrusted() });
+        }
+    }
+    getFolders() {
+        return this._workspaceConfiguration.getFolders();
+    }
+    setFolders(folders, jsonEditingService) {
+        if (this._workspaceIdentifier) {
+            return jsonEditingService.write(this._workspaceIdentifier.configPath, [{ path: ['folders'], value: folders }], true)
+                .then(() => this.reload());
+        }
+        return Promise.resolve();
+    }
+    isTransient() {
+        return this._workspaceConfiguration.isTransient();
+    }
+    getConfiguration() {
+        return this._workspaceConfiguration.getWorkspaceSettings();
+    }
+    updateWorkspaceTrust(trusted) {
+        this._isWorkspaceTrusted = trusted;
+        return this.reparseWorkspaceSettings();
+    }
+    reparseWorkspaceSettings() {
+        this._workspaceConfiguration.reparseWorkspaceSettings({ scopes: WORKSPACE_SCOPES, skipRestricted: this.isUntrusted() });
+        return this.getConfiguration();
+    }
+    getRestrictedSettings() {
+        return this._workspaceConfiguration.getRestrictedSettings();
+    }
+    async waitAndInitialize(workspaceIdentifier) {
+        await whenProviderRegistered(workspaceIdentifier.configPath, this.fileService);
+        if (!(this._workspaceConfiguration instanceof FileServiceBasedWorkspaceConfiguration)) {
+            const fileServiceBasedWorkspaceConfiguration = this._register(( (new FileServiceBasedWorkspaceConfiguration(this.fileService, this.uriIdentityService, this.logService))));
+            await fileServiceBasedWorkspaceConfiguration.load(workspaceIdentifier, { scopes: WORKSPACE_SCOPES, skipRestricted: this.isUntrusted() });
+            this.doInitialize(fileServiceBasedWorkspaceConfiguration);
+            this.onDidWorkspaceConfigurationChange(false, true);
+        }
+    }
+    doInitialize(fileServiceBasedWorkspaceConfiguration) {
+        this._workspaceConfigurationDisposables.clear();
+        this._workspaceConfiguration = this._workspaceConfigurationDisposables.add(fileServiceBasedWorkspaceConfiguration);
+        this._workspaceConfigurationDisposables.add(this._workspaceConfiguration.onDidChange(e => this.onDidWorkspaceConfigurationChange(true, false)));
+        this._initialized = true;
+    }
+    isUntrusted() {
+        return !this._isWorkspaceTrusted;
+    }
+    async onDidWorkspaceConfigurationChange(reload, fromCache) {
+        if (reload) {
+            await this.reload();
+        }
+        this.updateCache();
+        this._onDidUpdateConfiguration.fire(fromCache);
+    }
+    async updateCache() {
+        if (this._workspaceIdentifier && this.configurationCache.needsCaching(this._workspaceIdentifier.configPath) && this._workspaceConfiguration instanceof FileServiceBasedWorkspaceConfiguration) {
+            const content = await this._workspaceConfiguration.resolveContent(this._workspaceIdentifier);
+            await this._cachedConfiguration.updateWorkspace(this._workspaceIdentifier, content);
+        }
+    }
+}
+class FileServiceBasedWorkspaceConfiguration extends Disposable {
+    constructor(fileService, uriIdentityService, logService) {
+        super();
+        this.fileService = fileService;
+        this.logService = logService;
+        this._workspaceIdentifier = null;
+        this._onDidChange = this._register(( (new Emitter())));
+        this.onDidChange = this._onDidChange.event;
+        this.workspaceConfigurationModelParser = ( (new WorkspaceConfigurationModelParser('')));
+        this.workspaceSettings = ( (new ConfigurationModel()));
+        this._register(Event.any(Event.filter(this.fileService.onDidFilesChange, e => !!this._workspaceIdentifier && e.contains(this._workspaceIdentifier.configPath)), Event.filter(this.fileService.onDidRunOperation, e => !!this._workspaceIdentifier && (e.isOperation(0 ) || e.isOperation(3 ) || e.isOperation(1 ) || e.isOperation(4 )) && uriIdentityService.extUri.isEqual(e.resource, this._workspaceIdentifier.configPath)))(() => this.reloadConfigurationScheduler.schedule()));
+        this.reloadConfigurationScheduler = this._register(( (new RunOnceScheduler(() => this._onDidChange.fire(), 50))));
+        this.workspaceConfigWatcher = this._register(this.watchWorkspaceConfigurationFile());
+    }
+    get workspaceIdentifier() {
+        return this._workspaceIdentifier;
+    }
+    async resolveContent(workspaceIdentifier) {
+        const content = await this.fileService.readFile(workspaceIdentifier.configPath);
+        return (
+             (content.value.toString())
+        );
+    }
+    async load(workspaceIdentifier, configurationParseOptions) {
+        if (!this._workspaceIdentifier || this._workspaceIdentifier.id !== workspaceIdentifier.id) {
+            this._workspaceIdentifier = workspaceIdentifier;
+            this.workspaceConfigurationModelParser = ( (new WorkspaceConfigurationModelParser(this._workspaceIdentifier.id)));
+            dispose(this.workspaceConfigWatcher);
+            this.workspaceConfigWatcher = this._register(this.watchWorkspaceConfigurationFile());
+        }
+        let contents = '';
+        try {
+            contents = await this.resolveContent(this._workspaceIdentifier);
+        }
+        catch (error) {
+            const exists = await this.fileService.exists(this._workspaceIdentifier.configPath);
+            if (exists) {
+                this.logService.error(error);
+            }
+        }
+        this.workspaceConfigurationModelParser.parse(contents, configurationParseOptions);
+        this.consolidate();
+    }
+    getConfigurationModel() {
+        return this.workspaceConfigurationModelParser.configurationModel;
+    }
+    getFolders() {
+        return this.workspaceConfigurationModelParser.folders;
+    }
+    isTransient() {
+        return this.workspaceConfigurationModelParser.transient;
+    }
+    getWorkspaceSettings() {
+        return this.workspaceSettings;
+    }
+    reparseWorkspaceSettings(configurationParseOptions) {
+        this.workspaceConfigurationModelParser.reparseWorkspaceSettings(configurationParseOptions);
+        this.consolidate();
+        return this.getWorkspaceSettings();
+    }
+    getRestrictedSettings() {
+        return this.workspaceConfigurationModelParser.getRestrictedWorkspaceSettings();
+    }
+    consolidate() {
+        this.workspaceSettings = this.workspaceConfigurationModelParser.settingsModel.merge(this.workspaceConfigurationModelParser.launchModel, this.workspaceConfigurationModelParser.tasksModel);
+    }
+    watchWorkspaceConfigurationFile() {
+        return this._workspaceIdentifier ? this.fileService.watch(this._workspaceIdentifier.configPath) : Disposable.None;
+    }
+}
+class CachedWorkspaceConfiguration {
+    constructor(configurationCache) {
+        this.configurationCache = configurationCache;
+        this.onDidChange = Event.None;
+        this.workspaceConfigurationModelParser = ( (new WorkspaceConfigurationModelParser('')));
+        this.workspaceSettings = ( (new ConfigurationModel()));
+    }
+    async load(workspaceIdentifier, configurationParseOptions) {
+        try {
+            const key = this.getKey(workspaceIdentifier);
+            const contents = await this.configurationCache.read(key);
+            const parsed = JSON.parse(contents);
+            if (parsed.content) {
+                this.workspaceConfigurationModelParser = ( (new WorkspaceConfigurationModelParser(key.key)));
+                this.workspaceConfigurationModelParser.parse(parsed.content, configurationParseOptions);
+                this.consolidate();
+            }
+        }
+        catch (e) {
+        }
+    }
+    get workspaceIdentifier() {
+        return null;
+    }
+    getConfigurationModel() {
+        return this.workspaceConfigurationModelParser.configurationModel;
+    }
+    getFolders() {
+        return this.workspaceConfigurationModelParser.folders;
+    }
+    isTransient() {
+        return this.workspaceConfigurationModelParser.transient;
+    }
+    getWorkspaceSettings() {
+        return this.workspaceSettings;
+    }
+    reparseWorkspaceSettings(configurationParseOptions) {
+        this.workspaceConfigurationModelParser.reparseWorkspaceSettings(configurationParseOptions);
+        this.consolidate();
+        return this.getWorkspaceSettings();
+    }
+    getRestrictedSettings() {
+        return this.workspaceConfigurationModelParser.getRestrictedWorkspaceSettings();
+    }
+    consolidate() {
+        this.workspaceSettings = this.workspaceConfigurationModelParser.settingsModel.merge(this.workspaceConfigurationModelParser.launchModel, this.workspaceConfigurationModelParser.tasksModel);
+    }
+    async updateWorkspace(workspaceIdentifier, content) {
+        try {
+            const key = this.getKey(workspaceIdentifier);
+            if (content) {
+                await this.configurationCache.write(key, JSON.stringify({ content }));
+            }
+            else {
+                await this.configurationCache.remove(key);
+            }
+        }
+        catch (error) {
+        }
+    }
+    getKey(workspaceIdentifier) {
+        return {
+            type: 'workspaces',
+            key: workspaceIdentifier.id
+        };
+    }
+}
+class CachedFolderConfiguration {
+    constructor(folder, configFolderRelativePath, configurationParseOptions, configurationCache) {
+        this.configurationCache = configurationCache;
+        this.onDidChange = Event.None;
+        this.key = { type: 'folder', key: ( (hash(( (joinPath(folder, configFolderRelativePath).toString()))).toString(16))) };
+        this._folderSettingsModelParser = ( (new ConfigurationModelParser('CachedFolderConfiguration')));
+        this._folderSettingsParseOptions = configurationParseOptions;
+        this._standAloneConfigurations = [];
+        this.configurationModel = ( (new ConfigurationModel()));
+    }
+    async loadConfiguration() {
+        try {
+            const contents = await this.configurationCache.read(this.key);
+            const { content: configurationContents } = JSON.parse(( (contents.toString())));
+            if (configurationContents) {
+                for (const key of ( (Object.keys(configurationContents)))) {
+                    if (key === FOLDER_SETTINGS_NAME) {
+                        this._folderSettingsModelParser.parse(configurationContents[key], this._folderSettingsParseOptions);
+                    }
+                    else {
+                        const standAloneConfigurationModelParser = ( (new StandaloneConfigurationModelParser(key, key)));
+                        standAloneConfigurationModelParser.parse(configurationContents[key]);
+                        this._standAloneConfigurations.push(standAloneConfigurationModelParser.configurationModel);
+                    }
+                }
+            }
+            this.consolidate();
+        }
+        catch (e) {
+        }
+        return this.configurationModel;
+    }
+    async updateConfiguration(settingsContent, standAloneConfigurationContents) {
+        const content = {};
+        if (settingsContent) {
+            content[FOLDER_SETTINGS_NAME] = settingsContent;
+        }
+        standAloneConfigurationContents.forEach(([key, contents]) => {
+            if (contents) {
+                content[key] = contents;
+            }
+        });
+        if (( (Object.keys(content))).length) {
+            await this.configurationCache.write(this.key, JSON.stringify({ content }));
+        }
+        else {
+            await this.configurationCache.remove(this.key);
+        }
+    }
+    getRestrictedSettings() {
+        return this._folderSettingsModelParser.restrictedConfigurations;
+    }
+    reparse(configurationParseOptions) {
+        this._folderSettingsParseOptions = configurationParseOptions;
+        this._folderSettingsModelParser.reparse(this._folderSettingsParseOptions);
+        this.consolidate();
+        return this.configurationModel;
+    }
+    consolidate() {
+        this.configurationModel = this._folderSettingsModelParser.configurationModel.merge(...this._standAloneConfigurations);
+    }
+    getUnsupportedKeys() {
+        return [];
+    }
+}
+class FolderConfiguration extends Disposable {
+    constructor(useCache, workspaceFolder, configFolderRelativePath, workbenchState, workspaceTrusted, fileService, uriIdentityService, logService, configurationCache) {
+        super();
+        this.workspaceFolder = workspaceFolder;
+        this.workbenchState = workbenchState;
+        this.workspaceTrusted = workspaceTrusted;
+        this.configurationCache = configurationCache;
+        this._onDidChange = this._register(( (new Emitter())));
+        this.onDidChange = this._onDidChange.event;
+        this.scopes = 3  === this.workbenchState ? FOLDER_SCOPES : WORKSPACE_SCOPES;
+        this.configurationFolder = uriIdentityService.extUri.joinPath(workspaceFolder.uri, configFolderRelativePath);
+        this.cachedFolderConfiguration = ( (new CachedFolderConfiguration(
+            workspaceFolder.uri,
+            configFolderRelativePath,
+            { scopes: this.scopes, skipRestricted: this.isUntrusted() },
+            configurationCache
+        )));
+        if (useCache && this.configurationCache.needsCaching(workspaceFolder.uri)) {
+            this.folderConfiguration = this.cachedFolderConfiguration;
+            whenProviderRegistered(workspaceFolder.uri, fileService)
+                .then(() => {
+                this.folderConfiguration = this._register(this.createFileServiceBasedConfiguration(fileService, uriIdentityService, logService));
+                this._register(this.folderConfiguration.onDidChange(e => this.onDidFolderConfigurationChange()));
+                this.onDidFolderConfigurationChange();
+            });
+        }
+        else {
+            this.folderConfiguration = this._register(this.createFileServiceBasedConfiguration(fileService, uriIdentityService, logService));
+            this._register(this.folderConfiguration.onDidChange(e => this.onDidFolderConfigurationChange()));
+        }
+    }
+    loadConfiguration() {
+        return this.folderConfiguration.loadConfiguration();
+    }
+    updateWorkspaceTrust(trusted) {
+        this.workspaceTrusted = trusted;
+        return this.reparse();
+    }
+    reparse() {
+        const configurationModel = this.folderConfiguration.reparse({ scopes: this.scopes, skipRestricted: this.isUntrusted() });
+        this.updateCache();
+        return configurationModel;
+    }
+    getRestrictedSettings() {
+        return this.folderConfiguration.getRestrictedSettings();
+    }
+    isUntrusted() {
+        return !this.workspaceTrusted;
+    }
+    onDidFolderConfigurationChange() {
+        this.updateCache();
+        this._onDidChange.fire();
+    }
+    createFileServiceBasedConfiguration(fileService, uriIdentityService, logService) {
+        const settingsResource = uriIdentityService.extUri.joinPath(this.configurationFolder, `${FOLDER_SETTINGS_NAME}.json`);
+        const standAloneConfigurationResources = ( ([TASKS_CONFIGURATION_KEY, LAUNCH_CONFIGURATION_KEY].map(
+            name => ([name, uriIdentityService.extUri.joinPath(this.configurationFolder, `${name}.json`)])
+        )));
+        return (
+             (new FileServiceBasedConfiguration(
+                 (this.configurationFolder.toString()),
+                settingsResource,
+                standAloneConfigurationResources,
+                { scopes: this.scopes, skipRestricted: this.isUntrusted() },
+                fileService,
+                uriIdentityService,
+                logService
+            ))
+        );
+    }
+    async updateCache() {
+        if (this.configurationCache.needsCaching(this.configurationFolder) && this.folderConfiguration instanceof FileServiceBasedConfiguration) {
+            const [settingsContent, standAloneConfigurationContents] = await this.folderConfiguration.resolveContents();
+            this.cachedFolderConfiguration.updateConfiguration(settingsContent, standAloneConfigurationContents);
+        }
+    }
+}
+export { DefaultConfiguration, FolderConfiguration, RemoteUserConfiguration, UserConfiguration, WorkspaceConfiguration };