@codingame/monaco-vscode-api 4.5.1 → 5.0.0

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

@@ -36,7 +36,9 @@ import { registerThemingParticipant } from '../../../../platform/theme/common/th
 import { CodeActionTriggerSource, CodeActionKind } from '../common/types.js';
 import { CodeActionModel } from './codeActionModel.js';
 import { HierarchicalKind } from '../../../../base/common/hierarchicalKind.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.service.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; }
@@ -44,32 +46,33 @@ let CodeActionController = class CodeActionController extends Disposable {
     static get(editor) {
         return editor.getContribution(CodeActionController_1.ID);
     }
-    constructor(editor, markerService, contextKeyService, instantiationService, languageFeaturesService, progressService, _commandService, _configurationService, _actionWidgetService, _instantiationService) {
+    constructor(editor, markerService, contextKeyService, instantiationService, languageFeaturesService, progressService, _commandService, _configurationService, _actionWidgetService, _instantiationService, _telemetryService) {
         super();
         this._commandService = _commandService;
         this._configurationService = _configurationService;
         this._actionWidgetService = _actionWidgetService;
         this._instantiationService = _instantiationService;
-        this._activeCodeActions = this._register(( new MutableDisposable()));
+        this._telemetryService = _telemetryService;
+        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()));
     }
@@ -78,6 +81,11 @@ let CodeActionController = class CodeActionController extends Disposable {
         super.dispose();
     }
     async showCodeActionsFromLightbulb(actions, at) {
+        this._telemetryService.publicLog2('codeAction.showCodeActionsFromLightbulb', {
+            codeActionListLength: actions.validActions.length,
+            codeActions: ( (actions.validActions.map(action => action.action.title))),
+            codeActionProviders: ( (actions.validActions.map(action => action.provider?.displayName ?? ''))),
+        });
         if (actions.allAIFixes && actions.validActions.length === 1) {
             const actionItem = actions.validActions[0];
             const command = actionItem.action.command;
@@ -218,13 +226,19 @@ let CodeActionController = class CodeActionController extends Disposable {
         const anchor = Position.isIPosition(at) ? this.toCoords(at) : at;
         const delegate = {
             onSelect: async (action, preview) => {
-                this._applyCodeAction(action,  true, !!preview, ApplyCodeActionReason.FromCodeActions);
-                this._actionWidgetService.hide();
+                this._applyCodeAction(action,  true, !!preview, options.fromLightbulb ? ApplyCodeActionReason.FromAILightbulb : ApplyCodeActionReason.FromCodeActions);
+                this._actionWidgetService.hide(false);
                 currentDecorations.clear();
             },
-            onHide: () => {
+            onHide: (didCancel) => {
                 this._editor?.focus();
                 currentDecorations.clear();
+                if (options.fromLightbulb && didCancel !== undefined) {
+                    this._telemetryService.publicLog2('codeAction.showCodeActionList.onHide', {
+                        codeActionListLength: actions.validActions.length,
+                        didCancel: didCancel,
+                    });
+                }
             },
             onHover: async (action, token) => {
                 if (token.isCancellationRequested) {
@@ -233,13 +247,15 @@ 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
+                        CodeActionKind.RefactorRewrite,
+                        CodeActionKind.RefactorMove,
+                        CodeActionKind.Source
                     ];
-                    canPreview = ( refactorKinds.some(refactorKind => refactorKind.contains(hierarchicalKind)));
+                    canPreview = ( (refactorKinds.some(refactorKind => refactorKind.contains(hierarchicalKind))));
                 }
                 return { canPreview: canPreview || !!action.action.edit?.edits.length };
             },
@@ -250,23 +266,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 +318,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 +339,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 +352,18 @@ 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))),
+    ( (__param(10, ITelemetryService)))
+], 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);

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

@@ -273,6 +273,11 @@ class CodeActionModel extends Disposable {
                 if (!isManualToAutoTransition) {
                     this.setState(newState);
                 }
+                else {
+                    setTimeout(() => {
+                        this.setState(newState);
+                    }, 500);
+                }
             }, undefined));
             this._codeActionOracle.value.trigger({ type: 2 , triggerAction: CodeActionTriggerSource.Default });
         }

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

@@ -12,12 +12,13 @@ import { localizeWithPath } from '../../../../nls.js';
 import { ICommandService } from '../../../../platform/commands/common/commands.service.js';
 import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
 var LightBulbWidget_1;
+const _moduleId = "vs/editor/contrib/codeAction/browser/lightBulbWidget";
 var LightBulbState;
