@codingame/monaco-vscode-api 1.69.24 → 1.76.0-next.1

package/dist/configuration.js

@@ -1,28 +1,24 @@
-import { E as Emitter, _ as __decorate, a as __param } from './workspace.js';
-import { U as UserSettings, p as parseTree, f as findNodeAtLocation, c as createScanner } from './polyfill.js';
-import { b as IPolicyService, N as NullPolicyService } from './missing-services.js';
-import { i 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, 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 { E as Emitter, _ as __decorate, a as __param } from './contextkey.js';
+import { I as IPolicyService, N as NullPolicyService, b as NullPolicyConfiguration, P as PolicyConfiguration, U as UserSettings, c as parseTree, d as findNodeAtLocation, e as createScanner } from './polyfill.js';
+import { c as IExtensionService, I as ILifecycleService } from './missing-services.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { isArray } from 'monaco-editor/esm/vs/base/common/types.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { DefaultConfiguration } from 'monaco-editor/esm/vs/platform/configuration/common/configurations.js';
 import { extUriBiasedIgnorePathCase } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
-import { bg as Position$2, bh as keyFromOverrideIdentifiers, bi as configurationDefaultsSchemaId } from './extHost.js';
-export { bj as ConfigurationScope } from './extHost.js';
+import { Configuration, ConfigurationModel, ConfigurationChangeEvent } from 'monaco-editor/esm/vs/platform/configuration/common/configurationModels.js';
+import { RunOnceScheduler, Delayer } from 'monaco-editor/esm/vs/base/common/async.js';
+import { bn as Position$2, bo as keyFromOverrideIdentifiers, bp as configurationDefaultsSchemaId } from './extHost.js';
+export { bq as ConfigurationScope } from './extHost.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.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 { r as IUserDataProfilesService, c as IFileService, l as IWorkbenchEnvironmentService } from './services2.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Extensions, applicationSettings, windowSettings, resourceSettings, allSettings, machineSettings, machineOverridableSettings, OVERRIDE_PROPERTY_PATTERN, resourceLanguageSettingsSchemaId } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.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';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
 import { g as getServiceOverride$2 } from './workspaceContext.js';
 import { g as getServiceOverride$1 } from './files.js';
