monaco-editor11 1.1.0 → 1.1.2

package/dist/workers/hoverContribution.js

@@ -0,0 +1,56 @@
+import { ShowOrFocusHoverAction, ShowDefinitionPreviewHoverAction, HideContentHoverAction, ScrollUpHoverAction, ScrollDownHoverAction, ScrollLeftHoverAction, ScrollRightHoverAction, PageUpHoverAction, PageDownHoverAction, GoToTopHoverAction, GoToBottomHoverAction, IncreaseHoverVerbosityLevel, DecreaseHoverVerbosityLevel } from './hoverActions.js';
+import { registerEditorContribution, registerEditorAction } from '../../../browser/editorExtensions.js';
+import '../../../../platform/theme/common/colorUtils.js';
+import '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import { editorHoverBorder } from '../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../platform/theme/common/colors/inputColors.js';
+import '../../../../platform/theme/common/colors/listColors.js';
+import '../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
+import { registerThemingParticipant } from '../../../../platform/theme/common/themeService.js';
+import { HoverParticipantRegistry } from './hoverTypes.js';
+import { MarkdownHoverParticipant } from './markdownHoverParticipant.js';
+import { MarkerHoverParticipant } from './markerHoverParticipant.js';
+import { ContentHoverController } from './contentHoverController.js';
+import { GlyphHoverController } from './glyphHoverController.js';
+import './hover.css';
+import { AccessibleViewRegistry } from '../../../../platform/accessibility/browser/accessibleViewRegistry.js';
+import { HoverAccessibleView, HoverAccessibilityHelp, ExtHoverAccessibleView } from './hoverAccessibleViews.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+registerEditorContribution(ContentHoverController.ID, ContentHoverController, 2 /* EditorContributionInstantiation.BeforeFirstInteraction */);
+registerEditorContribution(GlyphHoverController.ID, GlyphHoverController, 2 /* EditorContributionInstantiation.BeforeFirstInteraction */);
+registerEditorAction(ShowOrFocusHoverAction);
+registerEditorAction(ShowDefinitionPreviewHoverAction);
+registerEditorAction(HideContentHoverAction);
+registerEditorAction(ScrollUpHoverAction);
+registerEditorAction(ScrollDownHoverAction);
+registerEditorAction(ScrollLeftHoverAction);
+registerEditorAction(ScrollRightHoverAction);
+registerEditorAction(PageUpHoverAction);
+registerEditorAction(PageDownHoverAction);
+registerEditorAction(GoToTopHoverAction);
+registerEditorAction(GoToBottomHoverAction);
+registerEditorAction(IncreaseHoverVerbosityLevel);
+registerEditorAction(DecreaseHoverVerbosityLevel);
+HoverParticipantRegistry.register(MarkdownHoverParticipant);
+HoverParticipantRegistry.register(MarkerHoverParticipant);
+// theming
+registerThemingParticipant((theme, collector) => {
+    const hoverBorder = theme.getColor(editorHoverBorder);
+    if (hoverBorder) {
+        collector.addRule(`.monaco-editor .monaco-hover .hover-row:not(:first-child):not(:empty) { border-top: 1px solid ${hoverBorder.transparent(0.5)}; }`);
+        collector.addRule(`.monaco-editor .monaco-hover hr { border-top: 1px solid ${hoverBorder.transparent(0.5)}; }`);
+        collector.addRule(`.monaco-editor .monaco-hover hr { border-bottom: 0px solid ${hoverBorder.transparent(0.5)}; }`);
+    }
+});
+AccessibleViewRegistry.register(new HoverAccessibleView());
+AccessibleViewRegistry.register(new HoverAccessibilityHelp());
+AccessibleViewRegistry.register(new ExtHoverAccessibleView());

package/dist/workers/hoverCopyButton.js

