@codingame/monaco-vscode-api 20.1.1 → 20.2.1

package/vscode/src/vs/editor/contrib/gotoSymbol/browser/peek/referencesWidget.css

@@ -1,62 +1,84 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/* -- zone widget */
 .monaco-editor .zone-widget .zone-widget-container.reference-zone-widget {
 	border-top-width: 1px;
 	border-bottom-width: 1px;
 }
+
 .monaco-editor .reference-zone-widget .inline {
 	display: inline-block;
 	vertical-align: top;
 }
+
 .monaco-editor .reference-zone-widget .messages {
 	height: 100%;
 	width: 100%;
 	text-align: center;
 	padding: 3em 0;
 }
+
 .monaco-editor .reference-zone-widget .ref-tree {
 	line-height: 23px;
 	background-color: var(--vscode-peekViewResult-background);
 	color: var(--vscode-peekViewResult-lineForeground);
 }
+
 .monaco-editor .reference-zone-widget .ref-tree .reference {
 	text-overflow: ellipsis;
 	overflow: hidden;
 }
+
 .monaco-editor .reference-zone-widget .ref-tree .reference-file {
 	display: inline-flex;
 	width: 100%;
 	height: 100%;
 	color: var(--vscode-peekViewResult-fileForeground);
 }
+
 .monaco-editor .reference-zone-widget .ref-tree .monaco-list:focus .selected .reference-file {
 	color: inherit !important;
 }
+
 .monaco-editor .reference-zone-widget .ref-tree .monaco-list:focus .monaco-list-rows > .monaco-list-row.selected:not(.highlighted) {
 	background-color: var(--vscode-peekViewResult-selectionBackground);
 	color: var(--vscode-peekViewResult-selectionForeground) !important;
 }
+
 .monaco-editor .reference-zone-widget .ref-tree .reference-file .count {
 	margin-right: 12px;
 	margin-left: auto;
 }
+
 .monaco-editor .reference-zone-widget .ref-tree .referenceMatch .highlight {
 	background-color: var(--vscode-peekViewResult-matchHighlightBackground);
 }
+
 .monaco-editor .reference-zone-widget .preview .reference-decoration {
 	background-color: var(--vscode-peekViewEditor-matchHighlightBackground);
 	border: 2px solid var(--vscode-peekViewEditor-matchHighlightBorder);
 	box-sizing: border-box;
 }
+
 .monaco-editor .reference-zone-widget .preview .monaco-editor .monaco-editor-background,
 .monaco-editor .reference-zone-widget .preview .monaco-editor .inputarea.ime-input {
 	background-color: var(--vscode-peekViewEditor-background);
 }
+
 .monaco-editor .reference-zone-widget .preview .monaco-editor .margin {
 	background-color: var(--vscode-peekViewEditorGutter-background);
 }
+
+/* High Contrast Theming */
+
 .monaco-editor.hc-black .reference-zone-widget .ref-tree .reference-file,
 .monaco-editor.hc-light .reference-zone-widget .ref-tree .reference-file {
 	font-weight: bold;
 }
