@codingame/monaco-vscode-api 4.5.1 → 4.5.2

package/vscode/src/vs/editor/contrib/codeAction/browser/codeActionCommands.js

@@ -8,8 +8,14 @@ import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextke
 import { CodeActionCommandArgs, CodeActionTriggerSource, CodeActionKind } from '../common/types.js';
 import { CodeActionController } from './codeActionController.js';
 import { SUPPORTED_CODE_ACTIONS } from './codeActionModel.js';
+const _moduleId = "vs/editor/contrib/codeAction/browser/codeActionCommands";
 function contextKeyForSupportedActions(kind) {
-    return ( ContextKeyExpr.regex(( SUPPORTED_CODE_ACTIONS.keys())[0], ( new RegExp('(\\s|^)' + escapeRegExpCharacters(kind.value) + '\\b'))));
+    return (
+         (ContextKeyExpr.regex(
+            ( (SUPPORTED_CODE_ACTIONS.keys()))[0],
+             (new RegExp('(\\s|^)' + escapeRegExpCharacters(kind.value) + '\\b'))
+        ))
+    );
 }
 const argsSchema = {
     type: 'object',
@@ -17,45 +23,29 @@ const argsSchema = {
     properties: {
         'kind': {
             type: 'string',
-            description: ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/codeActionCommands',
-                'args.schema.kind',
-                "Kind of the code action to run."
-            )),
+            description: ( localizeWithPath(_moduleId, 0, "Kind of the code action to run.")),
         },
         'apply': {
             type: 'string',
-            description: ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/codeActionCommands',
-                'args.schema.apply',
-                "Controls when the returned actions are applied."
-            )),
+            description: ( localizeWithPath(_moduleId, 1, "Controls when the returned actions are applied.")),
             default: "ifSingle" ,
             enum: ["first" , "ifSingle" , "never" ],
             enumDescriptions: [
+                ( localizeWithPath(_moduleId, 2, "Always apply the first returned code action.")),
                 ( localizeWithPath(
-                    'vs/editor/contrib/codeAction/browser/codeActionCommands',
-                    'args.schema.apply.first',
-                    "Always apply the first returned code action."
-                )),
-                ( localizeWithPath(
-                    'vs/editor/contrib/codeAction/browser/codeActionCommands',
-                    'args.schema.apply.ifSingle',
+                    _moduleId,
+                    3,
                     "Apply the first returned code action if it is the only one."
                 )),
-                ( localizeWithPath(
-                    'vs/editor/contrib/codeAction/browser/codeActionCommands',
-                    'args.schema.apply.never',
-                    "Do not apply the returned code actions."
-                )),
+                ( localizeWithPath(_moduleId, 4, "Do not apply the returned code actions.")),
             ]
         },
         'preferred': {
             type: 'boolean',
             default: false,
             description: ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/codeActionCommands',
-                'args.schema.preferred',
+                _moduleId,
+                5,
                 "Controls if only preferred code actions should be returned."
             )),
         }