@@ -32,6 +28,7 @@ import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/c
 import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
 import { createTextBuffer, TextModel } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 function isConfigurationOverrides(thing) {
     return thing
         && typeof thing === 'object'
@@ -41,157 +38,10 @@ function isConfigurationOverrides(thing) {
 function isConfigurationUpdateOverrides(thing) {
     return thing
         && typeof thing === 'object'
-        && (!thing.overrideIdentifiers || isArray(thing.overrideIdentifiers))
+        && (!thing.overrideIdentifiers || Array.isArray(thing.overrideIdentifiers))
         && !thing.overrideIdentifier
         && (!thing.resource || thing.resource instanceof URI);
 }
-class DefaultConfiguration extends Disposable {
-    constructor() {
-        super(...arguments);
-        this._onDidChangeConfiguration = this._register(( (new Emitter())));
-        this.onDidChangeConfiguration = this._onDidChangeConfiguration.event;
-    }
-    get configurationModel() {
-        if (!this._configurationModel) {
-            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)));
-        return this.configurationModel;
-    }
-    reload() {
-        this._configurationModel = undefined;
-        return this.configurationModel;
-    }
-    onDidUpdateConfiguration(properties, defaultsOverrides) {
-        this._configurationModel = undefined;
-        this._onDidChangeConfiguration.fire({ defaults: this.configurationModel, properties });
-    }
-    getConfigurationDefaultOverrides() {
-        return {};
-    }
-}
-class DefaultConfigurationModel extends ConfigurationModel {
-    constructor(configurationDefaultsOverrides = {}) {
-        const properties = ( (Registry.as(Extensions.Configuration))).getConfigurationProperties();
-        const keys = ( (Object.keys(properties)));
-        const contents = Object.create(null);
-        const overrides = [];
-        for (const key in properties) {
-            const defaultOverrideValue = configurationDefaultsOverrides[key];
-            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)))) {
-            if (OVERRIDE_PROPERTY_REGEX.test(key)) {
-                overrides.push({
-                    identifiers: overrideIdentifiersFromKey(key),
-                    keys: ( (Object.keys(contents[key]))),
-                    contents: toValuesTree(contents[key], message => console.error(`Conflict in default settings file: ${message}`)),
-                });
-            }
-        }
-        super(contents, keys, overrides);
-    }
-}
-class NullPolicyConfiguration {
-    constructor() {
-        this.onDidChangeConfiguration = Event.None;
-        this.configurationModel = ( (new ConfigurationModel()));
-    }
-    async initialize() { return this.configurationModel; }
-}
-let PolicyConfiguration = class PolicyConfiguration extends Disposable {
-    constructor(defaultConfiguration, policyService, logService) {
-        super();
-        this.defaultConfiguration = defaultConfiguration;
-        this.policyService = policyService;
-        this.logService = logService;
-        this._onDidChangeConfiguration = this._register(( (new Emitter())));
-        this.onDidChangeConfiguration = this._onDidChangeConfiguration.event;
-        this._configurationModel = ( (new ConfigurationModel()));
-    }
-    get configurationModel() { return this._configurationModel; }
-    async initialize() {
-        this.update(await this.registerPolicyDefinitions(this.defaultConfiguration.configurationModel.keys), false);
-        this._register(this.policyService.onDidChange(policyNames => this.onDidChangePolicies(policyNames)));
-        this._register(this.defaultConfiguration.onDidChangeConfiguration(async ({ properties }) => this.update(await this.registerPolicyDefinitions(properties), true)));
-        return this._configurationModel;
-    }
-    async registerPolicyDefinitions(properties) {
-        const policyDefinitions = {};
-        const keys = [];
-        const configurationProperties = ( (Registry.as(Extensions.Configuration))).getConfigurationProperties();
-        for (const key of properties) {
-            const config = configurationProperties[key];
-            if (!config) {
-                keys.push(key);
-                continue;
-            }
-            if (config.policy) {
-                if (config.type !== 'string' && config.type !== 'number') {
-                    this.logService.warn(`Policy ${config.policy.name} has unsupported type ${config.type}`);
-                    continue;
-                }
-                keys.push(key);
-                policyDefinitions[config.policy.name] = { type: config.type };
-            }
-        }
-        if (!isEmptyObject(policyDefinitions)) {
-            await this.policyService.registerPolicyDefinitions(policyDefinitions);
-        }
-        return keys;
-    }
-    onDidChangePolicies(policyNames) {
-        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 changed = [];
-        const wasEmpty = this._configurationModel.isEmpty();
-        for (const key of keys) {
-            const policyName = configurationProperties[key]?.policy?.name;
-            if (policyName) {
-                const policyValue = this.policyService.getPolicyValue(policyName);
-                if (wasEmpty ? policyValue !== undefined : !equals(this._configurationModel.getValue(key), policyValue)) {
-                    changed.push([key, policyValue]);
-                }
-            }
-            else {
-                if (this._configurationModel.getValue(key) !== undefined) {
-                    changed.push([key, undefined]);
-                }
-            }
-        }
-        if (changed.length) {
-            const old = this._configurationModel;
-            this._configurationModel = ( (new ConfigurationModel()));
-            for (const key of old.keys) {
-                this._configurationModel.setValue(key, old.getValue(key));
-            }
-            for (const [key, policyValue] of changed) {
-                if (policyValue === undefined) {
-                    this._configurationModel.removeValue(key);
-                }
-                else {
-                    this._configurationModel.setValue(key, policyValue);
-                }
-            }
-            if (trigger) {
-                this._onDidChangeConfiguration.fire(this._configurationModel);
-            }
-        }
-    }
-};
-PolicyConfiguration = ( (__decorate([
-    ( (__param(1, IPolicyService))),
-    ( (__param(2, ILogService)))
-], PolicyConfiguration)));
 function format(documentText, range, options) {
     let initialIndentLevel;
     let formatText;
@@ -690,7 +540,7 @@ let TextResourceConfigurationService = class TextResourceConfigurationService ex
         return {
             affectedKeys: configurationChangeEvent.affectedKeys,
             affectsConfiguration: (resource, configuration) => {
-                const overrideIdentifier = this.getLanguage(resource, null);
+                const overrideIdentifier = resource ? this.getLanguage(resource, null) : undefined;
                 return configurationChangeEvent.affectsConfiguration(configuration, { resource, overrideIdentifier });
             }
         };
@@ -716,16 +566,17 @@ WORKSPACE_STANDALONE_CONFIGURATIONS[LAUNCH_CONFIGURATION_KEY] = `${FOLDER_CONFIG
 const USER_STANDALONE_CONFIGURATIONS = Object.create(null);
 USER_STANDALONE_CONFIGURATIONS[TASKS_CONFIGURATION_KEY] = `${TASKS_CONFIGURATION_KEY}.json`;
 let RegisterConfigurationSchemasContribution = class RegisterConfigurationSchemasContribution extends Disposable {
-    constructor(workspaceContextService, environmentService, workspaceTrustManagementService) {
+    constructor(workspaceContextService, environmentService, workspaceTrustManagementService, extensionService, lifecycleService) {
         super();
         this.workspaceContextService = workspaceContextService;
         this.environmentService = environmentService;
         this.workspaceTrustManagementService = workspaceTrustManagementService;
-        this.registerConfigurationSchemas();
-        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()));
+        extensionService.whenInstalledExtensionsRegistered().then(() => {
+            this.registerConfigurationSchemas();
+            const configurationRegistry = ( (Registry.as(Extensions.Configuration)));
+            const delayer = this._register(( (new Delayer(50))));
+            this._register(Event.any(configurationRegistry.onDidUpdateConfiguration, configurationRegistry.onDidSchemaChange, workspaceTrustManagementService.onDidChangeTrust)(() => delayer.trigger(() => this.registerConfigurationSchemas(), lifecycleService.phase === 4  ? undefined : 2500 )));
+        });
     }
     registerConfigurationSchemas() {
         const jsonRegistry = ( (Registry.as(Extensions$1.JSONContribution)));
@@ -738,11 +589,7 @@ let RegisterConfigurationSchemasContribution = class RegisterConfigurationSchema
         };
         const userSettingsSchema = this.environmentService.remoteAuthority ?
             {
-                properties: {
-                    ...applicationSettings.properties,
-                    ...windowSettings.properties,
-                    ...resourceSettings.properties
-                },
+                properties: Object.assign({}, applicationSettings.properties, windowSettings.properties, resourceSettings.properties),
                 patternProperties: allSettings.patternProperties,
                 additionalProperties: true,
                 allowTrailingCommas: true,
@@ -750,35 +597,21 @@ let RegisterConfigurationSchemasContribution = class RegisterConfigurationSchema
             }
             : allSettingsSchema;
         const profileSettingsSchema = {
-            properties: {
-                ...machineSettings.properties,
-                ...machineOverridableSettings.properties,
-                ...windowSettings.properties,
-                ...resourceSettings.properties
-            },
+            properties: Object.assign({}, machineSettings.properties, machineOverridableSettings.properties, windowSettings.properties, resourceSettings.properties),
             patternProperties: allSettings.patternProperties,
             additionalProperties: true,
             allowTrailingCommas: true,
             allowComments: true
         };
         const machineSettingsSchema = {
-            properties: {
-                ...machineSettings.properties,
-                ...machineOverridableSettings.properties,
-                ...windowSettings.properties,
-                ...resourceSettings.properties
-            },
+            properties: Object.assign({}, machineSettings.properties, machineOverridableSettings.properties, windowSettings.properties, resourceSettings.properties),
             patternProperties: allSettings.patternProperties,
             additionalProperties: true,
             allowTrailingCommas: true,
             allowComments: true
         };
         const workspaceSettingsSchema = {
-            properties: {
-                ...this.checkAndFilterPropertiesRequiringTrust(machineOverridableSettings.properties),
-                ...this.checkAndFilterPropertiesRequiringTrust(windowSettings.properties),
-                ...this.checkAndFilterPropertiesRequiringTrust(resourceSettings.properties)
-            },
+            properties: Object.assign({}, this.checkAndFilterPropertiesRequiringTrust(machineOverridableSettings.properties), this.checkAndFilterPropertiesRequiringTrust(windowSettings.properties), this.checkAndFilterPropertiesRequiringTrust(resourceSettings.properties)),
             patternProperties: allSettings.patternProperties,
             additionalProperties: true,
             allowTrailingCommas: true,
@@ -786,17 +619,11 @@ let RegisterConfigurationSchemasContribution = class RegisterConfigurationSchema
         };
         jsonRegistry.registerSchema(defaultSettingsSchemaId, {
             properties: ( (Object.keys(allSettings.properties))).reduce((result, key) => {
-                result[key] = {
-                    ...allSettings.properties[key],
-                    deprecationMessage: undefined
-                };
+                result[key] = Object.assign({ deprecationMessage: undefined }, allSettings.properties[key]);
                 return result;
             }, {}),
             patternProperties: ( (Object.keys(allSettings.patternProperties))).reduce((result, key) => {
-                result[key] = {
-                    ...allSettings.patternProperties[key],
-                    deprecationMessage: undefined
-                };
+                result[key] = Object.assign({ deprecationMessage: undefined }, allSettings.patternProperties[key]);
                 return result;
             }, {}),
             additionalProperties: true,
@@ -808,10 +635,7 @@ let RegisterConfigurationSchemasContribution = class RegisterConfigurationSchema
         jsonRegistry.registerSchema(machineSettingsSchemaId, machineSettingsSchema);
         if (3  === this.workspaceContextService.getWorkbenchState()) {
             const folderSettingsSchema = {
-                properties: {
-                    ...this.checkAndFilterPropertiesRequiringTrust(machineOverridableSettings.properties),
-                    ...this.checkAndFilterPropertiesRequiringTrust(resourceSettings.properties)
-                },
+                properties: Object.assign({}, this.checkAndFilterPropertiesRequiringTrust(machineOverridableSettings.properties), this.checkAndFilterPropertiesRequiringTrust(resourceSettings.properties)),
                 patternProperties: allSettings.patternProperties,
                 additionalProperties: true,
                 allowTrailingCommas: true,
@@ -830,11 +654,7 @@ let RegisterConfigurationSchemasContribution = class RegisterConfigurationSchema
                 'configurationDefaults.description',
                 'Contribute defaults for configurations'
             ))),
-            properties: {
-                ...machineOverridableSettings.properties,
-                ...windowSettings.properties,
-                ...resourceSettings.properties
-            },
+            properties: Object.assign({}, machineOverridableSettings.properties, windowSettings.properties, resourceSettings.properties),
             patternProperties: {
                 [OVERRIDE_PROPERTY_PATTERN]: {
                     type: 'object',
@@ -861,7 +681,9 @@ let RegisterConfigurationSchemasContribution = class RegisterConfigurationSchema
 RegisterConfigurationSchemasContribution = ( (__decorate([
     ( (__param(0, IWorkspaceContextService))),
     ( (__param(1, IWorkbenchEnvironmentService))),
-    ( (__param(2, IWorkspaceTrustManagementService)))
+    ( (__param(2, IWorkspaceTrustManagementService))),
+    ( (__param(3, IExtensionService))),
+    ( (__param(4, ILifecycleService)))
 ], RegisterConfigurationSchemasContribution)));
 async function updateUserConfiguration(configurationJson) {
     const userDataProfilesService = StandaloneServices.get(IUserDataProfilesService);
@@ -898,9 +720,13 @@ let InjectedConfigurationService = class InjectedConfigurationService extends Co
     constructor(userDataProfilesService, fileService, policyService, logService) {
         super(userDataProfilesService.defaultProfile.settingsResource, fileService, policyService, logService);
         this.userDataProfilesService = userDataProfilesService;
-        this.initialize().catch(error => {
-            logService.error(error);
-        });
+    }
+    getValue(...args) {
+        const value = super.getValue.apply(this, args);
+        if (args[0] === 'keyboard') {
+            return value ?? {};
+        }
+        return value;
     }
     async updateValue(key, value, arg3, arg4) {
         const overrides = isConfigurationUpdateOverrides(arg3)
@@ -926,9 +752,13 @@ InjectedConfigurationService = ( __decorate([
     ( __param(2, IPolicyService)),
     ( __param(3, ILogService))
 ], InjectedConfigurationService));
-function initialize(instantiationService) {
+async function initialize(instantiationService) {
     instantiationService.createInstance(RegisterConfigurationSchemasContribution);
-    void updateUserConfiguration('{}');
+    const configurationService = instantiationService.invokeFunction((accessor) => accessor.get(IConfigurationService));
+    await Promise.all([
+        updateUserConfiguration('{}'),
+        configurationService.initialize()
+    ]);
 }
 function getServiceOverride() {
     onServicesInitialized(initialize);

package/dist/{workspace.js → contextkey.js}

@@ -1,8 +1,6 @@
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api.js';
 import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { isMacintosh, isLinux, isWindows, isWeb, isEdge, isFirefox, isChrome, isSafari } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 const Emitter = monaco.Emitter;
 var NeverShowAgainScope;
 ( (function(NeverShowAgainScope) {
@@ -145,11 +143,6 @@ class ContextKeyTrueExpr {
 }
 ContextKeyTrueExpr.INSTANCE = ( new ContextKeyTrueExpr());
 class ContextKeyDefinedExpr {
-    constructor(key, negated) {
-        this.key = key;
-        this.negated = negated;
-        this.type = 2 ;
-    }
     static create(key, negated = null) {
         const constantValue = CONSTANT_VALUES.get(key);
         if (typeof constantValue === 'boolean') {
@@ -157,6 +150,11 @@ class ContextKeyDefinedExpr {
         }
         return ( new ContextKeyDefinedExpr(key, negated));
     }
+    constructor(key, negated) {
+        this.key = key;
+        this.negated = negated;
+        this.type = 2 ;
+    }
     cmp(other) {
         if (other.type !== this.type) {
             return this.type - other.type;
@@ -196,12 +194,6 @@ class ContextKeyDefinedExpr {
     }
 }
 class ContextKeyEqualsExpr {
-    constructor(key, value, negated) {
-        this.key = key;
-        this.value = value;
-        this.negated = negated;
-        this.type = 4 ;
-    }
     static create(key, value, negated = null) {
         if (typeof value === 'boolean') {
             return (value ? ( ContextKeyDefinedExpr.create(key, negated)) : ( ContextKeyNotExpr.create(key, negated)));
@@ -213,6 +205,12 @@ class ContextKeyEqualsExpr {
         }
         return ( new ContextKeyEqualsExpr(key, value, negated));
     }
+    constructor(key, value, negated) {
+        this.key = key;
+        this.value = value;
+        this.negated = negated;
+        this.type = 4 ;
+    }
     cmp(other) {
         if (other.type !== this.type) {
             return this.type - other.type;
@@ -253,12 +251,6 @@ class ContextKeyEqualsExpr {
     }
 }
 class ContextKeyNotEqualsExpr {
-    constructor(key, value, negated) {
-        this.key = key;
-        this.value = value;
-        this.negated = negated;
-        this.type = 5 ;
-    }
     static create(key, value, negated = null) {
         if (typeof value === 'boolean') {
             if (value) {
@@ -273,6 +265,12 @@ class ContextKeyNotEqualsExpr {
         }
         return ( new ContextKeyNotEqualsExpr(key, value, negated));
     }
+    constructor(key, value, negated) {
+        this.key = key;
+        this.value = value;
+        this.negated = negated;
+        this.type = 5 ;
+    }
     cmp(other) {
         if (other.type !== this.type) {
             return this.type - other.type;
@@ -313,11 +311,6 @@ class ContextKeyNotEqualsExpr {
     }
 }
 class ContextKeyNotExpr {
-    constructor(key, negated) {
-        this.key = key;
-        this.negated = negated;
-        this.type = 3 ;
-    }
     static create(key, negated = null) {
         const constantValue = CONSTANT_VALUES.get(key);
         if (typeof constantValue === 'boolean') {
@@ -325,6 +318,11 @@ class ContextKeyNotExpr {
         }
         return ( new ContextKeyNotExpr(key, negated));
     }
+    constructor(key, negated) {
+        this.key = key;
+        this.negated = negated;
+        this.type = 3 ;
+    }
     cmp(other) {
         if (other.type !== this.type) {
             return this.type - other.type;
@@ -364,6 +362,9 @@ class ContextKeyNotExpr {
     }
 }
 class RawContextKey extends ContextKeyDefinedExpr {
+    static all() {
+        return ( RawContextKey._info.values());
+    }
     constructor(key, defaultValue, metaOrHide) {
         super(key, null);
         this._defaultValue = defaultValue;
@@ -374,9 +375,6 @@ class RawContextKey extends ContextKeyDefinedExpr {
             RawContextKey._info.push({ key, description: metaOrHide, type: defaultValue !== null && defaultValue !== undefined ? typeof defaultValue : undefined });
         }
     }
-    static all() {
-        return ( RawContextKey._info.values());
-    }
     bindTo(target) {
         return target.createKey(this.key, this._defaultValue);
     }
@@ -418,23 +416,4 @@ function cmp2(key1, value1, key2, value2) {
     }
     return 0;
 }
-function isWorkspaceIdentifier(obj) {
-    const workspaceIdentifier = obj;
-    return typeof workspaceIdentifier?.id === 'string' && URI.isUri(workspaceIdentifier.configPath);
-}
-class WorkspaceFolder {
-    constructor(data,
-    raw) {
-        this.raw = raw;
-        this.uri = data.uri;
-        this.index = data.index;
-        this.name = data.name;
-    }
-    toResource(relativePath) {
-        return joinPath(this.uri, relativePath);
-    }
-    toJSON() {
-        return { uri: this.uri, name: this.name, index: this.index };
-    }
-}
-export { ContextKeyExprType as C, Emitter as E, NotificationsFilter as N, RawContextKey as R, WorkspaceFolder as W, __decorate as _, __param as a, NeverShowAgainScope as b, __classPrivateFieldSet as c, __classPrivateFieldGet as d, NoOpNotification as e, isWorkspaceIdentifier as i };
+export { ContextKeyExprType as C, Emitter as E, NotificationsFilter as N, RawContextKey as R, __decorate as _, __param as a, NeverShowAgainScope as b, __classPrivateFieldSet as c, __classPrivateFieldGet as d, NoOpNotification as e };