@codingame/monaco-vscode-api 1.83.2 → 1.83.3

package/vscode/src/vs/platform/quickinput/browser/helpQuickAccess.js

@@ -0,0 +1,59 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/quickinput/common/quickAccess.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+var HelpQuickAccessProvider_1;
+let HelpQuickAccessProvider = class HelpQuickAccessProvider {
+    static { HelpQuickAccessProvider_1 = this; }
+    static { this.PREFIX = '?'; }
+    constructor(quickInputService, keybindingService) {
+        this.quickInputService = quickInputService;
+        this.keybindingService = keybindingService;
+        this.registry = ( Registry.as(Extensions.Quickaccess));
+    }
+    provide(picker) {
+        const disposables = ( new DisposableStore());
+        disposables.add(picker.onDidAccept(() => {
+            const [item] = picker.selectedItems;
+            if (item) {
+                this.quickInputService.quickAccess.show(item.prefix, { preserveValue: true });
+            }
+        }));
+        disposables.add(picker.onDidChangeValue(value => {
+            const providerDescriptor = this.registry.getQuickAccessProvider(value.substr(HelpQuickAccessProvider_1.PREFIX.length));
+            if (providerDescriptor && providerDescriptor.prefix && providerDescriptor.prefix !== HelpQuickAccessProvider_1.PREFIX) {
+                this.quickInputService.quickAccess.show(providerDescriptor.prefix, { preserveValue: true });
+            }
+        }));
+        picker.items = this.getQuickAccessProviders().filter(p => p.prefix !== HelpQuickAccessProvider_1.PREFIX);
+        return disposables;
+    }
+    getQuickAccessProviders() {
+        const providers = this.registry
+            .getQuickAccessProviders()
+            .sort((providerA, providerB) => providerA.prefix.localeCompare(providerB.prefix))
+            .flatMap(provider => this.createPicks(provider));
+        return providers;
+    }
+    createPicks(provider) {
+        return ( provider.helpEntries.map(helpEntry => {
+            const prefix = helpEntry.prefix || provider.prefix;
+            const label = prefix || '\u2026' ;
+            return {
+                prefix,
+                label,
+                keybinding: helpEntry.commandId ? this.keybindingService.lookupKeybinding(helpEntry.commandId) : undefined,
+                ariaLabel: localizeWithPath('vs/platform/quickinput/browser/helpQuickAccess', 'helpPickAriaLabel', "{0}, {1}", label, helpEntry.description),
+                description: helpEntry.description
+            };
+        }));
+    }
+};
+HelpQuickAccessProvider = HelpQuickAccessProvider_1 = ( __decorate([
+    ( __param(0, IQuickInputService)),
+    ( __param(1, IKeybindingService))
+], HelpQuickAccessProvider));
+export { HelpQuickAccessProvider };

package/vscode/src/vs/platform/quickinput/browser/pickerQuickAccess.js