-( (function(LightBulbState) {
-    ( (function(Type) {
+( ((function(LightBulbState) {
+    ( ((function(Type) {
         Type[Type["Hidden"] = 0] = "Hidden";
         Type[Type["Showing"] = 1] = "Showing";
-    })(LightBulbState.Type || (LightBulbState.Type = {})));
+    })(LightBulbState.Type || (LightBulbState.Type = {}))));
     LightBulbState.Hidden = { type: 0  };
     class Showing {
         constructor(actions, trigger, editorPosition, widgetPosition) {
@@ -29,7 +30,7 @@ var LightBulbState;
         }
     }
     LightBulbState.Showing = Showing;
-})(LightBulbState || (LightBulbState = {})));
+})(LightBulbState || (LightBulbState = {}))));
 let LightBulbWidget = class LightBulbWidget extends Disposable {
     static { LightBulbWidget_1 = this; }
     static { this.ID = 'editor.contrib.lightbulbWidget'; }
@@ -38,11 +39,12 @@ let LightBulbWidget = class LightBulbWidget extends Disposable {
         super();
         this._editor = _editor;
         this._keybindingService = _keybindingService;
-        this._onClick = this._register(( new Emitter()));
+        this._onClick = this._register(( (new Emitter())));
         this.onClick = this._onClick.event;
         this._state = LightBulbState.Hidden;
         this._iconClasses = [];
         this._domNode = $('div.lightBulbWidget');
+        this._domNode.role = 'listbox';
         this._register(Gesture.ignoreTarget(this._domNode));
         this._editor.addContentWidget(this);
         this._register(this._editor.onDidChangeModelContent(_ => {
@@ -185,43 +187,29 @@ let LightBulbWidget = class LightBulbWidget extends Disposable {
             return;
         }
         if (autoRun) {
-            this.title = ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/lightBulbWidget',
-                'codeActionAutoRun',
-                "Run: {0}",
-                this.state.actions.validActions[0].action.title
-            ));
+            this.title = ( localizeWithPath(_moduleId, 0, "Run: {0}", this.state.actions.validActions[0].action.title));
         }
         else if (autoFix && this._preferredKbLabel) {
             this.title = ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/lightBulbWidget',
-                'preferredcodeActionWithKb',
+                _moduleId,
+                1,
                 "Show Code Actions. Preferred Quick Fix Available ({0})",
                 this._preferredKbLabel
             ));
         }
         else if (!autoFix && this._quickFixKbLabel) {
-            this.title = ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/lightBulbWidget',
-                'codeActionWithKb',
-                "Show Code Actions ({0})",
-                this._quickFixKbLabel
-            ));
+            this.title = ( localizeWithPath(_moduleId, 2, "Show Code Actions ({0})", this._quickFixKbLabel));
         }
         else if (!autoFix) {
-            this.title = ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/lightBulbWidget',
-                'codeAction',
-                "Show Code Actions"
-            ));
+            this.title = ( localizeWithPath(_moduleId, 3, "Show Code Actions"));
         }
     }
     set title(value) {
         this._domNode.title = value;
     }
 };
-LightBulbWidget = LightBulbWidget_1 = ( __decorate([
-    ( __param(1, IKeybindingService)),
-    ( __param(2, ICommandService))
-], LightBulbWidget));
+LightBulbWidget = LightBulbWidget_1 = ( (__decorate([
+    ( (__param(1, IKeybindingService))),
+    ( (__param(2, ICommandService)))
+], LightBulbWidget)));
 export { LightBulbWidget };

package/vscode/src/vs/editor/contrib/codelens/browser/codeLensCache.js