@@ -0,0 +1,54 @@
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { IClipboardService } from '../../../../platform/clipboard/common/clipboardService.js';
+import { IHoverService } from '../../../../platform/hover/browser/hover.js';
+import { localize } from '../../../../nls.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { SimpleButton } from '../../find/browser/findWidget.js';
+import { status } from '../../../../base/browser/ui/aria/aria.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+/**
+ * A button that appears in hover parts to copy their content to the clipboard.
+ */
+let HoverCopyButton = class HoverCopyButton extends Disposable {
+    constructor(_container, _getContent, _clipboardService, _hoverService) {
+        super();
+        this._container = _container;
+        this._getContent = _getContent;
+        this._clipboardService = _clipboardService;
+        this._hoverService = _hoverService;
+        this._container.classList.add('hover-row-with-copy');
+        this._button = this._register(new SimpleButton({
+            label: localize(1128, "Copy"),
+            icon: Codicon.copy,
+            onTrigger: () => this._copyContent(),
+            className: 'hover-copy-button',
+        }, this._hoverService));
+        this._container.appendChild(this._button.domNode);
+    }
+    async _copyContent() {
+        const content = this._getContent();
+        if (content) {
+            await this._clipboardService.writeText(content);
+            status(localize(1129, "Copied to clipboard"));
+        }
+    }
+};
+HoverCopyButton = __decorate([
+    __param(2, IClipboardService),
+    __param(3, IHoverService)
+], HoverCopyButton);
+
+export { HoverCopyButton };

package/dist/workers/hoverDelegate2.js

@@ -0,0 +1,39 @@
+import { Disposable } from '../../../common/lifecycle.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+let baseHoverDelegate = {
+    showInstantHover: () => undefined,
+    showDelayedHover: () => undefined,
+    setupDelayedHover: () => Disposable.None,
+    setupDelayedHoverAtMouse: () => Disposable.None,
+    hideHover: () => undefined,
+    showAndFocusLastHover: () => undefined,
+    setupManagedHover: () => ({
+        dispose: () => undefined,
+        show: () => undefined,
+        hide: () => undefined,
+        update: () => undefined,
+    }),
+    showManagedHover: () => undefined
+};
+/**
+ * Sets the hover delegate for use **only in the `base/` layer**.
+ */
+function setBaseLayerHoverDelegate(hoverDelegate) {
+    baseHoverDelegate = hoverDelegate;
+}
+/**
+ * Gets the hover delegate for use **only in the `base/` layer**.
+ *
+ * Since the hover service depends on various platform services, this delegate essentially bypasses
+ * the standard dependency injection mechanism by injecting a global hover service at start up. The
+ * only reason this should be used is if `IHoverService` is not available.
+ */
+function getBaseLayerHoverDelegate() {
+    return baseHoverDelegate;
+}
+
+export { getBaseLayerHoverDelegate, setBaseLayerHoverDelegate };

package/dist/workers/hoverDelegateFactory.js

@@ -0,0 +1,34 @@
+import { Lazy } from '../../../common/lazy.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const nullHoverDelegateFactory = () => ({
+    get delay() { return -1; },
+    dispose: () => { },
+    showHover: () => { return undefined; },
+});
+let hoverDelegateFactory = nullHoverDelegateFactory;
+const defaultHoverDelegateMouse = new Lazy(() => hoverDelegateFactory('mouse', false));
+const defaultHoverDelegateElement = new Lazy(() => hoverDelegateFactory('element', false));
+// TODO: Remove when getDefaultHoverDelegate is no longer used
+function setHoverDelegateFactory(hoverDelegateProvider) {
+    hoverDelegateFactory = hoverDelegateProvider;
+}
+// TODO: Refine type for use in new IHoverService interface
+function getDefaultHoverDelegate(placement) {
+    if (placement === 'element') {
+        return defaultHoverDelegateElement.value;
+    }
+    return defaultHoverDelegateMouse.value;
+}
+// TODO: Create equivalent in IHoverService
+function createInstantHoverDelegate() {
+    // Creates a hover delegate with instant hover enabled.
+    // This hover belongs to the consumer and requires the them to dispose it.
+    // Instant hover only makes sense for 'element' placement.
+    return hoverDelegateFactory('element', true);
+}
+
+export { createInstantHoverDelegate, getDefaultHoverDelegate, setHoverDelegateFactory };

package/dist/workers/hoverOperation.js