@@ -0,0 +1,212 @@
+import { timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Disposable, MutableDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isFunction } from 'monaco-editor/esm/vs/base/common/types.js';
+var TriggerAction;
+( (function(TriggerAction) {
+    TriggerAction[TriggerAction["NO_ACTION"] = 0] = "NO_ACTION";
+    TriggerAction[TriggerAction["CLOSE_PICKER"] = 1] = "CLOSE_PICKER";
+    TriggerAction[TriggerAction["REFRESH_PICKER"] = 2] = "REFRESH_PICKER";
+    TriggerAction[TriggerAction["REMOVE_ITEM"] = 3] = "REMOVE_ITEM";
+})(TriggerAction || (TriggerAction = {})));
+function isPicksWithActive(obj) {
+    const candidate = obj;
+    return Array.isArray(candidate.items);
+}
+function isFastAndSlowPicks(obj) {
+    const candidate = obj;
+    return !!candidate.picks && candidate.additionalPicks instanceof Promise;
+}
+class PickerQuickAccessProvider extends Disposable {
+    constructor(prefix, options) {
+        super();
+        this.prefix = prefix;
+        this.options = options;
+    }
+    provide(picker, token, runOptions) {
+        const disposables = ( new DisposableStore());
+        picker.canAcceptInBackground = !!this.options?.canAcceptInBackground;
+        picker.matchOnLabel = picker.matchOnDescription = picker.matchOnDetail = picker.sortByLabel = false;
+        let picksCts = undefined;
+        const picksDisposable = disposables.add(( new MutableDisposable()));
+        const updatePickerItems = async () => {
+            const picksDisposables = picksDisposable.value = ( new DisposableStore());
+            picksCts?.dispose(true);
+            picker.busy = false;
+            picksCts = ( new CancellationTokenSource(token));
+            const picksToken = picksCts.token;
+            const picksFilter = picker.value.substr(this.prefix.length).trim();
+            const providedPicks = this._getPicks(picksFilter, picksDisposables, picksToken, runOptions);
+            const applyPicks = (picks, skipEmpty) => {
+                let items;
+                let activeItem = undefined;
+                if (isPicksWithActive(picks)) {
+                    items = picks.items;
+                    activeItem = picks.active;
+                }
+                else {
+                    items = picks;
+                }
+                if (items.length === 0) {
+                    if (skipEmpty) {
+                        return false;
+                    }
+                    if ((picksFilter.length > 0 || picker.hideInput) && this.options?.noResultsPick) {
+                        if (isFunction(this.options.noResultsPick)) {
+                            items = [this.options.noResultsPick(picksFilter)];
+                        }
+                        else {
+                            items = [this.options.noResultsPick];
+                        }
+                    }
+                }
+                picker.items = items;
+                if (activeItem) {
+                    picker.activeItems = [activeItem];
+                }
+                return true;
+            };
+            const applyFastAndSlowPicks = async (fastAndSlowPicks) => {
+                let fastPicksApplied = false;
+                let slowPicksApplied = false;
+                await Promise.all([
+                    (async () => {
+                        if (typeof fastAndSlowPicks.mergeDelay === 'number') {
+                            await timeout(fastAndSlowPicks.mergeDelay);
+                            if (picksToken.isCancellationRequested) {
+                                return;
+                            }
+                        }
+                        if (!slowPicksApplied) {
+                            fastPicksApplied = applyPicks(fastAndSlowPicks.picks, true );
+                        }
+                    })(),
+                    (async () => {
+                        picker.busy = true;
+                        try {
+                            const awaitedAdditionalPicks = await fastAndSlowPicks.additionalPicks;
+                            if (picksToken.isCancellationRequested) {
+                                return;
+                            }
+                            let picks;
+                            let activePick = undefined;
+                            if (isPicksWithActive(fastAndSlowPicks.picks)) {
+                                picks = fastAndSlowPicks.picks.items;
+                                activePick = fastAndSlowPicks.picks.active;
+                            }
+                            else {
+                                picks = fastAndSlowPicks.picks;
+                            }
+                            let additionalPicks;
+                            let additionalActivePick = undefined;
+                            if (isPicksWithActive(awaitedAdditionalPicks)) {
+                                additionalPicks = awaitedAdditionalPicks.items;
+                                additionalActivePick = awaitedAdditionalPicks.active;
+                            }
+                            else {
+                                additionalPicks = awaitedAdditionalPicks;
+                            }
+                            if (additionalPicks.length > 0 || !fastPicksApplied) {
+                                let fallbackActivePick = undefined;
+                                if (!activePick && !additionalActivePick) {
+                                    const fallbackActivePickCandidate = picker.activeItems[0];
+                                    if (fallbackActivePickCandidate && picks.indexOf(fallbackActivePickCandidate) !== -1) {
+                                        fallbackActivePick = fallbackActivePickCandidate;
+                                    }
+                                }
+                                applyPicks({
+                                    items: [...picks, ...additionalPicks],
+                                    active: activePick || additionalActivePick || fallbackActivePick
+                                });
+                            }
+                        }
+                        finally {
+                            if (!picksToken.isCancellationRequested) {
+                                picker.busy = false;
+                            }
+                            slowPicksApplied = true;
+                        }
+                    })()
+                ]);
+            };
+            if (providedPicks === null) ;
+            else if (isFastAndSlowPicks(providedPicks)) {
+                await applyFastAndSlowPicks(providedPicks);
+            }
+            else if (!(providedPicks instanceof Promise)) {
+                applyPicks(providedPicks);
+            }
+            else {
+                picker.busy = true;
+                try {
+                    const awaitedPicks = await providedPicks;
+                    if (picksToken.isCancellationRequested) {
+                        return;
+                    }
+                    if (isFastAndSlowPicks(awaitedPicks)) {
+                        await applyFastAndSlowPicks(awaitedPicks);
+                    }
+                    else {
+                        applyPicks(awaitedPicks);
+                    }
+                }
+                finally {
+                    if (!picksToken.isCancellationRequested) {
+                        picker.busy = false;
+                    }
+                }
+            }
+        };
+        disposables.add(picker.onDidChangeValue(() => updatePickerItems()));
+        updatePickerItems();
+        disposables.add(picker.onDidAccept(event => {
+            const [item] = picker.selectedItems;
+            if (typeof item?.accept === 'function') {
+                if (!event.inBackground) {
+                    picker.hide();
+                }
+                item.accept(picker.keyMods, event);
+            }
+        }));
+        disposables.add(picker.onDidTriggerItemButton(async ({ button, item }) => {
+            if (typeof item.trigger === 'function') {
+                const buttonIndex = item.buttons?.indexOf(button) ?? -1;
+                if (buttonIndex >= 0) {
+                    const result = item.trigger(buttonIndex, picker.keyMods);
+                    const action = (typeof result === 'number') ? result : await result;
+                    if (token.isCancellationRequested) {
+                        return;
+                    }
+                    switch (action) {
+                        case TriggerAction.NO_ACTION:
+                            break;
+                        case TriggerAction.CLOSE_PICKER:
+                            picker.hide();
+                            break;
+                        case TriggerAction.REFRESH_PICKER:
+                            updatePickerItems();
+                            break;
+                        case TriggerAction.REMOVE_ITEM: {
+                            const index = picker.items.indexOf(item);
+                            if (index !== -1) {
+                                const items = picker.items.slice();
+                                const removed = items.splice(index, 1);
+                                const activeItems = picker.activeItems.filter(activeItem => activeItem !== removed[0]);
+                                const keepScrollPositionBefore = picker.keepScrollPosition;
+                                picker.keepScrollPosition = true;
+                                picker.items = items;
+                                if (activeItems) {
+                                    picker.activeItems = activeItems;
+                                }
+                                picker.keepScrollPosition = keepScrollPositionBefore;
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+        }));
+        return disposables;
+    }
+}
+export { PickerQuickAccessProvider, TriggerAction };

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

@@ -1,6 +1,6 @@
 import { getErrorMessage } from 'monaco-editor/esm/vs/base/common/errors.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { CONTEXT_LOG_LEVEL, LogLevelToString, LogLevel } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 const IRequestService = ( createDecorator('requestService'));
@@ -29,7 +29,7 @@ class AbstractRequestService extends Disposable {
         super();
         this.counter = 0;
         this.logger = loggerService.createLogger('network', {
-            name: ( localize('request', "Network Requests")),
+            name: localizeWithPath('vs/platform/request/common/request', 'request', "Network Requests"),
             when: ( CONTEXT_LOG_LEVEL.isEqualTo(LogLevelToString(LogLevel.Trace))).serialize()
         });
     }

package/vscode/src/vs/platform/theme/common/tokenClassificationRegistry.js

@@ -156,34 +156,25 @@ class TokenClassificationRegistry {
             definitions: {
                 style: {
                     type: 'object',
-                    description: ( nls.localize('schema.token.settings', 'Colors and styles for the token.')),
+                    description: nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'schema.token.settings', 'Colors and styles for the token.'),
                     properties: {
                         foreground: {
                             type: 'string',
-                            description: ( nls.localize('schema.token.foreground', 'Foreground color for the token.')),
+                            description: nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'schema.token.foreground', 'Foreground color for the token.'),
                             format: 'color-hex',
                             default: '#ff0000'
                         },
                         background: {
                             type: 'string',
-                            deprecationMessage: ( nls.localize(
-                                'schema.token.background.warning',
-                                'Token background colors are currently not supported.'
-                            ))
+                            deprecationMessage: nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'schema.token.background.warning', 'Token background colors are currently not supported.')
                         },
                         fontStyle: {
                             type: 'string',
-                            description: ( nls.localize(
-                                'schema.token.fontStyle',
-                                'Sets the all font styles of the rule: \'italic\', \'bold\', \'underline\' or \'strikethrough\' or a combination. All styles that are not listed are unset. The empty string unsets all styles.'
-                            )),
+                            description: nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'schema.token.fontStyle', 'Sets the all font styles of the rule: \'italic\', \'bold\', \'underline\' or \'strikethrough\' or a combination. All styles that are not listed are unset. The empty string unsets all styles.'),
                             pattern: fontStylePattern,
-                            patternErrorMessage: ( nls.localize(
-                                'schema.fontStyle.error',
-                                'Font style must be \'italic\', \'bold\', \'underline\' or \'strikethrough\' or a combination. The empty string unsets all styles.'
-                            )),
+                            patternErrorMessage: nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'schema.fontStyle.error', 'Font style must be \'italic\', \'bold\', \'underline\' or \'strikethrough\' or a combination. The empty string unsets all styles.'),
                             defaultSnippets: [
-                                { label: ( nls.localize('schema.token.fontStyle.none', 'None (clear inherited style)')), bodyText: '""' },
+                                { label: nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'schema.token.fontStyle.none', 'None (clear inherited style)'), bodyText: '""' },
                                 { body: 'italic' },
                                 { body: 'bold' },
                                 { body: 'underline' },
@@ -203,31 +194,19 @@ class TokenClassificationRegistry {
                         },
                         bold: {
                             type: 'boolean',
-                            description: ( nls.localize(
-                                'schema.token.bold',
-                                'Sets or unsets the font style to bold. Note, the presence of \'fontStyle\' overrides this setting.'
-                            )),
+                            description: nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'schema.token.bold', 'Sets or unsets the font style to bold. Note, the presence of \'fontStyle\' overrides this setting.'),
                         },
                         italic: {
                             type: 'boolean',
-                            description: ( nls.localize(
-                                'schema.token.italic',
-                                'Sets or unsets the font style to italic. Note, the presence of \'fontStyle\' overrides this setting.'
-                            )),
+                            description: nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'schema.token.italic', 'Sets or unsets the font style to italic. Note, the presence of \'fontStyle\' overrides this setting.'),
                         },
                         underline: {
                             type: 'boolean',
-                            description: ( nls.localize(
-                                'schema.token.underline',
-                                'Sets or unsets the font style to underline. Note, the presence of \'fontStyle\' overrides this setting.'
-                            )),
+                            description: nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'schema.token.underline', 'Sets or unsets the font style to underline. Note, the presence of \'fontStyle\' overrides this setting.'),
                         },
                         strikethrough: {
                             type: 'boolean',
-                            description: ( nls.localize(
-                                'schema.token.strikethrough',
-                                'Sets or unsets the font style to strikethrough. Note, the presence of \'fontStyle\' overrides this setting.'
-                            )),
+                            description: nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'schema.token.strikethrough', 'Sets or unsets the font style to strikethrough. Note, the presence of \'fontStyle\' overrides this setting.'),
                         }
                     },
                     defaultSnippets: [{ body: { foreground: '${1:#FF0000}', fontStyle: '${2:bold}' } }]