@@ -71,13 +61,9 @@ class QuickFixAction extends EditorAction {
     constructor() {
         super({
             id: quickFixCommandId,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/codeActionCommands',
-                'quickfix.trigger.label',
-                "Quick Fix..."
-            )),
+            label: ( localizeWithPath(_moduleId, 6, "Quick Fix...")),
             alias: 'Quick Fix...',
-            precondition: ( ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider)),
+            precondition: ( (ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider))),
             kbOpts: {
                 kbExpr: EditorContextKeys.textInputFocus,
                 primary: 2048  | 89 ,
@@ -86,18 +72,14 @@ class QuickFixAction extends EditorAction {
         });
     }
     run(_accessor, editor) {
-        return triggerCodeActionsForEditorSelection(editor, ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.quickFix.noneMessage',
-            "No code actions available"
-        )), undefined, undefined, CodeActionTriggerSource.QuickFix);
+        return triggerCodeActionsForEditorSelection(editor, ( localizeWithPath(_moduleId, 7, "No code actions available")), undefined, undefined, CodeActionTriggerSource.QuickFix);
     }
 }
 class CodeActionCommand extends EditorCommand {
     constructor() {
         super({
             id: codeActionCommandId,
-            precondition: ( ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider)),
+            precondition: ( (ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider))),
             metadata: {
                 description: 'Trigger a code action',
                 args: [{ name: 'args', schema: argsSchema, }]
@@ -112,28 +94,15 @@ class CodeActionCommand extends EditorCommand {
         return triggerCodeActionsForEditorSelection(editor, typeof userArgs?.kind === 'string'
             ? args.preferred
                 ? ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.codeAction.noneMessage.preferred.kind',
+            _moduleId,
+            8,
             "No preferred code actions for '{0}' available",
             userArgs.kind
         ))
-                : ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.codeAction.noneMessage.kind',
-            "No code actions for '{0}' available",
-            userArgs.kind
-        ))
+                : ( localizeWithPath(_moduleId, 9, "No code actions for '{0}' available", userArgs.kind))
             : args.preferred
-                ? ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.codeAction.noneMessage.preferred',
-            "No preferred code actions available"
-        ))
-                : ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.codeAction.noneMessage',
-            "No code actions available"
-        )), {
+                ? ( localizeWithPath(_moduleId, 10, "No preferred code actions available"))
+                : ( localizeWithPath(_moduleId, 11, "No code actions available")), {
             include: args.kind,
             includeSourceActions: true,
             onlyIncludePreferredActions: args.preferred,
@@ -144,13 +113,9 @@ class RefactorAction extends EditorAction {
     constructor() {
         super({
             id: refactorCommandId,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/codeActionCommands',
-                'refactor.label',
-                "Refactor..."
-            )),
+            label: ( localizeWithPath(_moduleId, 12, "Refactor...")),
             alias: 'Refactor...',
-            precondition: ( ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider)),
+            precondition: ( (ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider))),
             kbOpts: {
                 kbExpr: EditorContextKeys.textInputFocus,
                 primary: 2048  | 1024  | 48 ,
@@ -162,10 +127,10 @@ class RefactorAction extends EditorAction {
             contextMenuOpts: {
                 group: '1_modification',
                 order: 2,
-                when: ( ContextKeyExpr.and(
+                when: ( (ContextKeyExpr.and(
                     EditorContextKeys.writable,
                     contextKeyForSupportedActions(CodeActionKind.Refactor)
-                )),
+                ))),
             },
             metadata: {
                 description: 'Refactor...',
@@ -181,28 +146,15 @@ class RefactorAction extends EditorAction {
         return triggerCodeActionsForEditorSelection(editor, typeof userArgs?.kind === 'string'
             ? args.preferred
                 ? ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.refactor.noneMessage.preferred.kind',
+            _moduleId,
+            13,
             "No preferred refactorings for '{0}' available",
             userArgs.kind
         ))
-                : ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.refactor.noneMessage.kind',
-            "No refactorings for '{0}' available",
-            userArgs.kind
-        ))
+                : ( localizeWithPath(_moduleId, 14, "No refactorings for '{0}' available", userArgs.kind))
             : args.preferred
-                ? ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.refactor.noneMessage.preferred',
-            "No preferred refactorings available"
-        ))
-                : ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.refactor.noneMessage',
-            "No refactorings available"
-        )), {
+                ? ( localizeWithPath(_moduleId, 15, "No preferred refactorings available"))
+                : ( localizeWithPath(_moduleId, 16, "No refactorings available")), {
             include: CodeActionKind.Refactor.contains(args.kind) ? args.kind : HierarchicalKind.None,
             onlyIncludePreferredActions: args.preferred
         }, args.apply, CodeActionTriggerSource.Refactor);
