@codingame/monaco-vscode-api 4.5.1 → 5.0.0

package/vscode/src/vs/editor/contrib/indentation/browser/indentation.js

@@ -8,22 +8,22 @@ import { EditorContextKeys } from '../../../common/editorContextKeys.js';
 import { ILanguageConfigurationService } from '../../../common/languages/languageConfigurationRegistry.js';
 import { IModelService } from '../../../common/services/model.js';
 import { getSpaceCnt, generateIndent } from '../common/indentUtils.js';
-import { localizeWithPath } from '../../../../nls.js';
+import { localizeWithPath, localize2WithPath } from '../../../../nls.js';
 import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.service.js';
 import { getGoodIndentForLine, getIndentMetadata } from '../../../common/languages/autoIndent.js';
 import { getReindentEditOperations } from '../common/indentation.js';
+const _moduleId = "vs/editor/contrib/indentation/browser/indentation";
 class IndentationToSpacesAction extends EditorAction {
     static { this.ID = 'editor.action.indentationToSpaces'; }
     constructor() {
         super({
             id: IndentationToSpacesAction.ID,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/indentation/browser/indentation',
-                'indentationToSpaces',
-                "Convert Indentation to Spaces"
-            )),
+            label: ( localizeWithPath(_moduleId, 0, "Convert Indentation to Spaces")),
             alias: 'Convert Indentation to Spaces',
-            precondition: EditorContextKeys.writable
+            precondition: EditorContextKeys.writable,
+            metadata: {
+                description: ( localize2WithPath(_moduleId, 1, "Convert the tab indentation to spaces.")),
+            }
         });
     }
     run(accessor, editor) {
@@ -36,7 +36,7 @@ class IndentationToSpacesAction extends EditorAction {
         if (!selection) {
             return;
         }
-        const command = ( new IndentationToSpacesCommand(selection, modelOpts.tabSize));
+        const command = ( (new IndentationToSpacesCommand(selection, modelOpts.tabSize)));
         editor.pushUndoStop();
         editor.executeCommands(this.id, [command]);
         editor.pushUndoStop();
@@ -50,13 +50,12 @@ class IndentationToTabsAction extends EditorAction {
     constructor() {
         super({
             id: IndentationToTabsAction.ID,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/indentation/browser/indentation',
-                'indentationToTabs',
-                "Convert Indentation to Tabs"
-            )),
+            label: ( localizeWithPath(_moduleId, 2, "Convert Indentation to Tabs")),
             alias: 'Convert Indentation to Tabs',
-            precondition: EditorContextKeys.writable
+            precondition: EditorContextKeys.writable,
+            metadata: {
+                description: ( localize2WithPath(_moduleId, 3, "Convert the spaces indentation to tabs.")),
+            }
         });
     }
     run(accessor, editor) {
@@ -69,7 +68,7 @@ class IndentationToTabsAction extends EditorAction {
         if (!selection) {
             return;
         }
-        const command = ( new IndentationToTabsCommand(selection, modelOpts.tabSize));
+        const command = ( (new IndentationToTabsCommand(selection, modelOpts.tabSize)));
         editor.pushUndoStop();
         editor.executeCommands(this.id, [command]);
         editor.pushUndoStop();
@@ -93,36 +92,20 @@ class ChangeIndentationSizeAction extends EditorAction {
         }
         const creationOpts = modelService.getCreationOptions(model.getLanguageId(), model.uri, model.isForSimpleWidget);
         const modelOpts = model.getOptions();
-        const picks = ( [1, 2, 3, 4, 5, 6, 7, 8].map(n => ({
-            id: ( n.toString()),
-            label: ( n.toString()),
+        const picks = ( ([1, 2, 3, 4, 5, 6, 7, 8].map(n => ({
+            id: ( (n.toString())),
+            label: ( (n.toString())),
             description: (n === creationOpts.tabSize && n === modelOpts.tabSize
-                ? ( localizeWithPath(
-                'vs/editor/contrib/indentation/browser/indentation',
-                'configuredTabSize',
-                "Configured Tab Size"
-            ))
+                ? ( localizeWithPath(_moduleId, 4, "Configured Tab Size"))
                 : n === creationOpts.tabSize
-                    ? ( localizeWithPath(
-                'vs/editor/contrib/indentation/browser/indentation',
-                'defaultTabSize',
-                "Default Tab Size"
-            ))
+                    ? ( localizeWithPath(_moduleId, 5, "Default Tab Size"))
                     : n === modelOpts.tabSize
-                        ? ( localizeWithPath(
-                'vs/editor/contrib/indentation/browser/indentation',
-                'currentTabSize',
-                "Current Tab Size"
-            ))
+                        ? ( localizeWithPath(_moduleId, 6, "Current Tab Size"))
                         : undefined)
-        })));
+        }))));
         const autoFocusIndex = Math.min(model.getOptions().tabSize - 1, 7);
         setTimeout(() => {
-            quickInputService.pick(picks, { placeHolder: ( localizeWithPath(
-                'vs/editor/contrib/indentation/browser/indentation',
-                { key: 'selectTabWidth', comment: ['Tab corresponds to the tab key'] },
-                "Select Tab Size for Current File"
-            )), activeItem: picks[autoFocusIndex] }).then(pick => {
+            quickInputService.pick(picks, { placeHolder: ( localizeWithPath(_moduleId, 7, "Select Tab Size for Current File")), activeItem: picks[autoFocusIndex] }).then(pick => {
                 if (pick) {
                     if (model && !model.isDisposed()) {
                         const pickedVal = parseInt(pick.label, 10);
@@ -149,13 +132,12 @@ class IndentUsingTabs extends ChangeIndentationSizeAction {
     constructor() {
         super(false, false, {
             id: IndentUsingTabs.ID,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/indentation/browser/indentation',
-                'indentUsingTabs',
-                "Indent Using Tabs"
-            )),
+            label: ( localizeWithPath(_moduleId, 8, "Indent Using Tabs")),
             alias: 'Indent Using Tabs',
-            precondition: undefined
+            precondition: undefined,
+            metadata: {
+                description: ( localize2WithPath(_moduleId, 9, "Use indentation with tabs.")),
+            }
         });
     }
 }
@@ -164,13 +146,12 @@ class IndentUsingSpaces extends ChangeIndentationSizeAction {
     constructor() {
         super(true, false, {
             id: IndentUsingSpaces.ID,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/indentation/browser/indentation',
-                'indentUsingSpaces',
-                "Indent Using Spaces"
-            )),
+            label: ( localizeWithPath(_moduleId, 10, "Indent Using Spaces")),
             alias: 'Indent Using Spaces',
-            precondition: undefined
+            precondition: undefined,
+            metadata: {
+                description: ( localize2WithPath(_moduleId, 11, "Use indentation with spaces.")),
+            }
         });
     }
 }
@@ -179,13 +160,12 @@ class ChangeTabDisplaySize extends ChangeIndentationSizeAction {
     constructor() {
         super(true, true, {
             id: ChangeTabDisplaySize.ID,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/indentation/browser/indentation',
-                'changeTabDisplaySize',
-                "Change Tab Display Size"
-            )),
+            label: ( localizeWithPath(_moduleId, 12, "Change Tab Display Size")),
             alias: 'Change Tab Display Size',
-            precondition: undefined
+            precondition: undefined,
+            metadata: {
+                description: ( localize2WithPath(_moduleId, 13, "Change the space size equivalent of the tab.")),
+            }
         });
     }
 }
@@ -194,13 +174,12 @@ class DetectIndentation extends EditorAction {
     constructor() {
         super({
             id: DetectIndentation.ID,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/indentation/browser/indentation',
-                'detectIndentation',
-                "Detect Indentation from Content"
-            )),
+            label: ( localizeWithPath(_moduleId, 14, "Detect Indentation from Content")),
             alias: 'Detect Indentation from Content',
-            precondition: undefined
+            precondition: undefined,
+            metadata: {
+                description: ( localize2WithPath(_moduleId, 15, "Detect the indentation from content.")),
+            }
         });
     }
     run(accessor, editor) {
@@ -217,13 +196,12 @@ class ReindentLinesAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.reindentlines',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/indentation/browser/indentation',
-                'editor.reindentlines',
-                "Reindent Lines"
-            )),
+            label: ( localizeWithPath(_moduleId, 16, "Reindent Lines")),
             alias: 'Reindent Lines',
-            precondition: EditorContextKeys.writable
+            precondition: EditorContextKeys.writable,
+            metadata: {
+                description: ( localize2WithPath(_moduleId, 17, "Reindent the lines of the editor.")),
+            }
         });
     }
     run(accessor, editor) {
@@ -244,13 +222,12 @@ class ReindentSelectedLinesAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.reindentselectedlines',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/indentation/browser/indentation',
-                'editor.reindentselectedlines',
-                "Reindent Selected Lines"
-            )),
+            label: ( localizeWithPath(_moduleId, 18, "Reindent Selected Lines")),
             alias: 'Reindent Selected Lines',