+
 .monaco-editor.hc-black .reference-zone-widget .ref-tree .referenceMatch .highlight,
 .monaco-editor.hc-light .reference-zone-widget .ref-tree .referenceMatch .highlight {
 	border: 1px dotted var(--vscode-contrastActiveBorder, transparent);

package/vscode/src/vs/editor/contrib/gotoSymbol/browser/peek/referencesWidget.d.ts

@@ -21,6 +21,9 @@ export interface SelectionEvent {
     readonly source: "editor" | "tree" | "title";
     readonly element?: Location;
 }
+/**
+ * ZoneWidget that is shown inside the editor
+ */
 export declare class ReferenceWidget extends PeekViewWidget {
     private _defaultTreeKeyboardSupport;
     layoutData: LayoutData;

package/vscode/src/vs/editor/contrib/hover/browser/contentHoverWidgetWrapper.d.ts

@@ -23,6 +23,9 @@ export declare class ContentHoverWidgetWrapper extends Disposable implements IHo
     constructor(_editor: ICodeEditor, _instantiationService: IInstantiationService, _keybindingService: IKeybindingService, _hoverService: IHoverService);
     private _initializeHoverParticipants;
     private _registerListeners;
+    /**
+     * Returns true if the hover shows now or will show.
+     */
     private _startShowingOrUpdateHover;
     private _startHoverOperationIfNecessary;
     private _setCurrentResult;

package/vscode/src/vs/editor/contrib/hover/browser/hover.css

@@ -1,40 +1,54 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
 .monaco-editor .hoverHighlight {
 	background-color: var(--vscode-editor-hoverHighlightBackground);
 }
+
 .monaco-editor .monaco-resizable-hover {
 	border: 1px solid var(--vscode-editorHoverWidget-border);
 	border-radius: 3px;
 	box-sizing: content-box;
 }
+
 .monaco-editor .monaco-resizable-hover > .monaco-hover {
 	border: none;
 	border-radius: none;
 }
+
 .monaco-editor .monaco-hover {
 	border: 1px solid var(--vscode-editorHoverWidget-border);
 	border-radius: 3px;
 	color: var(--vscode-editorHoverWidget-foreground);
 	background-color: var(--vscode-editorHoverWidget-background);
 }
+
 .monaco-editor .monaco-hover a {
 	color: var(--vscode-textLink-foreground);
 }
+
 .monaco-editor .monaco-hover a:hover {
 	color: var(--vscode-textLink-activeForeground);
 }
+
 .monaco-editor .monaco-hover .hover-row {
 	display: flex;
 }
+
 .monaco-editor .monaco-hover .hover-row .hover-row-contents {
 	min-width: 0;
 	display: flex;
 	flex-direction: column;
 }
+
 .monaco-editor .monaco-hover .hover-row .verbosity-actions {
 	border-right: 1px solid var(--vscode-editorHoverWidget-border);
 	width: 22px;
 	overflow-y: clip;
 }
+
 .monaco-editor .monaco-hover .hover-row .verbosity-actions-inner {
 	display: flex;
 	flex-direction: column;
@@ -43,19 +57,24 @@
 	justify-content: flex-end;
 	position: relative;
 }
+
 .monaco-editor .monaco-hover .hover-row .verbosity-actions-inner .codicon {
 	cursor: pointer;
 	font-size: 11px;
 }
+
 .monaco-editor .monaco-hover .hover-row .verbosity-actions-inner .codicon.enabled {
 	color: var(--vscode-textLink-foreground);
 }
+
 .monaco-editor .monaco-hover .hover-row .verbosity-actions-inner .codicon.disabled {
 	opacity: 0.6;
 }
+
 .monaco-editor .monaco-hover .hover-row .actions {
 	background-color: var(--vscode-editorHoverWidget-statusBarBackground);
 }
+
 .monaco-editor .monaco-hover code {
 	background-color: var(--vscode-textCodeBlock-background);
 }

package/vscode/src/vs/editor/contrib/hover/browser/hoverOperation.d.ts

@@ -3,7 +3,13 @@ import { CancellationToken } from "../../../../base/common/cancellation.js";
 import { Disposable } from "../../../../base/common/lifecycle.js";
 import { ICodeEditor } from "../../../browser/editorBrowser.js";
 export interface IHoverComputer<TArgs, TResult> {
+    /**
+     * This is called after half the hover time
+     */
     computeAsync?: (args: TArgs, token: CancellationToken) => AsyncIterableObject<TResult>;
+    /**
+     * This is called after all the hover time
+     */
     computeSync?: (args: TArgs) => TResult[];
 }
 export declare enum HoverStartMode {
@@ -22,6 +28,16 @@ export declare class HoverResult<TArgs, TResult> {
     readonly options: TArgs;
     constructor(value: TResult[], isComplete: boolean, hasLoadingMessage: boolean, options: TArgs);
 }
+/**
+ * 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.
+ */
 export declare class HoverOperation<TArgs, TResult> extends Disposable {
     private readonly _editor;
     private readonly _computer;

package/vscode/src/vs/editor/contrib/hover/browser/hoverTypes.d.ts

@@ -9,10 +9,26 @@ import { Range } from "../../../common/core/range.js";
 import { IModelDecoration } from "../../../common/model.js";
 import { HoverStartSource } from "./hoverOperation.js";
 export interface IHoverPart {
+    /**
+     * The creator of this hover part.
+     */
     readonly owner: IEditorHoverParticipant;
+    /**
+     * The range where this hover part applies.
+     */
     readonly range: Range;
+    /**
+     * Force the hover to always be rendered at this specific range,
+     * even in the case of multiple hover parts.
+     */
     readonly forceShowAtRange?: boolean;
+    /**
+     * If true, the hover item should appear before content
+     */
     readonly isBeforeContent?: boolean;
+    /**
+     * Is this hover part still valid for this new anchor?
+     */
     isValidForHoverAnchor(anchor: HoverAnchor): boolean;
 }
 export declare enum HoverAnchorType {
@@ -58,22 +74,52 @@ export interface IEditorHoverColorPickerWidget {
     layout(): void;
 }
 export interface IEditorHoverContext {
+    /**
+     * The contents rendered inside the fragment have been changed, which means that the hover should relayout.
+     */
     onContentsChanged(): void;
+    /**
+     * Set the minimum dimensions of the resizable hover
+     */
     setMinimumDimensions(dimensions: Dimension): void;
+    /**
+     * Hide the hover.
+     */
     hide(): void;
+    /**
+     * Focus the hover.
+     */
     focus(): void;
 }
 export interface IEditorHoverRenderContext extends IEditorHoverContext {
+    /**
+     * The fragment where dom elements should be attached.
+     */
     readonly fragment: DocumentFragment;
+    /**
+     * The status bar for actions for this hover.
+     */
     readonly statusBar: IEditorHoverStatusBar;
 }
 export interface IRenderedHoverPart<T extends IHoverPart> extends IDisposable {
+    /**
+     * The rendered hover part.
+     */
     hoverPart: T;
+    /**
+     * The HTML element containing the hover part.
+     */
     hoverElement: HTMLElement;
 }
 export interface IRenderedHoverParts<T extends IHoverPart> extends IDisposable {
+    /**
+     * Array of rendered hover parts.
+     */
     renderedHoverParts: IRenderedHoverPart<T>[];
 }
+/**
+ * Default implementation of IRenderedHoverParts.
+ */
 export declare class RenderedHoverParts<T extends IHoverPart> implements IRenderedHoverParts<T> {
     readonly renderedHoverParts: IRenderedHoverPart<T>[];
     private readonly disposables?;
@@ -104,6 +150,14 @@ export declare const HoverParticipantRegistry: {
     getAll(): IEditorHoverParticipantCtor[];
 };
 export interface IHoverWidget {
+    /**
+     * Returns whether the hover widget is shown or should show in the future.
+     * If the widget should show, this triggers the display.
+     * @param mouseEvent editor mouse event
+     */
     showsOrWillShow(mouseEvent: IEditorMouseEvent): boolean;
+    /**
+     * Hides the hover.
+     */
     hide(): void;
 }

package/vscode/src/vs/editor/contrib/inPlaceReplace/browser/inPlaceReplace.css

@@ -1,3 +1,9 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+
 .monaco-editor.vs .valueSetReplacement {
 	outline: solid 2px var(--vscode-editorBracketMatch-border);
 }

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/controller/inlineCompletionsController.d.ts

@@ -27,6 +27,9 @@ export declare class InlineCompletionsController extends Disposable {
     private static readonly _instances;
     static hot: import("../../../../../base/common/observable.js").IObservable<typeof InlineCompletionsController>;
     static ID: string;
+    /**
+     * Find the controller in the focused editor or in the outer editor (if applicable)
+     */
     static getInFocusedEditorOrParent(accessor: ServicesAccessor): InlineCompletionsController | null;
     static get(editor: ICodeEditor): InlineCompletionsController | null;
     private readonly _editorObs;

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/hintsWidget/inlineCompletionsHintsWidget.css

@@ -1,35 +1,47 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
 .monaco-editor .inlineSuggestionsHints {
 	padding: 4px;
+
 	.warningMessage p {
 		margin: 0;
 	}
 }
+
 .monaco-editor .inlineSuggestionsHints.withBorder {
 	z-index: 39;
 	color: var(--vscode-editorHoverWidget-foreground);
 	background-color: var(--vscode-editorHoverWidget-background);
 	border: 1px solid var(--vscode-editorHoverWidget-border);
 }
+
 .monaco-editor .inlineSuggestionsHints a {
 	color: var(--vscode-foreground) !important;
 }
+
 .monaco-editor .inlineSuggestionsHints a:hover {
 	color: var(--vscode-foreground) !important;
 }
+
 .monaco-editor .inlineSuggestionsHints .keybinding {
 	display: flex;
 	margin-left: 4px;
 	opacity: 0.6;
 }
+
 .monaco-editor .inlineSuggestionsHints .keybinding .monaco-keybinding-key {
 	font-size: 8px;
 	padding: 2px 3px;
 }
+
 .monaco-editor .inlineSuggestionsHints .availableSuggestionCount a {
 	display: flex;
 	min-width: 19px;
 	justify-content: center;
 }
+
 .monaco-editor .inlineSuggestionStatusBarItemLabel {
 	margin-right: 2px;
 }

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/model/computeGhostText.d.ts

@@ -3,5 +3,17 @@ import { Position } from "../../../../common/core/position.js";
 import { TextReplacement } from "../../../../common/core/edits/textEdit.js";
 import { ITextModel } from "../../../../common/model.js";
 import { GhostText } from "./ghostText.js";
+/**
+ * @param previewSuffixLength Sets where to split `inlineCompletion.text`.
+ * 	If the text is `hello` and the suffix length is 2, the non-preview part is `hel` and the preview-part is `lo`.
+*/
 export declare function computeGhostText(edit: TextReplacement, model: ITextModel, mode: "prefix" | "subword" | "subwordSmart", cursorPosition?: Position, previewSuffixLength?: number): GhostText | undefined;
+/**
+ * When matching `if ()` with `if (f() = 1) { g(); }`,
+ * align it like this:        `if (       )`
+ * Not like this:			  `if (  )`
+ * Also not like this:		  `if (             )`.
+ *
+ * The parenthesis are preprocessed to ensure that they match correctly.
+ */
 export declare function smartDiff(originalValue: string, newValue: string, smartBracketMatching: boolean): (readonly IDiffChange[]) | undefined;

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/model/ghostText.d.ts

@@ -6,6 +6,9 @@ export declare class GhostText {
     readonly parts: GhostTextPart[];
     constructor(lineNumber: number, parts: GhostTextPart[]);
     equals(other: GhostText): boolean;
+    /**
+     * Only used for testing/debugging.
+    */
     render(documentText: string, debug?: boolean): string;
     renderForScreenReader(lineText: string): string;
     isEmpty(): boolean;
@@ -18,10 +21,17 @@ export interface IGhostTextLine {
 export declare class GhostTextPart {
     readonly column: number;
     readonly text: string;
+    /**
+     * Indicates if this part is a preview of an inline suggestion when a suggestion is previewed.
+    */
     readonly preview: boolean;
     private _inlineDecorations;
     readonly lines: IGhostTextLine[];
-    constructor(column: number, text: string, preview: boolean, _inlineDecorations?: InlineDecoration[]);
+    constructor(column: number, text: string, 
+    /**
+     * Indicates if this part is a preview of an inline suggestion when a suggestion is previewed.
+    */
+    preview: boolean, _inlineDecorations?: InlineDecoration[]);
     equals(other: GhostTextPart): boolean;
 }
 export declare class GhostTextReplacement {

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/model/graph.d.ts

@@ -2,6 +2,9 @@ export declare class DirectedGraph<T> {
     private readonly _nodes;
     private readonly _outgoingEdges;
     static from<T>(nodes: readonly T[], getOutgoing: (node: T) => readonly T[]): DirectedGraph<T>;
+    /**
+     * After this, the graph is guaranteed to have no cycles.
+     */
     removeCycles(): {
         foundCycles: T[];
     };

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/model/inlineCompletionsSource.d.ts

@@ -55,6 +55,9 @@ declare class InlineCompletionsState extends Disposable {
     constructor(inlineCompletions: readonly InlineSuggestionItem[], request: UpdateRequest | undefined);
     private _findById;
     private _findByHash;
+    /**
+     * Applies the edit on the state.
+    */
     createStateWithAppliedEdit(edit: StringEdit, textModel: ITextModel): InlineCompletionsState;
     createStateWithAppliedResults(updatedSuggestions: InlineSuggestionItem[], request: UpdateRequest, textModel: ITextModel, cursorPosition: Position, itemIdToPreserveAtTop: InlineSuggestionIdentity | undefined): InlineCompletionsState;
     clone(): InlineCompletionsState;

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/model/inlineSuggestionItem.d.ts

@@ -19,6 +19,10 @@ declare abstract class InlineSuggestionItemBase {
     readonly identity: InlineSuggestionIdentity;
     readonly displayLocation: InlineSuggestDisplayLocation | undefined;
     constructor(_data: InlineSuggestData, identity: InlineSuggestionIdentity, displayLocation: InlineSuggestDisplayLocation | undefined);
+    /**
+     * A reference to the original inline completion list this inline completion has been constructed from.
+     * Used for event data to ensure referential equality.
+    */
     get source(): InlineSuggestionList;
     get isFromExplicitRequest(): boolean;
     get forwardStable(): boolean;
@@ -31,8 +35,13 @@ declare abstract class InlineSuggestionItemBase {
     get warning(): InlineCompletionWarning | undefined;
     get showInlineEditMenu(): boolean;
     get hash(): string;
+    /** @deprecated */
     get shownCommand(): Command | undefined;
     get requestUuid(): string;
+    /**
+     * A reference to the original inline completion this inline completion has been constructed from.
+     * Used for event data to ensure referential equality.
+    */
     private get _sourceInlineCompletion();
     abstract getSingleTextEdit(): TextReplacement;
     abstract withEdit(userEdit: StringEdit, textModel: ITextModel): InlineSuggestionItem | undefined;
@@ -46,6 +55,9 @@ declare abstract class InlineSuggestionItemBase {
     setEndOfLifeReason(reason: InlineCompletionEndOfLifeReason): void;
     reportInlineEditError(reason: string): void;
     setIsPreceeded(): void;
+    /**
+     * Avoid using this method. Instead introduce getters for the needed properties.
+    */
     getSourceCompletion(): InlineCompletion;
 }
 export declare class InlineSuggestionIdentity {

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/model/provideInlineCompletions.d.ts

@@ -12,6 +12,7 @@ import { ITextModel } from "../../../../common/model.js";
 import { InlineCompletionViewData, InlineCompletionViewKind } from "../view/inlineEdits/inlineEditsViewInterface.js";
 export type InlineCompletionContextWithoutUuid = Omit<InlineCompletionContext, "requestUuid">;
 export declare function provideInlineCompletions(providers: InlineCompletionsProvider[], position: Position, model: ITextModel, context: InlineCompletionContextWithoutUuid, requestInfo: InlineSuggestRequestInfo, languageConfigurationService?: ILanguageConfigurationService): IInlineCompletionProviderResult;
+/** If the token is eventually cancelled, this will not leak either. */
 export declare function runWhenCancelled(token: CancellationToken, callback: () => void): IDisposable;
 export interface IInlineCompletionProviderResult {
     get didAllProvidersReturn(): boolean;
@@ -59,9 +60,17 @@ export declare class InlineSuggestData {
     getSingleTextEdit(): TextReplacement;
     reportInlineEditShown(commandService: ICommandService, updatedInsertText: string, viewKind: InlineCompletionViewKind, viewData: InlineCompletionViewData): Promise<void>;
     reportPartialAccept(acceptedCharacters: number, info: PartialAcceptInfo): void;
+    /**
+     * Sends the end of life event to the provider.
+     * If no reason is provided, the last set reason is used.
+     * If no reason was set, the default reason is used.
+    */
     reportEndOfLife(reason?: InlineCompletionEndOfLifeReason): void;
     reportInlineEditError(message: string): void;
     setIsPreceeded(): void;
+    /**
+     * Sets the end of life reason, but does not send the event to the provider yet.
+    */
     setEndOfLifeReason(reason: InlineCompletionEndOfLifeReason): void;
     private updateShownDuration;
     private reportInlineEditHidden;
@@ -79,6 +88,10 @@ export declare enum InlineCompletionEditorType {
     DiffEditor = "diffEditor",
     Notebook = "notebook"
 }
+/**
+ * A ref counted pointer to the computed `InlineCompletions` and the `InlineCompletionsProvider` that
+ * computed them.
+ */
 export declare class InlineSuggestionList {
     readonly inlineSuggestions: InlineCompletions;
     readonly inlineSuggestionsData: readonly InlineSuggestData[];

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/model/typingSpeed.d.ts

@@ -4,6 +4,10 @@ interface TypingIntervalResult {
     averageInterval: number;
     characterCount: number;
 }
+/**
+ * Tracks typing speed as average milliseconds between keystrokes.
+ * Higher values indicate slower typing.
+ */
 export declare class TypingInterval extends Disposable {
     private readonly _textModel;
     private readonly _typingSessions;
@@ -16,6 +20,12 @@ export declare class TypingInterval extends Disposable {
     private static readonly SESSION_HISTORY_LIMIT;
     private static readonly TYPING_SPEED_WINDOW_MS;
     private static readonly MIN_CHARS_FOR_RELIABLE_SPEED;
+    /**
+     * Gets the current typing interval as average milliseconds between keystrokes
+     * and the number of characters involved in the computation.
+     * Higher interval values indicate slower typing.
+     * Returns { interval: 0, characterCount: 0 } if no typing data is available.
+     */
     getTypingInterval(): TypingIntervalResult;
     constructor(_textModel: ITextModel);
     private _updateTypingSpeed;
@@ -26,6 +36,9 @@ export declare class TypingInterval extends Disposable {
     private _finalizeCurrentSession;
     private _calculateTypingInterval;
     private _calculateSpeedFromSessions;
+    /**
+     * Reset all typing speed data
+     */
     reset(): void;
     dispose(): void;
 }

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/structuredLogger.d.ts

@@ -35,6 +35,9 @@ interface IFetchResult {
     isInlineEdit: boolean;
     source: string;
 }
+/**
+ * The sourceLabel must not contain '@'!
+*/
 export declare function formatRecordableLogEntry<T extends IRecordableLogEntry>(entry: T): string;
 export declare class StructuredLogger<T extends IRecordableLogEntry> extends Disposable {
     private readonly _contextKey;

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/view/ghostText/ghostTextView.css

@@ -1,36 +1,49 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
 .monaco-editor .suggest-preview-additional-widget {
 	white-space: nowrap;
 }
+
 .monaco-editor .suggest-preview-additional-widget .content-spacer {
 	color: transparent;
 	white-space: pre;
 }
+
 .monaco-editor .suggest-preview-additional-widget .button {
 	display: inline-block;
 	cursor: pointer;
 	text-decoration: underline;
 	text-underline-position: under;
 }
+
 .monaco-editor .ghost-text-hidden {
 	opacity: 0;
 	font-size: 0;
 }
+
 .monaco-editor .ghost-text-decoration,
 .monaco-editor .suggest-preview-text .ghost-text {
 	font-style: italic;
 }
+
 .monaco-editor .suggest-preview-text.clickable .view-line {
 	z-index: 1;
 }
+
 .monaco-editor .ghost-text-decoration.clickable,
 .monaco-editor .ghost-text-decoration-preview.clickable,
 .monaco-editor .suggest-preview-text.clickable .ghost-text {
 	cursor: pointer;
 }
+
 .monaco-editor .inline-completion-text-to-replace {
 	text-decoration: underline;
 	text-underline-position: under;
 }
+
 .monaco-editor .ghost-text-decoration,
 .monaco-editor .ghost-text-decoration-preview,
 .monaco-editor .suggest-preview-text .ghost-text {
@@ -43,17 +56,20 @@
 	background-color: var(--vscode-editorGhostText-background);
 	border: 1px solid var(--vscode-editorGhostText-border);
 }
+
 .monaco-editor .ghost-text-decoration.warning,
 .monaco-editor .ghost-text-decoration-preview.warning,
 .monaco-editor .suggest-preview-text .ghost-text.warning {
 	background: var(--monaco-editor-warning-decoration) repeat-x bottom left;
 	border-bottom: 4px double var(--vscode-editorWarning-border);
 }
+
 .ghost-text-view-warning-widget-icon {
 	.codicon {
 		color: var(--vscode-editorWarning-foreground) !important;
 	}
 }
+
 .monaco-editor {
 	.edits-fadeout-decoration {
 		opacity: var(--animation-opacity, 1);

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/view/inlineEdits/inlineEditsViews/inlineEditsWordReplacementView.d.ts

@@ -7,6 +7,7 @@ import { ILanguageService } from "../../../../../../common/languages/language.se
 import { IInlineEditsView, InlineEditTabAction } from "../inlineEditsViewInterface.js";
 export declare class InlineEditsWordReplacementView extends Disposable implements IInlineEditsView {
     private readonly _editor;
+    /** Must be single-line in both sides */
     private readonly _edit;
     protected readonly _tabAction: IObservable<InlineEditTabAction>;
     private readonly _languageService;
@@ -18,7 +19,9 @@ export declare class InlineEditsWordReplacementView extends Disposable implement
     private readonly _line;
     private readonly _hoverableElement;
     readonly isHovered: IObservable<boolean>;
-    constructor(_editor: ObservableCodeEditor, _edit: TextReplacement, _tabAction: IObservable<InlineEditTabAction>, _languageService: ILanguageService);
+    constructor(_editor: ObservableCodeEditor, 
+    /** Must be single-line in both sides */
+    _edit: TextReplacement, _tabAction: IObservable<InlineEditTabAction>, _languageService: ILanguageService);
     private readonly _renderTextEffect;
     private readonly _layout;
     private readonly _root;