@@ -212,20 +164,16 @@ class SourceAction extends EditorAction {
     constructor() {
         super({
             id: sourceActionCommandId,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/codeActionCommands',
-                'source.label',
-                "Source Action..."
-            )),
+            label: ( localizeWithPath(_moduleId, 17, "Source Action...")),
             alias: 'Source Action...',
-            precondition: ( ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider)),
+            precondition: ( (ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider))),
             contextMenuOpts: {
                 group: '1_modification',
                 order: 2.1,
-                when: ( ContextKeyExpr.and(
+                when: ( (ContextKeyExpr.and(
                     EditorContextKeys.writable,
                     contextKeyForSupportedActions(CodeActionKind.Source)
-                )),
+                ))),
             },
             metadata: {
                 description: 'Source Action...',
@@ -241,28 +189,15 @@ class SourceAction extends EditorAction {
         return triggerCodeActionsForEditorSelection(editor, typeof userArgs?.kind === 'string'
             ? args.preferred
                 ? ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.source.noneMessage.preferred.kind',
+            _moduleId,
+            18,
             "No preferred source actions for '{0}' available",
             userArgs.kind
         ))
-                : ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.source.noneMessage.kind',
-            "No source actions for '{0}' available",
-            userArgs.kind
-        ))
+                : ( localizeWithPath(_moduleId, 19, "No source actions for '{0}' available", userArgs.kind))
             : args.preferred