@@ -0,0 +1,168 @@
+import { createCancelableAsyncIterableProducer, RunOnceScheduler } from '../../../../base/common/async.js';
+import { onUnexpectedError } from '../../../../base/common/errors.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class HoverResult {
+    constructor(value, isComplete, hasLoadingMessage, options) {
+        this.value = value;
+        this.isComplete = isComplete;
+        this.hasLoadingMessage = hasLoadingMessage;
+        this.options = options;
+    }
+}
+/**
+ * Computing the hover is very fine tuned.
+ *
+ * Suppose the hover delay is 300ms (the default). Then, when resting the mouse at an anchor:
+ * - at 150ms, the async computation is triggered (i.e. semantic hover)
+ *   - if async results already come in, they are not rendered yet.
+ * - at 300ms, the sync computation is triggered (i.e. decorations, markers)
+ *   - if there are sync or async results, they are rendered.
+ * - at 900ms, if the async computation hasn't finished, a "Loading..." result is added.
+ */
+class HoverOperation extends Disposable {
+    constructor(_editor, _computer) {
+        super();
+        this._editor = _editor;
+        this._computer = _computer;
+        this._onResult = this._register(new Emitter());
+        this.onResult = this._onResult.event;
+        this._asyncComputationScheduler = this._register(new Debouncer((options) => this._triggerAsyncComputation(options), 0));
+        this._syncComputationScheduler = this._register(new Debouncer((options) => this._triggerSyncComputation(options), 0));
+        this._loadingMessageScheduler = this._register(new Debouncer((options) => this._triggerLoadingMessage(options), 0));
+        this._state = 0 /* HoverOperationState.Idle */;
+        this._asyncIterable = null;
+        this._asyncIterableDone = false;
+        this._result = [];
+    }
+    dispose() {
+        if (this._asyncIterable) {
+            this._asyncIterable.cancel();
+            this._asyncIterable = null;
+        }
+        this._options = undefined;
+        super.dispose();
+    }
+    get _hoverTime() {
+        return this._editor.getOption(69 /* EditorOption.hover */).delay;
+    }
+    get _firstWaitTime() {
+        return this._hoverTime / 2;
+    }
+    get _secondWaitTime() {
+        return this._hoverTime - this._firstWaitTime;
+    }
+    get _loadingMessageTime() {
+        return 3 * this._hoverTime;
+    }
+    _setState(state, options) {
+        this._options = options;
+        this._state = state;
+        this._fireResult(options);
+    }
+    _triggerAsyncComputation(options) {
+        this._setState(2 /* HoverOperationState.SecondWait */, options);
+        this._syncComputationScheduler.schedule(options, this._secondWaitTime);
+        if (this._computer.computeAsync) {
+            this._asyncIterableDone = false;
+            this._asyncIterable = createCancelableAsyncIterableProducer(token => this._computer.computeAsync(options, token));
+            (async () => {
+                try {
+                    for await (const item of this._asyncIterable) {
+                        if (item) {
+                            this._result.push(item);
+                            this._fireResult(options);
+                        }
+                    }
+                    this._asyncIterableDone = true;
+                    if (this._state === 3 /* HoverOperationState.WaitingForAsync */ || this._state === 4 /* HoverOperationState.WaitingForAsyncShowingLoading */) {
+                        this._setState(0 /* HoverOperationState.Idle */, options);
+                    }
+                }
+                catch (e) {
+                    onUnexpectedError(e);
+                }
+            })();
+        }
+        else {
+            this._asyncIterableDone = true;
+        }
+    }
+    _triggerSyncComputation(options) {
+        if (this._computer.computeSync) {
+            this._result = this._result.concat(this._computer.computeSync(options));
+        }
+        this._setState(this._asyncIterableDone ? 0 /* HoverOperationState.Idle */ : 3 /* HoverOperationState.WaitingForAsync */, options);
+    }
+    _triggerLoadingMessage(options) {
+        if (this._state === 3 /* HoverOperationState.WaitingForAsync */) {
+            this._setState(4 /* HoverOperationState.WaitingForAsyncShowingLoading */, options);
+        }
+    }
+    _fireResult(options) {
+        if (this._state === 1 /* HoverOperationState.FirstWait */ || this._state === 2 /* HoverOperationState.SecondWait */) {
+            // Do not send out results before the hover time
+            return;
+        }
+        const isComplete = (this._state === 0 /* HoverOperationState.Idle */);
+        const hasLoadingMessage = (this._state === 4 /* HoverOperationState.WaitingForAsyncShowingLoading */);
+        this._onResult.fire(new HoverResult(this._result.slice(0), isComplete, hasLoadingMessage, options));
+    }
+    start(mode, options) {
+        if (mode === 0 /* HoverStartMode.Delayed */) {
+            if (this._state === 0 /* HoverOperationState.Idle */) {
+                this._setState(1 /* HoverOperationState.FirstWait */, options);
+                this._asyncComputationScheduler.schedule(options, this._firstWaitTime);
+                this._loadingMessageScheduler.schedule(options, this._loadingMessageTime);
+            }
+        }
+        else {
+            switch (this._state) {
+                case 0 /* HoverOperationState.Idle */:
+                    this._triggerAsyncComputation(options);
+                    this._syncComputationScheduler.cancel();
+                    this._triggerSyncComputation(options);
+                    break;
+                case 2 /* HoverOperationState.SecondWait */:
+                    this._syncComputationScheduler.cancel();
+                    this._triggerSyncComputation(options);
+                    break;
+            }
+        }
+    }
+    cancel() {
+        this._asyncComputationScheduler.cancel();
+        this._syncComputationScheduler.cancel();
+        this._loadingMessageScheduler.cancel();
+        if (this._asyncIterable) {
+            this._asyncIterable.cancel();
+            this._asyncIterable = null;
+        }
+        this._result = [];
+        this._options = undefined;
+        this._state = 0 /* HoverOperationState.Idle */;
+    }
+    get options() {
+        return this._options;
+    }
+}
+class Debouncer extends Disposable {
+    constructor(runner, debounceTimeMs) {
+        super();
+        this._scheduler = this._register(new RunOnceScheduler(() => runner(this._options), debounceTimeMs));
+    }
+    schedule(options, debounceTimeMs) {
+        this._options = options;
+        this._scheduler.schedule(debounceTimeMs);
+    }
+    cancel() {
+        this._scheduler.cancel();
+    }
+}
+
+export { HoverOperation, HoverResult };

