@codingame/monaco-vscode-api 1.76.1 → 1.76.3-next.0

package/dist/configurationRegistry.js

@@ -0,0 +1,441 @@
+import { E as Emitter } from './services2.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { getLanguageTagSettingPlainKey } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { isString, isUndefinedOrNull, isUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
+var ConfigurationScope;
+( (function(ConfigurationScope) {
+    ConfigurationScope[ConfigurationScope["APPLICATION"] = 1] = "APPLICATION";
+    ConfigurationScope[ConfigurationScope["MACHINE"] = 2] = "MACHINE";
+    ConfigurationScope[ConfigurationScope["WINDOW"] = 3] = "WINDOW";
+    ConfigurationScope[ConfigurationScope["RESOURCE"] = 4] = "RESOURCE";
+    ConfigurationScope[ConfigurationScope["LANGUAGE_OVERRIDABLE"] = 5] = "LANGUAGE_OVERRIDABLE";
+    ConfigurationScope[ConfigurationScope["MACHINE_OVERRIDABLE"] = 6] = "MACHINE_OVERRIDABLE";
+})(ConfigurationScope || (ConfigurationScope = {})));
+const resourceLanguageSettingsSchemaId = 'vscode://schemas/settings/resourceLanguage';
+const configurationDefaultsSchemaId = 'vscode://schemas/settings/configurationDefaults';
+const contributionRegistry = ( Registry.as(Extensions.JSONContribution));
+class ConfigurationRegistry {
+    constructor() {
+        this.overrideIdentifiers = ( new Set());
+        this._onDidSchemaChange = ( new Emitter());
+        this.onDidSchemaChange = this._onDidSchemaChange.event;
+        this._onDidUpdateConfiguration = ( new Emitter());
+        this.onDidUpdateConfiguration = this._onDidUpdateConfiguration.event;
+        this.configurationDefaultsOverrides = ( new Map());
+        this.defaultLanguageConfigurationOverridesNode = {
+            id: 'defaultOverrides',
+            title: ( localize(
+                'defaultLanguageConfigurationOverrides.title',
+                "Default Language Configuration Overrides"
+            )),
+            properties: {}
+        };
+        this.configurationContributors = [this.defaultLanguageConfigurationOverridesNode];
+        this.resourceLanguageSettingsSchema = {
+            properties: {},
+            patternProperties: {},
+            additionalProperties: true,
+            allowTrailingCommas: true,
+            allowComments: true
+        };
+        this.configurationProperties = {};
+        this.policyConfigurations = ( new Map());
+        this.excludedConfigurationProperties = {};
+        contributionRegistry.registerSchema(resourceLanguageSettingsSchemaId, this.resourceLanguageSettingsSchema);
+        this.registerOverridePropertyPatternKey();
+    }
+    registerConfiguration(configuration, validate = true) {
+        this.registerConfigurations([configuration], validate);
+    }
+    registerConfigurations(configurations, validate = true) {
+        const properties = ( new Set());
+        this.doRegisterConfigurations(configurations, validate, properties);
+        contributionRegistry.registerSchema(resourceLanguageSettingsSchemaId, this.resourceLanguageSettingsSchema);
+        this._onDidSchemaChange.fire();
+        this._onDidUpdateConfiguration.fire({ properties });
+    }
+    deregisterConfigurations(configurations) {
+        const properties = ( new Set());
+        this.doDeregisterConfigurations(configurations, properties);
+        contributionRegistry.registerSchema(resourceLanguageSettingsSchemaId, this.resourceLanguageSettingsSchema);
+        this._onDidSchemaChange.fire();
+        this._onDidUpdateConfiguration.fire({ properties });
+    }
+    updateConfigurations({ add, remove }) {
+        const properties = ( new Set());
+        this.doDeregisterConfigurations(remove, properties);
+        this.doRegisterConfigurations(add, false, properties);
+        contributionRegistry.registerSchema(resourceLanguageSettingsSchemaId, this.resourceLanguageSettingsSchema);
+        this._onDidSchemaChange.fire();
+        this._onDidUpdateConfiguration.fire({ properties });
+    }
+    registerDefaultConfigurations(configurationDefaults) {
+        const properties = ( new Set());
+        this.doRegisterDefaultConfigurations(configurationDefaults, properties);
+        this._onDidSchemaChange.fire();
+        this._onDidUpdateConfiguration.fire({ properties, defaultsOverrides: true });
+    }
+    doRegisterDefaultConfigurations(configurationDefaults, bucket) {
+        const overrideIdentifiers = [];
+        for (const { overrides, source } of configurationDefaults) {
+            for (const key in overrides) {
+                bucket.add(key);
+                if (OVERRIDE_PROPERTY_REGEX.test(key)) {
+                    const configurationDefaultOverride = this.configurationDefaultsOverrides.get(key);
+                    const valuesSources = configurationDefaultOverride?.valuesSources ?? ( new Map());
+                    if (source) {
+                        for (const configuration of ( Object.keys(overrides[key]))) {
+                            valuesSources.set(configuration, source);
+                        }
+                    }
+                    const defaultValue = { ...(configurationDefaultOverride?.value || {}), ...overrides[key] };
+                    this.configurationDefaultsOverrides.set(key, { source, value: defaultValue, valuesSources });
+                    const plainKey = getLanguageTagSettingPlainKey(key);
+                    const property = {
+                        type: 'object',
+                        default: defaultValue,
+                        description: ( localize(
+                            'defaultLanguageConfiguration.description',
+                            "Configure settings to be overridden for the {0} language.",
+                            plainKey
+                        )),
+                        $ref: resourceLanguageSettingsSchemaId,
+                        defaultDefaultValue: defaultValue,
+                        source: isString(source) ? undefined : source,
+                        defaultValueSource: source
+                    };
+                    overrideIdentifiers.push(...overrideIdentifiersFromKey(key));
+                    this.configurationProperties[key] = property;
+                    this.defaultLanguageConfigurationOverridesNode.properties[key] = property;
+                }
+                else {
+                    this.configurationDefaultsOverrides.set(key, { value: overrides[key], source });
+                    const property = this.configurationProperties[key];
+                    if (property) {
+                        this.updatePropertyDefaultValue(key, property);
+                        this.updateSchema(key, property);
+                    }
+                }
+            }
+        }
+        this.doRegisterOverrideIdentifiers(overrideIdentifiers);
+    }
+    deregisterDefaultConfigurations(defaultConfigurations) {
+        const properties = ( new Set());
+        this.doDeregisterDefaultConfigurations(defaultConfigurations, properties);
+        this._onDidSchemaChange.fire();
+        this._onDidUpdateConfiguration.fire({ properties, defaultsOverrides: true });
+    }
+    doDeregisterDefaultConfigurations(defaultConfigurations, bucket) {
+        for (const { overrides, source } of defaultConfigurations) {
+            for (const key in overrides) {
+                const configurationDefaultsOverride = this.configurationDefaultsOverrides.get(key);
+                const id = isString(source) ? source : source?.id;
+                const configurationDefaultsOverrideSourceId = isString(configurationDefaultsOverride?.source) ? configurationDefaultsOverride?.source : configurationDefaultsOverride?.source?.id;
+                if (id !== configurationDefaultsOverrideSourceId) {
+                    continue;
+                }
+                bucket.add(key);
+                this.configurationDefaultsOverrides.delete(key);
+                if (OVERRIDE_PROPERTY_REGEX.test(key)) {
+                    delete this.configurationProperties[key];
+                    delete this.defaultLanguageConfigurationOverridesNode.properties[key];
+                }
+                else {
+                    const property = this.configurationProperties[key];
+                    if (property) {
+                        this.updatePropertyDefaultValue(key, property);
+                        this.updateSchema(key, property);
+                    }
+                }
+            }
+        }
+        this.updateOverridePropertyPatternKey();
+    }
+    deltaConfiguration(delta) {
+        let defaultsOverrides = false;
+        const properties = ( new Set());
+        if (delta.removedDefaults) {
+            this.doDeregisterDefaultConfigurations(delta.removedDefaults, properties);
+            defaultsOverrides = true;
+        }
+        if (delta.addedDefaults) {
+            this.doRegisterDefaultConfigurations(delta.addedDefaults, properties);
+            defaultsOverrides = true;
+        }
+        if (delta.removedConfigurations) {
+            this.doDeregisterConfigurations(delta.removedConfigurations, properties);
+        }
+        if (delta.addedConfigurations) {
+            this.doRegisterConfigurations(delta.addedConfigurations, false, properties);
+        }
+        this._onDidSchemaChange.fire();
+        this._onDidUpdateConfiguration.fire({ properties, defaultsOverrides });
+    }
+    notifyConfigurationSchemaUpdated(...configurations) {
+        this._onDidSchemaChange.fire();
+    }
+    registerOverrideIdentifiers(overrideIdentifiers) {
+        this.doRegisterOverrideIdentifiers(overrideIdentifiers);
+        this._onDidSchemaChange.fire();
+    }
+    doRegisterOverrideIdentifiers(overrideIdentifiers) {
+        for (const overrideIdentifier of overrideIdentifiers) {
+            this.overrideIdentifiers.add(overrideIdentifier);
+        }
+        this.updateOverridePropertyPatternKey();
+    }
+    doRegisterConfigurations(configurations, validate, bucket) {
+        configurations.forEach(configuration => {
+            this.validateAndRegisterProperties(configuration, validate, configuration.extensionInfo, configuration.restrictedProperties, undefined, bucket);
+            this.configurationContributors.push(configuration);
+            this.registerJSONConfiguration(configuration);
+        });
+    }
+    doDeregisterConfigurations(configurations, bucket) {
+        const deregisterConfiguration = (configuration) => {
+            if (configuration.properties) {
+                for (const key in configuration.properties) {
+                    bucket.add(key);
+                    const property = this.configurationProperties[key];
+                    if (property?.policy?.name) {
+                        this.policyConfigurations.delete(property.policy.name);
+                    }
+                    delete this.configurationProperties[key];
+                    this.removeFromSchema(key, configuration.properties[key]);
+                }
+            }
+            configuration.allOf?.forEach(node => deregisterConfiguration(node));
+        };
+        for (const configuration of configurations) {
+            deregisterConfiguration(configuration);
+            const index = this.configurationContributors.indexOf(configuration);
+            if (index !== -1) {
+                this.configurationContributors.splice(index, 1);
+            }
+        }
+    }
+    validateAndRegisterProperties(configuration, validate = true, extensionInfo, restrictedProperties, scope = 3 , bucket) {
+        scope = isUndefinedOrNull(configuration.scope) ? scope : configuration.scope;
+        const properties = configuration.properties;
+        if (properties) {
+            for (const key in properties) {
+                const property = properties[key];
+                if (validate && validateProperty(key, property)) {
+                    delete properties[key];
+                    continue;
+                }
+                property.source = extensionInfo;
+                property.defaultDefaultValue = properties[key].default;
+                this.updatePropertyDefaultValue(key, property);
+                if (OVERRIDE_PROPERTY_REGEX.test(key)) {
+                    property.scope = undefined;
+                }
+                else {
+                    property.scope = isUndefinedOrNull(property.scope) ? scope : property.scope;
+                    property.restricted = isUndefinedOrNull(property.restricted) ? !!restrictedProperties?.includes(key) : property.restricted;
+                }
+                if (properties[key].hasOwnProperty('included') && !properties[key].included) {
+                    this.excludedConfigurationProperties[key] = properties[key];
+                    delete properties[key];
+                    continue;
+                }
+                else {
+                    this.configurationProperties[key] = properties[key];
+                    if (properties[key].policy?.name) {
+                        this.policyConfigurations.set(properties[key].policy.name, key);
+                    }
+                }
+                if (!properties[key].deprecationMessage && properties[key].markdownDeprecationMessage) {
+                    properties[key].deprecationMessage = properties[key].markdownDeprecationMessage;
+                }
+                bucket.add(key);
+            }
+        }
+        const subNodes = configuration.allOf;
+        if (subNodes) {
+            for (const node of subNodes) {
+                this.validateAndRegisterProperties(node, validate, extensionInfo, restrictedProperties, scope, bucket);
+            }
+        }
+    }
+    getConfigurations() {
+        return this.configurationContributors;
+    }
+    getConfigurationProperties() {
+        return this.configurationProperties;
+    }
+    getPolicyConfigurations() {
+        return this.policyConfigurations;
+    }
+    getExcludedConfigurationProperties() {
+        return this.excludedConfigurationProperties;
+    }
+    getConfigurationDefaultsOverrides() {
+        return this.configurationDefaultsOverrides;
+    }
+    registerJSONConfiguration(configuration) {
+        const register = (configuration) => {
+            const properties = configuration.properties;
+            if (properties) {
+                for (const key in properties) {
+                    this.updateSchema(key, properties[key]);
+                }
+            }
+            const subNodes = configuration.allOf;
+            subNodes?.forEach(register);
+        };
+        register(configuration);
+    }
+    updateSchema(key, property) {
+        switch (property.scope) {
+            case 1 :
+                break;
+            case 2 :
+                break;
+            case 6 :
+                break;
+            case 3 :
+                break;
+            case 4 :
+                break;
+            case 5 :
+                this.resourceLanguageSettingsSchema.properties[key] = property;
+                break;
+        }
+    }
+    removeFromSchema(key, property) {
+        switch (property.scope) {
+            case 1 :
+                break;
+            case 2 :
+                break;
+            case 6 :
+                break;
+            case 3 :
+                break;
+            case 4 :
+            case 5 :
+                delete this.resourceLanguageSettingsSchema.properties[key];
+                break;
+        }
+    }
+    updateOverridePropertyPatternKey() {
+        for (const overrideIdentifier of ( this.overrideIdentifiers.values())) {
+            const overrideIdentifierProperty = `[${overrideIdentifier}]`;
+            const resourceLanguagePropertiesSchema = {
+                type: 'object',
+                description: ( localize(
+                    'overrideSettings.defaultDescription',
+                    "Configure editor settings to be overridden for a language."
+                )),
+                errorMessage: ( localize(
+                    'overrideSettings.errorMessage',
+                    "This setting does not support per-language configuration."
+                )),
+                $ref: resourceLanguageSettingsSchemaId,
+            };
+            this.updatePropertyDefaultValue(overrideIdentifierProperty, resourceLanguagePropertiesSchema);
+        }
+    }
+    registerOverridePropertyPatternKey() {
+        this._onDidSchemaChange.fire();
+    }
+    updatePropertyDefaultValue(key, property) {
+        const configurationdefaultOverride = this.configurationDefaultsOverrides.get(key);
+        let defaultValue = configurationdefaultOverride?.value;
+        let defaultSource = configurationdefaultOverride?.source;
+        if (isUndefined(defaultValue)) {
+            defaultValue = property.defaultDefaultValue;
+            defaultSource = undefined;
+        }
+        if (isUndefined(defaultValue)) {
+            defaultValue = getDefaultValue(property.type);
+        }
+        property.default = defaultValue;
+        property.defaultValueSource = defaultSource;
+    }
+}
+const OVERRIDE_IDENTIFIER_PATTERN = `\\[([^\\]]+)\\]`;
+const OVERRIDE_IDENTIFIER_REGEX = ( new RegExp(OVERRIDE_IDENTIFIER_PATTERN, 'g'));
+const OVERRIDE_PROPERTY_PATTERN = `^(${OVERRIDE_IDENTIFIER_PATTERN})+$`;
+const OVERRIDE_PROPERTY_REGEX = ( new RegExp(OVERRIDE_PROPERTY_PATTERN));
+function overrideIdentifiersFromKey(key) {
+    const identifiers = [];
+    if (OVERRIDE_PROPERTY_REGEX.test(key)) {
+        let matches = OVERRIDE_IDENTIFIER_REGEX.exec(key);
+        while (matches?.length) {
+            const identifier = matches[1].trim();
+            if (identifier) {
+                identifiers.push(identifier);
+            }
+            matches = OVERRIDE_IDENTIFIER_REGEX.exec(key);
+        }
+    }
+    return distinct(identifiers);
+}
+function keyFromOverrideIdentifiers(overrideIdentifiers) {
+    return overrideIdentifiers.reduce((result, overrideIdentifier) => `${result}[${overrideIdentifier}]`, '');
+}
+function getDefaultValue(type) {
+    const t = Array.isArray(type) ? type[0] : type;
+    switch (t) {
+        case 'boolean':
+            return false;
+        case 'integer':
+        case 'number':
+            return 0;
+        case 'string':
+            return '';
+        case 'array':
+            return [];
+        case 'object':
+            return {};
+        default:
+            return null;
+    }
+}
+const configurationRegistry = ( new ConfigurationRegistry());
+function validateProperty(property, schema) {
+    if (!property.trim()) {
+        return ( localize('config.property.empty', "Cannot register an empty property"));
+    }
+    if (OVERRIDE_PROPERTY_REGEX.test(property)) {
+        return ( localize(
+            'config.property.languageDefault',
+            "Cannot register '{0}'. This matches property pattern '\\\\[.*\\\\]$' for describing language specific editor settings. Use 'configurationDefaults' contribution.",
+            property
+        ));
+    }
+    if (configurationRegistry.getConfigurationProperties()[property] !== undefined) {
+        return ( localize(
+            'config.property.duplicate',
+            "Cannot register '{0}'. This property is already registered.",
+            property
+        ));
+    }
+    if (schema.policy?.name && configurationRegistry.getPolicyConfigurations().get(schema.policy?.name) !== undefined) {
+        return ( localize(
+            'config.policy.duplicate',
+            "Cannot register '{0}'. The associated policy {1} is already registered with {2}.",
+            property,
+            schema.policy?.name,
+            configurationRegistry.getPolicyConfigurations().get(schema.policy?.name)
+        ));
+    }
+    return null;
+}
+function getScopes() {
+    const scopes = [];
+    const configurationProperties = configurationRegistry.getConfigurationProperties();
+    for (const key of ( Object.keys(configurationProperties))) {
+        scopes.push([key, configurationProperties[key].scope]);
+    }
+    scopes.push(['launch', 4 ]);
+    scopes.push(['task', 4 ]);
+    return scopes;
+}
+export { ConfigurationScope as C, configurationDefaultsSchemaId as c, getScopes as g, keyFromOverrideIdentifiers as k };