@@ -390,38 +369,38 @@ function createDefaultTokenClassificationRegistry() {
             console.log(e);
         }
     }
-    registerTokenType('comment', ( nls.localize('comment', "Style for comments.")), [['comment']]);
-    registerTokenType('string', ( nls.localize('string', "Style for strings.")), [['string']]);
-    registerTokenType('keyword', ( nls.localize('keyword', "Style for keywords.")), [['keyword.control']]);
-    registerTokenType('number', ( nls.localize('number', "Style for numbers.")), [['constant.numeric']]);
-    registerTokenType('regexp', ( nls.localize('regexp', "Style for expressions.")), [['constant.regexp']]);
-    registerTokenType('operator', ( nls.localize('operator', "Style for operators.")), [['keyword.operator']]);
-    registerTokenType('namespace', ( nls.localize('namespace', "Style for namespaces.")), [['entity.name.namespace']]);
-    registerTokenType('type', ( nls.localize('type', "Style for types.")), [['entity.name.type'], ['support.type']]);
-    registerTokenType('struct', ( nls.localize('struct', "Style for structs.")), [['entity.name.type.struct']]);
-    registerTokenType('class', ( nls.localize('class', "Style for classes.")), [['entity.name.type.class'], ['support.class']]);
-    registerTokenType('interface', ( nls.localize('interface', "Style for interfaces.")), [['entity.name.type.interface']]);
-    registerTokenType('enum', ( nls.localize('enum', "Style for enums.")), [['entity.name.type.enum']]);
-    registerTokenType('typeParameter', ( nls.localize('typeParameter', "Style for type parameters.")), [['entity.name.type.parameter']]);
-    registerTokenType('function', ( nls.localize('function', "Style for functions")), [['entity.name.function'], ['support.function']]);
-    registerTokenType('member', ( nls.localize('member', "Style for member functions")), [], 'method', 'Deprecated use `method` instead');
-    registerTokenType('method', ( nls.localize('method', "Style for method (member functions)")), [['entity.name.function.member'], ['support.function']]);
-    registerTokenType('macro', ( nls.localize('macro', "Style for macros.")), [['entity.name.function.preprocessor']]);
-    registerTokenType('variable', ( nls.localize('variable', "Style for variables.")), [['variable.other.readwrite'], ['entity.name.variable']]);
-    registerTokenType('parameter', ( nls.localize('parameter', "Style for parameters.")), [['variable.parameter']]);
-    registerTokenType('property', ( nls.localize('property', "Style for properties.")), [['variable.other.property']]);
-    registerTokenType('enumMember', ( nls.localize('enumMember', "Style for enum members.")), [['variable.other.enummember']]);
-    registerTokenType('event', ( nls.localize('event', "Style for events.")), [['variable.other.event']]);
-    registerTokenType('decorator', ( nls.localize('decorator', "Style for decorators & annotations.")), [['entity.name.decorator'], ['entity.name.function']]);
-    registerTokenType('label', ( nls.localize('labels', "Style for labels. ")), undefined);
-    registry.registerTokenModifier('declaration', ( nls.localize('declaration', "Style for all symbol declarations.")), undefined);
-    registry.registerTokenModifier('documentation', ( nls.localize('documentation', "Style to use for references in documentation.")), undefined);
-    registry.registerTokenModifier('static', ( nls.localize('static', "Style to use for symbols that are static.")), undefined);
-    registry.registerTokenModifier('abstract', ( nls.localize('abstract', "Style to use for symbols that are abstract.")), undefined);
-    registry.registerTokenModifier('deprecated', ( nls.localize('deprecated', "Style to use for symbols that are deprecated.")), undefined);
-    registry.registerTokenModifier('modification', ( nls.localize('modification', "Style to use for write accesses.")), undefined);
-    registry.registerTokenModifier('async', ( nls.localize('async', "Style to use for symbols that are async.")), undefined);
-    registry.registerTokenModifier('readonly', ( nls.localize('readonly', "Style to use for symbols that are read-only.")), undefined);
+    registerTokenType('comment', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'comment', "Style for comments."), [['comment']]);
+    registerTokenType('string', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'string', "Style for strings."), [['string']]);
+    registerTokenType('keyword', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'keyword', "Style for keywords."), [['keyword.control']]);
+    registerTokenType('number', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'number', "Style for numbers."), [['constant.numeric']]);
+    registerTokenType('regexp', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'regexp', "Style for expressions."), [['constant.regexp']]);
+    registerTokenType('operator', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'operator', "Style for operators."), [['keyword.operator']]);
+    registerTokenType('namespace', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'namespace', "Style for namespaces."), [['entity.name.namespace']]);
+    registerTokenType('type', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'type', "Style for types."), [['entity.name.type'], ['support.type']]);
+    registerTokenType('struct', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'struct', "Style for structs."), [['entity.name.type.struct']]);
+    registerTokenType('class', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'class', "Style for classes."), [['entity.name.type.class'], ['support.class']]);
+    registerTokenType('interface', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'interface', "Style for interfaces."), [['entity.name.type.interface']]);
+    registerTokenType('enum', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'enum', "Style for enums."), [['entity.name.type.enum']]);
+    registerTokenType('typeParameter', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'typeParameter', "Style for type parameters."), [['entity.name.type.parameter']]);
+    registerTokenType('function', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'function', "Style for functions"), [['entity.name.function'], ['support.function']]);
+    registerTokenType('member', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'member', "Style for member functions"), [], 'method', 'Deprecated use `method` instead');
+    registerTokenType('method', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'method', "Style for method (member functions)"), [['entity.name.function.member'], ['support.function']]);
+    registerTokenType('macro', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'macro', "Style for macros."), [['entity.name.function.preprocessor']]);
+    registerTokenType('variable', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'variable', "Style for variables."), [['variable.other.readwrite'], ['entity.name.variable']]);
+    registerTokenType('parameter', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'parameter', "Style for parameters."), [['variable.parameter']]);
+    registerTokenType('property', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'property', "Style for properties."), [['variable.other.property']]);
+    registerTokenType('enumMember', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'enumMember', "Style for enum members."), [['variable.other.enummember']]);
+    registerTokenType('event', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'event', "Style for events."), [['variable.other.event']]);
+    registerTokenType('decorator', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'decorator', "Style for decorators & annotations."), [['entity.name.decorator'], ['entity.name.function']]);
+    registerTokenType('label', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'labels', "Style for labels. "), undefined);
+    registry.registerTokenModifier('declaration', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'declaration', "Style for all symbol declarations."), undefined);
+    registry.registerTokenModifier('documentation', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'documentation', "Style to use for references in documentation."), undefined);
+    registry.registerTokenModifier('static', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'static', "Style to use for symbols that are static."), undefined);
+    registry.registerTokenModifier('abstract', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'abstract', "Style to use for symbols that are abstract."), undefined);
+    registry.registerTokenModifier('deprecated', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'deprecated', "Style to use for symbols that are deprecated."), undefined);
+    registry.registerTokenModifier('modification', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'modification', "Style to use for write accesses."), undefined);
+    registry.registerTokenModifier('async', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'async', "Style to use for symbols that are async."), undefined);
+    registry.registerTokenModifier('readonly', nls.localizeWithPath('vs/platform/theme/common/tokenClassificationRegistry', 'readonly', "Style to use for symbols that are read-only."), undefined);
     registerTokenStyleDefault('variable.readonly', [['variable.other.constant']]);
     registerTokenStyleDefault('property.readonly', [['variable.other.constant.property']]);
     registerTokenStyleDefault('type.defaultLibrary', [['support.type']]);