@@ -20,7 +20,7 @@ let CodeLensCache = class CodeLensCache {
     constructor(storageService) {
         this._fakeProvider = new class {
             provideCodeLenses() {
-                throw new Error('not supported');
+                throw ( new Error('not supported'));
             }
         };
         this._cache = ( new LRUCache(20, 0.75));

package/vscode/src/vs/editor/contrib/codelens/browser/codelensController.js

@@ -15,6 +15,7 @@ import { INotificationService } from '../../../../platform/notification/common/n
 import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.service.js';
 import { ILanguageFeatureDebounceService } from '../../../common/services/languageFeatureDebounce.js';
 import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
+const _moduleId = "vs/editor/contrib/codelens/browser/codelensController";
 let CodeLensContribution = class CodeLensContribution {
     static { this.ID = 'css.editor.codeLens'; }
     constructor(_editor, _languageFeaturesService, debounceService, _commandService, _notificationService, _codeLensCache) {
@@ -23,16 +24,16 @@ let CodeLensContribution = class CodeLensContribution {
         this._commandService = _commandService;
         this._notificationService = _notificationService;
         this._codeLensCache = _codeLensCache;
-        this._disposables = ( new DisposableStore());
-        this._localToDispose = ( new DisposableStore());
+        this._disposables = ( (new DisposableStore()));
+        this._localToDispose = ( (new DisposableStore()));
         this._lenses = [];
-        this._oldCodeLensModels = ( new DisposableStore());
+        this._oldCodeLensModels = ( (new DisposableStore()));
         this._provideCodeLensDebounce = debounceService.for(_languageFeaturesService.codeLensProvider, 'CodeLensProvide', { min: 250 });
         this._resolveCodeLensesDebounce = debounceService.for(_languageFeaturesService.codeLensProvider, 'CodeLensResolve', { min: 250, salt: 'resolve' });
-        this._resolveCodeLensesScheduler = ( new RunOnceScheduler(
+        this._resolveCodeLensesScheduler = ( (new RunOnceScheduler(
             () => this._resolveCodeLensesInViewport(),
             this._resolveCodeLensesDebounce.default()
-        ));
+        )));
         this._disposables.add(this._editor.onDidChangeModel(() => this._onModelChange()));
         this._disposables.add(this._editor.onDidChangeModelLanguage(() => this._onModelChange()));
         this._disposables.add(this._editor.onDidChangeConfiguration((e) => {
@@ -104,7 +105,7 @@ let CodeLensContribution = class CodeLensContribution {
         if (cachedLenses) {
             this._renderCodeLensSymbols(cachedLenses);
         }
-        if (!( this._languageFeaturesService.codeLensProvider.has(model))) {
+        if (!( (this._languageFeaturesService.codeLensProvider.has(model)))) {
             if (cachedLenses) {
                 disposableTimeout(() => {
                     const cachedLensesNow = this._codeLensCache.get(model);
@@ -122,7 +123,7 @@ let CodeLensContribution = class CodeLensContribution {
                 this._localToDispose.add(registration);
             }
         }
-        const scheduler = ( new RunOnceScheduler(() => {
+        const scheduler = ( (new RunOnceScheduler(() => {
             const t1 = Date.now();
             this._getCodeLensModelPromise?.cancel();
             this._getCodeLensModelPromise = createCancelablePromise(token => getCodeLensModel(this._languageFeaturesService.codeLensProvider, model, token));
@@ -137,7 +138,7 @@ let CodeLensContribution = class CodeLensContribution {
                 this._renderCodeLensSymbols(result);
                 this._resolveCodeLensesInViewportSoon();
             }, onUnexpectedError);
-        }, this._provideCodeLensDebounce.get(model)));
+        }, this._provideCodeLensDebounce.get(model))));
         this._localToDispose.add(scheduler);
         this._localToDispose.add(toDisposable(() => this._resolveCodeLensesScheduler.cancel()));
         this._localToDispose.add(this._editor.onDidChangeModelContent(() => {
@@ -154,7 +155,7 @@ let CodeLensContribution = class CodeLensContribution {
                             lastLensLineNumber = lens.getLineNumber();
                         }
                     });
-                    const helper = ( new CodeLensHelper());
+                    const helper = ( (new CodeLensHelper()));
                     toDispose.forEach((l) => {
                         l.dispose(helper, viewZonesAccessor);
                         this._lenses.splice(this._lenses.indexOf(l), 1);
@@ -216,7 +217,7 @@ let CodeLensContribution = class CodeLensContribution {
         scheduler.schedule();
     }
     _disposeAllLenses(decChangeAccessor, viewZoneChangeAccessor) {
-        const helper = ( new CodeLensHelper());
+        const helper = ( (new CodeLensHelper()));
         for (const lens of this._lenses) {
             lens.dispose(helper, viewZoneChangeAccessor);
         }
@@ -252,7 +253,7 @@ let CodeLensContribution = class CodeLensContribution {
         const layoutInfo = this._getLayoutInfo();
         this._editor.changeDecorations(decorationsAccessor => {
             this._editor.changeViewZones(viewZoneAccessor => {
-                const helper = ( new CodeLensHelper());
+                const helper = ( (new CodeLensHelper()));
                 let codeLensIndex = 0;
                 let groupsIndex = 0;
                 while (groupsIndex < groups.length && codeLensIndex < this._lenses.length) {
@@ -268,14 +269,14 @@ let CodeLensContribution = class CodeLensContribution {
                         codeLensIndex++;
                     }
                     else {
-                        this._lenses.splice(codeLensIndex, 0, ( new CodeLensWidget(
+                        this._lenses.splice(codeLensIndex, 0, ( (new CodeLensWidget(
                             groups[groupsIndex],
                             this._editor,
                             helper,
                             viewZoneAccessor,
                             layoutInfo.codeLensHeight,
                             () => this._resolveCodeLensesInViewportSoon()
-                        )));
+                        ))));
                         codeLensIndex++;
                         groupsIndex++;
                     }
@@ -285,14 +286,14 @@ let CodeLensContribution = class CodeLensContribution {
                     this._lenses.splice(codeLensIndex, 1);
                 }
                 while (groupsIndex < groups.length) {
-                    this._lenses.push(( new CodeLensWidget(
+                    this._lenses.push(( (new CodeLensWidget(
                         groups[groupsIndex],
                         this._editor,
                         helper,
                         viewZoneAccessor,
                         layoutInfo.codeLensHeight,
                         () => this._resolveCodeLensesInViewportSoon()
-                    )));
+                    ))));
                     groupsIndex++;
                 }
                 helper.commit(decorationsAccessor);
@@ -327,9 +328,9 @@ let CodeLensContribution = class CodeLensContribution {
         }
         const t1 = Date.now();
         const resolvePromise = createCancelablePromise(token => {
-            const promises = ( toResolve.map((request, i) => {
-                const resolvedSymbols = ( new Array(request.length));
-                const promises = ( request.map((request, i) => {
+            const promises = ( (toResolve.map((request, i) => {
+                const resolvedSymbols = ( (new Array(request.length)));
+                const promises = ( (request.map((request, i) => {
                     if (!request.symbol.command && typeof request.provider.resolveCodeLens === 'function') {
                         return Promise.resolve(request.provider.resolveCodeLens(model, request.symbol, token)).then(symbol => {
                             resolvedSymbols[i] = symbol;
@@ -339,13 +340,13 @@ let CodeLensContribution = class CodeLensContribution {
                         resolvedSymbols[i] = request.symbol;
                         return Promise.resolve(undefined);
                     }
-                }));
+                })));
                 return Promise.all(promises).then(() => {
                     if (!token.isCancellationRequested && !lenses[i].isDisposed()) {
                         lenses[i].updateCommands(resolvedSymbols);
                     }
                 });
-            }));
+            })));
             return Promise.all(promises);
         });
         this._resolveCodeLensesPromise = resolvePromise;
@@ -374,24 +375,20 @@ let CodeLensContribution = class CodeLensContribution {
             : undefined;
     }
 };
-CodeLensContribution = ( __decorate([
-    ( __param(1, ILanguageFeaturesService)),
-    ( __param(2, ILanguageFeatureDebounceService)),
-    ( __param(3, ICommandService)),
-    ( __param(4, INotificationService)),
-    ( __param(5, ICodeLensCache))
-], CodeLensContribution));
+CodeLensContribution = ( (__decorate([
+    ( (__param(1, ILanguageFeaturesService))),
+    ( (__param(2, ILanguageFeatureDebounceService))),
+    ( (__param(3, ICommandService))),
+    ( (__param(4, INotificationService))),
+    ( (__param(5, ICodeLensCache)))
+], CodeLensContribution)));
 registerEditorContribution(CodeLensContribution.ID, CodeLensContribution, 1 );
 registerEditorAction(class ShowLensesInCurrentLine extends EditorAction {
     constructor() {
         super({
             id: 'codelens.showLensesInCurrentLine',
             precondition: EditorContextKeys.hasCodeLensProvider,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/codelens/browser/codelensController',
-                'showLensOnLine',
-                "Show CodeLens Commands For Current Line"
-            )),
+            label: ( localizeWithPath(_moduleId, 0, "Show CodeLens Commands For Current Line")),
             alias: 'Show CodeLens Commands For Current Line',
         });
     }
@@ -425,11 +422,7 @@ registerEditorAction(class ShowLensesInCurrentLine extends EditorAction {
         }
         const item = await quickInputService.pick(items, {
             canPickMany: false,
-            placeHolder: ( localizeWithPath(
-                'vs/editor/contrib/codelens/browser/codelensController',
-                'placeHolder',
-                "Select a command"
-            ))
+            placeHolder: ( localizeWithPath(_moduleId, 1, "Select a command"))
         });
         if (!item) {
             return;

package/vscode/src/vs/editor/contrib/colorPicker/browser/colorContributions.js

@@ -3,7 +3,7 @@ import { registerEditorContribution } from '../../../browser/editorExtensions.js
 import { Range } from '../../../common/core/range.js';
 import { ColorDecorationInjectedTextMarker } from './colorDetector.js';
 import { ColorHoverParticipant } from './colorHoverParticipant.js';
-import { HoverController } from '../../hover/browser/hover.js';
+import { HoverController } from '../../hover/browser/hoverController.js';
 import { HoverParticipantRegistry } from '../../hover/browser/hoverTypes.js';
 class ColorContribution extends Disposable {
     static { this.ID = 'editor.contrib.colorContribution'; }