package/dist/contextkeys.js

@@ -0,0 +1,211 @@
+import { registerColor, editorBackground, widgetBorder, contrastBorder, editorWidgetBackground, lighten, darken } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { _ as __decorate, a as __param, n as IFileService } from './services2.js';
+import { RawContextKey, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isEqual, basename, dirname, extname } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+function isErrorWithActions(obj) {
+    const candidate = obj;
+    return candidate instanceof Error && Array.isArray(candidate.actions);
+}
+function createErrorWithActions(messageOrError, actions) {
+    let error;
+    if (typeof messageOrError === 'string') {
+        error = ( new Error(messageOrError));
+    }
+    else {
+        error = messageOrError;
+    }
+    error.actions = actions;
+    return error;
+}
+const PANEL_BACKGROUND = ( registerColor('panel.background', {
+    dark: editorBackground,
+    light: editorBackground,
+    hcDark: editorBackground,
+    hcLight: editorBackground
+}, ( localize(
+    'panelBackground',
+    "Panel background color. Panels are shown below the editor area and contain views like output and integrated terminal."
+))));
+const SIDE_BAR_BACKGROUND = ( registerColor('sideBar.background', {
+    dark: '#252526',
+    light: '#F3F3F3',
+    hcDark: '#000000',
+    hcLight: '#FFFFFF'
+}, ( localize(
+    'sideBarBackground',
+    "Side bar background color. The side bar is the container for views like explorer and search."
+))));
+const NOTIFICATIONS_CENTER_BORDER = ( registerColor('notificationCenter.border', {
+    dark: widgetBorder,
+    light: widgetBorder,
+    hcDark: contrastBorder,
+    hcLight: contrastBorder
+}, ( localize(
+    'notificationCenterBorder',
+    "Notifications center border color. Notifications slide in from the bottom right of the window."
+))));
+const NOTIFICATIONS_TOAST_BORDER = ( registerColor('notificationToast.border', {
+    dark: widgetBorder,
+    light: widgetBorder,
+    hcDark: contrastBorder,
+    hcLight: contrastBorder
+}, ( localize(
+    'notificationToastBorder',
+    "Notification toast border color. Notifications slide in from the bottom right of the window."
+))));
+const NOTIFICATIONS_BACKGROUND = ( registerColor('notifications.background', {
+    dark: editorWidgetBackground,
+    light: editorWidgetBackground,
+    hcDark: editorWidgetBackground,
+    hcLight: editorWidgetBackground
+}, ( localize(
+    'notificationsBackground',
+    "Notifications background color. Notifications slide in from the bottom right of the window."
+))));
+const NOTIFICATIONS_CENTER_HEADER_FOREGROUND = ( registerColor('notificationCenterHeader.foreground', {
+    dark: null,
+    light: null,
+    hcDark: null,
+    hcLight: null
+}, ( localize(
+    'notificationCenterHeaderForeground',
+    "Notifications center header foreground color. Notifications slide in from the bottom right of the window."
+))));
+const NOTIFICATIONS_CENTER_HEADER_BACKGROUND = ( registerColor('notificationCenterHeader.background', {
+    dark: ( lighten(NOTIFICATIONS_BACKGROUND, 0.3)),
+    light: ( darken(NOTIFICATIONS_BACKGROUND, 0.05)),
+    hcDark: NOTIFICATIONS_BACKGROUND,
+    hcLight: NOTIFICATIONS_BACKGROUND
+}, ( localize(
+    'notificationCenterHeaderBackground',
+    "Notifications center header background color. Notifications slide in from the bottom right of the window."
+))));
+const NotificationFocusedContext = ( new RawContextKey('notificationFocus', true, ( localize('notificationFocus', "Whether a notification has keyboard focus"))));
+const NotificationsCenterVisibleContext = ( new RawContextKey('notificationCenterVisible', false, ( localize('notificationCenterVisible', "Whether the notifications center is visible"))));
+const NotificationsToastsVisibleContext = ( new RawContextKey('notificationToastsVisible', false, ( localize('notificationToastsVisible', "Whether a notification toast is visible"))));
+const PanelFocusContext = ( new RawContextKey('panelFocus', false, ( localize('panelFocus', "Whether the panel has keyboard focus"))));
+let ResourceContextKey = class ResourceContextKey {
+    constructor(_contextKeyService, _fileService, _languageService, _modelService) {
+        this._contextKeyService = _contextKeyService;
+        this._fileService = _fileService;
+        this._languageService = _languageService;
+        this._modelService = _modelService;
+        this._disposables = ( new DisposableStore());
+        this._schemeKey = ResourceContextKey.Scheme.bindTo(this._contextKeyService);
+        this._filenameKey = ResourceContextKey.Filename.bindTo(this._contextKeyService);
+        this._dirnameKey = ResourceContextKey.Dirname.bindTo(this._contextKeyService);
+        this._pathKey = ResourceContextKey.Path.bindTo(this._contextKeyService);
+        this._langIdKey = ResourceContextKey.LangId.bindTo(this._contextKeyService);
+        this._resourceKey = ResourceContextKey.Resource.bindTo(this._contextKeyService);
+        this._extensionKey = ResourceContextKey.Extension.bindTo(this._contextKeyService);
+        this._hasResource = ResourceContextKey.HasResource.bindTo(this._contextKeyService);
+        this._isFileSystemResource = ResourceContextKey.IsFileSystemResource.bindTo(this._contextKeyService);
+        this._disposables.add(_fileService.onDidChangeFileSystemProviderRegistrations(() => {
+            const resource = this.get();
+            this._isFileSystemResource.set(Boolean(resource && _fileService.hasProvider(resource)));
+        }));
+        this._disposables.add(_modelService.onModelAdded(model => {
+            if (isEqual(model.uri, this.get())) {
+                this._setLangId();
+            }
+        }));
+        this._disposables.add(_modelService.onModelLanguageChanged(e => {
+            if (isEqual(e.model.uri, this.get())) {
+                this._setLangId();
+            }
+        }));
+    }
+    dispose() {
+        this._disposables.dispose();
+    }
+    _setLangId() {
+        const value = this.get();
+        if (!value) {
+            this._langIdKey.set(null);
+            return;
+        }
+        const langId = this._modelService.getModel(value)?.getLanguageId() ?? this._languageService.guessLanguageIdByFilepathOrFirstLine(value);
+        this._langIdKey.set(langId);
+    }
+    set(value) {
+        value = value ?? undefined;
+        if (isEqual(this._value, value)) {
+            return;
+        }
+        this._value = value;
+        this._contextKeyService.bufferChangeEvents(() => {
+            this._resourceKey.set(value ? ( value.toString()) : null);
+            this._schemeKey.set(value ? value.scheme : null);
+            this._filenameKey.set(value ? basename(value) : null);
+            this._dirnameKey.set(value ? this.uriToPath(dirname(value)) : null);
+            this._pathKey.set(value ? this.uriToPath(value) : null);
+            this._setLangId();
+            this._extensionKey.set(value ? extname(value) : null);
+            this._hasResource.set(Boolean(value));
+            this._isFileSystemResource.set(value ? this._fileService.hasProvider(value) : false);
+        });
+    }
+    uriToPath(uri) {
+        if (uri.scheme === Schemas.file) {
+            return uri.fsPath;
+        }
+        return uri.path;
+    }
+    reset() {
+        this._value = undefined;
+        this._contextKeyService.bufferChangeEvents(() => {
+            this._resourceKey.reset();
+            this._schemeKey.reset();
+            this._filenameKey.reset();
+            this._dirnameKey.reset();
+            this._pathKey.reset();
+            this._langIdKey.reset();
+            this._extensionKey.reset();
+            this._hasResource.reset();
+            this._isFileSystemResource.reset();
+        });
+    }
+    get() {
+        return this._value;
+    }
+};
+ResourceContextKey.Scheme = ( new RawContextKey('resourceScheme', undefined, { type: 'string', description: ( localize('resourceScheme', "The scheme of the resource")) }));
+ResourceContextKey.Filename = ( new RawContextKey(
+    'resourceFilename',
+    undefined,
+    { type: 'string', description: ( localize('resourceFilename', "The file name of the resource")) }
+));
+ResourceContextKey.Dirname = ( new RawContextKey(
+    'resourceDirname',
+    undefined,
+    { type: 'string', description: ( localize('resourceDirname', "The folder name the resource is contained in")) }
+));
+ResourceContextKey.Path = ( new RawContextKey('resourcePath', undefined, { type: 'string', description: ( localize('resourcePath', "The full path of the resource")) }));
+ResourceContextKey.LangId = ( new RawContextKey('resourceLangId', undefined, { type: 'string', description: ( localize('resourceLangId', "The language identifier of the resource")) }));
+ResourceContextKey.Resource = ( new RawContextKey('resource', undefined, { type: 'URI', description: ( localize('resource', "The full value of the resource including scheme and path")) }));
+ResourceContextKey.Extension = ( new RawContextKey(
+    'resourceExtname',
+    undefined,
+    { type: 'string', description: ( localize('resourceExtname', "The extension name of the resource")) }
+));
+ResourceContextKey.HasResource = ( new RawContextKey('resourceSet', undefined, { type: 'boolean', description: ( localize('resourceSet', "Whether a resource is present or not")) }));
+ResourceContextKey.IsFileSystemResource = ( new RawContextKey(
+    'isFileSystemResource',
+    undefined,
+    { type: 'boolean', description: ( localize(
+        'isFileSystemResource',
+        "Whether the resource is backed by a file system provider"
+    )) }
+));
+ResourceContextKey = ( __decorate([
+    ( __param(0, IContextKeyService)),
+    ( __param(1, IFileService)),
+    ( __param(2, ILanguageService)),
+    ( __param(3, IModelService))
+], ResourceContextKey));
+export { NotificationsToastsVisibleContext as N, PanelFocusContext as P, SIDE_BAR_BACKGROUND as S, NOTIFICATIONS_BACKGROUND as a, NOTIFICATIONS_TOAST_BORDER as b, NotificationsCenterVisibleContext as c, NOTIFICATIONS_CENTER_BORDER as d, NOTIFICATIONS_CENTER_HEADER_FOREGROUND as e, NOTIFICATIONS_CENTER_HEADER_BACKGROUND as f, NotificationFocusedContext as g, PANEL_BACKGROUND as h, isErrorWithActions as i, createErrorWithActions as j };

package/dist/debug.d.ts

@@ -0,0 +1,22 @@
+import * as monaco from 'monaco-editor';
+
+type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
+
+interface IRawLanguageExtensionPoint {
+    id: string;
+    extensions: string[];
+    filenames: string[];
+    filenamePatterns: string[];
+    firstLine: string;
+    aliases: string[];
+    mimetypes: string[];
+    configuration: string;
+    icon: {
+        light: string;
+        dark: string;
+    };
+}
+
+declare function getServiceOverride(): IEditorOverrideServices;
+
+export { IRawLanguageExtensionPoint, getServiceOverride as default };