@codingame/monaco-vscode-api 4.5.1 → 4.5.2

package/vscode/src/vs/editor/contrib/inlayHints/browser/inlayHintsHover.js

@@ -16,6 +16,7 @@ import { localizeWithPath } from '../../../../nls.js';
 import { isMacintosh } from '../../../../base/common/platform.js';
 import { asCommandLink } from './inlayHints.js';
 import { isNonEmptyArray } from '../../../../base/common/arrays.js';
+const _moduleId = "vs/editor/contrib/inlayHints/browser/inlayHintsHover";
 class InlayHintsHoverAnchor extends HoverForeignElementAnchor {
     constructor(part, owner, initialMousePosX, initialMousePosY) {
         super(10, owner, part.item.anchor.range, initialMousePosX, initialMousePosY, true);
@@ -40,7 +41,9 @@ let InlayHintsHover = class InlayHintsHover extends MarkdownHoverParticipant {
         if (!(options instanceof ModelDecorationInjectedTextOptions && options.attachedData instanceof RenderedInlayHintLabelPart)) {
             return null;
         }
-        return ( new InlayHintsHoverAnchor(options.attachedData, this, mouseEvent.event.posx, mouseEvent.event.posy));
+        return (
+             (new InlayHintsHoverAnchor(options.attachedData, this, mouseEvent.event.posx, mouseEvent.event.posy))
+        );
     }
     computeSync() {
         return [];
@@ -49,97 +52,71 @@ let InlayHintsHover = class InlayHintsHover extends MarkdownHoverParticipant {
         if (!(anchor instanceof InlayHintsHoverAnchor)) {
             return AsyncIterableObject.EMPTY;
         }
-        return ( new AsyncIterableObject(async (executor) => {
-            const { part } = anchor;
-            await part.item.resolve(token);
-            if (token.isCancellationRequested) {
-                return;
-            }
-            let itemTooltip;
-            if (typeof part.item.hint.tooltip === 'string') {
-                itemTooltip = ( new MarkdownString()).appendText(part.item.hint.tooltip);
-            }
-            else if (part.item.hint.tooltip) {
-                itemTooltip = part.item.hint.tooltip;
-            }
-            if (itemTooltip) {
-                executor.emitOne(( new MarkdownHover(this, anchor.range, [itemTooltip], false, 0)));
-            }
-            if (isNonEmptyArray(part.item.hint.textEdits)) {
-                executor.emitOne(( new MarkdownHover(this, anchor.range, [( new MarkdownString()).appendText(( localizeWithPath(
-                    'vs/editor/contrib/inlayHints/browser/inlayHintsHover',
-                    'hint.dbl',
-                    "Double-click to insert"
-                )))], false, 10001)));
-            }
-            let partTooltip;
-            if (typeof part.part.tooltip === 'string') {
-                partTooltip = ( new MarkdownString()).appendText(part.part.tooltip);
-            }
-            else if (part.part.tooltip) {
-                partTooltip = part.part.tooltip;
-            }
-            if (partTooltip) {
-                executor.emitOne(( new MarkdownHover(this, anchor.range, [partTooltip], false, 1)));
-            }
-            if (part.part.location || part.part.command) {
-                let linkHint;
-                const useMetaKey = this._editor.getOption(78 ) === 'altKey';
-                const kb = useMetaKey
-                    ? isMacintosh
-                        ? ( localizeWithPath(
-                    'vs/editor/contrib/inlayHints/browser/inlayHintsHover',
-                    'links.navigate.kb.meta.mac',
-                    "cmd + click"
-                ))
-                        : ( localizeWithPath(
-                    'vs/editor/contrib/inlayHints/browser/inlayHintsHover',
-                    'links.navigate.kb.meta',
-                    "ctrl + click"
-                ))
-                    : isMacintosh
-                        ? ( localizeWithPath(
-                    'vs/editor/contrib/inlayHints/browser/inlayHintsHover',
-                    'links.navigate.kb.alt.mac',
-                    "option + click"
-                ))
-                        : ( localizeWithPath(
-                    'vs/editor/contrib/inlayHints/browser/inlayHintsHover',
-                    'links.navigate.kb.alt',
-                    "alt + click"
-                ));
-                if (part.part.location && part.part.command) {
-                    linkHint = ( new MarkdownString()).appendText(( localizeWithPath(
-                        'vs/editor/contrib/inlayHints/browser/inlayHintsHover',
-                        'hint.defAndCommand',
-                        'Go to Definition ({0}), right click for more',
-                        kb
-                    )));
+        return (
+             (new AsyncIterableObject(async (executor) => {
+                const { part } = anchor;
+                await part.item.resolve(token);
+                if (token.isCancellationRequested) {
+                    return;
                 }
-                else if (part.part.location) {
-                    linkHint = ( new MarkdownString()).appendText(( localizeWithPath(
-                        'vs/editor/contrib/inlayHints/browser/inlayHintsHover',
-                        'hint.def',
-                        'Go to Definition ({0})',
-                        kb
-                    )));
+                let itemTooltip;
+                if (typeof part.item.hint.tooltip === 'string') {
+                    itemTooltip = ( (new MarkdownString())).appendText(part.item.hint.tooltip);
                 }
-                else if (part.part.command) {
-                    linkHint = ( new MarkdownString(`[${( localizeWithPath(
-                        'vs/editor/contrib/inlayHints/browser/inlayHintsHover',
-                        'hint.cmd',
-                        "Execute Command"
-                    ))}](${asCommandLink(part.part.command)} "${part.part.command.title}") (${kb})`, { isTrusted: true }));
+                else if (part.item.hint.tooltip) {
+                    itemTooltip = part.item.hint.tooltip;
                 }
-                if (linkHint) {
-                    executor.emitOne(( new MarkdownHover(this, anchor.range, [linkHint], false, 10000)));
+                if (itemTooltip) {
+                    executor.emitOne(( (new MarkdownHover(this, anchor.range, [itemTooltip], false, 0))));
                 }
-            }
-            const iterable = await this._resolveInlayHintLabelPartHover(part, token);
-            for await (const item of iterable) {
-                executor.emitOne(item);
-            }
-        }));
+                if (isNonEmptyArray(part.item.hint.textEdits)) {
+                    executor.emitOne(( (new MarkdownHover(
+                        this,
+                        anchor.range,
+                        [( (new MarkdownString())).appendText(( localizeWithPath(_moduleId, 0, "Double-click to insert")))],
+                        false,
+                        10001
+                    ))));
+                }
+                let partTooltip;
+                if (typeof part.part.tooltip === 'string') {
+                    partTooltip = ( (new MarkdownString())).appendText(part.part.tooltip);
+                }
+                else if (part.part.tooltip) {
+                    partTooltip = part.part.tooltip;
+                }
+                if (partTooltip) {
+                    executor.emitOne(( (new MarkdownHover(this, anchor.range, [partTooltip], false, 1))));
+                }
+                if (part.part.location || part.part.command) {
+                    let linkHint;
+                    const useMetaKey = this._editor.getOption(78 ) === 'altKey';
+                    const kb = useMetaKey
+                        ? isMacintosh
+                            ? ( localizeWithPath(_moduleId, 1, "cmd + click"))
+                            : ( localizeWithPath(_moduleId, 2, "ctrl + click"))
+                        : isMacintosh
+                            ? ( localizeWithPath(_moduleId, 3, "option + click"))
+                            : ( localizeWithPath(_moduleId, 4, "alt + click"));
+                    if (part.part.location && part.part.command) {
+                        linkHint = ( (new MarkdownString())).appendText(( localizeWithPath(_moduleId, 5, 'Go to Definition ({0}), right click for more', kb)));
+                    }
+                    else if (part.part.location) {
+                        linkHint = ( (new MarkdownString())).appendText(( localizeWithPath(_moduleId, 6, 'Go to Definition ({0})', kb)));
+                    }
+                    else if (part.part.command) {
+                        linkHint = ( (new MarkdownString(`[${( localizeWithPath(_moduleId, 7, "Execute Command"))}](${asCommandLink(part.part.command)} "${part.part.command.title}") (${kb})`, { isTrusted: true })));
+                    }
+                    if (linkHint) {
+                        executor.emitOne(( (new MarkdownHover(this, anchor.range, [linkHint], false, 10000))));
+                    }
+                }
+                const iterable = await this._resolveInlayHintLabelPartHover(part, token);
+                for await (const item of iterable) {
+                    executor.emitOne(item);
+                }
+            }))
+        );
     }
     async _resolveInlayHintLabelPartHover(part, token) {
         if (!part.part.location) {
@@ -149,23 +126,27 @@ let InlayHintsHover = class InlayHintsHover extends MarkdownHoverParticipant {
         const ref = await this._resolverService.createModelReference(uri);
         try {
             const model = ref.object.textEditorModel;
-            if (!( this._languageFeaturesService.hoverProvider.has(model))) {
+            if (!( (this._languageFeaturesService.hoverProvider.has(model)))) {
                 return AsyncIterableObject.EMPTY;
             }
-            return ( getHover(this._languageFeaturesService.hoverProvider, model, ( new Position(range.startLineNumber, range.startColumn)), token)
-                .filter(item => !isEmptyMarkdownString(item.hover.contents))
-                .map(item => ( new MarkdownHover(this, part.item.anchor.range, item.hover.contents, false, 2 + item.ordinal))));
+            return (
+                 (getHover(this._languageFeaturesService.hoverProvider, model, ( (new Position(range.startLineNumber, range.startColumn))), token)
+                    .filter(item => !isEmptyMarkdownString(item.hover.contents))
+                    .map(
+                    item => ( (new MarkdownHover(this, part.item.anchor.range, item.hover.contents, false, 2 + item.ordinal)))
+                ))
+            );
         }
         finally {
             ref.dispose();
         }
     }
 };
-InlayHintsHover = ( __decorate([
-    ( __param(1, ILanguageService)),
-    ( __param(2, IOpenerService)),
-    ( __param(3, IConfigurationService)),
-    ( __param(4, ITextModelService)),
-    ( __param(5, ILanguageFeaturesService))
-], InlayHintsHover));
+InlayHintsHover = ( (__decorate([
+    ( (__param(1, ILanguageService))),
+    ( (__param(2, IOpenerService))),
+    ( (__param(3, IConfigurationService))),
+    ( (__param(4, ITextModelService))),
+    ( (__param(5, ILanguageFeaturesService)))
+], InlayHintsHover)));
 export { InlayHintsHover };

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/commands.js

@@ -13,21 +13,18 @@ import { localizeWithPath } from '../../../../nls.js';
 import { Action2, MenuId } from '../../../../platform/actions/common/actions.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
 import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+const _moduleId = "vs/editor/contrib/inlineCompletions/browser/commands";
 class ShowNextInlineSuggestionAction extends EditorAction {
     static { this.ID = showNextInlineSuggestionActionId; }
     constructor() {
         super({
             id: ShowNextInlineSuggestionAction.ID,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/inlineCompletions/browser/commands',
-                'action.inlineSuggest.showNext',
-                "Show Next Inline Suggestion"
-            )),
+            label: ( localizeWithPath(_moduleId, 0, "Show Next Inline Suggestion")),
             alias: 'Show Next Inline Suggestion',
-            precondition: ( ContextKeyExpr.and(
+            precondition: ( (ContextKeyExpr.and(
                 EditorContextKeys.writable,
                 InlineCompletionContextKeys.inlineSuggestionVisible
-            )),
+            ))),
             kbOpts: {
                 weight: 100,
                 primary: 512  | 94 ,
@@ -44,16 +41,12 @@ class ShowPreviousInlineSuggestionAction extends EditorAction {
     constructor() {
         super({
             id: ShowPreviousInlineSuggestionAction.ID,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/inlineCompletions/browser/commands',
-                'action.inlineSuggest.showPrevious',
-                "Show Previous Inline Suggestion"
-            )),
+            label: ( localizeWithPath(_moduleId, 1, "Show Previous Inline Suggestion")),
             alias: 'Show Previous Inline Suggestion',
-            precondition: ( ContextKeyExpr.and(
+            precondition: ( (ContextKeyExpr.and(
                 EditorContextKeys.writable,
                 InlineCompletionContextKeys.inlineSuggestionVisible
-            )),
+            ))),
             kbOpts: {
                 weight: 100,
                 primary: 512  | 92 ,
@@ -69,11 +62,7 @@ class TriggerInlineSuggestionAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.inlineSuggest.trigger',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/inlineCompletions/browser/commands',
-                'action.inlineSuggest.trigger',
-                "Trigger Inline Suggestion"
-            )),
+            label: ( localizeWithPath(_moduleId, 2, "Trigger Inline Suggestion")),
             alias: 'Trigger Inline Suggestion',
             precondition: EditorContextKeys.writable
         });
@@ -90,31 +79,23 @@ class AcceptNextWordOfInlineCompletion extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.inlineSuggest.acceptNextWord',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/inlineCompletions/browser/commands',
-                'action.inlineSuggest.acceptNextWord',
-                "Accept Next Word Of Inline Suggestion"
-            )),
+            label: ( localizeWithPath(_moduleId, 3, "Accept Next Word Of Inline Suggestion")),
             alias: 'Accept Next Word Of Inline Suggestion',
-            precondition: ( ContextKeyExpr.and(
+            precondition: ( (ContextKeyExpr.and(
                 EditorContextKeys.writable,
                 InlineCompletionContextKeys.inlineSuggestionVisible
-            )),
+            ))),
             kbOpts: {
                 weight: 100  + 1,
                 primary: 2048  | 17 ,
-                kbExpr: ( ContextKeyExpr.and(
+                kbExpr: ( (ContextKeyExpr.and(
                     EditorContextKeys.writable,
                     InlineCompletionContextKeys.inlineSuggestionVisible
-                )),
+                ))),
             },
             menuOpts: [{
                     menuId: MenuId.InlineSuggestionToolbar,
-                    title: ( localizeWithPath(
-                        'vs/editor/contrib/inlineCompletions/browser/commands',
-                        'acceptWord',
-                        'Accept Word'
-                    )),
+                    title: ( localizeWithPath(_moduleId, 4, 'Accept Word')),
                     group: 'primary',
                     order: 2,
                 }],
@@ -129,26 +110,18 @@ class AcceptNextLineOfInlineCompletion extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.inlineSuggest.acceptNextLine',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/inlineCompletions/browser/commands',
-                'action.inlineSuggest.acceptNextLine',
-                "Accept Next Line Of Inline Suggestion"
-            )),
+            label: ( localizeWithPath(_moduleId, 5, "Accept Next Line Of Inline Suggestion")),
             alias: 'Accept Next Line Of Inline Suggestion',
-            precondition: ( ContextKeyExpr.and(
+            precondition: ( (ContextKeyExpr.and(
                 EditorContextKeys.writable,
                 InlineCompletionContextKeys.inlineSuggestionVisible
-            )),
+            ))),
             kbOpts: {
                 weight: 100  + 1,
             },
             menuOpts: [{
                     menuId: MenuId.InlineSuggestionToolbar,
-                    title: ( localizeWithPath(
-                        'vs/editor/contrib/inlineCompletions/browser/commands',
-                        'acceptLine',
-                        'Accept Line'
-                    )),
+                    title: ( localizeWithPath(_moduleId, 6, 'Accept Line')),
                     group: 'secondary',
                     order: 2,
                 }],
@@ -163,23 +136,25 @@ class AcceptInlineCompletion extends EditorAction {
     constructor() {
         super({
             id: inlineSuggestCommitId,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/inlineCompletions/browser/commands',
-                'action.inlineSuggest.accept',
-                "Accept Inline Suggestion"
-            )),
+            label: ( localizeWithPath(_moduleId, 7, "Accept Inline Suggestion")),
             alias: 'Accept Inline Suggestion',
             precondition: InlineCompletionContextKeys.inlineSuggestionVisible,
             menuOpts: [{
                     menuId: MenuId.InlineSuggestionToolbar,
-                    title: ( localizeWithPath('vs/editor/contrib/inlineCompletions/browser/commands', 'accept', "Accept")),
+                    title: ( localizeWithPath(_moduleId, 8, "Accept")),
                     group: 'primary',
                     order: 1,
                 }],
             kbOpts: {
                 primary: 2 ,
                 weight: 200,
-                kbExpr: ( ContextKeyExpr.and(InlineCompletionContextKeys.inlineSuggestionVisible, ( EditorContextKeys.tabMovesFocus.toNegated()), InlineCompletionContextKeys.inlineSuggestionHasIndentationLessThanTabSize, ( Context.Visible.toNegated()), ( EditorContextKeys.hoverFocused.toNegated()))),
+                kbExpr: ( (ContextKeyExpr.and(
+                    InlineCompletionContextKeys.inlineSuggestionVisible,
+                     (EditorContextKeys.tabMovesFocus.toNegated()),
+                    InlineCompletionContextKeys.inlineSuggestionHasIndentationLessThanTabSize,
+                     (Context.Visible.toNegated()),
+                     (EditorContextKeys.hoverFocused.toNegated())
+                ))),
             }
         });
     }
@@ -196,11 +171,7 @@ class HideInlineCompletion extends EditorAction {
     constructor() {
         super({
             id: HideInlineCompletion.ID,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/inlineCompletions/browser/commands',
-                'action.inlineSuggest.hide',
-                "Hide Inline Suggestion"
-            )),
+            label: ( localizeWithPath(_moduleId, 9, "Hide Inline Suggestion")),
             alias: 'Hide Inline Suggestion',
             precondition: InlineCompletionContextKeys.inlineSuggestionVisible,
             kbOpts: {
@@ -221,11 +192,7 @@ class ToggleAlwaysShowInlineSuggestionToolbar extends Action2 {
     constructor() {
         super({
             id: ToggleAlwaysShowInlineSuggestionToolbar.ID,
-            title: ( localizeWithPath(
-                'vs/editor/contrib/inlineCompletions/browser/commands',
-                'action.inlineSuggest.alwaysShowToolbar',
-                "Always Show Toolbar"
-            )),
+            title: ( localizeWithPath(_moduleId, 10, "Always Show Toolbar")),
             f1: false,
             precondition: undefined,
             menu: [{
@@ -233,7 +200,7 @@ class ToggleAlwaysShowInlineSuggestionToolbar extends Action2 {
                     group: 'secondary',
                     order: 10,
                 }],
-            toggled: ( ContextKeyExpr.equals('config.editor.inlineSuggest.showToolbar', 'always'))
+            toggled: ( (ContextKeyExpr.equals('config.editor.inlineSuggest.showToolbar', 'always')))
         });
     }
     async run(accessor, editor) {

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/hoverParticipant.js

@@ -17,6 +17,7 @@ import { IAccessibilityService } from '../../../../platform/accessibility/common
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import { IOpenerService } from '../../../../platform/opener/common/opener.service.js';
 import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.service.js';
+const _moduleId = "vs/editor/contrib/inlineCompletions/browser/hoverParticipant";
 class InlineCompletionsHover {
     constructor(owner, range, controller) {
         this.owner = owner;
@@ -48,39 +49,45 @@ let InlineCompletionsHoverParticipant = class InlineCompletionsHoverParticipant
         if (target.type === 8 ) {
             const viewZoneData = target.detail;
             if (controller.shouldShowHoverAtViewZone(viewZoneData.viewZoneId)) {
-                return ( new HoverForeignElementAnchor(
-                    1000,
-                    this,
-                    Range.fromPositions(this._editor.getModel().validatePosition(viewZoneData.positionBefore || viewZoneData.position)),
-                    mouseEvent.event.posx,
-                    mouseEvent.event.posy,
-                    false
-                ));
+                return (
+                     (new HoverForeignElementAnchor(
+                        1000,
+                        this,
+                        Range.fromPositions(this._editor.getModel().validatePosition(viewZoneData.positionBefore || viewZoneData.position)),
+                        mouseEvent.event.posx,
+                        mouseEvent.event.posy,
+                        false
+                    ))
+                );
             }
         }
         if (target.type === 7 ) {
             if (controller.shouldShowHoverAt(target.range)) {
-                return ( new HoverForeignElementAnchor(
-                    1000,
-                    this,
-                    target.range,
-                    mouseEvent.event.posx,
-                    mouseEvent.event.posy,
-                    false
-                ));
+                return (
+                     (new HoverForeignElementAnchor(
+                        1000,
+                        this,
+                        target.range,
+                        mouseEvent.event.posx,
+                        mouseEvent.event.posy,
+                        false
+                    ))
+                );
             }
         }
         if (target.type === 6 ) {
             const mightBeForeignElement = target.detail.mightBeForeignElement;
             if (mightBeForeignElement && controller.shouldShowHoverAt(target.range)) {
-                return ( new HoverForeignElementAnchor(
-                    1000,
-                    this,
-                    target.range,
-                    mouseEvent.event.posx,
-                    mouseEvent.event.posy,
-                    false
-                ));
+                return (
+                     (new HoverForeignElementAnchor(
+                        1000,
+                        this,
+                        target.range,
+                        mouseEvent.event.posx,
+                        mouseEvent.event.posy,
+                        false
+                    ))
+                );
             }
         }
         return null;
@@ -91,21 +98,21 @@ let InlineCompletionsHoverParticipant = class InlineCompletionsHoverParticipant
         }
         const controller = InlineCompletionsController.get(this._editor);
         if (controller && controller.shouldShowHoverAt(anchor.range)) {
-            return [( new InlineCompletionsHover(this, anchor.range, controller))];
+            return [( (new InlineCompletionsHover(this, anchor.range, controller)))];
         }
         return [];
     }
     renderHoverParts(context, hoverParts) {
-        const disposableStore = ( new DisposableStore());
+        const disposableStore = ( (new DisposableStore()));
         const part = hoverParts[0];
         this._telemetryService.publicLog2('inlineCompletionHover.shown');
         if (this.accessibilityService.isScreenReaderOptimized() && !this._editor.getOption(8 )) {
             this.renderScreenReaderText(context, part, disposableStore);
         }
         const model = part.controller.model.get();
-        const w = this._instantiationService.createInstance(InlineSuggestionHintsContentWidget, this._editor, false, constObservable(null), model.selectedInlineCompletionIndex, model.inlineCompletionsCount, ( model.selectedInlineCompletion.map(
+        const w = this._instantiationService.createInstance(InlineSuggestionHintsContentWidget, this._editor, false, constObservable(null), model.selectedInlineCompletionIndex, model.inlineCompletionsCount, ( (model.selectedInlineCompletion.map(
             v =>  v?.inlineCompletion.source.inlineCompletions.commands ?? []
-        )));
+        ))));
         context.fragment.appendChild(w.getDomNode());
         model.triggerExplicitly();
         disposableStore.add(w);
@@ -115,18 +122,14 @@ let InlineCompletionsHoverParticipant = class InlineCompletionsHoverParticipant
         const $$1 = $;
         const markdownHoverElement = $$1('div.hover-row.markdown-hover');
         const hoverContentsElement = append(markdownHoverElement, $$1('div.hover-contents', { ['aria-live']: 'assertive' }));
-        const renderer = disposableStore.add(( new MarkdownRenderer({ editor: this._editor }, this._languageService, this._openerService)));
+        const renderer = disposableStore.add(( (new MarkdownRenderer({ editor: this._editor }, this._languageService, this._openerService))));
         const render = (code) => {
             disposableStore.add(renderer.onDidRenderAsync(() => {
                 hoverContentsElement.className = 'hover-contents code-hover-contents';
                 context.onContentsChanged();
             }));
-            const inlineSuggestionAvailable = ( localizeWithPath(
-                'vs/editor/contrib/inlineCompletions/browser/hoverParticipant',
-                'inlineSuggestionFollows',
-                "Suggestion:"
-            ));
-            const renderedContents = disposableStore.add(renderer.render(( new MarkdownString()).appendText(inlineSuggestionAvailable).appendCodeblock('text', code)));
+            const inlineSuggestionAvailable = ( localizeWithPath(_moduleId, 0, "Suggestion:"));
+            const renderedContents = disposableStore.add(renderer.render(( (new MarkdownString())).appendText(inlineSuggestionAvailable).appendCodeblock('text', code)));
             hoverContentsElement.replaceChildren(renderedContents.element);
         };
         disposableStore.add(autorun(reader => {
@@ -142,11 +145,11 @@ let InlineCompletionsHoverParticipant = class InlineCompletionsHoverParticipant
         context.fragment.appendChild(markdownHoverElement);
     }
 };
-InlineCompletionsHoverParticipant = ( __decorate([
-    ( __param(1, ILanguageService)),
-    ( __param(2, IOpenerService)),
-    ( __param(3, IAccessibilityService)),
-    ( __param(4, IInstantiationService)),
-    ( __param(5, ITelemetryService))
-], InlineCompletionsHoverParticipant));
+InlineCompletionsHoverParticipant = ( (__decorate([
+    ( (__param(1, ILanguageService))),
+    ( (__param(2, IOpenerService))),
+    ( (__param(3, IAccessibilityService))),
+    ( (__param(4, IInstantiationService))),
+    ( (__param(5, ITelemetryService)))
+], InlineCompletionsHoverParticipant)));
 export { InlineCompletionsHover, InlineCompletionsHoverParticipant };

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/inlineCompletionContextKeys.js

@@ -7,27 +7,20 @@ import { CursorColumns } from '../../../common/core/cursorColumns.js';
 import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
 import { Disposable } from '../../../../base/common/lifecycle.js';
 import { localizeWithPath } from '../../../../nls.js';
+const _moduleId = "vs/editor/contrib/inlineCompletions/browser/inlineCompletionContextKeys";
 class InlineCompletionContextKeys extends Disposable {
-    static { this.inlineSuggestionVisible = ( new RawContextKey('inlineSuggestionVisible', false, ( localizeWithPath(
-        'vs/editor/contrib/inlineCompletions/browser/inlineCompletionContextKeys',
-        'inlineSuggestionVisible',
-        "Whether an inline suggestion is visible"
-    )))); }
-    static { this.inlineSuggestionHasIndentation = ( new RawContextKey('inlineSuggestionHasIndentation', false, ( localizeWithPath(
-        'vs/editor/contrib/inlineCompletions/browser/inlineCompletionContextKeys',
-        'inlineSuggestionHasIndentation',
-        "Whether the inline suggestion starts with whitespace"
-    )))); }
-    static { this.inlineSuggestionHasIndentationLessThanTabSize = ( new RawContextKey('inlineSuggestionHasIndentationLessThanTabSize', true, ( localizeWithPath(
-        'vs/editor/contrib/inlineCompletions/browser/inlineCompletionContextKeys',
-        'inlineSuggestionHasIndentationLessThanTabSize',
+    static { this.inlineSuggestionVisible = ( (new RawContextKey('inlineSuggestionVisible', false, ( localizeWithPath(_moduleId, 0, "Whether an inline suggestion is visible"))))); }
+    static { this.inlineSuggestionHasIndentation = ( (new RawContextKey('inlineSuggestionHasIndentation', false, ( localizeWithPath(_moduleId, 1, "Whether the inline suggestion starts with whitespace"))))); }
+    static { this.inlineSuggestionHasIndentationLessThanTabSize = ( (new RawContextKey('inlineSuggestionHasIndentationLessThanTabSize', true, ( localizeWithPath(
+        _moduleId,
+        2,
         "Whether the inline suggestion starts with whitespace that is less than what would be inserted by tab"
-    )))); }
-    static { this.suppressSuggestions = ( new RawContextKey('inlineSuggestionSuppressSuggestions', undefined, ( localizeWithPath(
-        'vs/editor/contrib/inlineCompletions/browser/inlineCompletionContextKeys',
-        'suppressSuggestions',
+    ))))); }
+    static { this.suppressSuggestions = ( (new RawContextKey('inlineSuggestionSuppressSuggestions', undefined, ( localizeWithPath(
+        _moduleId,
+        3,
         "Whether suggestions should be suppressed for the current suggestion"
-    )))); }
+    ))))); }
     constructor(contextKeyService, model) {
         super();
         this.contextKeyService = contextKeyService;