@codingame/monaco-vscode-api 1.69.8 → 1.69.9

package/dist/configuration.js

@@ -1,28 +1,25 @@
-import { b as __decorate, d as __param } from './contextkey.js';
+import { _ as __decorate, a as __param } from './contextkey.js';
 import { E as Emitter, U as UserSettings } from './polyfill.js';
-import { e as IPolicyService, N as NullPolicyService, f as IUserDataProfilesService } from './missing-services.js';
+import { e as IUserDataProfilesService, f as IPolicyService, N as NullPolicyService } from './missing-services.js';
 import { b as isEmptyObject } from './types.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { Extensions, OVERRIDE_PROPERTY_REGEX, overrideIdentifiersFromKey, machineOverridableSettings, windowSettings, resourceSettings, allSettings, OVERRIDE_PROPERTY_PATTERN, resourceLanguageSettingsSchemaId, applicationSettings, machineSettings } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
-import { ConfigurationModel, Configuration, ConfigurationChangeEvent } from 'monaco-editor/esm/vs/platform/configuration/common/configurationModels.js';
-import { addToValueTree, toValuesTree, IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Extensions, machineOverridableSettings, windowSettings, resourceSettings, allSettings, OVERRIDE_PROPERTY_PATTERN, resourceLanguageSettingsSchemaId, OVERRIDE_PROPERTY_REGEX, overrideIdentifiersFromKey, applicationSettings, machineSettings } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { Configuration, ConfigurationModel, ConfigurationChangeEvent } from 'monaco-editor/esm/vs/platform/configuration/common/configurationModels.js';
+import { IConfigurationService, addToValueTree, toValuesTree } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import { equals } from 'monaco-editor/esm/vs/base/common/objects.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { isArray, isUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { isArray } from 'monaco-editor/esm/vs/base/common/types.js';
 import { extUriBiasedIgnorePathCase } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
-import { bf as Position, bg as getTelemetryLevel, bh as configurationDefaultsSchemaId } from './extHost.js';
-export { bi as ConfigurationScope } from './extHost.js';
+import { bf as Position$2, bg as configurationDefaultsSchemaId } from './extHost.js';
+export { bh as ConfigurationScope } from './extHost.js';
 import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
 import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
-import { e as IWorkbenchEnvironmentService, d as IFileService } from './services2.js';
-import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { language } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { i as IFileService, j as IWorkbenchEnvironmentService } from './services2.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
 import { IWorkspaceTrustManagementService } from 'monaco-editor/esm/vs/platform/workspace/common/workspaceTrust.js';
