@codingame/monaco-vscode-api 1.69.5 → 1.69.8

package/dist/configuration.js

@@ -1,24 +1,28 @@
-import { _ as __decorate, a as __param } from './contextkey.js';
-import { h as IPolicyService, j as IUserDataProfilesService, E as Emitter, k as NullPolicyService, U as UserSettings } from './missing-services.js';
+import { b as __decorate, d 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 { 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, machineOverridableSettings, windowSettings, resourceSettings, allSettings, OVERRIDE_PROPERTY_PATTERN, resourceLanguageSettingsSchemaId, applicationSettings, machineSettings, OVERRIDE_PROPERTY_REGEX, overrideIdentifiersFromKey } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.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 { IConfigurationService, addToValueTree, toValuesTree } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { addToValueTree, toValuesTree, IConfigurationService } 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 } from 'monaco-editor/esm/vs/base/common/types.js';
+import { isArray, isUndefined } 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$2, bg as configurationDefaultsSchemaId } from './extHost.js';
-export { bh as ConfigurationScope } from './extHost.js';
+import { bf as Position, bg as getTelemetryLevel, bh as configurationDefaultsSchemaId } from './extHost.js';
+export { bi 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 { g as IWorkbenchEnvironmentService, I as IFileService } from './services2.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 { 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';
@@ -46,18 +50,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() {
@@ -74,8 +78,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) {
@@ -83,11 +87,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}`)),
                 });
             }
@@ -98,7 +102,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; }
 }
@@ -108,9 +112,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() {
@@ -122,7 +126,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) {
@@ -144,12 +148,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) {
@@ -168,7 +172,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));
             }
@@ -186,38 +190,33 @@ 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();
@@ -228,15 +227,13 @@ 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();
@@ -258,7 +255,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);
@@ -279,13 +276,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$2.isIPosition(arg2) ? arg2 : null, arg3);
+            return this._getValue(resource, Position.isIPosition(arg2) ? arg2 : null, arg3);
         }
         return this._getValue(resource, null, typeof arg2 === 'string' ? arg2 : undefined);
     }
@@ -372,11 +369,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';
@@ -391,6 +388,283 @@ 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();
@@ -398,13 +672,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,
@@ -461,14 +735,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
@@ -502,10 +776,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,
@@ -534,16 +808,53 @@ let RegisterConfigurationSchemasContribution = class RegisterConfigurationSchema
         return result;
     }
 };
-RegisterConfigurationSchemasContribution = ( (__decorate([
-    ( (__param(0, IWorkspaceContextService))),
-    ( (__param(1, IWorkbenchEnvironmentService))),
-    ( (__param(2, IWorkspaceTrustManagementService)))
-], RegisterConfigurationSchemasContribution)));
+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));
 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);
@@ -562,12 +873,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);
 }
@@ -576,8 +887,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 };