package/dist/workers/hoverParticipant.js

@@ -0,0 +1,161 @@
+import { $, append, reset } from '../../../../../base/browser/dom.js';
+import { MarkdownString } from '../../../../../base/common/htmlContent.js';
+import { DisposableStore } from '../../../../../base/common/lifecycle.js';
+import '../../../../../base/common/observableInternal/index.js';
+import { Range } from '../../../../common/core/range.js';
+import { HoverForeignElementAnchor, RenderedHoverParts } from '../../../hover/browser/hoverTypes.js';
+import { InlineCompletionsController } from '../controller/inlineCompletionsController.js';
+import { InlineSuggestionHintsContentWidget } from './inlineCompletionsHintsWidget.js';
+import { IMarkdownRendererService } from '../../../../../platform/markdown/browser/markdownRenderer.js';
+import { localize } from '../../../../../nls.js';
+import { IAccessibilityService } from '../../../../../platform/accessibility/common/accessibility.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { ITelemetryService } from '../../../../../platform/telemetry/common/telemetry.js';
+import { GhostTextView } from '../view/ghostText/ghostTextView.js';
+import { autorunWithStore, autorun } from '../../../../../base/common/observableInternal/reactions/autorun.js';
+import { constObservable } from '../../../../../base/common/observableInternal/observables/constObservable.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+class InlineCompletionsHover {
+    constructor(owner, range, controller) {
+        this.owner = owner;
+        this.range = range;
+        this.controller = controller;
+    }
+    isValidForHoverAnchor(anchor) {
+        return (anchor.type === 1 /* HoverAnchorType.Range */
+            && this.range.startColumn <= anchor.range.startColumn
+            && this.range.endColumn >= anchor.range.endColumn);
+    }
+}
+let InlineCompletionsHoverParticipant = class InlineCompletionsHoverParticipant {
+    constructor(_editor, accessibilityService, _instantiationService, _telemetryService, _markdownRendererService) {
+        this._editor = _editor;
+        this.accessibilityService = accessibilityService;
+        this._instantiationService = _instantiationService;
+        this._telemetryService = _telemetryService;
+        this._markdownRendererService = _markdownRendererService;
+        this.hoverOrdinal = 4;
+    }
+    suggestHoverAnchor(mouseEvent) {
+        const controller = InlineCompletionsController.get(this._editor);
+        if (!controller) {
+            return null;
+        }
+        const target = mouseEvent.target;
+        if (target.type === 8 /* MouseTargetType.CONTENT_VIEW_ZONE */) {
+            // handle the case where the mouse is over the view zone
+            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);
+            }
+        }
+        if (target.type === 7 /* MouseTargetType.CONTENT_EMPTY */) {
+            // handle the case where the mouse is over the empty portion of a line following ghost text
+            if (controller.shouldShowHoverAt(target.range)) {
+                return new HoverForeignElementAnchor(1000, this, target.range, mouseEvent.event.posx, mouseEvent.event.posy, false);
+            }
+        }
+        if (target.type === 6 /* MouseTargetType.CONTENT_TEXT */) {
+            // handle the case where the mouse is directly over ghost text
+            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);
+            }
+        }
+        if (target.type === 9 /* MouseTargetType.CONTENT_WIDGET */ && target.element) {
+            const ctx = GhostTextView.getWarningWidgetContext(target.element);
+            if (ctx && controller.shouldShowHoverAt(ctx.range)) {
+                return new HoverForeignElementAnchor(1000, this, ctx.range, mouseEvent.event.posx, mouseEvent.event.posy, false);
+            }
+        }
+        return null;
+    }
+    computeSync(anchor, lineDecorations) {
+        if (this._editor.getOption(71 /* EditorOption.inlineSuggest */).showToolbar !== 'onHover') {
+            return [];
+        }
+        const controller = InlineCompletionsController.get(this._editor);
+        if (controller && controller.shouldShowHoverAt(anchor.range)) {
+            return [new InlineCompletionsHover(this, anchor.range, controller)];
+        }
+        return [];
+    }
+    renderHoverParts(context, hoverParts) {
+        const disposables = new DisposableStore();
+        const part = hoverParts[0];
+        this._telemetryService.publicLog2('inlineCompletionHover.shown');
+        if (this.accessibilityService.isScreenReaderOptimized() && !this._editor.getOption(12 /* EditorOption.screenReaderAnnounceInlineSuggestion */)) {
+            disposables.add(this.renderScreenReaderText(context, part));
+        }
+        const model = part.controller.model.get();
+        const widgetNode = document.createElement('div');
+        context.fragment.appendChild(widgetNode);
+        disposables.add(autorunWithStore((reader, store) => {
+            const w = store.add(this._instantiationService.createInstance(InlineSuggestionHintsContentWidget.hot.read(reader), this._editor, false, constObservable(null), model.selectedInlineCompletionIndex, model.inlineCompletionsCount, model.activeCommands, model.warning, () => {
+                context.onContentsChanged();
+            }));
+            widgetNode.replaceChildren(w.getDomNode());
+        }));
+        model.triggerExplicitly();
+        const renderedHoverPart = {
+            hoverPart: part,
+            hoverElement: widgetNode,
+            dispose() { disposables.dispose(); }
+        };
+        return new RenderedHoverParts([renderedHoverPart]);
+    }
+    getAccessibleContent(hoverPart) {
+        return localize(1205, 'There are inline completions here');
+    }
+    renderScreenReaderText(context, part) {
+        const disposables = new DisposableStore();
+        const $$1 = $;
+        const markdownHoverElement = $$1('div.hover-row.markdown-hover');
+        const hoverContentsElement = append(markdownHoverElement, $$1('div.hover-contents', { ['aria-live']: 'assertive' }));
+        const render = (code) => {
+            const inlineSuggestionAvailable = localize(1206, "Suggestion:");
+            const renderedContents = disposables.add(this._markdownRendererService.render(new MarkdownString().appendText(inlineSuggestionAvailable).appendCodeblock('text', code), {
+                context: this._editor,
+                asyncRenderCallback: () => {
+                    hoverContentsElement.className = 'hover-contents code-hover-contents';
+                    context.onContentsChanged();
+                }
+            }));
+            hoverContentsElement.replaceChildren(renderedContents.element);
+        };
+        disposables.add(autorun(reader => {
+            /** @description update hover */
+            const ghostText = part.controller.model.read(reader)?.primaryGhostText.read(reader);
+            if (ghostText) {
+                const lineText = this._editor.getModel().getLineContent(ghostText.lineNumber);
+                render(ghostText.renderForScreenReader(lineText));
+            }
+            else {
+                reset(hoverContentsElement);
+            }
+        }));
+        context.fragment.appendChild(markdownHoverElement);
+        return disposables;
+    }
+};
+InlineCompletionsHoverParticipant = __decorate([
+    __param(1, IAccessibilityService),
+    __param(2, IInstantiationService),
+    __param(3, ITelemetryService),
+    __param(4, IMarkdownRendererService)
+], InlineCompletionsHoverParticipant);
+
+export { InlineCompletionsHover, InlineCompletionsHoverParticipant };