@@ -50,18 +47,18 @@ function isConfigurationUpdateOverrides(thing) {
 class DefaultConfiguration extends Disposable {
     constructor() {
         super(...arguments);
-        this._onDidChangeConfiguration = this._register(( new Emitter()));
+        this._onDidChangeConfiguration = this._register(( (new Emitter())));
         this.onDidChangeConfiguration = this._onDidChangeConfiguration.event;
     }
     get configurationModel() {
         if (!this._configurationModel) {
-            this._configurationModel = ( new DefaultConfigurationModel(this.getConfigurationDefaultOverrides()));
+            this._configurationModel = ( (new DefaultConfigurationModel(this.getConfigurationDefaultOverrides())));
         }
         return this._configurationModel;
     }
     async initialize() {
         this._configurationModel = undefined;
-        this._register(( Registry.as(Extensions.Configuration)).onDidUpdateConfiguration(({ properties, defaultsOverrides }) => this.onDidUpdateConfiguration(properties, defaultsOverrides)));
+        this._register(( (Registry.as(Extensions.Configuration))).onDidUpdateConfiguration(({ properties, defaultsOverrides }) => this.onDidUpdateConfiguration(properties, defaultsOverrides)));
         return this.configurationModel;
     }
     reload() {
@@ -78,8 +75,8 @@ class DefaultConfiguration extends Disposable {
 }
 class DefaultConfigurationModel extends ConfigurationModel {
     constructor(configurationDefaultsOverrides = {}) {
-        const properties = ( Registry.as(Extensions.Configuration)).getConfigurationProperties();
-        const keys = ( Object.keys(properties));
+        const properties = ( (Registry.as(Extensions.Configuration))).getConfigurationProperties();
+        const keys = ( (Object.keys(properties)));
         const contents = Object.create(null);
         const overrides = [];
         for (const key in properties) {
@@ -87,11 +84,11 @@ class DefaultConfigurationModel extends ConfigurationModel {
             const value = defaultOverrideValue !== undefined ? defaultOverrideValue : properties[key].default;
             addToValueTree(contents, key, value, message => console.error(`Conflict in default settings: ${message}`));
         }
-        for (const key of ( Object.keys(contents))) {
+        for (const key of ( (Object.keys(contents)))) {
             if (OVERRIDE_PROPERTY_REGEX.test(key)) {
                 overrides.push({
                     identifiers: overrideIdentifiersFromKey(key),
-                    keys: ( Object.keys(contents[key])),
+                    keys: ( (Object.keys(contents[key]))),
                     contents: toValuesTree(contents[key], message => console.error(`Conflict in default settings file: ${message}`)),
                 });
             }
@@ -102,7 +99,7 @@ class DefaultConfigurationModel extends ConfigurationModel {
 class NullPolicyConfiguration {
     constructor() {
         this.onDidChangeConfiguration = Event.None;
-        this.configurationModel = ( new ConfigurationModel());
+        this.configurationModel = ( (new ConfigurationModel()));
     }
     async initialize() { return this.configurationModel; }
 }
@@ -112,9 +109,9 @@ let PolicyConfiguration = class PolicyConfiguration extends Disposable {
         this.defaultConfiguration = defaultConfiguration;
         this.policyService = policyService;
         this.logService = logService;
-        this._onDidChangeConfiguration = this._register(( new Emitter()));
+        this._onDidChangeConfiguration = this._register(( (new Emitter())));
         this.onDidChangeConfiguration = this._onDidChangeConfiguration.event;
-        this._configurationModel = ( new ConfigurationModel());
+        this._configurationModel = ( (new ConfigurationModel()));
     }
     get configurationModel() { return this._configurationModel; }
     async initialize() {
@@ -126,7 +123,7 @@ let PolicyConfiguration = class PolicyConfiguration extends Disposable {
     async registerPolicyDefinitions(properties) {
         const policyDefinitions = {};
         const keys = [];
-        const configurationProperties = ( Registry.as(Extensions.Configuration)).getConfigurationProperties();
+        const configurationProperties = ( (Registry.as(Extensions.Configuration))).getConfigurationProperties();
         for (const key of properties) {
             const config = configurationProperties[key];
             if (!config) {
@@ -148,12 +145,12 @@ let PolicyConfiguration = class PolicyConfiguration extends Disposable {
         return keys;
     }
     onDidChangePolicies(policyNames) {
-        const policyConfigurations = ( Registry.as(Extensions.Configuration)).getPolicyConfigurations();
+        const policyConfigurations = ( (Registry.as(Extensions.Configuration))).getPolicyConfigurations();
         const keys = coalesce(policyNames.map(policyName => policyConfigurations.get(policyName)));
         this.update(keys, true);
     }
     update(keys, trigger) {
-        const configurationProperties = ( Registry.as(Extensions.Configuration)).getConfigurationProperties();
+        const configurationProperties = ( (Registry.as(Extensions.Configuration))).getConfigurationProperties();
         const changed = [];
         const wasEmpty = this._configurationModel.isEmpty();
         for (const key of keys) {
@@ -172,7 +169,7 @@ let PolicyConfiguration = class PolicyConfiguration extends Disposable {
         }
         if (changed.length) {
             const old = this._configurationModel;
-            this._configurationModel = ( new ConfigurationModel());
+            this._configurationModel = ( (new ConfigurationModel()));
             for (const key of old.keys) {
                 this._configurationModel.setValue(key, old.getValue(key));
             }
@@ -190,33 +187,38 @@ let PolicyConfiguration = class PolicyConfiguration extends Disposable {
         }
     }
 };
-PolicyConfiguration = ( __decorate([
-    ( __param(1, IPolicyService)),
-    ( __param(2, ILogService))
-], PolicyConfiguration));
+PolicyConfiguration = ( (__decorate([
+    ( (__param(1, IPolicyService))),
+    ( (__param(2, ILogService)))
+], PolicyConfiguration)));
 class ConfigurationService extends Disposable {
     constructor(settingsResource, fileService, policyService, logService) {
         super();
         this.settingsResource = settingsResource;
-        this._onDidChangeConfiguration = this._register(( new Emitter()));
+        this._onDidChangeConfiguration = this._register(( (new Emitter())));
         this.onDidChangeConfiguration = this._onDidChangeConfiguration.event;
-        this.defaultConfiguration = this._register(( new DefaultConfiguration()));
-        this.policyConfiguration = policyService instanceof NullPolicyService ? ( new NullPolicyConfiguration()) : this._register(( new PolicyConfiguration(this.defaultConfiguration, policyService, logService)));
-        this.userConfiguration = this._register(( new UserSettings(this.settingsResource, undefined, extUriBiasedIgnorePathCase, fileService)));
-        this.configuration = ( new Configuration(
+        this.defaultConfiguration = this._register(( (new DefaultConfiguration())));
+        this.policyConfiguration = policyService instanceof NullPolicyService ? ( (new NullPolicyConfiguration())) : this._register(( (new PolicyConfiguration(this.defaultConfiguration, policyService, logService))));
+        this.userConfiguration = this._register(( (new UserSettings(this.settingsResource, undefined, extUriBiasedIgnorePathCase, fileService))));
+        this.configuration = ( (new Configuration(
             this.defaultConfiguration.configurationModel,
             this.policyConfiguration.configurationModel,
-            ( new ConfigurationModel()),
-            ( new ConfigurationModel())
-        ));
-        this.reloadConfigurationScheduler = this._register(( new RunOnceScheduler(() => this.reloadConfiguration(), 50)));
+             (new ConfigurationModel()),
+             (new ConfigurationModel())
+        )));
+        this.reloadConfigurationScheduler = this._register(( (new RunOnceScheduler(() => this.reloadConfiguration(), 50))));
         this._register(this.defaultConfiguration.onDidChangeConfiguration(({ defaults, properties }) => this.onDidDefaultConfigurationChange(defaults, properties)));
         this._register(this.policyConfiguration.onDidChangeConfiguration(model => this.onDidPolicyConfigurationChange(model)));
         this._register(this.userConfiguration.onDidChange(() => this.reloadConfigurationScheduler.schedule()));
     }
     async initialize() {
         const [defaultModel, policyModel, userModel] = await Promise.all([this.defaultConfiguration.initialize(), this.policyConfiguration.initialize(), this.userConfiguration.loadConfiguration()]);
-        this.configuration = ( new Configuration(defaultModel, policyModel, ( new ConfigurationModel()), userModel));
+        this.configuration = ( (new Configuration(
+            defaultModel,
+            policyModel,
+             (new ConfigurationModel()),
+            userModel
+        )));
     }
     getConfigurationData() {
         return this.configuration.toData();
@@ -227,13 +229,15 @@ class ConfigurationService extends Disposable {
         return this.configuration.getValue(section, overrides, undefined);
     }
     updateValue(key, value, arg3, arg4) {
-        return Promise.reject(( new Error('not supported')));
+        return Promise.reject(( (new Error('not supported'))));
     }
     inspect(key) {
         return this.configuration.inspect(key, {}, undefined);
     }
     keys() {
-        return ( this.configuration.keys(undefined));
+        return (
+             (this.configuration.keys(undefined))
+        );
     }
     async reloadConfiguration() {
         const configurationModel = await this.userConfiguration.loadConfiguration();
@@ -255,7 +259,7 @@ class ConfigurationService extends Disposable {
         this.trigger(change, previous, 7 );
     }
     trigger(configurationChange, previous, source) {
-        const event = ( new ConfigurationChangeEvent(configurationChange, { data: previous }, this.configuration));
+        const event = ( (new ConfigurationChangeEvent(configurationChange, { data: previous }, this.configuration)));
         event.source = source;
         event.sourceConfig = this.getTargetConfiguration(source);
         this._onDidChangeConfiguration.fire(event);
@@ -276,13 +280,13 @@ let TextResourceConfigurationService = class TextResourceConfigurationService ex
         this.configurationService = configurationService;
         this.modelService = modelService;
         this.languageService = languageService;
-        this._onDidChangeConfiguration = this._register(( new Emitter()));
+        this._onDidChangeConfiguration = this._register(( (new Emitter())));
         this.onDidChangeConfiguration = this._onDidChangeConfiguration.event;
         this._register(this.configurationService.onDidChangeConfiguration(e => this._onDidChangeConfiguration.fire(this.toResourceConfigurationChangeEvent(e))));
     }
     getValue(resource, arg2, arg3) {
         if (typeof arg3 === 'string') {
-            return this._getValue(resource, Position.isIPosition(arg2) ? arg2 : null, arg3);
+            return this._getValue(resource, Position$2.isIPosition(arg2) ? arg2 : null, arg3);
         }
         return this._getValue(resource, null, typeof arg2 === 'string' ? arg2 : undefined);
     }
@@ -369,11 +373,11 @@ let TextResourceConfigurationService = class TextResourceConfigurationService ex
         };
     }
 };
-TextResourceConfigurationService = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, IModelService)),
-    ( __param(2, ILanguageService))
-], TextResourceConfigurationService));
+TextResourceConfigurationService = ( (__decorate([
+    ( (__param(0, IConfigurationService))),
+    ( (__param(1, IModelService))),
+    ( (__param(2, ILanguageService)))
+], TextResourceConfigurationService)));
 const FOLDER_CONFIG_FOLDER_NAME = '.vscode';
 const defaultSettingsSchemaId = 'vscode://schemas/settings/default';
 const userSettingsSchemaId = 'vscode://schemas/settings/user';
@@ -388,283 +392,6 @@ WORKSPACE_STANDALONE_CONFIGURATIONS[TASKS_CONFIGURATION_KEY] = `${FOLDER_CONFIG_
 WORKSPACE_STANDALONE_CONFIGURATIONS[LAUNCH_CONFIGURATION_KEY] = `${FOLDER_CONFIG_FOLDER_NAME}/${LAUNCH_CONFIGURATION_KEY}.json`;
 const USER_STANDALONE_CONFIGURATIONS = Object.create(null);
 USER_STANDALONE_CONFIGURATIONS[TASKS_CONFIGURATION_KEY] = `${TASKS_CONFIGURATION_KEY}.json`;
-class Memento {
-    constructor(id, storageService) {
-        this.storageService = storageService;
-        this.id = Memento.COMMON_PREFIX + id;
-    }
-    getMemento(scope, target) {
-        switch (scope) {
-            case 1 : {
-                let workspaceMemento = Memento.workspaceMementos.get(this.id);
-                if (!workspaceMemento) {
-                    workspaceMemento = ( new ScopedMemento(this.id, scope, target, this.storageService));
-                    Memento.workspaceMementos.set(this.id, workspaceMemento);
-                }
-                return workspaceMemento.getMemento();
-            }
-            case 0 : {
-                let profileMemento = Memento.profileMementos.get(this.id);
-                if (!profileMemento) {
-                    profileMemento = ( new ScopedMemento(this.id, scope, target, this.storageService));
-                    Memento.profileMementos.set(this.id, profileMemento);
-                }
-                return profileMemento.getMemento();
-            }
-            case -1 : {
-                let applicationMemento = Memento.applicationMementos.get(this.id);
-                if (!applicationMemento) {
-                    applicationMemento = ( new ScopedMemento(this.id, scope, target, this.storageService));
-                    Memento.applicationMementos.set(this.id, applicationMemento);
-                }
-                return applicationMemento.getMemento();
-            }
-        }
-    }
-    saveMemento() {
-        Memento.workspaceMementos.get(this.id)?.save();
-        Memento.profileMementos.get(this.id)?.save();
-        Memento.applicationMementos.get(this.id)?.save();
-    }
-    static clear(scope) {
-        switch (scope) {
-            case 1 :
-                Memento.workspaceMementos.clear();
-                break;
-            case 0 :
-                Memento.profileMementos.clear();
-                break;
-            case -1 :
-                Memento.applicationMementos.clear();
-                break;
-        }
-    }
-}
-Memento.applicationMementos = ( new Map());
-Memento.profileMementos = ( new Map());
-Memento.workspaceMementos = ( new Map());
-Memento.COMMON_PREFIX = 'memento/';
-class ScopedMemento {
-    constructor(id, scope, target, storageService) {
-        this.id = id;
-        this.scope = scope;
-        this.target = target;
-        this.storageService = storageService;
-        this.mementoObj = this.load();
-    }
-    getMemento() {
-        return this.mementoObj;
-    }
-    load() {
-        const memento = this.storageService.get(this.id, this.scope);
-        if (memento) {
-            try {
-                return JSON.parse(memento);
-            }
-            catch (error) {
-                onUnexpectedError(`[memento]: failed to parse contents: ${error} (id: ${this.id}, scope: ${this.scope}, contents: ${memento})`);
-            }
-        }
-        return {};
-    }
-    save() {
-        if (!isEmptyObject(this.mementoObj)) {
-            this.storageService.store(this.id, JSON.stringify(this.mementoObj), this.scope, this.target);
-        }
-        else {
-            this.storageService.remove(this.id, this.scope);
-        }
-    }
-}
-const ASSIGNMENT_STORAGE_KEY = 'VSCode.ABExp.FeatureData';
-const ASSIGNMENT_REFETCH_INTERVAL = 0;
-var TargetPopulation;
-( (function(TargetPopulation) {
-    TargetPopulation["Team"] = "team";
-    TargetPopulation["Internal"] = "internal";
-    TargetPopulation["Insiders"] = "insider";
-    TargetPopulation["Public"] = "public";
-})(TargetPopulation || (TargetPopulation = {})));
-var Filters;
-( (function(Filters) {
-    Filters["Market"] = "X-MSEdge-Market";
-    Filters["CorpNet"] = "X-FD-Corpnet";
-    Filters["ApplicationVersion"] = "X-VSCode-AppVersion";
-    Filters["Build"] = "X-VSCode-Build";
-    Filters["ClientId"] = "X-MSEdge-ClientId";
-    Filters["ExtensionName"] = "X-VSCode-ExtensionName";
-    Filters["ExtensionVersion"] = "X-VSCode-ExtensionVersion";
-    Filters["Language"] = "X-VSCode-Language";
-    Filters["TargetPopulation"] = "X-VSCode-TargetPopulation";
-})(Filters || (Filters = {})));
-class AssignmentFilterProvider {
-    constructor(version, appName, machineId, targetPopulation) {
-        this.version = version;
-        this.appName = appName;
-        this.machineId = machineId;
-        this.targetPopulation = targetPopulation;
-    }
-    getFilterValue(filter) {
-        switch (filter) {
-            case Filters.ApplicationVersion:
-                return this.version;
-            case Filters.Build:
-                return this.appName;
-            case Filters.ClientId:
-                return this.machineId;
-            case Filters.Language:
-                return language;
-            case Filters.ExtensionName:
-                return 'vscode-core';
-            case Filters.ExtensionVersion:
-                return '999999.0';
-            case Filters.TargetPopulation:
-                return this.targetPopulation;
-            default:
-                return '';
-        }
-    }
-    getFilters() {
-        const filters = ( new Map());
-        const filterValues = ( Object.values(Filters));
-        for (const value of filterValues) {
-            filters.set(value, this.getFilterValue(value));
-        }
-        return filters;
-    }
-}
-class BaseAssignmentService {
-    constructor(getMachineId, configurationService, productService, telemetry, keyValueStorage) {
-        this.getMachineId = getMachineId;
-        this.configurationService = configurationService;
-        this.productService = productService;
-        this.telemetry = telemetry;
-        this.keyValueStorage = keyValueStorage;
-        this.networkInitialized = false;
-        if (productService.tasConfig && this.experimentsEnabled && getTelemetryLevel(this.configurationService) === 3 ) {
-            this.tasClient = this.setupTASClient();
-        }
-        const overrideDelaySetting = this.configurationService.getValue('experiments.overrideDelay');
-        const overrideDelay = typeof overrideDelaySetting === 'number' ? overrideDelaySetting : 0;
-        this.overrideInitDelay = ( new Promise(resolve => setTimeout(resolve, overrideDelay)));
-    }
-    get experimentsEnabled() {
-        return true;
-    }
-    async getTreatment(name) {
-        await this.overrideInitDelay;
-        const override = this.configurationService.getValue('experiments.override.' + name);
-        if (override !== undefined) {
-            return override;
-        }
-        if (!this.tasClient) {
-            return undefined;
-        }
-        if (!this.experimentsEnabled) {
-            return undefined;
-        }
-        let result;
-        const client = await this.tasClient;
-        if (this.networkInitialized) {
-            result = client.getTreatmentVariable('vscode', name);
-        }
-        else {
-            result = await client.getTreatmentVariableAsync('vscode', name, true);
-        }
-        result = client.getTreatmentVariable('vscode', name);
-        return result;
-    }
-    async setupTASClient() {
-        const targetPopulation = this.productService.quality === 'stable' ? TargetPopulation.Public : TargetPopulation.Insiders;
-        const machineId = await this.getMachineId();
-        const filterProvider = ( new AssignmentFilterProvider(
-            this.productService.version,
-            this.productService.nameLong,
-            machineId,
-            targetPopulation
-        ));
-        const tasConfig = this.productService.tasConfig;
-        const tasClient = new ((await import('tas-client-umd').then(module => module.default ?? module)).ExperimentationService)({
-            filterProviders: [filterProvider],
-            telemetry: this.telemetry,
-            storageKey: ASSIGNMENT_STORAGE_KEY,
-            keyValueStorage: this.keyValueStorage,
-            featuresTelemetryPropertyName: tasConfig.featuresTelemetryPropertyName,
-            assignmentContextTelemetryPropertyName: tasConfig.assignmentContextTelemetryPropertyName,
-            telemetryEventName: tasConfig.telemetryEventName,
-            endpoint: tasConfig.endpoint,
-            refetchInterval: ASSIGNMENT_REFETCH_INTERVAL,
-        });
-        await tasClient.initializePromise;
-        tasClient.initialFetch.then(() => this.networkInitialized = true);
-        return tasClient;
-    }
-}
-const IWorkbenchAssignmentService = ( createDecorator('WorkbenchAssignmentService'));
-class MementoKeyValueStorage {
-    constructor(memento) {
-        this.memento = memento;
-        this.mementoObj = memento.getMemento(-1 , 1 );
-    }
-    async getValue(key, defaultValue) {
-        const value = await this.mementoObj[key];
-        return value || defaultValue;
-    }
-    setValue(key, value) {
-        this.mementoObj[key] = value;
-        this.memento.saveMemento();
-    }
-}
-class WorkbenchAssignmentServiceTelemetry {
-    constructor(telemetryService, productService) {
-        this.telemetryService = telemetryService;
-        this.productService = productService;
-    }
-    get assignmentContext() {
-        return this._lastAssignmentContext?.split(';');
-    }
-    setSharedProperty(name, value) {
-        if (name === this.productService.tasConfig?.assignmentContextTelemetryPropertyName) {
-            this._lastAssignmentContext = value;
-        }
-        this.telemetryService.setExperimentProperty(name, value);
-    }
-    postEvent(eventName, props) {
-        const data = {};
-        for (const [key, value] of props.entries()) {
-            data[key] = value;
-        }
-        this.telemetryService.publicLog(eventName, data);
-    }
-}
-(class WorkbenchAssignmentService extends BaseAssignmentService {
-    constructor(telemetryService, storageService, configurationService, productService) {
-        super(() => {
-            return telemetryService.getTelemetryInfo().then(telemetryInfo => {
-                return telemetryInfo.machineId;
-            });
-        }, configurationService, productService, ( new WorkbenchAssignmentServiceTelemetry(telemetryService, productService)), ( new MementoKeyValueStorage(( new Memento('experiment.service.memento', storageService)))));
-        this.telemetryService = telemetryService;
-    }
-    get experimentsEnabled() {
-        return this.configurationService.getValue('workbench.enableExperiments') === true;
-    }
-    async getTreatment(name) {
-        const result = await super.getTreatment(name);
-        this.telemetryService.publicLog2('tasClientReadTreatmentComplete', { treatmentName: name, treatmentValue: JSON.stringify(result) });
-        return result;
-    }
-    async getCurrentExperiments() {
-        if (!this.tasClient) {
-            return undefined;
-        }
-        if (!this.experimentsEnabled) {
-            return undefined;
-        }
-        await this.tasClient;
-        return this.telemetry?.assignmentContext;
-    }
-});
 let RegisterConfigurationSchemasContribution = class RegisterConfigurationSchemasContribution extends Disposable {
     constructor(workspaceContextService, environmentService, workspaceTrustManagementService) {
         super();
@@ -672,13 +399,13 @@ let RegisterConfigurationSchemasContribution = class RegisterConfigurationSchema
         this.environmentService = environmentService;
         this.workspaceTrustManagementService = workspaceTrustManagementService;
         this.registerConfigurationSchemas();
-        const configurationRegistry = ( Registry.as(Extensions.Configuration));
+        const configurationRegistry = ( (Registry.as(Extensions.Configuration)));
         this._register(configurationRegistry.onDidUpdateConfiguration(e => this.registerConfigurationSchemas()));
         this._register(configurationRegistry.onDidSchemaChange(e => this.registerConfigurationSchemas()));
         this._register(workspaceTrustManagementService.onDidChangeTrust(() => this.registerConfigurationSchemas()));
     }
     registerConfigurationSchemas() {
-        const jsonRegistry = ( Registry.as(Extensions$1.JSONContribution));
+        const jsonRegistry = ( (Registry.as(Extensions$1.JSONContribution)));
         const allSettingsSchema = {
             properties: allSettings.properties,
             patternProperties: allSettings.patternProperties,
@@ -735,14 +462,14 @@ let RegisterConfigurationSchemasContribution = class RegisterConfigurationSchema
             allowComments: true
         };
         jsonRegistry.registerSchema(defaultSettingsSchemaId, {
-            properties: ( Object.keys(allSettings.properties)).reduce((result, key) => {
+            properties: ( (Object.keys(allSettings.properties))).reduce((result, key) => {
                 result[key] = {
                     ...allSettings.properties[key],
                     deprecationMessage: undefined
                 };
                 return result;
             }, {}),
-            patternProperties: ( Object.keys(allSettings.patternProperties)).reduce((result, key) => {
+            patternProperties: ( (Object.keys(allSettings.patternProperties))).reduce((result, key) => {
                 result[key] = {
                     ...allSettings.patternProperties[key],
                     deprecationMessage: undefined
@@ -776,10 +503,10 @@ let RegisterConfigurationSchemasContribution = class RegisterConfigurationSchema
         }
         jsonRegistry.registerSchema(configurationDefaultsSchemaId, {
             type: 'object',
-            description: ( localize(
+            description: ( (localize(
                 'configurationDefaults.description',
                 'Contribute defaults for configurations'
-            )),
+            ))),
             properties: {
                 ...machineOverridableSettings.properties,
                 ...windowSettings.properties,
@@ -808,53 +535,16 @@ let RegisterConfigurationSchemasContribution = class RegisterConfigurationSchema
         return result;
     }
 };
-RegisterConfigurationSchemasContribution = ( __decorate([
-    ( __param(0, IWorkspaceContextService)),
-    ( __param(1, IWorkbenchEnvironmentService)),
-    ( __param(2, IWorkspaceTrustManagementService))
-], RegisterConfigurationSchemasContribution));
-let UpdateExperimentalSettingsDefaults = class UpdateExperimentalSettingsDefaults extends Disposable {
-    constructor(workbenchAssignmentService) {
-        super();
-        this.workbenchAssignmentService = workbenchAssignmentService;
-        this.processedExperimentalSettings = ( new Set());
-        this.configurationRegistry = ( Registry.as(Extensions.Configuration));
-        this.processExperimentalSettings(( Object.keys(this.configurationRegistry.getConfigurationProperties())));
-        this._register(this.configurationRegistry.onDidUpdateConfiguration(({ properties }) => this.processExperimentalSettings(properties)));
-    }
-    async processExperimentalSettings(properties) {
-        const overrides = {};
-        const allProperties = this.configurationRegistry.getConfigurationProperties();
-        for (const property of properties) {
-            const schema = allProperties[property];
-            if (!schema?.tags?.includes('experimental')) {
-                continue;
-            }
-            if (this.processedExperimentalSettings.has(property)) {
-                continue;
-            }
-            this.processedExperimentalSettings.add(property);
-            try {
-                const value = await this.workbenchAssignmentService.getTreatment(`config.${property}`);
-                if (!isUndefined(value) && !equals(value, schema.default)) {
-                    overrides[property] = value;
-                }
-            }
-            catch (error) {  }
-        }
-        if (( Object.keys(overrides)).length) {
-            this.configurationRegistry.registerDefaultConfigurations([{ overrides, source: ( localize('experimental', "Experiments")) }]);
-        }
-    }
-};
-UpdateExperimentalSettingsDefaults = ( __decorate([
-    ( __param(0, IWorkbenchAssignmentService))
-], UpdateExperimentalSettingsDefaults));
+RegisterConfigurationSchemasContribution = ( (__decorate([
+    ( (__param(0, IWorkspaceContextService))),
+    ( (__param(1, IWorkbenchEnvironmentService))),
+    ( (__param(2, IWorkspaceTrustManagementService)))
+], RegisterConfigurationSchemasContribution)));
 function updateUserConfiguration(configurationJson) {
     const userDataProfilesService = StandaloneServices.get(IUserDataProfilesService);
     void StandaloneServices.get(IFileService).writeFile(userDataProfilesService.defaultProfile.settingsResource, VSBuffer.fromString(configurationJson));
 }
-const configurationRegistry = Registry.as(Extensions.Configuration);
+const configurationRegistry = ( Registry.as(Extensions.Configuration));
 let InjectedConfigurationService = class InjectedConfigurationService extends ConfigurationService {
     constructor(userDataProfilesService, fileService, policyService, logService) {
         super(userDataProfilesService.defaultProfile.settingsResource, fileService, policyService, logService);
@@ -873,12 +563,12 @@ let InjectedConfigurationService = class InjectedConfigurationService extends Co
         return Promise.reject(new Error('not supported'));
     }
 };
-InjectedConfigurationService = __decorate([
-    __param(0, IUserDataProfilesService),
-    __param(1, IFileService),
-    __param(2, IPolicyService),
-    __param(3, ILogService)
-], InjectedConfigurationService);
+InjectedConfigurationService = ( __decorate([
+    ( __param(0, IUserDataProfilesService)),
+    ( __param(1, IFileService)),
+    ( __param(2, IPolicyService)),
+    ( __param(3, ILogService))
+], InjectedConfigurationService));
 function initialize(instantiationService) {
     instantiationService.createInstance(RegisterConfigurationSchemasContribution);
 }
@@ -887,8 +577,8 @@ function getServiceOverride() {
     return {
         ...getServiceOverride$1(),
         ...getServiceOverride$2(),
-        [IConfigurationService.toString()]: new SyncDescriptor(InjectedConfigurationService),
-        [ITextResourceConfigurationService.toString()]: new SyncDescriptor(TextResourceConfigurationService)
+        [( IConfigurationService.toString())]: new SyncDescriptor(InjectedConfigurationService),
+        [( ITextResourceConfigurationService.toString())]: new SyncDescriptor(TextResourceConfigurationService)
     };
 }
 export { configurationRegistry, getServiceOverride as default, updateUserConfiguration };