-            precondition: EditorContextKeys.writable
+            precondition: EditorContextKeys.writable,
+            metadata: {
+                description: ( localize2WithPath(_moduleId, 19, "Reindent the selected lines of the editor.")),
+            }
         });
     }
     run(accessor, editor) {
@@ -329,8 +306,8 @@ let AutoIndentOnPaste = class AutoIndentOnPaste {
     constructor(editor, _languageConfigurationService) {
         this.editor = editor;
         this._languageConfigurationService = _languageConfigurationService;
-        this.callOnDispose = ( new DisposableStore());
-        this.callOnModel = ( new DisposableStore());
+        this.callOnDispose = ( (new DisposableStore()));
+        this.callOnModel = ( (new DisposableStore()));
         this.callOnDispose.add(editor.onDidChangeConfiguration(() => this.update()));
         this.callOnDispose.add(editor.onDidChangeModel(() => this.update()));
         this.callOnDispose.add(editor.onDidChangeModelLanguage(() => this.update()));
@@ -391,7 +368,7 @@ let AutoIndentOnPaste = class AutoIndentOnPaste {
                 if (newSpaceCnt !== oldSpaceCnt) {
                     const newIndent = generateIndent(newSpaceCnt, tabSize, insertSpaces);
                     textEdits.push({
-                        range: ( new Range(startLineNumber, 1, startLineNumber, oldIndentation.length + 1)),
+                        range: ( (new Range(startLineNumber, 1, startLineNumber, oldIndentation.length + 1))),
                         text: newIndent
                     });
                     firstLineText = newIndent + firstLineText.substr(oldIndentation.length);
@@ -448,7 +425,7 @@ let AutoIndentOnPaste = class AutoIndentOnPaste {
                         const newIndent = generateIndent(newSpacesCnt, tabSize, insertSpaces);
                         if (newIndent !== originalIndent) {
                             textEdits.push({
-                                range: ( new Range(i, 1, i, originalIndent.length + 1)),
+                                range: ( (new Range(i, 1, i, originalIndent.length + 1))),
                                 text: newIndent
                             });
                         }
@@ -458,7 +435,7 @@ let AutoIndentOnPaste = class AutoIndentOnPaste {
         }
         if (textEdits.length > 0) {
             this.editor.pushUndoStop();
-            const cmd = ( new AutoIndentOnPasteCommand(textEdits, this.editor.getSelection()));
+            const cmd = ( (new AutoIndentOnPasteCommand(textEdits, this.editor.getSelection())));
             this.editor.executeCommand('autoIndentOnPaste', cmd);
             this.editor.pushUndoStop();
         }
@@ -483,9 +460,9 @@ let AutoIndentOnPaste = class AutoIndentOnPaste {
         this.callOnModel.dispose();
     }
 };
-AutoIndentOnPaste = ( __decorate([
-    ( __param(1, ILanguageConfigurationService))
-], AutoIndentOnPaste));
+AutoIndentOnPaste = ( (__decorate([
+    ( (__param(1, ILanguageConfigurationService)))
+], AutoIndentOnPaste)));
 function getIndentationEditOperations(model, builder, tabSize, tabsToSpaces) {
     if (model.getLineCount() === 1 && model.getLineMaxColumn(1) === 1) {
         return;
@@ -494,7 +471,7 @@ function getIndentationEditOperations(model, builder, tabSize, tabsToSpaces) {
     for (let i = 0; i < tabSize; i++) {
         spaces += ' ';
     }
-    const spacesRegExp = ( new RegExp(spaces, 'gi'));
+    const spacesRegExp = ( (new RegExp(spaces, 'gi')));
     for (let lineNumber = 1, lineCount = model.getLineCount(); lineNumber <= lineCount; lineNumber++) {
         let lastIndentationColumn = model.getLineFirstNonWhitespaceColumn(lineNumber);
         if (lastIndentationColumn === 0) {
@@ -503,7 +480,7 @@ function getIndentationEditOperations(model, builder, tabSize, tabsToSpaces) {
         if (lastIndentationColumn === 1) {
             continue;
         }
-        const originalIndentationRange = ( new Range(lineNumber, 1, lineNumber, lastIndentationColumn));
+        const originalIndentationRange = ( (new Range(lineNumber, 1, lineNumber, lastIndentationColumn)));
         const originalIndentation = model.getValueInRange(originalIndentationRange);
         const newIndentation = (tabsToSpaces
             ? originalIndentation.replace(/\t/ig, spaces)

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

@@ -71,7 +71,7 @@ class InlayHintsFragments {
         }))));
         await Promise.all(promises.flat());
         if (token.isCancellationRequested || model.isDisposed()) {
-            throw new CancellationError();
+            throw ( new CancellationError());
         }
         return ( new InlayHintsFragments(ranges, data, model));
     }

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

@@ -6,7 +6,7 @@ import { ModelDecorationInjectedTextOptions } from '../../../common/model/textMo
 import { HoverForeignElementAnchor } from '../../hover/browser/hoverTypes.js';
 import { ILanguageService } from '../../../common/languages/language.js';
 import { ITextModelService } from '../../../common/services/resolverService.js';
-import { getHover } from '../../hover/browser/getHover.js';
+import { getHoverProviderResultsAsAsyncIterable } from '../../hover/browser/getHover.js';
 import { MarkdownHoverParticipant, MarkdownHover } from '../../hover/browser/markdownHoverParticipant.js';
 import { InlayHintsController, RenderedInlayHintLabelPart } from './inlayHintsController.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
@@ -16,6 +16,9 @@ import { localizeWithPath } from '../../../../nls.js';
 import { isMacintosh } from '../../../../base/common/platform.js';
 import { asCommandLink } from './inlayHints.js';
 import { isNonEmptyArray } from '../../../../base/common/arrays.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
+import { IHoverService } from '../../../../platform/hover/browser/hover.service.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);
@@ -23,8 +26,8 @@ class InlayHintsHoverAnchor extends HoverForeignElementAnchor {
     }
 }
 let InlayHintsHover = class InlayHintsHover extends MarkdownHoverParticipant {
-    constructor(editor, languageService, openerService, configurationService, _resolverService, languageFeaturesService) {
-        super(editor, languageService, openerService, configurationService, languageFeaturesService);
+    constructor(editor, languageService, openerService, keybindingService, hoverService, configurationService, _resolverService, languageFeaturesService) {
+        super(editor, languageService, openerService, configurationService, languageFeaturesService, keybindingService, hoverService);
         this._resolverService = _resolverService;
         this.hoverOrdinal = 6;
     }
@@ -40,7 +43,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 +54,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 +128,29 @@ 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 (
+                 (getHoverProviderResultsAsAsyncIterable(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, IKeybindingService))),
+    ( (__param(4, IHoverService))),
+    ( (__param(5, IConfigurationService))),
+    ( (__param(6, ITextModelService))),
+    ( (__param(7, ILanguageFeaturesService)))
+], InlayHintsHover)));
 export { InlayHintsHover };