@codingame/monaco-vscode-api 6.0.2 → 7.0.0

package/vscode/src/vs/editor/contrib/hover/browser/markdownHoverParticipant.js

@@ -1,14 +1,14 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { addDisposableListener, EventType, append, $ as $$1 } from '../../../../base/browser/dom.js';
+import { append, $ as $$1 } from '../../../../base/browser/dom.js';
 import { asArray, compareBy, numberComparator } from '../../../../base/common/arrays.js';
 import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
 import { MarkdownString, isEmptyMarkdownString } from '../../../../base/common/htmlContent.js';
-import { Disposable, toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { DisposableStore, toDisposable } from '../../../../base/common/lifecycle.js';
 import { MarkdownRenderer } from '../../../browser/widget/markdownRenderer/browser/markdownRenderer.js';
 import { DECREASE_HOVER_VERBOSITY_ACTION_ID, INCREASE_HOVER_VERBOSITY_ACTION_ID } from './hoverActionIds.js';
 import { Range } from '../../../common/core/range.js';
 import { ILanguageService } from '../../../common/languages/language.js';
-import { HoverAnchorType } from './hoverTypes.js';
+import { HoverAnchorType, RenderedHoverParts } from './hoverTypes.js';
 import { localizeWithPath } from '../../../../nls.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
 import { IOpenerService } from '../../../../platform/opener/common/opener.service.js';
@@ -26,6 +26,7 @@ import { WorkbenchHoverDelegate } from '../../../../platform/hover/browser/hover
 import { IHoverService } from '../../../../platform/hover/browser/hover.service.js';
 import { AsyncIterableObject } from '../../../../base/common/async.js';
 import { getHoverProviderResultsAsAsyncIterable } from './getHover.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.service.js';
 const _moduleId = "vs/editor/contrib/hover/browser/markdownHoverParticipant";
 const $ = $$1;
 const increaseHoverVerbosityIcon = registerIcon('hover-increase-verbosity', Codicon.add, ( localizeWithPath(_moduleId, 0, 'Icon for increaseing hover verbosity.')));
@@ -61,7 +62,7 @@ class HoverSource {
     }
 }
 let MarkdownHoverParticipant = class MarkdownHoverParticipant {
-    constructor(_editor, _languageService, _openerService, _configurationService, _languageFeaturesService, _keybindingService, _hoverService) {
+    constructor(_editor, _languageService, _openerService, _configurationService, _languageFeaturesService, _keybindingService, _hoverService, _commandService) {
         this._editor = _editor;
         this._languageService = _languageService;
         this._openerService = _openerService;
@@ -69,6 +70,7 @@ let MarkdownHoverParticipant = class MarkdownHoverParticipant {
         this._languageFeaturesService = _languageFeaturesService;
         this._keybindingService = _keybindingService;
         this._hoverService = _hoverService;
+        this._commandService = _commandService;
         this.hoverOrdinal = 3;
     }
     createLoadingMessage(anchor) {
@@ -167,9 +169,11 @@ let MarkdownHoverParticipant = class MarkdownHoverParticipant {
         this._renderedHoverParts = ( (new MarkdownRenderedHoverParts(
             hoverParts,
             context.fragment,
+            this,
             this._editor,
             this._languageService,
             this._openerService,
+            this._commandService,
             this._keybindingService,
             this._hoverService,
             this._configurationService,
@@ -177,17 +181,14 @@ let MarkdownHoverParticipant = class MarkdownHoverParticipant {
         )));
         return this._renderedHoverParts;
     }
-    markdownHoverContentAtIndex(index) {
-        return this._renderedHoverParts?.markdownHoverContentAtIndex(index) ?? '';
-    }
-    focusedMarkdownHoverIndex() {
-        return this._renderedHoverParts?.focusedMarkdownHoverIndex() ?? 1;
+    getAccessibleContent(hoverPart) {
+        return this._renderedHoverParts?.getAccessibleContent(hoverPart) ?? '';
     }
     doesMarkdownHoverAtIndexSupportVerbosityAction(index, action) {
         return this._renderedHoverParts?.doesMarkdownHoverAtIndexSupportVerbosityAction(index, action) ?? false;
     }
     updateMarkdownHoverVerbosityLevel(action, index, focus) {
-        this._renderedHoverParts?.updateMarkdownHoverPartVerbosityLevel(action, index, focus);
+        return Promise.resolve(this._renderedHoverParts?.updateMarkdownHoverPartVerbosityLevel(action, index, focus));
     }
 };
 MarkdownHoverParticipant = ( (__decorate([
@@ -196,73 +197,84 @@ MarkdownHoverParticipant = ( (__decorate([
     ( (__param(3, IConfigurationService))),
     ( (__param(4, ILanguageFeaturesService))),
     ( (__param(5, IKeybindingService))),
-    ( (__param(6, IHoverService)))
+    ( (__param(6, IHoverService))),
+    ( (__param(7, ICommandService)))
 ], MarkdownHoverParticipant)));
-class MarkdownRenderedHoverParts extends Disposable {
-    constructor(hoverParts,
-    hoverPartsContainer, _editor, _languageService, _openerService, _keybindingService, _hoverService, _configurationService, _onFinishedRendering) {
-        super();
+class RenderedMarkdownHoverPart {
+    constructor(hoverPart, hoverElement, disposables) {
+        this.hoverPart = hoverPart;
+        this.hoverElement = hoverElement;
+        this.disposables = disposables;
+    }
+    get hoverAccessibleContent() {
+        return this.hoverElement.innerText.trim();
+    }
+    dispose() {
+        this.disposables.dispose();
+    }
+}
+class MarkdownRenderedHoverParts {
+    constructor(hoverParts, hoverPartsContainer, _hoverParticipant, _editor, _languageService, _openerService, _commandService, _keybindingService, _hoverService, _configurationService, _onFinishedRendering) {
+        this._hoverParticipant = _hoverParticipant;
         this._editor = _editor;
         this._languageService = _languageService;
         this._openerService = _openerService;
+        this._commandService = _commandService;
         this._keybindingService = _keybindingService;
         this._hoverService = _hoverService;
         this._configurationService = _configurationService;
         this._onFinishedRendering = _onFinishedRendering;
-        this._focusedHoverPartIndex = -1;
         this._ongoingHoverOperations = ( (new Map()));
-        this._renderedHoverParts = this._renderHoverParts(hoverParts, hoverPartsContainer, this._onFinishedRendering);
-        this._register(toDisposable(() => {
-            this._renderedHoverParts.forEach(renderedHoverPart => {
-                renderedHoverPart.disposables.dispose();
+        this._disposables = ( (new DisposableStore()));
+        this.renderedHoverParts = this._renderHoverParts(hoverParts, hoverPartsContainer, this._onFinishedRendering);
+        this._disposables.add(toDisposable(() => {
+            this.renderedHoverParts.forEach(renderedHoverPart => {
+                renderedHoverPart.dispose();
+            });
+            this._ongoingHoverOperations.forEach(operation => {
+                operation.tokenSource.dispose(true);
             });
-        }));
-        this._register(toDisposable(() => {
-            this._ongoingHoverOperations.forEach(operation => { operation.tokenSource.dispose(true); });
         }));
     }
     _renderHoverParts(hoverParts, hoverPartsContainer, onFinishedRendering) {
         hoverParts.sort(compareBy(hover => hover.ordinal, numberComparator));
         return (
-             (hoverParts.map((hoverPart, hoverIndex) => {
-                const renderedHoverPart = this._renderHoverPart(hoverIndex, hoverPart.contents, hoverPart.source, onFinishedRendering);
-                hoverPartsContainer.appendChild(renderedHoverPart.renderedMarkdown);
+             (hoverParts.map(hoverPart => {
+                const renderedHoverPart = this._renderHoverPart(hoverPart, onFinishedRendering);
+                hoverPartsContainer.appendChild(renderedHoverPart.hoverElement);
                 return renderedHoverPart;
             }))
         );
     }
-    _renderHoverPart(hoverPartIndex, hoverContents, hoverSource, onFinishedRendering) {
-        const { renderedMarkdown, disposables } = this._renderMarkdownContent(hoverContents, onFinishedRendering);
+    _renderHoverPart(hoverPart, onFinishedRendering) {
+        const renderedMarkdownPart = this._renderMarkdownHover(hoverPart, onFinishedRendering);
+        const renderedMarkdownElement = renderedMarkdownPart.hoverElement;
+        const hoverSource = hoverPart.source;
+        const disposables = ( (new DisposableStore()));
+        disposables.add(renderedMarkdownPart);
         if (!hoverSource) {
-            return { renderedMarkdown, disposables };
+            return (
+                 (new RenderedMarkdownHoverPart(hoverPart, renderedMarkdownElement, disposables))
+            );
         }
         const canIncreaseVerbosity = hoverSource.supportsVerbosityAction(HoverVerbosityAction.Increase);
         const canDecreaseVerbosity = hoverSource.supportsVerbosityAction(HoverVerbosityAction.Decrease);
         if (!canIncreaseVerbosity && !canDecreaseVerbosity) {
-            return { renderedMarkdown, disposables, hoverSource };
+            return (
+                 (new RenderedMarkdownHoverPart(hoverPart, renderedMarkdownElement, disposables))
+            );
         }
         const actionsContainer = $('div.verbosity-actions');
-        renderedMarkdown.prepend(actionsContainer);
+        renderedMarkdownElement.prepend(actionsContainer);
         disposables.add(this._renderHoverExpansionAction(actionsContainer, HoverVerbosityAction.Increase, canIncreaseVerbosity));
         disposables.add(this._renderHoverExpansionAction(actionsContainer, HoverVerbosityAction.Decrease, canDecreaseVerbosity));
-        this._register(addDisposableListener(renderedMarkdown, EventType.FOCUS_IN, (event) => {
-            event.stopPropagation();
-            this._focusedHoverPartIndex = hoverPartIndex;
-        }));
-        this._register(addDisposableListener(renderedMarkdown, EventType.FOCUS_OUT, (event) => {
-            event.stopPropagation();
-            this._focusedHoverPartIndex = -1;
-        }));
-        return { renderedMarkdown, disposables, hoverSource };
+        return (
+             (new RenderedMarkdownHoverPart(hoverPart, renderedMarkdownElement, disposables))
+        );
     }
-    _renderMarkdownContent(markdownContent, onFinishedRendering) {
-        const renderedMarkdown = $('div.hover-row');
-        renderedMarkdown.tabIndex = 0;
-        const renderedMarkdownContents = $('div.hover-row-contents');
-        renderedMarkdown.appendChild(renderedMarkdownContents);
-        const disposables = ( (new DisposableStore()));
-        disposables.add(renderMarkdownInContainer(this._editor, renderedMarkdownContents, markdownContent, this._languageService, this._openerService, onFinishedRendering));
-        return { renderedMarkdown, disposables };
+    _renderMarkdownHover(markdownHover, onFinishedRendering) {
+        const renderedMarkdownHover = renderMarkdownInContainer(this._editor, markdownHover, this._languageService, this._openerService, onFinishedRendering);
+        return renderedMarkdownHover;
     }
     _renderHoverExpansionAction(container, action, actionEnabled) {
         const store = ( (new DisposableStore()));
@@ -276,50 +288,68 @@ class MarkdownRenderedHoverParts extends Disposable {
             this._configurationService,
             this._hoverService
         )));
-        store.add(this._hoverService.setupUpdatableHover(hoverDelegate, actionElement, labelForHoverVerbosityAction(this._keybindingService, action)));
+        store.add(this._hoverService.setupManagedHover(hoverDelegate, actionElement, labelForHoverVerbosityAction(this._keybindingService, action)));
         if (!actionEnabled) {
             actionElement.classList.add('disabled');
             return store;
         }
         actionElement.classList.add('enabled');
-        const actionFunction = () => this.updateMarkdownHoverPartVerbosityLevel(action);
+        const actionFunction = () => this._commandService.executeCommand(action === HoverVerbosityAction.Increase ? INCREASE_HOVER_VERBOSITY_ACTION_ID : DECREASE_HOVER_VERBOSITY_ACTION_ID);
         store.add(( (new ClickAction(actionElement, actionFunction))));
         store.add(( (new KeyDownAction(actionElement, actionFunction, [KeyCode.Enter, KeyCode.Space]))));
         return store;
     }
-    async updateMarkdownHoverPartVerbosityLevel(action, index = -1, focus = true) {
+    async updateMarkdownHoverPartVerbosityLevel(action, index, focus = true) {
         const model = this._editor.getModel();
         if (!model) {
-            return;
+            return undefined;
         }
-        const indexOfInterest = index !== -1 ? index : this._focusedHoverPartIndex;
-        const hoverRenderedPart = this._getRenderedHoverPartAtIndex(indexOfInterest);
-        if (!hoverRenderedPart || !hoverRenderedPart.hoverSource?.supportsVerbosityAction(action)) {
-            return;
+        const hoverRenderedPart = this._getRenderedHoverPartAtIndex(index);
+        const hoverSource = hoverRenderedPart?.hoverPart.source;
+        if (!hoverRenderedPart || !hoverSource?.supportsVerbosityAction(action)) {
+            return undefined;
         }
-        const hoverSource = hoverRenderedPart.hoverSource;
         const newHover = await this._fetchHover(hoverSource, model, action);
         if (!newHover) {
-            return;
+            return undefined;
         }
         const newHoverSource = ( (new HoverSource(newHover, hoverSource.hoverProvider, hoverSource.hoverPosition)));
-        const newHoverRenderedPart = this._renderHoverPart(indexOfInterest, newHover.contents, newHoverSource, this._onFinishedRendering);
-        this._replaceRenderedHoverPartAtIndex(indexOfInterest, newHoverRenderedPart);
+        const initialHoverPart = hoverRenderedPart.hoverPart;
+        const newHoverPart = ( (new MarkdownHover(
+            this._hoverParticipant,
+            initialHoverPart.range,
+            newHover.contents,
+            initialHoverPart.isBeforeContent,
+            initialHoverPart.ordinal,
+            newHoverSource
+        )));
+        const newHoverRenderedPart = this._renderHoverPart(newHoverPart, this._onFinishedRendering);
+        this._replaceRenderedHoverPartAtIndex(index, newHoverRenderedPart, newHoverPart);
         if (focus) {
-            this._focusOnHoverPartWithIndex(indexOfInterest);
+            this._focusOnHoverPartWithIndex(index);
         }
-        this._onFinishedRendering();
+        return {
+            hoverPart: newHoverPart,
+            hoverElement: newHoverRenderedPart.hoverElement
+        };
     }
-    markdownHoverContentAtIndex(index) {
-        const hoverRenderedPart = this._getRenderedHoverPartAtIndex(index);
-        return hoverRenderedPart?.renderedMarkdown.innerText ?? '';
-    }
-    focusedMarkdownHoverIndex() {
-        return this._focusedHoverPartIndex;
+    getAccessibleContent(hoverPart) {
+        const renderedHoverPartIndex = this.renderedHoverParts.findIndex(renderedHoverPart => renderedHoverPart.hoverPart === hoverPart);
+        if (renderedHoverPartIndex === -1) {
+            return undefined;
+        }
+        const renderedHoverPart = this._getRenderedHoverPartAtIndex(renderedHoverPartIndex);
+        if (!renderedHoverPart) {
+            return undefined;
+        }
+        const hoverElementInnerText = renderedHoverPart.hoverElement.innerText;
+        const accessibleContent = hoverElementInnerText.replace(/[^\S\n\r]+/gu, ' ');
+        return accessibleContent;
     }
     doesMarkdownHoverAtIndexSupportVerbosityAction(index, action) {
         const hoverRenderedPart = this._getRenderedHoverPartAtIndex(index);
-        if (!hoverRenderedPart || !hoverRenderedPart.hoverSource?.supportsVerbosityAction(action)) {
+        const hoverSource = hoverRenderedPart?.hoverPart.source;
+        if (!hoverRenderedPart || !hoverSource?.supportsVerbosityAction(action)) {
             return false;
         }
         return true;
@@ -346,49 +376,67 @@ class MarkdownRenderedHoverParts extends Disposable {
         this._ongoingHoverOperations.delete(provider);
         return hover;
     }
-    _replaceRenderedHoverPartAtIndex(index, renderedHoverPart) {
-        if (index >= this._renderHoverParts.length || index < 0) {
+    _replaceRenderedHoverPartAtIndex(index, renderedHoverPart, hoverPart) {
+        if (index >= this.renderedHoverParts.length || index < 0) {
             return;
         }
-        const currentRenderedHoverPart = this._renderedHoverParts[index];
-        const currentRenderedMarkdown = currentRenderedHoverPart.renderedMarkdown;
-        currentRenderedMarkdown.replaceWith(renderedHoverPart.renderedMarkdown);
-        currentRenderedHoverPart.disposables.dispose();
-        this._renderedHoverParts[index] = renderedHoverPart;
+        const currentRenderedHoverPart = this.renderedHoverParts[index];
+        const currentRenderedMarkdown = currentRenderedHoverPart.hoverElement;
+        const renderedMarkdown = renderedHoverPart.hoverElement;
+        const renderedChildrenElements = Array.from(renderedMarkdown.children);
+        currentRenderedMarkdown.replaceChildren(...renderedChildrenElements);
+        const newRenderedHoverPart = ( (new RenderedMarkdownHoverPart(hoverPart, currentRenderedMarkdown, renderedHoverPart.disposables)));
+        currentRenderedMarkdown.focus();
+        currentRenderedHoverPart.dispose();
+        this.renderedHoverParts[index] = newRenderedHoverPart;
     }
     _focusOnHoverPartWithIndex(index) {
-        this._renderedHoverParts[index].renderedMarkdown.focus();
+        this.renderedHoverParts[index].hoverElement.focus();
     }
     _getRenderedHoverPartAtIndex(index) {
-        return this._renderedHoverParts[index];
+        return this.renderedHoverParts[index];
+    }
+    dispose() {
+        this._disposables.dispose();
     }
 }
-function renderMarkdownHovers(context, hoverParts, editor, languageService, openerService) {
-    hoverParts.sort(compareBy(hover => hover.ordinal, numberComparator));
-    const disposables = ( (new DisposableStore()));
-    for (const hoverPart of hoverParts) {
-        disposables.add(renderMarkdownInContainer(editor, context.fragment, hoverPart.contents, languageService, openerService, context.onContentsChanged));
+function renderMarkdownHovers(context, markdownHovers, editor, languageService, openerService) {
+    markdownHovers.sort(compareBy(hover => hover.ordinal, numberComparator));
+    const renderedHoverParts = [];
+    for (const markdownHover of markdownHovers) {
+        renderedHoverParts.push(renderMarkdownInContainer(editor, markdownHover, languageService, openerService, context.onContentsChanged));
     }
-    return disposables;
+    return (
+         (new RenderedHoverParts(renderedHoverParts))
+    );
 }
-function renderMarkdownInContainer(editor, container, markdownStrings, languageService, openerService, onFinishedRendering) {
-    const store = ( (new DisposableStore()));
-    for (const contents of markdownStrings) {
-        if (isEmptyMarkdownString(contents)) {
+function renderMarkdownInContainer(editor, markdownHover, languageService, openerService, onFinishedRendering) {
+    const disposables = ( (new DisposableStore()));
+    const renderedMarkdown = $('div.hover-row');
+    const renderedMarkdownContents = $('div.hover-row-contents');
+    renderedMarkdown.appendChild(renderedMarkdownContents);
+    const markdownStrings = markdownHover.contents;
+    for (const markdownString of markdownStrings) {
+        if (isEmptyMarkdownString(markdownString)) {
             continue;
         }
         const markdownHoverElement = $('div.markdown-hover');
         const hoverContentsElement = append(markdownHoverElement, $('div.hover-contents'));
-        const renderer = store.add(( (new MarkdownRenderer({ editor }, languageService, openerService))));
-        store.add(renderer.onDidRenderAsync(() => {
+        const renderer = disposables.add(( (new MarkdownRenderer({ editor }, languageService, openerService))));
+        disposables.add(renderer.onDidRenderAsync(() => {
             hoverContentsElement.className = 'hover-contents code-hover-contents';
             onFinishedRendering();
         }));
-        const renderedContents = store.add(renderer.render(contents));
+        const renderedContents = disposables.add(renderer.render(markdownString));
         hoverContentsElement.appendChild(renderedContents.element);
-        container.appendChild(markdownHoverElement);
+        renderedMarkdownContents.appendChild(markdownHoverElement);
     }
-    return store;
+    const renderedHoverPart = {
+        hoverPart: markdownHover,
+        hoverElement: renderedMarkdown,
+        dispose() { disposables.dispose(); }
+    };
+    return renderedHoverPart;
 }
 function labelForHoverVerbosityAction(keybindingService, action) {
     switch (action) {

package/vscode/src/vs/editor/contrib/hover/browser/markerHoverParticipant.js

@@ -14,7 +14,7 @@ import { quickFixCommandId, getCodeActions } from '../../codeAction/browser/code
 import { CodeActionController } from '../../codeAction/browser/codeActionController.js';
 import { CodeActionKind, CodeActionTriggerSource } from '../../codeAction/common/types.js';
 import { MarkerController, NextMarkerAction } from '../../gotoError/browser/gotoError.js';
-import { HoverAnchorType } from './hoverTypes.js';
+import { HoverAnchorType, RenderedHoverParts } from './hoverTypes.js';
 import { localizeWithPath } from '../../../../nls.js';
 import { MarkerSeverity, IMarkerData } from '../../../../platform/markers/common/markers.js';
 import { IOpenerService } from '../../../../platform/opener/common/opener.service.js';
@@ -74,17 +74,29 @@ let MarkerHoverParticipant = class MarkerHoverParticipant {
     }
     renderHoverParts(context, hoverParts) {
         if (!hoverParts.length) {
-            return Disposable.None;
+            return (
+                 (new RenderedHoverParts([]))
+            );
         }
         const disposables = ( (new DisposableStore()));
-        hoverParts.forEach(msg => context.fragment.appendChild(this.renderMarkerHover(msg, disposables)));
+        const renderedHoverParts = [];
+        hoverParts.forEach(hoverPart => {
+            const renderedMarkerHover = this._renderMarkerHover(hoverPart);
+            context.fragment.appendChild(renderedMarkerHover.hoverElement);
+            renderedHoverParts.push(renderedMarkerHover);
+        });
         const markerHoverForStatusbar = hoverParts.length === 1 ? hoverParts[0] : hoverParts.sort((a, b) => MarkerSeverity.compare(a.marker.severity, b.marker.severity))[0];
         this.renderMarkerStatusbar(context, markerHoverForStatusbar, disposables);
-        return disposables;
+        return (
+             (new RenderedHoverParts(renderedHoverParts))
+        );
+    }
+    getAccessibleContent(hoverPart) {
+        return hoverPart.marker.message;
     }
-    renderMarkerHover(markerHover, disposables) {
+    _renderMarkerHover(markerHover) {
+        const disposables = ( (new DisposableStore()));
         const hoverElement = $('div.hover-row');
-        hoverElement.tabIndex = 0;
         const markerElement = append(hoverElement, $('div.marker.hover-contents'));
         const { source, message, code, relatedInformation } = markerHover.marker;
         this._editor.applyFontInfo(markerElement);
@@ -140,7 +152,12 @@ let MarkerHoverParticipant = class MarkerHoverParticipant {
                 this._editor.applyFontInfo(messageElement);
             }
         }
-        return hoverElement;
+        const renderedHoverPart = {
+            hoverPart: markerHover,
+            hoverElement,
+            dispose: () => disposables.dispose()
+        };
+        return renderedHoverPart;
     }
     renderMarkerStatusbar(context, markerHover, disposables) {
         if (markerHover.marker.severity === MarkerSeverity.Error || markerHover.marker.severity === MarkerSeverity.Warning || markerHover.marker.severity === MarkerSeverity.Info) {

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

@@ -337,6 +337,10 @@ let AutoIndentOnPaste = class AutoIndentOnPaste {
         if (!model) {
             return;
         }
+        const containsOnlyWhitespace = this.rangeContainsOnlyWhitespaceCharacters(model, range);
+        if (containsOnlyWhitespace) {
+            return;
+        }
         if (isStartOrEndInString(model, range)) {
             return;
         }
@@ -378,7 +382,7 @@ let AutoIndentOnPaste = class AutoIndentOnPaste {
                         range: ( (new Range(startLineNumber, 1, startLineNumber, oldIndentation.length + 1))),
                         text: newIndent
                     });
-                    firstLineText = newIndent + firstLineText.substr(oldIndentation.length);
+                    firstLineText = newIndent + firstLineText.substring(oldIndentation.length);
                 }
                 else {
                     const indentMetadata = getIndentMetadata(model, startLineNumber, this._languageConfigurationService);
@@ -447,6 +451,37 @@ let AutoIndentOnPaste = class AutoIndentOnPaste {
             this.editor.pushUndoStop();
         }
     }
+    rangeContainsOnlyWhitespaceCharacters(model, range) {
+        const lineContainsOnlyWhitespace = (content) => {
+            return content.trim().length === 0;
+        };
+        let containsOnlyWhitespace = true;
+        if (range.startLineNumber === range.endLineNumber) {
+            const lineContent = model.getLineContent(range.startLineNumber);
+            const linePart = lineContent.substring(range.startColumn - 1, range.endColumn - 1);
+            containsOnlyWhitespace = lineContainsOnlyWhitespace(linePart);
+        }
+        else {
+            for (let i = range.startLineNumber; i <= range.endLineNumber; i++) {
+                const lineContent = model.getLineContent(i);
+                if (i === range.startLineNumber) {
+                    const linePart = lineContent.substring(range.startColumn - 1);
+                    containsOnlyWhitespace = lineContainsOnlyWhitespace(linePart);
+                }
+                else if (i === range.endLineNumber) {
+                    const linePart = lineContent.substring(0, range.endColumn - 1);
+                    containsOnlyWhitespace = lineContainsOnlyWhitespace(linePart);
+                }
+                else {
+                    containsOnlyWhitespace = model.getLineFirstNonWhitespaceColumn(i) === 0;
+                }
+                if (!containsOnlyWhitespace) {
+                    break;
+                }
+            }
+        }
+        return containsOnlyWhitespace;
+    }
     shouldIgnoreLine(model, lineNumber) {
         model.tokenization.forceTokenization(lineNumber);
         const nonWhitespaceColumn = model.getLineFirstNonWhitespaceColumn(lineNumber);

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

@@ -20,6 +20,7 @@ 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';
+import { ICommandService } from '../../../../platform/commands/common/commands.service.js';
 const _moduleId = "vs/editor/contrib/inlayHints/browser/inlayHintsHover";
 class InlayHintsHoverAnchor extends HoverForeignElementAnchor {
     constructor(part, owner, initialMousePosX, initialMousePosY) {
@@ -28,8 +29,8 @@ class InlayHintsHoverAnchor extends HoverForeignElementAnchor {
     }
 }
 let InlayHintsHover = class InlayHintsHover extends MarkdownHoverParticipant {
-    constructor(editor, languageService, openerService, keybindingService, hoverService, configurationService, _resolverService, languageFeaturesService) {
-        super(editor, languageService, openerService, configurationService, languageFeaturesService, keybindingService, hoverService);
+    constructor(editor, languageService, openerService, keybindingService, hoverService, configurationService, _resolverService, languageFeaturesService, commandService) {
+        super(editor, languageService, openerService, configurationService, languageFeaturesService, keybindingService, hoverService, commandService);
         this._resolverService = _resolverService;
         this.hoverOrdinal = 6;
     }
@@ -153,6 +154,7 @@ InlayHintsHover = ( (__decorate([
     ( (__param(4, IHoverService))),
     ( (__param(5, IConfigurationService))),
     ( (__param(6, ITextModelService))),
-    ( (__param(7, ILanguageFeaturesService)))
+    ( (__param(7, ILanguageFeaturesService))),
+    ( (__param(8, ICommandService)))
 ], InlayHintsHover)));
 export { InlayHintsHover };

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

@@ -31,7 +31,7 @@ let GhostTextWidget = class GhostTextWidget extends Disposable {
         this.model = model;
         this.languageService = languageService;
         this.isDisposed = observableValue(this, false);
-        this.currentTextModel = observableFromEvent(this.editor.onDidChangeModel, () =>  this.editor.getModel());
+        this.currentTextModel = observableFromEvent(this, this.editor.onDidChangeModel, () =>  this.editor.getModel());
         this.uiState = derived(this, reader => {
             if (this.isDisposed.read(reader)) {
                 return undefined;

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

@@ -11,7 +11,7 @@ import { MouseTargetType } from '../../../browser/editorBrowser.js';
 import { EditorOption } from '../../../common/config/editorOptions.js';
 import { Range } from '../../../common/core/range.js';
 import { ILanguageService } from '../../../common/languages/language.js';
-import { HoverForeignElementAnchor, HoverAnchorType } from '../../hover/browser/hoverTypes.js';
+import { HoverForeignElementAnchor, RenderedHoverParts, HoverAnchorType } from '../../hover/browser/hoverTypes.js';
 import { InlineCompletionsController } from './inlineCompletionsController.js';
 import { InlineSuggestionHintsContentWidget } from './inlineCompletionsHintsWidget.js';
 import { MarkdownRenderer } from '../../../browser/widget/markdownRenderer/browser/markdownRenderer.js';
@@ -106,34 +106,46 @@ let InlineCompletionsHoverParticipant = class InlineCompletionsHoverParticipant
         return [];
     }
     renderHoverParts(context, hoverParts) {
-        const disposableStore = ( (new DisposableStore()));
+        const disposables = ( (new DisposableStore()));
         const part = hoverParts[0];
         this._telemetryService.publicLog2('inlineCompletionHover.shown');
         if (this.accessibilityService.isScreenReaderOptimized() && !this._editor.getOption(EditorOption.screenReaderAnnounceInlineSuggestion)) {
-            this.renderScreenReaderText(context, part, disposableStore);
+            disposables.add(this.renderScreenReaderText(context, part));
         }
         const model = part.controller.model.get();
         const w = this._instantiationService.createInstance(InlineSuggestionHintsContentWidget, this._editor, false, constObservable(null), model.selectedInlineCompletionIndex, model.inlineCompletionsCount, model.activeCommands);
-        context.fragment.appendChild(w.getDomNode());
+        const widgetNode = w.getDomNode();
+        context.fragment.appendChild(widgetNode);
         model.triggerExplicitly();
-        disposableStore.add(w);
-        return disposableStore;
+        disposables.add(w);
+        const renderedHoverPart = {
+            hoverPart: part,
+            hoverElement: widgetNode,
+            dispose() { disposables.dispose(); }
+        };
+        return (
+             (new RenderedHoverParts([renderedHoverPart]))
+        );
+    }
+    getAccessibleContent(hoverPart) {
+        return ( localizeWithPath(_moduleId, 0, 'There are inline completions here'));
     }
-    renderScreenReaderText(context, part, disposableStore) {
+    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 renderer = disposableStore.add(( (new MarkdownRenderer({ editor: this._editor }, this._languageService, this._openerService))));
+        const renderer = disposables.add(( (new MarkdownRenderer({ editor: this._editor }, this._languageService, this._openerService))));
         const render = (code) => {
-            disposableStore.add(renderer.onDidRenderAsync(() => {
+            disposables.add(renderer.onDidRenderAsync(() => {
                 hoverContentsElement.className = 'hover-contents code-hover-contents';
                 context.onContentsChanged();
             }));
-            const inlineSuggestionAvailable = ( localizeWithPath(_moduleId, 0, "Suggestion:"));
-            const renderedContents = disposableStore.add(renderer.render(( (new MarkdownString())).appendText(inlineSuggestionAvailable).appendCodeblock('text', code)));
+            const inlineSuggestionAvailable = ( localizeWithPath(_moduleId, 1, "Suggestion:"));
+            const renderedContents = disposables.add(renderer.render(( (new MarkdownString())).appendText(inlineSuggestionAvailable).appendCodeblock('text', code)));
             hoverContentsElement.replaceChildren(renderedContents.element);
         };
-        disposableStore.add(autorun(reader => {
+        disposables.add(autorun(reader => {
             const ghostText = part.controller.model.read(reader)?.primaryGhostText.read(reader);
             if (ghostText) {
                 const lineText = this._editor.getModel().getLineContent(ghostText.lineNumber);
@@ -144,6 +156,7 @@ let InlineCompletionsHoverParticipant = class InlineCompletionsHoverParticipant
             }
         }));
         context.fragment.appendChild(markdownHoverElement);
+        return disposables;
     }
 };
 InlineCompletionsHoverParticipant = ( (__decorate([