@codingame/monaco-vscode-api 4.5.1 → 5.0.0

package/vscode/src/vs/workbench/browser/parts/compositePart.d.ts

@@ -17,6 +17,7 @@ import { WorkbenchToolBar } from '../../../platform/actions/browser/toolbar.js';
 import { IBoundarySashes } from '../../../base/browser/ui/sash/sash.js';
 import { IBaseActionViewItemOptions } from '../../../base/browser/ui/actionbar/actionViewItems.js';
 import { IHoverDelegate } from '../../../base/browser/ui/hover/hoverDelegate.js';
+import { IHoverService } from '../../../platform/hover/browser/hover.service.js';
 
 interface ICompositeTitleLabel {
     /**
@@ -33,6 +34,7 @@ declare abstract class CompositePart<T extends Composite> extends Part {
     protected readonly storageService: IStorageService;
     protected readonly contextMenuService: IContextMenuService;
     protected readonly keybindingService: IKeybindingService;
+    private readonly hoverService;
     protected readonly instantiationService: IInstantiationService;
     protected readonly registry: CompositeRegistry<T>;
     private readonly activeCompositeSettingsKey;
@@ -59,7 +61,7 @@ declare abstract class CompositePart<T extends Composite> extends Part {
     private readonly actionsListener;
     private currentCompositeOpenToken;
     private boundarySashes;
-    constructor(notificationService: INotificationService, storageService: IStorageService, contextMenuService: IContextMenuService, layoutService: IWorkbenchLayoutService, keybindingService: IKeybindingService, instantiationService: IInstantiationService, themeService: IThemeService, registry: CompositeRegistry<T>, activeCompositeSettingsKey: string, defaultCompositeId: string, nameForTelemetry: string, compositeCSSClass: string, titleForegroundColor: string | undefined, id: string, options: IPartOptions);
+    constructor(notificationService: INotificationService, storageService: IStorageService, contextMenuService: IContextMenuService, layoutService: IWorkbenchLayoutService, keybindingService: IKeybindingService, hoverService: IHoverService, instantiationService: IInstantiationService, themeService: IThemeService, registry: CompositeRegistry<T>, activeCompositeSettingsKey: string, defaultCompositeId: string, nameForTelemetry: string, compositeCSSClass: string, titleForegroundColor: string | undefined, id: string, options: IPartOptions);
     protected openComposite(id: string, focus?: boolean): Composite | undefined;
     private doOpenComposite;
     protected createComposite(id: string, isActive?: boolean): Composite;

package/vscode/src/vs/workbench/browser/parts/editor/binaryDiffEditor.js

@@ -11,6 +11,7 @@ import { IConfigurationService } from '../../../../platform/configuration/common
 import { ITextResourceConfigurationService } from '../../../../editor/common/services/textResourceConfiguration.js';
 import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.service.js';
 import { IEditorService } from '../../../services/editor/common/editorService.service.js';
+const _moduleId = "vs/workbench/browser/parts/editor/binaryDiffEditor";
 let BinaryResourceDiffEditor = class BinaryResourceDiffEditor extends SideBySideEditor {
     static { this.ID = BINARY_DIFF_EDITOR_ID; }
     constructor(group, telemetryService, instantiationService, themeService, storageService, configurationService, textResourceConfigurationService, editorService, editorGroupService) {
@@ -20,25 +21,19 @@ let BinaryResourceDiffEditor = class BinaryResourceDiffEditor extends SideBySide
         const primary = this.getPrimaryEditorPane();
         const secondary = this.getSecondaryEditorPane();
         if (primary instanceof BaseBinaryResourceEditor && secondary instanceof BaseBinaryResourceEditor) {
-            return ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/binaryDiffEditor',
-                'metadataDiff',
-                "{0} ↔ {1}",
-                secondary.getMetadata(),
-                primary.getMetadata()
-            ));
+            return ( localizeWithPath(_moduleId, 0, "{0} ↔ {1}", secondary.getMetadata(), primary.getMetadata()));
         }
         return undefined;
     }
 };
-BinaryResourceDiffEditor = ( __decorate([
-    ( __param(1, ITelemetryService)),
-    ( __param(2, IInstantiationService)),
-    ( __param(3, IThemeService)),
-    ( __param(4, IStorageService)),
-    ( __param(5, IConfigurationService)),
-    ( __param(6, ITextResourceConfigurationService)),
-    ( __param(7, IEditorService)),
-    ( __param(8, IEditorGroupsService))
-], BinaryResourceDiffEditor));
+BinaryResourceDiffEditor = ( (__decorate([
+    ( (__param(1, ITelemetryService))),
+    ( (__param(2, IInstantiationService))),
+    ( (__param(3, IThemeService))),
+    ( (__param(4, IStorageService))),
+    ( (__param(5, IConfigurationService))),
+    ( (__param(6, ITextResourceConfigurationService))),
+    ( (__param(7, IEditorService))),
+    ( (__param(8, IEditorGroupsService)))
+], BinaryResourceDiffEditor)));
 export { BinaryResourceDiffEditor };

package/vscode/src/vs/workbench/browser/parts/editor/binaryEditor.js

@@ -5,43 +5,36 @@ import { BinaryEditorModel } from '../../../common/editor/binaryEditorModel.js';
 import { IStorageService } from '../../../../platform/storage/common/storage.service.js';
 import { ByteSize } from '../../../../platform/files/common/files.js';
 import { EditorPlaceholder } from './editorPlaceholder.js';
+const _moduleId = "vs/workbench/browser/parts/editor/binaryEditor";
 let BaseBinaryResourceEditor = class BaseBinaryResourceEditor extends EditorPlaceholder {
     constructor(id, group, callbacks, telemetryService, themeService, storageService) {
         super(id, group, telemetryService, themeService, storageService);
         this.callbacks = callbacks;
-        this._onDidChangeMetadata = this._register(( new Emitter()));
+        this._onDidChangeMetadata = this._register(( (new Emitter())));
         this.onDidChangeMetadata = this._onDidChangeMetadata.event;
-        this._onDidOpenInPlace = this._register(( new Emitter()));
+        this._onDidOpenInPlace = this._register(( (new Emitter())));
         this.onDidOpenInPlace = this._onDidOpenInPlace.event;
     }
     getTitle() {
-        return this.input ? this.input.getName() : ( localizeWithPath(
-            'vs/workbench/browser/parts/editor/binaryEditor',
-            'binaryEditor',
-            "Binary Viewer"
-        ));
+        return this.input ? this.input.getName() : ( localizeWithPath(_moduleId, 0, "Binary Viewer"));
     }
     async getContents(input, options) {
         const model = await input.resolve();
         if (!(model instanceof BinaryEditorModel)) {
-            throw new Error('Unable to open file as binary');
+            throw ( (new Error('Unable to open file as binary')));
         }
         const size = model.getSize();
         this.handleMetadataChanged(typeof size === 'number' ? ByteSize.formatSize(size) : '');
         return {
             icon: '$(warning)',
             label: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/binaryEditor',
-                'binaryError',
+                _moduleId,
+                1,
                 "The file is not displayed in the text editor because it is either binary or uses an unsupported text encoding."
             )),
             actions: [
                 {
-                    label: ( localizeWithPath(
-                        'vs/workbench/browser/parts/editor/binaryEditor',
-                        'openAnyway',
-                        "Open Anyway"
-                    )),
+                    label: ( localizeWithPath(_moduleId, 2, "Open Anyway")),
                     run: async () => {
                         await this.callbacks.openInternal(input, options);
                         this._onDidOpenInPlace.fire();
@@ -58,7 +51,7 @@ let BaseBinaryResourceEditor = class BaseBinaryResourceEditor extends EditorPlac
         return this.metadata;
     }
 };
-BaseBinaryResourceEditor = ( __decorate([
-    ( __param(5, IStorageService))
-], BaseBinaryResourceEditor));
+BaseBinaryResourceEditor = ( (__decorate([
+    ( (__param(5, IStorageService)))
+], BaseBinaryResourceEditor)));
 export { BaseBinaryResourceEditor };

package/vscode/src/vs/workbench/browser/parts/editor/breadcrumbs.js

@@ -3,13 +3,14 @@ import { localizeWithPath } from '../../../../nls.js';
 import { Extensions } from '../../../../platform/configuration/common/configurationRegistry.js';
 import { Registry } from '../../../../platform/registry/common/platform.js';
 import '../../../../platform/instantiation/common/instantiation.js';
+const _moduleId = "vs/workbench/browser/parts/editor/breadcrumbs";
 class BreadcrumbsService {
     constructor() {
-        this._map = ( new Map());
+        this._map = ( (new Map()));
     }
     register(group, widget) {
-        if (( this._map.has(group))) {
-            throw new Error(`group (${group}) has already a widget`);
+        if (( (this._map.has(group)))) {
+            throw ( (new Error(`group (${group}) has already a widget`)));
         }
         this._map.set(group, widget);
         return {
@@ -34,7 +35,7 @@ class BreadcrumbsConfig {
     static _stub(name) {
         return {
             bindTo(service) {
-                const onDidChange = ( new Emitter());
+                const onDidChange = ( (new Emitter()));
                 const listener = service.onDidChangeConfiguration(e => {
                     if (e.affectsConfiguration(name)) {
                         onDidChange.fire(undefined);
@@ -70,83 +71,55 @@ class BreadcrumbsConfig {
         };
     }
 }
-( Registry.as(Extensions.Configuration)).registerConfiguration({
+( (Registry.as(Extensions.Configuration))).registerConfiguration({
     id: 'breadcrumbs',
-    title: ( localizeWithPath(
-        'vs/workbench/browser/parts/editor/breadcrumbs',
-        'title',
-        "Breadcrumb Navigation"
-    )),
+    title: ( localizeWithPath(_moduleId, 0, "Breadcrumb Navigation")),
     order: 101,
     type: 'object',
     properties: {
         'breadcrumbs.enabled': {
-            description: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'enabled',
-                "Enable/disable navigation breadcrumbs."
-            )),
+            description: ( localizeWithPath(_moduleId, 1, "Enable/disable navigation breadcrumbs.")),
             type: 'boolean',
             default: true
         },
         'breadcrumbs.filePath': {
             description: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filepath',
+                _moduleId,
+                2,
                 "Controls whether and how file paths are shown in the breadcrumbs view."
             )),
             type: 'string',
             default: 'on',
             enum: ['on', 'off', 'last'],
             enumDescriptions: [
+                ( localizeWithPath(_moduleId, 3, "Show the file path in the breadcrumbs view.")),
+                ( localizeWithPath(_moduleId, 4, "Do not show the file path in the breadcrumbs view.")),
                 ( localizeWithPath(
-                    'vs/workbench/browser/parts/editor/breadcrumbs',
-                    'filepath.on',
-                    "Show the file path in the breadcrumbs view."
-                )),
-                ( localizeWithPath(
-                    'vs/workbench/browser/parts/editor/breadcrumbs',
-                    'filepath.off',
-                    "Do not show the file path in the breadcrumbs view."
-                )),
-                ( localizeWithPath(
-                    'vs/workbench/browser/parts/editor/breadcrumbs',
-                    'filepath.last',
+                    _moduleId,
+                    5,
                     "Only show the last element of the file path in the breadcrumbs view."
                 )),
             ]
         },
         'breadcrumbs.symbolPath': {
             description: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'symbolpath',
+                _moduleId,
+                6,
                 "Controls whether and how symbols are shown in the breadcrumbs view."
             )),
             type: 'string',
             default: 'on',
             enum: ['on', 'off', 'last'],
             enumDescriptions: [
-                ( localizeWithPath(
-                    'vs/workbench/browser/parts/editor/breadcrumbs',
-                    'symbolpath.on',
-                    "Show all symbols in the breadcrumbs view."
-                )),
-                ( localizeWithPath(
-                    'vs/workbench/browser/parts/editor/breadcrumbs',
-                    'symbolpath.off',
-                    "Do not show symbols in the breadcrumbs view."
-                )),
-                ( localizeWithPath(
-                    'vs/workbench/browser/parts/editor/breadcrumbs',
-                    'symbolpath.last',
-                    "Only show the current symbol in the breadcrumbs view."
-                )),
+                ( localizeWithPath(_moduleId, 7, "Show all symbols in the breadcrumbs view.")),
+                ( localizeWithPath(_moduleId, 8, "Do not show symbols in the breadcrumbs view.")),
+                ( localizeWithPath(_moduleId, 9, "Only show the current symbol in the breadcrumbs view.")),
             ]
         },
         'breadcrumbs.symbolSortOrder': {
             description: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'symbolSortOrder',
+                _moduleId,
+                10,
                 "Controls how symbols are sorted in the breadcrumbs outline view."
             )),
             type: 'string',
@@ -154,29 +127,13 @@ class BreadcrumbsConfig {
             scope: 5 ,
             enum: ['position', 'name', 'type'],
             enumDescriptions: [
-                ( localizeWithPath(
-                    'vs/workbench/browser/parts/editor/breadcrumbs',
-                    'symbolSortOrder.position',
-                    "Show symbol outline in file position order."
-                )),
-                ( localizeWithPath(
-                    'vs/workbench/browser/parts/editor/breadcrumbs',
-                    'symbolSortOrder.name',
-                    "Show symbol outline in alphabetical order."
-                )),
-                ( localizeWithPath(
-                    'vs/workbench/browser/parts/editor/breadcrumbs',
-                    'symbolSortOrder.type',
-                    "Show symbol outline in symbol type order."
-                )),
+                ( localizeWithPath(_moduleId, 11, "Show symbol outline in file position order.")),
+                ( localizeWithPath(_moduleId, 12, "Show symbol outline in alphabetical order.")),
+                ( localizeWithPath(_moduleId, 13, "Show symbol outline in symbol type order.")),
             ]
         },
         'breadcrumbs.icons': {
-            description: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'icons',
-                "Render breadcrumb items with icons."
-            )),
+            description: ( localizeWithPath(_moduleId, 14, "Render breadcrumb items with icons.")),
             type: 'boolean',
             default: true
         },
@@ -184,261 +141,157 @@ class BreadcrumbsConfig {
             type: 'boolean',
             default: true,
             scope: 5 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filteredTypes.file',
-                "When enabled breadcrumbs show `file`-symbols."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 15, "When enabled breadcrumbs show `file`-symbols."))
         },
         'breadcrumbs.showModules': {
             type: 'boolean',
             default: true,
             scope: 5 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filteredTypes.module',
-                "When enabled breadcrumbs show `module`-symbols."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 16, "When enabled breadcrumbs show `module`-symbols."))
         },
         'breadcrumbs.showNamespaces': {
             type: 'boolean',
             default: true,
             scope: 5 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filteredTypes.namespace',
-                "When enabled breadcrumbs show `namespace`-symbols."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 17, "When enabled breadcrumbs show `namespace`-symbols."))
         },
         'breadcrumbs.showPackages': {
             type: 'boolean',
             default: true,
             scope: 5 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filteredTypes.package',
-                "When enabled breadcrumbs show `package`-symbols."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 18, "When enabled breadcrumbs show `package`-symbols."))
         },
         'breadcrumbs.showClasses': {
             type: 'boolean',
             default: true,
             scope: 5 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filteredTypes.class',
-                "When enabled breadcrumbs show `class`-symbols."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 19, "When enabled breadcrumbs show `class`-symbols."))
         },
         'breadcrumbs.showMethods': {
             type: 'boolean',
             default: true,
             scope: 5 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filteredTypes.method',
-                "When enabled breadcrumbs show `method`-symbols."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 20, "When enabled breadcrumbs show `method`-symbols."))
         },
         'breadcrumbs.showProperties': {
             type: 'boolean',
             default: true,
             scope: 5 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filteredTypes.property',
-                "When enabled breadcrumbs show `property`-symbols."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 21, "When enabled breadcrumbs show `property`-symbols."))
         },
         'breadcrumbs.showFields': {
             type: 'boolean',
             default: true,
             scope: 5 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filteredTypes.field',
-                "When enabled breadcrumbs show `field`-symbols."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 22, "When enabled breadcrumbs show `field`-symbols."))
         },
         'breadcrumbs.showConstructors': {
             type: 'boolean',
             default: true,
             scope: 5 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filteredTypes.constructor',
-                "When enabled breadcrumbs show `constructor`-symbols."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 23, "When enabled breadcrumbs show `constructor`-symbols."))
         },
         'breadcrumbs.showEnums': {
             type: 'boolean',
             default: true,
             scope: 5 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filteredTypes.enum',
-                "When enabled breadcrumbs show `enum`-symbols."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 24, "When enabled breadcrumbs show `enum`-symbols."))
         },
         'breadcrumbs.showInterfaces': {
             type: 'boolean',
             default: true,
             scope: 5 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filteredTypes.interface',
-                "When enabled breadcrumbs show `interface`-symbols."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 25, "When enabled breadcrumbs show `interface`-symbols."))
         },
         'breadcrumbs.showFunctions': {
             type: 'boolean',
             default: true,
             scope: 5 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filteredTypes.function',
-                "When enabled breadcrumbs show `function`-symbols."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 26, "When enabled breadcrumbs show `function`-symbols."))
         },
         'breadcrumbs.showVariables': {
             type: 'boolean',
             default: true,
             scope: 5 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filteredTypes.variable',
-                "When enabled breadcrumbs show `variable`-symbols."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 27, "When enabled breadcrumbs show `variable`-symbols."))
         },
         'breadcrumbs.showConstants': {
             type: 'boolean',
             default: true,
             scope: 5 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filteredTypes.constant',
-                "When enabled breadcrumbs show `constant`-symbols."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 28, "When enabled breadcrumbs show `constant`-symbols."))
         },
         'breadcrumbs.showStrings': {
             type: 'boolean',
             default: true,
             scope: 5 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filteredTypes.string',
-                "When enabled breadcrumbs show `string`-symbols."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 29, "When enabled breadcrumbs show `string`-symbols."))
         },
         'breadcrumbs.showNumbers': {
             type: 'boolean',
             default: true,
             scope: 5 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filteredTypes.number',
-                "When enabled breadcrumbs show `number`-symbols."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 30, "When enabled breadcrumbs show `number`-symbols."))
         },
         'breadcrumbs.showBooleans': {
             type: 'boolean',
             default: true,
             scope: 5 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filteredTypes.boolean',
-                "When enabled breadcrumbs show `boolean`-symbols."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 31, "When enabled breadcrumbs show `boolean`-symbols."))
         },
         'breadcrumbs.showArrays': {
             type: 'boolean',
             default: true,
             scope: 5 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filteredTypes.array',
-                "When enabled breadcrumbs show `array`-symbols."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 32, "When enabled breadcrumbs show `array`-symbols."))
         },
         'breadcrumbs.showObjects': {
             type: 'boolean',
             default: true,
             scope: 5 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filteredTypes.object',
-                "When enabled breadcrumbs show `object`-symbols."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 33, "When enabled breadcrumbs show `object`-symbols."))
         },
         'breadcrumbs.showKeys': {
             type: 'boolean',
             default: true,
             scope: 5 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filteredTypes.key',
-                "When enabled breadcrumbs show `key`-symbols."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 34, "When enabled breadcrumbs show `key`-symbols."))
         },
         'breadcrumbs.showNull': {
             type: 'boolean',
             default: true,
             scope: 5 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filteredTypes.null',
-                "When enabled breadcrumbs show `null`-symbols."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 35, "When enabled breadcrumbs show `null`-symbols."))
         },
         'breadcrumbs.showEnumMembers': {
             type: 'boolean',
             default: true,
             scope: 5 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filteredTypes.enumMember',
-                "When enabled breadcrumbs show `enumMember`-symbols."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 36, "When enabled breadcrumbs show `enumMember`-symbols."))
         },
         'breadcrumbs.showStructs': {
             type: 'boolean',
             default: true,
             scope: 5 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filteredTypes.struct',
-                "When enabled breadcrumbs show `struct`-symbols."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 37, "When enabled breadcrumbs show `struct`-symbols."))
         },
         'breadcrumbs.showEvents': {
             type: 'boolean',
             default: true,
             scope: 5 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filteredTypes.event',
-                "When enabled breadcrumbs show `event`-symbols."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 38, "When enabled breadcrumbs show `event`-symbols."))
         },
         'breadcrumbs.showOperators': {
             type: 'boolean',
             default: true,
             scope: 5 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filteredTypes.operator',
-                "When enabled breadcrumbs show `operator`-symbols."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 39, "When enabled breadcrumbs show `operator`-symbols."))
         },
         'breadcrumbs.showTypeParameters': {
             type: 'boolean',
             default: true,
             scope: 5 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/breadcrumbs',
-                'filteredTypes.typeParameter',
-                "When enabled breadcrumbs show `typeParameter`-symbols."
-            ))
+            markdownDescription: ( localizeWithPath(_moduleId, 40, "When enabled breadcrumbs show `typeParameter`-symbols."))
         }
     }
 });