-                ? ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.source.noneMessage.preferred',
-            "No preferred source actions available"
-        ))
-                : ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.source.noneMessage',
-            "No source actions available"
-        )), {
+                ? ( localizeWithPath(_moduleId, 20, "No preferred source actions available"))
+                : ( localizeWithPath(_moduleId, 21, "No source actions available")), {
             include: CodeActionKind.Source.contains(args.kind) ? args.kind : HierarchicalKind.None,
             includeSourceActions: true,
             onlyIncludePreferredActions: args.preferred,
@@ -273,16 +208,12 @@ class OrganizeImportsAction extends EditorAction {
     constructor() {
         super({
             id: organizeImportsCommandId,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/codeActionCommands',
-                'organizeImports.label',
-                "Organize Imports"
-            )),
+            label: ( localizeWithPath(_moduleId, 22, "Organize Imports")),
             alias: 'Organize Imports',
-            precondition: ( ContextKeyExpr.and(
+            precondition: ( (ContextKeyExpr.and(
                 EditorContextKeys.writable,
                 contextKeyForSupportedActions(CodeActionKind.SourceOrganizeImports)
-            )),
+            ))),
             kbOpts: {
                 kbExpr: EditorContextKeys.textInputFocus,
                 primary: 1024  | 512  | 45 ,
@@ -291,51 +222,35 @@ class OrganizeImportsAction extends EditorAction {
         });
     }
     run(_accessor, editor) {
-        return triggerCodeActionsForEditorSelection(editor, ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.organize.noneMessage',
-            "No organize imports action available"
-        )), { include: CodeActionKind.SourceOrganizeImports, includeSourceActions: true }, "ifSingle" , CodeActionTriggerSource.OrganizeImports);
+        return triggerCodeActionsForEditorSelection(editor, ( localizeWithPath(_moduleId, 23, "No organize imports action available")), { include: CodeActionKind.SourceOrganizeImports, includeSourceActions: true }, "ifSingle" , CodeActionTriggerSource.OrganizeImports);
     }
 }
 class FixAllAction extends EditorAction {
     constructor() {
         super({
             id: fixAllCommandId,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/codeActionCommands',
-                'fixAll.label',
-                "Fix All"
-            )),
+            label: ( localizeWithPath(_moduleId, 24, "Fix All")),
             alias: 'Fix All',
-            precondition: ( ContextKeyExpr.and(
+            precondition: ( (ContextKeyExpr.and(
                 EditorContextKeys.writable,
                 contextKeyForSupportedActions(CodeActionKind.SourceFixAll)
-            ))
+            )))
         });
     }
     run(_accessor, editor) {
-        return triggerCodeActionsForEditorSelection(editor, ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'fixAll.noneMessage',
-            "No fix all action available"
-        )), { include: CodeActionKind.SourceFixAll, includeSourceActions: true }, "ifSingle" , CodeActionTriggerSource.FixAll);
+        return triggerCodeActionsForEditorSelection(editor, ( localizeWithPath(_moduleId, 25, "No fix all action available")), { include: CodeActionKind.SourceFixAll, includeSourceActions: true }, "ifSingle" , CodeActionTriggerSource.FixAll);
     }
 }
 class AutoFixAction extends EditorAction {
     constructor() {
         super({
             id: autoFixCommandId,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/codeActionCommands',
-                'autoFix.label',
-                "Auto Fix..."
-            )),
+            label: ( localizeWithPath(_moduleId, 26, "Auto Fix...")),
             alias: 'Auto Fix...',
-            precondition: ( ContextKeyExpr.and(
+            precondition: ( (ContextKeyExpr.and(
                 EditorContextKeys.writable,
                 contextKeyForSupportedActions(CodeActionKind.QuickFix)
-            )),
+            ))),
             kbOpts: {
                 kbExpr: EditorContextKeys.textInputFocus,
                 primary: 512  | 1024  | 89 ,
@@ -347,11 +262,7 @@ class AutoFixAction extends EditorAction {
         });
     }
     run(_accessor, editor) {
-        return triggerCodeActionsForEditorSelection(editor, ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.autoFix.noneMessage',
-            "No auto fixes available"
-        )), {
+        return triggerCodeActionsForEditorSelection(editor, ( localizeWithPath(_moduleId, 27, "No auto fixes available")), {
             include: CodeActionKind.QuickFix,
             onlyIncludePreferredActions: true
         }, "ifSingle" , CodeActionTriggerSource.AutoFix);

package/vscode/src/vs/editor/contrib/codeAction/browser/codeActionContributions.js

@@ -6,6 +6,7 @@ import { LightBulbWidget } from './lightBulbWidget.js';
 import { localizeWithPath } from '../../../../nls.js';
 import { Extensions } from '../../../../platform/configuration/common/configurationRegistry.js';
 import { Registry } from '../../../../platform/registry/common/platform.js';
+const _moduleId = "vs/editor/contrib/codeAction/browser/codeActionContributions";
 registerEditorContribution(CodeActionController.ID, CodeActionController, 3 );
 registerEditorContribution(LightBulbWidget.ID, LightBulbWidget, 4 );
 registerEditorAction(QuickFixAction);
@@ -14,31 +15,31 @@ registerEditorAction(SourceAction);
 registerEditorAction(OrganizeImportsAction);
 registerEditorAction(AutoFixAction);
 registerEditorAction(FixAllAction);
-registerEditorCommand(( new CodeActionCommand()));
-( Registry.as(Extensions.Configuration)).registerConfiguration({
+registerEditorCommand(( (new CodeActionCommand())));
+( (Registry.as(Extensions.Configuration))).registerConfiguration({
     ...editorConfigurationBaseNode,
     properties: {
         'editor.codeActionWidget.showHeaders': {
             type: 'boolean',
             scope: 5 ,
             description: ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/codeActionContributions',
-                'showCodeActionHeaders',
+                _moduleId,
+                0,
                 "Enable/disable showing group headers in the Code Action menu."
             )),
             default: true,
         },
     }
 });
-( Registry.as(Extensions.Configuration)).registerConfiguration({
+( (Registry.as(Extensions.Configuration))).registerConfiguration({
     ...editorConfigurationBaseNode,
     properties: {
         'editor.codeActionWidget.includeNearbyQuickFixes': {
             type: 'boolean',
             scope: 5 ,
             description: ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/codeActionContributions',
-                'includeNearbyQuickFixes',
+                _moduleId,
+                1,
                 "Enable/disable showing nearest Quick Fix within a line when not currently on a diagnostic."
             )),
             default: true,

package/vscode/src/vs/editor/contrib/codeAction/browser/codeActionController.js

@@ -37,6 +37,7 @@ import { CodeActionTriggerSource, CodeActionKind } from '../common/types.js';
 import { CodeActionModel } from './codeActionModel.js';
 import { HierarchicalKind } from '../../../../base/common/hierarchicalKind.js';
 var CodeActionController_1;
+const _moduleId = "vs/editor/contrib/codeAction/browser/codeActionController";
 const DECORATION_CLASS_NAME = 'quickfix-edit-highlight';
 let CodeActionController = class CodeActionController extends Disposable {
     static { CodeActionController_1 = this; }
@@ -50,26 +51,26 @@ let CodeActionController = class CodeActionController extends Disposable {
         this._configurationService = _configurationService;
         this._actionWidgetService = _actionWidgetService;
         this._instantiationService = _instantiationService;
-        this._activeCodeActions = this._register(( new MutableDisposable()));
+        this._activeCodeActions = this._register(( (new MutableDisposable())));
         this._showDisabled = false;
         this._disposed = false;
         this._editor = editor;
-        this._model = this._register(( new CodeActionModel(
+        this._model = this._register(( (new CodeActionModel(
             this._editor,
             languageFeaturesService.codeActionProvider,
             markerService,
             contextKeyService,
             progressService,
             _configurationService
-        )));
+        ))));
         this._register(this._model.onDidChangeState(newState => this.update(newState)));
-        this._lightBulbWidget = ( new Lazy(() => {
+        this._lightBulbWidget = ( (new Lazy(() => {
             const widget = this._editor.getContribution(LightBulbWidget.ID);
             if (widget) {
                 this._register(widget.onClick(e => this.showCodeActionsFromLightbulb(e.actions, e)));
             }
             return widget;
-        }));
+        })));
         this._resolver = instantiationService.createInstance(CodeActionKeybindingResolver);
         this._register(this._editor.onDidLayoutChange(() => this._actionWidgetService.hide()));
     }
@@ -233,13 +234,13 @@ let CodeActionController = class CodeActionController extends Disposable {
                 let canPreview = false;
                 const actionKind = action.action.kind;
                 if (actionKind) {
-                    const hierarchicalKind = ( new HierarchicalKind(actionKind));
+                    const hierarchicalKind = ( (new HierarchicalKind(actionKind)));
                     const refactorKinds = [
                         CodeActionKind.RefactorExtract,
                         CodeActionKind.RefactorInline,
                         CodeActionKind.RefactorRewrite
                     ];
-                    canPreview = ( refactorKinds.some(refactorKind => refactorKind.contains(hierarchicalKind)));
+                    canPreview = ( (refactorKinds.some(refactorKind => refactorKind.contains(hierarchicalKind))));
                 }
                 return { canPreview: canPreview || !!action.action.edit?.edits.length };
             },
@@ -250,23 +251,23 @@ let CodeActionController = class CodeActionController extends Disposable {
                     currentDecorations.clear();
                     if (ranges && ranges.length > 0) {
                         const decorations = (diagnostics && diagnostics?.length > 1)
-                            ? ( diagnostics.map(
+                            ? ( (diagnostics.map(
                             diagnostic => ({ range: diagnostic, options: CodeActionController_1.DECORATION })
-                        ))
-                            : ( ranges.map(range => ({ range, options: CodeActionController_1.DECORATION })));
+                        )))
+                            : ( (ranges.map(range => ({ range, options: CodeActionController_1.DECORATION }))));
                         currentDecorations.set(decorations);
                     }
                     else if (diagnostics && diagnostics.length > 0) {
-                        const decorations = ( diagnostics.map(
+                        const decorations = ( (diagnostics.map(
                             diagnostic => ({ range: diagnostic, options: CodeActionController_1.DECORATION })
-                        ));
+                        )));
                         currentDecorations.set(decorations);
                         const diagnostic = diagnostics[0];
                         if (diagnostic.startLineNumber && diagnostic.startColumn) {
                             const selectionText = this._editor.getModel()?.getWordAtPosition({ lineNumber: diagnostic.startLineNumber, column: diagnostic.startColumn })?.word;
                             status(( localizeWithPath(
-                                'vs/editor/contrib/codeAction/browser/codeActionController',
-                                'editingNewSelection',
+                                _moduleId,
+                                0,
                                 "Context: {0} at line {1} and column {2}.",
                                 selectionText,
                                 diagnostic.startLineNumber,
@@ -302,22 +303,18 @@ let CodeActionController = class CodeActionController extends Disposable {
         if (options.fromLightbulb) {
             return [];
         }
-        const resultActions = ( actions.documentation.map((command) => ({
+        const resultActions = ( (actions.documentation.map((command) => ({
             id: command.id,
             label: command.title,
             tooltip: command.tooltip ?? '',
             class: undefined,
             enabled: true,
             run: () => this._commandService.executeCommand(command.id, ...(command.arguments ?? [])),
-        })));
+        }))));
         if (options.includeDisabledActions && actions.validActions.length > 0 && actions.allActions.length !== actions.validActions.length) {
             resultActions.push(this._showDisabled ? {
                 id: 'hideMoreActions',
-                label: ( localizeWithPath(
-                    'vs/editor/contrib/codeAction/browser/codeActionController',
-                    'hideMoreActions',
-                    'Hide Disabled'
-                )),
+                label: ( localizeWithPath(_moduleId, 1, 'Hide Disabled')),
                 enabled: true,
                 tooltip: '',
                 class: undefined,
@@ -327,11 +324,7 @@ let CodeActionController = class CodeActionController extends Disposable {
                 }
             } : {
                 id: 'showMoreActions',
-                label: ( localizeWithPath(
-                    'vs/editor/contrib/codeAction/browser/codeActionController',
-                    'showMoreActions',
-                    'Show Disabled'
-                )),
+                label: ( localizeWithPath(_moduleId, 2, 'Show Disabled')),
                 enabled: true,
                 tooltip: '',
                 class: undefined,
@@ -344,17 +337,17 @@ let CodeActionController = class CodeActionController extends Disposable {
         return resultActions;
     }
 };
-CodeActionController = CodeActionController_1 = ( __decorate([
-    ( __param(1, IMarkerService)),
-    ( __param(2, IContextKeyService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, ILanguageFeaturesService)),
-    ( __param(5, IEditorProgressService)),
-    ( __param(6, ICommandService)),
-    ( __param(7, IConfigurationService)),
-    ( __param(8, IActionWidgetService)),
-    ( __param(9, IInstantiationService))
-], CodeActionController));
+CodeActionController = CodeActionController_1 = ( (__decorate([
+    ( (__param(1, IMarkerService))),
+    ( (__param(2, IContextKeyService))),
+    ( (__param(3, IInstantiationService))),
+    ( (__param(4, ILanguageFeaturesService))),
+    ( (__param(5, IEditorProgressService))),
+    ( (__param(6, ICommandService))),
+    ( (__param(7, IConfigurationService))),
+    ( (__param(8, IActionWidgetService))),
+    ( (__param(9, IInstantiationService)))
+], CodeActionController)));
 registerThemingParticipant((theme, collector) => {
     const addBackgroundColorRule = (selector, color) => {
         if (color) {

package/vscode/src/vs/editor/contrib/codeAction/browser/codeActionMenu.js

@@ -5,65 +5,36 @@ import { CodeActionKind } from '../common/types.js';
 import '../../symbolIcons/browser/symbolIcons.js';
 import { localizeWithPath } from '../../../../nls.js';
 import { HierarchicalKind } from '../../../../base/common/hierarchicalKind.js';
-const uncategorizedCodeActionGroup = ( Object.freeze({ kind: HierarchicalKind.Empty, title: ( localizeWithPath(
-    'vs/editor/contrib/codeAction/browser/codeActionMenu',
-    'codeAction.widget.id.more',
-    'More Actions...'
-)) }));
-const codeActionGroups = ( Object.freeze([
-    { kind: CodeActionKind.QuickFix, title: ( localizeWithPath(
-        'vs/editor/contrib/codeAction/browser/codeActionMenu',
-        'codeAction.widget.id.quickfix',
-        'Quick Fix'
-    )) },
-    { kind: CodeActionKind.RefactorExtract, title: ( localizeWithPath(
-        'vs/editor/contrib/codeAction/browser/codeActionMenu',
-        'codeAction.widget.id.extract',
-        'Extract'
-    )), icon: Codicon.wrench },
-    { kind: CodeActionKind.RefactorInline, title: ( localizeWithPath(
-        'vs/editor/contrib/codeAction/browser/codeActionMenu',
-        'codeAction.widget.id.inline',
-        'Inline'
-    )), icon: Codicon.wrench },
-    { kind: CodeActionKind.RefactorRewrite, title: ( localizeWithPath(
-        'vs/editor/contrib/codeAction/browser/codeActionMenu',
-        'codeAction.widget.id.convert',
-        'Rewrite'
-    )), icon: Codicon.wrench },
-    { kind: CodeActionKind.RefactorMove, title: ( localizeWithPath(
-        'vs/editor/contrib/codeAction/browser/codeActionMenu',
-        'codeAction.widget.id.move',
-        'Move'
-    )), icon: Codicon.wrench },
-    { kind: CodeActionKind.SurroundWith, title: ( localizeWithPath(
-        'vs/editor/contrib/codeAction/browser/codeActionMenu',
-        'codeAction.widget.id.surround',
-        'Surround With'
-    )), icon: Codicon.surroundWith },
-    { kind: CodeActionKind.Source, title: ( localizeWithPath(
-        'vs/editor/contrib/codeAction/browser/codeActionMenu',
-        'codeAction.widget.id.source',
-        'Source Action'
-    )), icon: Codicon.symbolFile },
+const _moduleId = "vs/editor/contrib/codeAction/browser/codeActionMenu";
+const uncategorizedCodeActionGroup = ( (Object.freeze({ kind: HierarchicalKind.Empty, title: ( localizeWithPath(_moduleId, 0, 'More Actions...')) })));
+const codeActionGroups = ( (Object.freeze([
+    { kind: CodeActionKind.QuickFix, title: ( localizeWithPath(_moduleId, 1, 'Quick Fix')) },
+    { kind: CodeActionKind.RefactorExtract, title: ( localizeWithPath(_moduleId, 2, 'Extract')), icon: Codicon.wrench },
+    { kind: CodeActionKind.RefactorInline, title: ( localizeWithPath(_moduleId, 3, 'Inline')), icon: Codicon.wrench },
+    { kind: CodeActionKind.RefactorRewrite, title: ( localizeWithPath(_moduleId, 4, 'Rewrite')), icon: Codicon.wrench },
+    { kind: CodeActionKind.RefactorMove, title: ( localizeWithPath(_moduleId, 5, 'Move')), icon: Codicon.wrench },
+    { kind: CodeActionKind.SurroundWith, title: ( localizeWithPath(_moduleId, 6, 'Surround With')), icon: Codicon.surroundWith },
+    { kind: CodeActionKind.Source, title: ( localizeWithPath(_moduleId, 7, 'Source Action')), icon: Codicon.symbolFile },
     uncategorizedCodeActionGroup,
-]));
+])));
 function toMenuItems(inputCodeActions, showHeaders, keybindingResolver) {
     if (!showHeaders) {
-        return ( inputCodeActions.map((action) => {
-            return {
-                kind: "action" ,
-                item: action,
-                group: uncategorizedCodeActionGroup,
-                disabled: !!action.action.disabled,
-                label: action.action.disabled || action.action.title,
-                canPreview: !!action.action.edit?.edits.length,
-            };
-        }));
+        return (
+             (inputCodeActions.map((action) => {
+                return {
+                    kind: "action" ,
+                    item: action,
+                    group: uncategorizedCodeActionGroup,
+                    disabled: !!action.action.disabled,
+                    label: action.action.disabled || action.action.title,
+                    canPreview: !!action.action.edit?.edits.length,
+                };
+            }))
+        );
     }
-    const menuEntries = ( codeActionGroups.map(group => ({ group, actions: [] })));
+    const menuEntries = ( (codeActionGroups.map(group => ({ group, actions: [] }))));
     for (const action of inputCodeActions) {
-        const kind = action.action.kind ? ( new HierarchicalKind(action.action.kind)) : HierarchicalKind.None;
+        const kind = action.action.kind ? ( (new HierarchicalKind(action.action.kind))) : HierarchicalKind.None;
         for (const menuEntry of menuEntries) {
             if (menuEntry.group.kind.contains(kind)) {
                 menuEntry.actions.push(action);