@codingame/monaco-vscode-api 7.1.0 → 7.1.1

package/vscode/src/vs/platform/configuration/common/configurationRegistry.js

@@ -1,11 +1,10 @@
 import { distinct } from '../../../base/common/arrays.js';
 import { Emitter } from '../../../base/common/event.js';
-import { isObject, isUndefinedOrNull, isUndefined, isString } from '../../../base/common/types.js';
-import { localizeWithPath } from '../../../nls.js';
+import { isEmptyObject, isObject, isUndefinedOrNull, isUndefined } from '../../../base/common/types.js';
+import { localize } from '../../../nls.js';
 import { getLanguageTagSettingPlainKey } from './configuration.js';
 import { Extensions as Extensions$1 } from '../../jsonschemas/common/jsonContributionRegistry.js';
 import { Registry } from '../../registry/common/platform.js';
-const _moduleId = "vs/platform/configuration/common/configurationRegistry";
 var EditPresentationTypes;
 ( ((function(EditPresentationTypes) {
     EditPresentationTypes["Multiline"] = "multilineText";
@@ -34,6 +33,7 @@ const configurationDefaultsSchemaId = 'vscode://schemas/settings/configurationDe
 const contributionRegistry = ( (Registry.as(Extensions$1.JSONContribution)));
 class ConfigurationRegistry {
     constructor() {
+        this.registeredConfigurationDefaults = [];
         this.overrideIdentifiers = ( (new Set()));
         this._onDidSchemaChange = ( (new Emitter()));
         this.onDidSchemaChange = this._onDidSchemaChange.event;
@@ -42,7 +42,7 @@ class ConfigurationRegistry {
         this.configurationDefaultsOverrides = ( (new Map()));
         this.defaultLanguageConfigurationOverridesNode = {
             id: 'defaultOverrides',
-            title: ( localizeWithPath(_moduleId, 0, "Default Language Configuration Overrides")),
+            title: ( localize(468, "Default Language Configuration Overrides")),
             properties: {}
         };
         this.configurationContributors = [this.defaultLanguageConfigurationOverridesNode];
@@ -91,89 +91,31 @@ class ConfigurationRegistry {
         this._onDidUpdateConfiguration.fire({ properties, defaultsOverrides: true });
     }
     doRegisterDefaultConfigurations(configurationDefaults, bucket) {
+        this.registeredConfigurationDefaults.push(...configurationDefaults);
         const overrideIdentifiers = [];
         for (const { overrides, source } of configurationDefaults) {
             for (const key in overrides) {
                 bucket.add(key);
+                const configurationDefaultOverridesForKey = this.configurationDefaultsOverrides.get(key)
+                    ?? this.configurationDefaultsOverrides.set(key, { configurationDefaultOverrides: [] }).get(key);
+                const value = overrides[key];
+                configurationDefaultOverridesForKey.configurationDefaultOverrides.push({ value, source });
                 if (OVERRIDE_PROPERTY_REGEX.test(key)) {
-                    const configurationDefaultOverride = this.configurationDefaultsOverrides.get(key);
-                    const valuesSources = configurationDefaultOverride?.valuesSources ?? ( (new Map()));
-                    const defaultValue = configurationDefaultOverride?.value || {};
-                    for (const configuration of ( (Object.keys(overrides[key])))) {
-                        const overrideValue = overrides[key][configuration];
-                        const isObjectSetting = isObject(overrideValue) && (isUndefined(defaultValue[configuration]) || isObject(defaultValue[configuration]));
-                        if (isObjectSetting) {
-                            defaultValue[configuration] = { ...(defaultValue[configuration] ?? {}), ...overrideValue };
-                            if (source) {
-                                let objectConfigurationSources = valuesSources.get(configuration);
-                                if (!objectConfigurationSources) {
-                                    objectConfigurationSources = ( (new Map()));
-                                    valuesSources.set(configuration, objectConfigurationSources);
-                                }
-                                if (!(objectConfigurationSources instanceof Map)) {
-                                    console.error('objectConfigurationSources is not a Map');
-                                    continue;
-                                }
-                                for (const objectKey in overrideValue) {
-                                    objectConfigurationSources.set(objectKey, source);
-                                }
-                            }
-                        }
-                        else {
-                            defaultValue[configuration] = overrideValue;
-                            if (source) {
-                                valuesSources.set(configuration, source);
-                            }
-                        }
+                    const newDefaultOverride = this.mergeDefaultConfigurationsForOverrideIdentifier(key, value, source, configurationDefaultOverridesForKey.configurationDefaultOverrideValue);
+                    if (!newDefaultOverride) {
+                        continue;
                     }
-                    this.configurationDefaultsOverrides.set(key, { source, value: defaultValue, valuesSources });
-                    const plainKey = getLanguageTagSettingPlainKey(key);
-                    const property = {
-                        type: 'object',
-                        default: defaultValue,
-                        description: ( localizeWithPath(
-                            _moduleId,
-                            1,
-                            "Configure settings to be overridden for the {0} language.",
-                            plainKey
-                        )),
-                        $ref: resourceLanguageSettingsSchemaId,
-                        defaultDefaultValue: defaultValue,
-                        source: isString(source) ? undefined : source,
-                        defaultValueSource: source
-                    };
+                    configurationDefaultOverridesForKey.configurationDefaultOverrideValue = newDefaultOverride;
+                    this.updateDefaultOverrideProperty(key, newDefaultOverride, source);
                     overrideIdentifiers.push(...overrideIdentifiersFromKey(key));
-                    this.configurationProperties[key] = property;
-                    this.defaultLanguageConfigurationOverridesNode.properties[key] = property;
                 }
                 else {
-                    const property = this.configurationProperties[key];
-                    const existingDefaultOverride = this.configurationDefaultsOverrides.get(key);
-                    let existingDefaultValue = existingDefaultOverride?.value ?? property?.defaultDefaultValue;
-                    let newDefaultValue = overrides[key];
-                    let newDefaultValueSource = source;
-                    const isObjectSetting = isObject(newDefaultValue) && (property !== undefined && property.type === 'object' ||
-                        property === undefined && (isUndefined(existingDefaultValue) || isObject(existingDefaultValue)));
-                    if (isObjectSetting) {
-                        if (!isObject(existingDefaultValue)) {
-                            existingDefaultValue = {};
-                        }
-                        newDefaultValue = { ...existingDefaultValue, ...newDefaultValue };
-                        newDefaultValueSource = existingDefaultOverride?.source ?? ( (new Map()));
-                        if (!(newDefaultValueSource instanceof Map)) {
-                            console.error('defaultValueSource is not a Map');
-                            continue;
-                        }
-                        for (const overrideObjectKey in overrides[key]) {
-                            if (source) {
-                                newDefaultValueSource.set(overrideObjectKey, source);
-                            }
-                            else {
-                                newDefaultValueSource.delete(overrideObjectKey);
-                            }
-                        }
+                    const newDefaultOverride = this.mergeDefaultConfigurationsForConfigurationProperty(key, value, source, configurationDefaultOverridesForKey.configurationDefaultOverrideValue);
+                    if (!newDefaultOverride) {
+                        continue;
                     }
-                    this.configurationDefaultsOverrides.set(key, { value: newDefaultValue, source: newDefaultValueSource });
+                    configurationDefaultOverridesForKey.configurationDefaultOverrideValue = newDefaultOverride;
+                    const property = this.configurationProperties[key];
                     if (property) {
                         this.updatePropertyDefaultValue(key, property);
                         this.updateSchema(key, property);
@@ -190,69 +132,48 @@ class ConfigurationRegistry {
         this._onDidUpdateConfiguration.fire({ properties, defaultsOverrides: true });
     }
     doDeregisterDefaultConfigurations(defaultConfigurations, bucket) {
+        for (const defaultConfiguration of defaultConfigurations) {
+            const index = this.registeredConfigurationDefaults.indexOf(defaultConfiguration);
+            if (index !== -1) {
+                this.registeredConfigurationDefaults.splice(index, 1);
+            }
+        }
         for (const { overrides, source } of defaultConfigurations) {
             for (const key in overrides) {
-                const id = isString(source) ? source : source?.id;
-                const configurationDefaultsOverride = this.configurationDefaultsOverrides.get(key);
-                if (!configurationDefaultsOverride) {
+                const configurationDefaultOverridesForKey = this.configurationDefaultsOverrides.get(key);
+                if (!configurationDefaultOverridesForKey) {
                     continue;
                 }
+                const index = configurationDefaultOverridesForKey.configurationDefaultOverrides
+                    .findIndex(configurationDefaultOverride => source ? configurationDefaultOverride.source?.id === source.id : configurationDefaultOverride.value === overrides[key]);
+                if (index === -1) {
+                    continue;
+                }
+                configurationDefaultOverridesForKey.configurationDefaultOverrides.splice(index, 1);
+                if (configurationDefaultOverridesForKey.configurationDefaultOverrides.length === 0) {
+                    this.configurationDefaultsOverrides.delete(key);
+                }
                 if (OVERRIDE_PROPERTY_REGEX.test(key)) {
-                    for (const configuration of ( (Object.keys(overrides[key])))) {
-                        const overrideValue = overrides[key][configuration];
-                        if (isObject(overrideValue)) {
-                            const configurationSource = configurationDefaultsOverride.valuesSources?.get(configuration);
-                            for (const overrideObjectKey of ( (Object.keys(overrideValue)))) {
-                                const keySource = configurationSource?.get(overrideObjectKey);
-                                const keySourceId = isString(keySource) ? keySource : keySource?.id;
-                                if (keySourceId === id) {
-                                    configurationSource?.delete(overrideObjectKey);
-                                    delete configurationDefaultsOverride.value[configuration][overrideObjectKey];
-                                }
-                            }
-                            if (( (Object.keys(configurationDefaultsOverride.value[configuration]))).length === 0) {
-                                delete configurationDefaultsOverride.value[configuration];
-                                configurationDefaultsOverride.valuesSources?.delete(configuration);
-                            }
-                        }
-                        else {
-                            const configurationSource = configurationDefaultsOverride.valuesSources?.get(configuration);
-                            const keySourceId = isString(configurationSource) ? configurationSource : configurationSource?.id;
-                            if (keySourceId === id) {
-                                configurationDefaultsOverride.valuesSources?.delete(configuration);
-                                delete configurationDefaultsOverride.value[configuration];
-                            }
-                        }
+                    let configurationDefaultOverrideValue;
+                    for (const configurationDefaultOverride of configurationDefaultOverridesForKey.configurationDefaultOverrides) {
+                        configurationDefaultOverrideValue = this.mergeDefaultConfigurationsForOverrideIdentifier(key, configurationDefaultOverride.value, configurationDefaultOverride.source, configurationDefaultOverrideValue);
+                    }
+                    if (configurationDefaultOverrideValue && !isEmptyObject(configurationDefaultOverrideValue.value)) {
+                        configurationDefaultOverridesForKey.configurationDefaultOverrideValue = configurationDefaultOverrideValue;
+                        this.updateDefaultOverrideProperty(key, configurationDefaultOverrideValue, source);
                     }
-                    const languageValues = this.configurationDefaultsOverrides.get(key);
-                    if (languageValues && ( (Object.keys(languageValues.value))).length === 0) {
+                    else {
                         this.configurationDefaultsOverrides.delete(key);
                         delete this.configurationProperties[key];
                         delete this.defaultLanguageConfigurationOverridesNode.properties[key];
                     }
                 }
                 else {
-                    if (configurationDefaultsOverride.source instanceof Map) {
-                        const keySources = configurationDefaultsOverride.source;
-                        for (const objectKey in overrides[key]) {
-                            const keySource = keySources.get(objectKey);
-                            const keySourceId = isString(keySource) ? keySource : keySource?.id;
-                            if (keySourceId === id) {
-                                keySources.delete(objectKey);
-                                delete configurationDefaultsOverride.value[objectKey];
-                            }
-                        }
-                        if (keySources.size === 0) {
-                            this.configurationDefaultsOverrides.delete(key);
-                        }
-                    }
-                    else {
-                        const configurationDefaultsOverrideSourceId = isString(configurationDefaultsOverride.source) ? configurationDefaultsOverride.source : configurationDefaultsOverride.source?.id;
-                        if (id !== configurationDefaultsOverrideSourceId) {
-                            continue;
-                        }
-                        this.configurationDefaultsOverrides.delete(key);
+                    let configurationDefaultOverrideValue;
+                    for (const configurationDefaultOverride of configurationDefaultOverridesForKey.configurationDefaultOverrides) {
+                        configurationDefaultOverrideValue = this.mergeDefaultConfigurationsForConfigurationProperty(key, configurationDefaultOverride.value, configurationDefaultOverride.source, configurationDefaultOverrideValue);
                     }
+                    configurationDefaultOverridesForKey.configurationDefaultOverrideValue = configurationDefaultOverrideValue;
                     const property = this.configurationProperties[key];
                     if (property) {
                         this.updatePropertyDefaultValue(key, property);
@@ -264,6 +185,76 @@ class ConfigurationRegistry {
         }
         this.updateOverridePropertyPatternKey();
     }
+    updateDefaultOverrideProperty(key, newDefaultOverride, source) {
+        const property = {
+            type: 'object',
+            default: newDefaultOverride.value,
+            description: ( localize(
+                469,
+                "Configure settings to be overridden for the {0} language.",
+                getLanguageTagSettingPlainKey(key)
+            )),
+            $ref: resourceLanguageSettingsSchemaId,
+            defaultDefaultValue: newDefaultOverride.value,
+            source,
+            defaultValueSource: source
+        };
+        this.configurationProperties[key] = property;
+        this.defaultLanguageConfigurationOverridesNode.properties[key] = property;
+    }
+    mergeDefaultConfigurationsForOverrideIdentifier(overrideIdentifier, configurationValueObject, valueSource, existingDefaultOverride) {
+        const defaultValue = existingDefaultOverride?.value || {};
+        const source = existingDefaultOverride?.source ?? ( (new Map()));
+        if (!(source instanceof Map)) {
+            console.error('objectConfigurationSources is not a Map');
+            return undefined;
+        }
+        for (const propertyKey of ( (Object.keys(configurationValueObject)))) {
+            const propertyDefaultValue = configurationValueObject[propertyKey];
+            const isObjectSetting = isObject(propertyDefaultValue) &&
+                (isUndefined(defaultValue[propertyKey]) || isObject(defaultValue[propertyKey]));
+            if (isObjectSetting) {
+                defaultValue[propertyKey] = { ...(defaultValue[propertyKey] ?? {}), ...propertyDefaultValue };
+                if (valueSource) {
+                    for (const objectKey in propertyDefaultValue) {
+                        source.set(`${propertyKey}.${objectKey}`, valueSource);
+                    }
+                }
+            }
+            else {
+                defaultValue[propertyKey] = propertyDefaultValue;
+                if (valueSource) {
+                    source.set(propertyKey, valueSource);
+                }
+                else {
+                    source.delete(propertyKey);
+                }
+            }
+        }
+        return { value: defaultValue, source };
+    }
+    mergeDefaultConfigurationsForConfigurationProperty(propertyKey, value, valuesSource, existingDefaultOverride) {
+        const property = this.configurationProperties[propertyKey];
+        const existingDefaultValue = existingDefaultOverride?.value ?? property?.defaultDefaultValue;
+        let source = valuesSource;
+        const isObjectSetting = isObject(value) &&
+            (property !== undefined && property.type === 'object' ||
+                property === undefined && (isUndefined(existingDefaultValue) || isObject(existingDefaultValue)));
+        if (isObjectSetting) {
+            source = existingDefaultOverride?.source ?? ( (new Map()));
+            if (!(source instanceof Map)) {
+                console.error('defaultValueSource is not a Map');
+                return undefined;
+            }
+            for (const objectKey in value) {
+                if (valuesSource) {
+                    source.set(`${propertyKey}.${objectKey}`, valuesSource);
+                }
+            }
+            value = { ...(isObject(existingDefaultValue) ? existingDefaultValue : {}), ...value };
+        }
+        return { value, source };
+    }
     deltaConfiguration(delta) {
         let defaultsOverrides = false;
         const properties = ( (new Set()));
@@ -383,8 +374,17 @@ class ConfigurationRegistry {
     getExcludedConfigurationProperties() {
         return this.excludedConfigurationProperties;
     }
+    getRegisteredDefaultConfigurations() {
+        return [...this.registeredConfigurationDefaults];
+    }
     getConfigurationDefaultsOverrides() {
-        return this.configurationDefaultsOverrides;
+        const configurationDefaultsOverrides = ( (new Map()));
+        for (const [key, value] of this.configurationDefaultsOverrides) {
+            if (value.configurationDefaultOverrideValue) {
+                configurationDefaultsOverrides.set(key, value.configurationDefaultOverrideValue);
+            }
+        }
+        return configurationDefaultsOverrides;
     }
     registerJSONConfiguration(configuration) {
         const register = (configuration) => {
@@ -450,8 +450,8 @@ class ConfigurationRegistry {
             const overrideIdentifierProperty = `[${overrideIdentifier}]`;
             const resourceLanguagePropertiesSchema = {
                 type: 'object',
-                description: ( localizeWithPath(_moduleId, 2, "Configure editor settings to be overridden for a language.")),
-                errorMessage: ( localizeWithPath(_moduleId, 3, "This setting does not support per-language configuration.")),
+                description: ( localize(470, "Configure editor settings to be overridden for a language.")),
+                errorMessage: ( localize(471, "This setting does not support per-language configuration.")),
                 $ref: resourceLanguageSettingsSchemaId,
             };
             this.updatePropertyDefaultValue(overrideIdentifierProperty, resourceLanguagePropertiesSchema);
@@ -466,8 +466,8 @@ class ConfigurationRegistry {
     registerOverridePropertyPatternKey() {
         const resourceLanguagePropertiesSchema = {
             type: 'object',
-            description: ( localizeWithPath(_moduleId, 2, "Configure editor settings to be overridden for a language.")),
-            errorMessage: ( localizeWithPath(_moduleId, 3, "This setting does not support per-language configuration.")),
+            description: ( localize(471, "Configure editor settings to be overridden for a language.")),
+            errorMessage: ( localize(471, "This setting does not support per-language configuration.")),
             $ref: resourceLanguageSettingsSchemaId,
         };
         allSettings.patternProperties[OVERRIDE_PROPERTY_PATTERN] = resourceLanguagePropertiesSchema;
@@ -479,9 +479,15 @@ class ConfigurationRegistry {
         this._onDidSchemaChange.fire();
     }
     updatePropertyDefaultValue(key, property) {
-        const configurationdefaultOverride = this.configurationDefaultsOverrides.get(key);
-        let defaultValue = configurationdefaultOverride?.value;
-        let defaultSource = configurationdefaultOverride?.source;
+        const configurationdefaultOverride = this.configurationDefaultsOverrides.get(key)?.configurationDefaultOverrideValue;
+        let defaultValue = undefined;
+        let defaultSource = undefined;
+        if (configurationdefaultOverride
+            && (!property.disallowConfigurationDefault || !configurationdefaultOverride.source)
+        ) {
+            defaultValue = configurationdefaultOverride.value;
+            defaultSource = configurationdefaultOverride.source;
+        }
         if (isUndefined(defaultValue)) {
             defaultValue = property.defaultDefaultValue;
             defaultSource = undefined;
@@ -536,28 +542,25 @@ const configurationRegistry = ( (new ConfigurationRegistry()));
 Registry.add(Extensions.Configuration, configurationRegistry);
 function validateProperty(property, schema) {
     if (!property.trim()) {
-        return ( localizeWithPath(_moduleId, 4, "Cannot register an empty property"));
+        return ( localize(472, "Cannot register an empty property"));
     }
     if (OVERRIDE_PROPERTY_REGEX.test(property)) {
-        return ( localizeWithPath(
-            _moduleId,
-            5,
+        return ( localize(
+            473,
             "Cannot register '{0}'. This matches property pattern '\\\\[.*\\\\]$' for describing language specific editor settings. Use 'configurationDefaults' contribution.",
             property
         ));
     }
     if (configurationRegistry.getConfigurationProperties()[property] !== undefined) {
-        return ( localizeWithPath(
-            _moduleId,
-            6,
+        return ( localize(
+            474,
             "Cannot register '{0}'. This property is already registered.",
             property
         ));
     }
     if (schema.policy?.name && configurationRegistry.getPolicyConfigurations().get(schema.policy?.name) !== undefined) {
-        return ( localizeWithPath(
-            _moduleId,
-            7,
+        return ( localize(
+            475,
             "Cannot register '{0}'. The associated policy {1} is already registered with {2}.",
             property,
             schema.policy?.name,
@@ -576,4 +579,35 @@ function getScopes() {
     scopes.push(['task', ConfigurationScope.RESOURCE]);
     return scopes;
 }
-export { ConfigurationScope, EditPresentationTypes, Extensions, OVERRIDE_PROPERTY_PATTERN, OVERRIDE_PROPERTY_REGEX, allSettings, applicationSettings, configurationDefaultsSchemaId, getDefaultValue, getScopes, keyFromOverrideIdentifiers, machineOverridableSettings, machineSettings, overrideIdentifiersFromKey, resourceLanguageSettingsSchemaId, resourceSettings, validateProperty, windowSettings };
+function getAllConfigurationProperties(configurationNode) {
+    const result = {};
+    for (const configuration of configurationNode) {
+        const properties = configuration.properties;
+        if (isObject(properties)) {
+            for (const key in properties) {
+                result[key] = properties[key];
+            }
+        }
+        if (configuration.allOf) {
+            Object.assign(result, getAllConfigurationProperties(configuration.allOf));
+        }
+    }
+    return result;
+}
+function parseScope(scope) {
+    switch (scope) {
+        case 'application':
+            return ConfigurationScope.APPLICATION;
+        case 'machine':
+            return ConfigurationScope.MACHINE;
+        case 'resource':
+            return ConfigurationScope.RESOURCE;
+        case 'machine-overridable':
+            return ConfigurationScope.MACHINE_OVERRIDABLE;
+        case 'language-overridable':
+            return ConfigurationScope.LANGUAGE_OVERRIDABLE;
+        default:
+            return ConfigurationScope.WINDOW;
+    }
+}
+export { ConfigurationScope, EditPresentationTypes, Extensions, OVERRIDE_PROPERTY_PATTERN, OVERRIDE_PROPERTY_REGEX, allSettings, applicationSettings, configurationDefaultsSchemaId, getAllConfigurationProperties, getDefaultValue, getScopes, keyFromOverrideIdentifiers, machineOverridableSettings, machineSettings, overrideIdentifiersFromKey, parseScope, resourceLanguageSettingsSchemaId, resourceSettings, validateProperty, windowSettings };

package/vscode/src/vs/platform/configuration/common/configurations.js

@@ -48,10 +48,10 @@ let DefaultConfiguration$1 = class DefaultConfiguration extends Disposable {
             const defaultOverrideValue = configurationDefaultsOverrides[key];
             const propertySchema = configurationProperties[key];
             if (defaultOverrideValue !== undefined) {
-                this._configurationModel.addValue(key, defaultOverrideValue);
+                this._configurationModel.setValue(key, defaultOverrideValue);
             }
             else if (propertySchema) {
-                this._configurationModel.addValue(key, propertySchema.default);
+                this._configurationModel.setValue(key, propertySchema.default);
             }
             else {
                 this._configurationModel.removeValue(key);

package/vscode/src/vs/platform/contextkey/browser/contextKeyService.js

@@ -6,13 +6,12 @@ import { MarshalledId } from '../../../base/common/marshallingIds.js';
 import { cloneAndChange, distinct } from '../../../base/common/objects.js';
 import { TernarySearchTree } from '../../../base/common/ternarySearchTree.js';
 import { URI } from '../../../base/common/uri.js';
-import { localizeWithPath } from '../../../nls.js';
+import { localize } from '../../../nls.js';
 import { CommandsRegistry } from '../../commands/common/commands.js';
 import { ConfigurationTarget } from '../../configuration/common/configuration.js';
 import { IConfigurationService } from '../../configuration/common/configuration.service.js';
 import { RawContextKey } from '../common/contextkey.js';
 import { IContextKeyService } from '../common/contextkey.service.js';
-const _moduleId = "vs/platform/contextkey/browser/contextKeyService";
 const KEYBINDING_CONTEXT_ATTR = 'data-keybinding-context';
 class Context {
     constructor(id, parent) {
@@ -506,7 +505,7 @@ CommandsRegistry.registerCommand({
         return [...RawContextKey.all()].sort((a, b) => a.key.localeCompare(b.key));
     },
     metadata: {
-        description: ( localizeWithPath(_moduleId, 0, "A command that returns information about context keys")),
+        description: ( localize(811, "A command that returns information about context keys")),
         args: []
     }
 });

package/vscode/src/vs/platform/contextkey/common/contextkey.js

@@ -2,9 +2,8 @@ import { CharCode } from '../../../base/common/charCode.js';
 import { isMacintosh, isLinux, isWindows, isWeb, isEdge, isFirefox, isChrome, isSafari } from '../../../base/common/platform.js';
 import { isFalsyOrWhitespace } from '../../../base/common/strings.js';
 import { Scanner, TokenType } from './scanner.js';
-import { localizeWithPath } from '../../../nls.js';
+import { localize } from '../../../nls.js';
 import { illegalArgument } from '../../../base/common/errors.js';
-const _moduleId = "vs/platform/contextkey/common/contextkey";
 const CONSTANT_VALUES = ( (new Map()));
 CONSTANT_VALUES.set('false', false);
 CONSTANT_VALUES.set('true', true);
@@ -46,18 +45,17 @@ var ContextKeyExprType;
 const defaultConfig = {
     regexParsingWithErrorRecovery: true
 };
-const errorEmptyString = ( localizeWithPath(_moduleId, 0, "Empty context key expression"));
-const hintEmptyString = ( localizeWithPath(
-    _moduleId,
-    1,
+const errorEmptyString = ( localize(476, "Empty context key expression"));
+const hintEmptyString = ( localize(
+    477,
     "Did you forget to write an expression? You can also put 'false' or 'true' to always evaluate to false or true, respectively."
 ));
-const errorNoInAfterNot = ( localizeWithPath(_moduleId, 2, "'in' after 'not'."));
-const errorClosingParenthesis = ( localizeWithPath(_moduleId, 3, "closing parenthesis ')'"));
-const errorUnexpectedToken = ( localizeWithPath(_moduleId, 4, "Unexpected token"));
-const hintUnexpectedToken = ( localizeWithPath(_moduleId, 5, "Did you forget to put && or || before the token?"));
-const errorUnexpectedEOF = ( localizeWithPath(_moduleId, 6, "Unexpected end of expression"));
-const hintUnexpectedEOF = ( localizeWithPath(_moduleId, 7, "Did you forget to put a context key?"));
+const errorNoInAfterNot = ( localize(478, "'in' after 'not'."));
+const errorClosingParenthesis = ( localize(479, "closing parenthesis ')'"));
+const errorUnexpectedToken = ( localize(480, "Unexpected token"));
+const hintUnexpectedToken = ( localize(481, "Did you forget to put && or || before the token?"));
+const errorUnexpectedEOF = ( localize(482, "Unexpected end of expression"));
+const hintUnexpectedEOF = ( localize(483, "Did you forget to put a context key?"));
 class Parser {
     static { this._parseError = ( (new Error())); }
     get lexingErrors() {
@@ -389,13 +387,7 @@ class Parser {
         throw this._errExpectedButGot(message, this._peek());
     }
     _errExpectedButGot(expected, got, additionalInfo) {
-        const message = ( localizeWithPath(
-            _moduleId,
-            8,
-            "Expected: {0}\nReceived: '{1}'.",
-            expected,
-            Scanner.getLexeme(got)
-        ));
+        const message = ( localize(484, "Expected: {0}\nReceived: '{1}'.", expected, Scanner.getLexeme(got)));
         const offset = got.offset;
         const lexeme = Scanner.getLexeme(got);
         this._parsingErrors.push({ message, offset, lexeme, additionalInfo });
@@ -479,8 +471,8 @@ function validateWhenClauses(whenClauses) {
                 return (
                      (parser.lexingErrors.map((se) => ({
                         errorMessage: se.additionalInfo ?
-                            ( localizeWithPath(_moduleId, 9, "Unexpected token. Hint: {0}", se.additionalInfo)) :
-                            ( localizeWithPath(_moduleId, 10, "Unexpected token.")),
+                            ( localize(485, "Unexpected token. Hint: {0}", se.additionalInfo)) :
+                            ( localize(486, "Unexpected token.")),
                         offset: se.offset,
                         length: se.lexeme.length,
                     })))

package/vscode/src/vs/platform/contextkey/common/contextkeys.js

@@ -1,20 +1,15 @@
 import { isWeb, isMacintosh, isLinux, isWindows, isIOS, isMobile } from '../../../base/common/platform.js';
-import { localizeWithPath } from '../../../nls.js';
+import { localize } from '../../../nls.js';
 import { RawContextKey } from './contextkey.js';
-const _moduleId = "vs/platform/contextkey/common/contextkeys";
-const IsMacContext = ( (new RawContextKey('isMac', isMacintosh, ( localizeWithPath(_moduleId, 0, "Whether the operating system is macOS")))));
-const IsLinuxContext = ( (new RawContextKey('isLinux', isLinux, ( localizeWithPath(_moduleId, 1, "Whether the operating system is Linux")))));
-const IsWindowsContext = ( (new RawContextKey('isWindows', isWindows, ( localizeWithPath(_moduleId, 2, "Whether the operating system is Windows")))));
-const IsWebContext = ( (new RawContextKey('isWeb', isWeb, ( localizeWithPath(_moduleId, 3, "Whether the platform is a web browser")))));
-const IsMacNativeContext = ( (new RawContextKey('isMacNative', isMacintosh && !isWeb, ( localizeWithPath(
- _moduleId,
- 4,
- "Whether the operating system is macOS on a non-browser platform"
-)))));
-const IsIOSContext = ( (new RawContextKey('isIOS', isIOS, ( localizeWithPath(_moduleId, 5, "Whether the operating system is iOS")))));
-const IsMobileContext = ( (new RawContextKey('isMobile', isMobile, ( localizeWithPath(_moduleId, 6, "Whether the platform is a mobile web browser")))));
+const IsMacContext = ( (new RawContextKey('isMac', isMacintosh, ( localize(4654, "Whether the operating system is macOS")))));
+const IsLinuxContext = ( (new RawContextKey('isLinux', isLinux, ( localize(4655, "Whether the operating system is Linux")))));
+const IsWindowsContext = ( (new RawContextKey('isWindows', isWindows, ( localize(4656, "Whether the operating system is Windows")))));
+const IsWebContext = ( (new RawContextKey('isWeb', isWeb, ( localize(4657, "Whether the platform is a web browser")))));
+const IsMacNativeContext = ( (new RawContextKey('isMacNative', isMacintosh && !isWeb, ( localize(4658, "Whether the operating system is macOS on a non-browser platform")))));
+const IsIOSContext = ( (new RawContextKey('isIOS', isIOS, ( localize(4659, "Whether the operating system is iOS")))));
+const IsMobileContext = ( (new RawContextKey('isMobile', isMobile, ( localize(4660, "Whether the platform is a mobile web browser")))));
 const IsDevelopmentContext = ( (new RawContextKey('isDevelopment', false, true)));
-const ProductQualityContext = ( (new RawContextKey('productQualityType', '', ( localizeWithPath(_moduleId, 7, "Quality type of VS Code")))));
+const ProductQualityContext = ( (new RawContextKey('productQualityType', '', ( localize(4661, "Quality type of VS Code")))));
 const InputFocusedContextKey = 'inputFocus';
-const InputFocusedContext = ( (new RawContextKey(InputFocusedContextKey, false, ( localizeWithPath(_moduleId, 8, "Whether keyboard focus is inside an input box")))));
+const InputFocusedContext = ( (new RawContextKey(InputFocusedContextKey, false, ( localize(4662, "Whether keyboard focus is inside an input box")))));
 export { InputFocusedContext, InputFocusedContextKey, IsDevelopmentContext, IsIOSContext, IsLinuxContext, IsMacContext, IsMacNativeContext, IsMobileContext, IsWebContext, IsWindowsContext, ProductQualityContext };

package/vscode/src/vs/platform/contextkey/common/scanner.js

@@ -1,7 +1,6 @@
 import { CharCode } from '../../../base/common/charCode.js';
 import { illegalState } from '../../../base/common/errors.js';
-import { localizeWithPath } from '../../../nls.js';
-const _moduleId = "vs/platform/contextkey/common/scanner";
+import { localize } from '../../../nls.js';
 var TokenType;
 ( ((function(TokenType) {
     TokenType[TokenType["LParen"] = 0] = "LParen";
@@ -29,26 +28,18 @@ var TokenType;
 function hintDidYouMean(...meant) {
     switch (meant.length) {
         case 1:
-            return ( localizeWithPath(_moduleId, 0, "Did you mean {0}?", meant[0]));
+            return ( localize(1643, "Did you mean {0}?", meant[0]));
         case 2:
-            return ( localizeWithPath(_moduleId, 1, "Did you mean {0} or {1}?", meant[0], meant[1]));
+            return ( localize(1644, "Did you mean {0} or {1}?", meant[0], meant[1]));
         case 3:
-            return ( localizeWithPath(
-                _moduleId,
-                2,
-                "Did you mean {0}, {1} or {2}?",
-                meant[0],
-                meant[1],
-                meant[2]
-            ));
+            return ( localize(1645, "Did you mean {0}, {1} or {2}?", meant[0], meant[1], meant[2]));
         default:
             return undefined;
     }
 }
-const hintDidYouForgetToOpenOrCloseQuote = ( localizeWithPath(_moduleId, 3, "Did you forget to open or close the quote?"));
-const hintDidYouForgetToEscapeSlash = ( localizeWithPath(
-    _moduleId,
-    4,
+const hintDidYouForgetToOpenOrCloseQuote = ( localize(1646, "Did you forget to open or close the quote?"));
+const hintDidYouForgetToEscapeSlash = ( localize(
+    1647,
     "Did you forget to escape the '/' (slash) character? Put two backslashes before it to escape, e.g., '\\\\/\'."
 ));
 class Scanner {

package/vscode/src/vs/platform/contextview/browser/contextMenuService.js

@@ -77,9 +77,8 @@ var ContextMenuMenuDelegate;
             getActions: () => {
                 const target = [];
                 if (menuId) {
-                    const menu = menuService.createMenu(menuId, contextKeyService ?? globalContextKeyService);
-                    createAndFillInContextMenuActions(menu, menuActionOptions, target);
-                    menu.dispose();
+                    const menu = menuService.getMenuActions(menuId, contextKeyService ?? globalContextKeyService, menuActionOptions);
+                    createAndFillInContextMenuActions(menu, target);
                 }
                 if (!delegate.getActions) {
                     return target;