package/vscode/src/vs/workbench/api/browser/mainThreadAuthentication.js

@@ -29,32 +29,28 @@ class MainThreadAuthenticationProvider extends Disposable {
     manageTrustedExtensions(accountName) {
         const allowedExtensions = readAllowedExtensions(this.storageService, this.id, accountName);
         if (!allowedExtensions.length) {
-            this.dialogService.info(( nls.localize('noTrustedExtensions', "This account has not been used by any extensions.")));
+            this.dialogService.info(nls.localizeWithPath('vs/workbench/api/browser/mainThreadAuthentication', 'noTrustedExtensions', "This account has not been used by any extensions."));
             return;
         }
         const quickPick = this.quickInputService.createQuickPick();
         quickPick.canSelectMany = true;
         quickPick.customButton = true;
-        quickPick.customLabel = ( nls.localize('manageTrustedExtensions.cancel', 'Cancel'));
+        quickPick.customLabel = nls.localizeWithPath('vs/workbench/api/browser/mainThreadAuthentication', 'manageTrustedExtensions.cancel', 'Cancel');
         const usages = readAccountUsages(this.storageService, this.id, accountName);
         const items = ( allowedExtensions.map(extension => {
             const usage = usages.find(usage => extension.id === usage.extensionId);
             return {
                 label: extension.name,
                 description: usage
-                    ? ( nls.localize(
-                    { key: 'accountLastUsedDate', comment: ['The placeholder {0} is a string with time information, such as "3 days ago"'] },
-                    "Last used this account {0}",
-                    fromNow(usage.lastUsed, true)
-                ))
-                    : ( nls.localize('notUsed', "Has not used this account")),
+                    ? nls.localizeWithPath('vs/workbench/api/browser/mainThreadAuthentication', { key: 'accountLastUsedDate', comment: ['The placeholder {0} is a string with time information, such as "3 days ago"'] }, "Last used this account {0}", fromNow(usage.lastUsed, true))
+                    : nls.localizeWithPath('vs/workbench/api/browser/mainThreadAuthentication', 'notUsed', "Has not used this account"),
                 extension
             };
         }));
         quickPick.items = items;
         quickPick.selectedItems = items.filter(item => item.extension.allowed === undefined || item.extension.allowed);
-        quickPick.title = ( nls.localize('manageTrustedExtensions', "Manage Trusted Extensions"));
-        quickPick.placeholder = ( nls.localize('manageExtensions', "Choose which extensions can access this account"));
+        quickPick.title = nls.localizeWithPath('vs/workbench/api/browser/mainThreadAuthentication', 'manageTrustedExtensions', "Manage Trusted Extensions");
+        quickPick.placeholder = nls.localizeWithPath('vs/workbench/api/browser/mainThreadAuthentication', 'manageExtensions', "Choose which extensions can access this account");
         quickPick.onDidAccept(() => {
             const updatedAllowedList = ( quickPick.items
                 .map(i => i.extension));
@@ -82,14 +78,9 @@ class MainThreadAuthenticationProvider extends Disposable {
         const { confirmed } = await this.dialogService.confirm({
             type: Severity.Info,
             message: accountUsages.length
-                ? ( nls.localize(
-                'signOutMessage',
-                "The account '{0}' has been used by: \n\n{1}\n\n Sign out from these extensions?",
-                accountName,
-                ( accountUsages.map(usage => usage.extensionName)).join('\n')
-            ))
-                : ( nls.localize('signOutMessageSimple', "Sign out of '{0}'?", accountName)),
-            primaryButton: ( nls.localize({ key: 'signOut', comment: ['&& denotes a mnemonic'] }, "&&Sign Out"))
+                ? nls.localizeWithPath('vs/workbench/api/browser/mainThreadAuthentication', 'signOutMessage', "The account '{0}' has been used by: \n\n{1}\n\n Sign out from these extensions?", accountName, ( accountUsages.map(usage => usage.extensionName)).join('\n'))
+                : nls.localizeWithPath('vs/workbench/api/browser/mainThreadAuthentication', 'signOutMessageSimple', "Sign out of '{0}'?", accountName),
+            primaryButton: nls.localizeWithPath('vs/workbench/api/browser/mainThreadAuthentication', { key: 'signOut', comment: ['&& denotes a mnemonic'] }, "&&Sign Out")
         });
         if (confirmed) {
             const removeSessionPromises = ( sessions.map(session => this.removeSession(session.id)));
@@ -106,7 +97,7 @@ class MainThreadAuthenticationProvider extends Disposable {
     }
     async removeSession(sessionId) {
         await this._proxy.$removeSession(this.id, sessionId);
-        this.notificationService.info(( nls.localize('signedOut', "Successfully signed out.")));
+        this.notificationService.info(nls.localizeWithPath('vs/workbench/api/browser/mainThreadAuthentication', 'signedOut', "Successfully signed out."));
     }
 }
 let MainThreadAuthentication = class MainThreadAuthentication extends Disposable {
@@ -155,23 +146,13 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
     }
     async loginPrompt(providerName, extensionName, recreatingSession, detail) {
         const message = recreatingSession
-            ? ( nls.localize(
-            'confirmRelogin',
-            "The extension '{0}' wants you to sign in again using {1}.",
-            extensionName,
-            providerName
-        ))
-            : ( nls.localize(
-            'confirmLogin',
-            "The extension '{0}' wants to sign in using {1}.",
-            extensionName,
-            providerName
-        ));
+            ? nls.localizeWithPath('vs/workbench/api/browser/mainThreadAuthentication', 'confirmRelogin', "The extension '{0}' wants you to sign in again using {1}.", extensionName, providerName)
+            : nls.localizeWithPath('vs/workbench/api/browser/mainThreadAuthentication', 'confirmLogin', "The extension '{0}' wants to sign in using {1}.", extensionName, providerName);
         const { confirmed } = await this.dialogService.confirm({
             type: Severity.Info,
             message,
             detail,
-            primaryButton: ( nls.localize({ key: 'allow', comment: ['&& denotes a mnemonic'] }, "&&Allow"))
+            primaryButton: nls.localizeWithPath('vs/workbench/api/browser/mainThreadAuthentication', { key: 'allow', comment: ['&& denotes a mnemonic'] }, "&&Allow")
         });
         return confirmed;
     }

package/vscode/src/vs/workbench/api/browser/mainThreadComments.js

@@ -14,7 +14,7 @@ import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/comm
 import { ViewPaneContainer } from '../../browser/parts/views/viewPaneContainer.js';
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
 class MainThreadCommentThread {
     get input() {
@@ -369,7 +369,7 @@ class MainThreadCommentController {
         };
     }
 }
-const commentsViewIcon = registerIcon('comments-view-icon', Codicon.commentDiscussion, ( localize('commentsViewIcon', 'View icon of the comments view.')));
+const commentsViewIcon = registerIcon('comments-view-icon', Codicon.commentDiscussion, localizeWithPath('vs/workbench/api/browser/mainThreadComments', 'commentsViewIcon', 'View icon of the comments view.'));
 let MainThreadComments = class MainThreadComments extends Disposable {
     constructor(extHostContext, _commentService, _viewsService, _viewDescriptorService) {
         super();

package/vscode/src/vs/workbench/api/browser/mainThreadCustomEditors.js

@@ -10,7 +10,7 @@ import { basename } from 'monaco-editor/esm/vs/base/common/path.js';
 import { isEqualOrParent, isEqual, toLocalResource } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import '../../../../../../override/vs/platform/dialogs/common/dialogs.js';
 import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
@@ -297,7 +297,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
                         return true;
                     }
                     return false;
-                })(), ( localize('vetoExtHostRestart', "Custom editor '{0}' could not be saved.", this.name)));
+                })(), localizeWithPath('vs/workbench/api/browser/mainThreadCustomEditors', 'vetoExtHostRestart', "Custom editor '{0}' could not be saved.", this.name));
             }));
         }
         if (startDirty) {
@@ -362,7 +362,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
         this._undoService.pushElement({
             type: 0 ,
             resource: this._editorResource,
-            label: label ?? ( localize('defaultEditLabel', "Edit")),
+            label: label ?? localizeWithPath('vs/workbench/api/browser/mainThreadCustomEditors', 'defaultEditLabel', "Edit"),
             code: 'undoredo.customEditorEdit',
             undo: () => this.undo(),
             redo: () => this.redo(),

package/vscode/src/vs/workbench/api/browser/mainThreadEditSessionIdentityParticipant.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { extHostCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { raceCancellationError } from 'monaco-editor/esm/vs/base/common/async.js';
@@ -12,10 +12,9 @@ class ExtHostEditSessionIdentityCreateParticipant {
     }
     async participate(workspaceFolder, token) {
         const p = ( new Promise((resolve, reject) => {
-            setTimeout(() => reject(( new Error(( localize(
-                'timeout.onWillCreateEditSessionIdentity',
-                "Aborted onWillCreateEditSessionIdentity-event after 10000ms"
-            ))))), this.timeout);
+            setTimeout(() => reject(( new Error(
+                localizeWithPath('vs/workbench/api/browser/mainThreadEditSessionIdentityParticipant', 'timeout.onWillCreateEditSessionIdentity', "Aborted onWillCreateEditSessionIdentity-event after 10000ms")
+            ))), this.timeout);
             this._proxy.$onWillCreateEditSessionIdentity(workspaceFolder.uri, token, this.timeout).then(resolve, reject);
         }));
         return raceCancellationError(p, token);