monaco-editor 0.56.0-dev-20260120 → 0.56.0-dev-20260121

package/esm/vs/editor/common/model/textModel.js

@@ -1351,15 +1351,15 @@ let TextModel = class TextModel extends Disposable {
         const endColumn = this.getLineMaxColumn(endLineNumber);
         const range = new Range(startLineNumber, 1, endLineNumber, endColumn);
         const decorations = this._getDecorationsInRange(range, ownerId, filterOutValidation, filterFontDecorations, onlyMarginDecorations);
-        pushMany(decorations, this._decorationProvider.getDecorationsInRange(range, ownerId, filterOutValidation));
-        pushMany(decorations, this._fontTokenDecorationsProvider.getDecorationsInRange(range, ownerId, filterOutValidation));
+        pushMany(decorations, this._decorationProvider.getDecorationsInRange(range, ownerId, filterOutValidation, filterFontDecorations));
+        pushMany(decorations, this._fontTokenDecorationsProvider.getDecorationsInRange(range, ownerId, filterOutValidation, filterFontDecorations));
         return decorations;
     }
     getDecorationsInRange(range, ownerId = 0, filterOutValidation = false, filterFontDecorations = false, onlyMinimapDecorations = false, onlyMarginDecorations = false) {
         const validatedRange = this.validateRange(range);
         const decorations = this._getDecorationsInRange(validatedRange, ownerId, filterOutValidation, filterFontDecorations, onlyMarginDecorations);
-        pushMany(decorations, this._decorationProvider.getDecorationsInRange(validatedRange, ownerId, filterOutValidation, onlyMinimapDecorations));
-        pushMany(decorations, this._fontTokenDecorationsProvider.getDecorationsInRange(validatedRange, ownerId, filterOutValidation, onlyMinimapDecorations));
+        pushMany(decorations, this._decorationProvider.getDecorationsInRange(validatedRange, ownerId, filterOutValidation, filterFontDecorations, onlyMinimapDecorations));
+        pushMany(decorations, this._fontTokenDecorationsProvider.getDecorationsInRange(validatedRange, ownerId, filterOutValidation, filterFontDecorations, onlyMinimapDecorations));
         return decorations;
     }
     getOverviewRulerDecorations(ownerId = 0, filterOutValidation = false, filterFontDecorations = false) {

package/esm/vs/editor/common/model/tokens/tokenizationFontDecorationsProvider.js

@@ -94,29 +94,33 @@ class TokenizationFontDecorationProvider extends Disposable {
         this._onDidChangeLineHeight.fire(affectedLineHeights);
         this._onDidChangeFont.fire(affectedLineFonts);
     }
-    getDecorationsInRange(range, ownerId, filterOutValidation, onlyMinimapDecorations) {
+    getDecorationsInRange(range, ownerId, filterOutValidation, filterFontDecorations, onlyMinimapDecorations) {
         const startOffsetOfRange = this.textModel.getOffsetAt(range.getStartPosition());
         const endOffsetOfRange = this.textModel.getOffsetAt(range.getEndPosition());
         const annotations = this._fontAnnotatedString.getAnnotationsIntersecting(new OffsetRange(startOffsetOfRange, endOffsetOfRange));
         const decorations = [];
         for (const annotation of annotations) {
-            const annotationStartPosition = this.textModel.getPositionAt(annotation.range.start);
-            const annotationEndPosition = this.textModel.getPositionAt(annotation.range.endExclusive);
-            const range = Range.fromPositions(annotationStartPosition, annotationEndPosition);
             const anno = annotation.annotation;
-            const className = classNameForFontTokenDecorations(anno.fontToken.fontFamily ?? '', anno.fontToken.fontSizeMultiplier ?? 0);
             const affectsFont = !!(anno.fontToken.fontFamily || anno.fontToken.fontSizeMultiplier);
-            const id = anno.decorationId;
-            decorations.push({
-                id: id,
-                options: {
-                    description: 'FontOptionDecoration',
-                    inlineClassName: className,
-                    affectsFont
-                },
-                ownerId: 0,
-                range
-            });
+            if (!(affectsFont && filterFontDecorations)) {
+                const annotationStartPosition = this.textModel.getPositionAt(annotation.range.start);
+                const annotationEndPosition = this.textModel.getPositionAt(annotation.range.endExclusive);
+                const range = Range.fromPositions(annotationStartPosition, annotationEndPosition);
+                const anno = annotation.annotation;
+                const className = classNameForFontTokenDecorations(anno.fontToken.fontFamily ?? '', anno.fontToken.fontSizeMultiplier ?? 0);
+                const id = anno.decorationId;
+                decorations.push({
+                    id: id,
+                    options: {
+                        description: 'FontOptionDecoration',
+                        inlineClassName: className,
+                        lineHeight: anno.fontToken.lineHeightMultiplier,
+                        affectsFont
+                    },
+                    ownerId: 0,
+                    range
+                });
+            }
         }
         return decorations;
     }

package/esm/vs/editor/common/viewModel/viewModelDecorations.js

@@ -84,10 +84,11 @@ class ViewModelDecorations {
         const decorationsInViewport = [];
         let decorationsInViewportLen = 0;
         const inlineDecorations = [];
+        const hasVariableFonts = [];
         for (let j = startLineNumber; j <= endLineNumber; j++) {
             inlineDecorations[j - startLineNumber] = [];
+            hasVariableFonts[j - startLineNumber] = false;
         }
-        let hasVariableFonts = false;
         for (let i = 0, len = modelDecorations.length; i < len; i++) {
             const modelDecoration = modelDecorations[i];
             const decorationOptions = modelDecoration.options;
@@ -103,23 +104,29 @@ class ViewModelDecorations {
                 const intersectedEndLineNumber = Math.min(endLineNumber, viewRange.endLineNumber);
                 for (let j = intersectedStartLineNumber; j <= intersectedEndLineNumber; j++) {
                     inlineDecorations[j - startLineNumber].push(inlineDecoration);
+                    if (decorationOptions.affectsFont) {
+                        hasVariableFonts[j - startLineNumber] = true;
+                    }
                 }
             }
             if (decorationOptions.beforeContentClassName) {
                 if (startLineNumber <= viewRange.startLineNumber && viewRange.startLineNumber <= endLineNumber) {
                     const inlineDecoration = new InlineDecoration(new Range(viewRange.startLineNumber, viewRange.startColumn, viewRange.startLineNumber, viewRange.startColumn), decorationOptions.beforeContentClassName, 1 /* InlineDecorationType.Before */);
                     inlineDecorations[viewRange.startLineNumber - startLineNumber].push(inlineDecoration);
+                    if (decorationOptions.affectsFont) {
+                        hasVariableFonts[viewRange.startLineNumber - startLineNumber] = true;
+                    }
                 }
             }
             if (decorationOptions.afterContentClassName) {
                 if (startLineNumber <= viewRange.endLineNumber && viewRange.endLineNumber <= endLineNumber) {
                     const inlineDecoration = new InlineDecoration(new Range(viewRange.endLineNumber, viewRange.endColumn, viewRange.endLineNumber, viewRange.endColumn), decorationOptions.afterContentClassName, 2 /* InlineDecorationType.After */);
                     inlineDecorations[viewRange.endLineNumber - startLineNumber].push(inlineDecoration);
+                    if (decorationOptions.affectsFont) {
+                        hasVariableFonts[viewRange.endLineNumber - startLineNumber] = true;
+                    }
                 }
             }
-            if (decorationOptions.affectsFont) {
-                hasVariableFonts = true;
-            }
         }
         return {
             decorations: decorationsInViewport,

package/esm/vs/editor/common/viewModel/viewModelImpl.js

@@ -105,6 +105,9 @@ class ViewModel extends Disposable {
         this._viewportStart.dispose();
         this._eventDispatcher.dispose();
     }
+    getEditorOption(id) {
+        return this._configuration.options.get(id);
+    }
     createLineBreaksComputer() {
         return this._lines.createLineBreaksComputer();
     }
@@ -119,6 +122,7 @@ class ViewModel extends Disposable {
         if (!allowVariableLineHeights) {
             return [];
         }
+        const defaultLineHeight = this._configuration.options.get(75 /* EditorOption.lineHeight */);
         const decorations = this.model.getCustomLineHeightsDecorations(this._editorId);
         return decorations.map((d) => {
             const lineNumber = d.range.startLineNumber;
@@ -127,7 +131,7 @@ class ViewModel extends Disposable {
                 decorationId: d.id,
                 startLineNumber: viewRange.startLineNumber,
                 endLineNumber: viewRange.endLineNumber,
-                lineHeight: d.options.lineHeight || 0
+                lineHeight: d.options.lineHeight ? d.options.lineHeight * defaultLineHeight : 0
             };
         });
     }
@@ -665,12 +669,14 @@ class ViewModel extends Disposable {
     }
     getViewportViewLineRenderingData(visibleRange, lineNumber) {
         const viewportDecorationsCollection = this._decorations.getDecorationsViewportData(visibleRange);
-        const inlineDecorations = viewportDecorationsCollection.inlineDecorations[lineNumber - visibleRange.startLineNumber];
-        return this._getViewLineRenderingData(lineNumber, inlineDecorations, viewportDecorationsCollection.hasVariableFonts, viewportDecorationsCollection.decorations);
+        const relativeLineNumber = lineNumber - visibleRange.startLineNumber;
+        const inlineDecorations = viewportDecorationsCollection.inlineDecorations[relativeLineNumber];
+        const hasVariableFonts = viewportDecorationsCollection.hasVariableFonts[relativeLineNumber];
+        return this._getViewLineRenderingData(lineNumber, inlineDecorations, hasVariableFonts, viewportDecorationsCollection.decorations);
     }
     getViewLineRenderingData(lineNumber) {
         const decorationsCollection = this._decorations.getDecorationsOnLine(lineNumber);
-        return this._getViewLineRenderingData(lineNumber, decorationsCollection.inlineDecorations[0], decorationsCollection.hasVariableFonts, decorationsCollection.decorations);
+        return this._getViewLineRenderingData(lineNumber, decorationsCollection.inlineDecorations[0], decorationsCollection.hasVariableFonts[0], decorationsCollection.decorations);
     }
     _getViewLineRenderingData(lineNumber, inlineDecorations, hasVariableFonts, decorations) {
         const mightContainRTL = this.model.mightContainRTL();
@@ -765,33 +771,38 @@ class ViewModel extends Disposable {
         }
         if (!hasNonEmptyRange && !emptySelectionClipboard) {
             // all ranges are empty
-            return '';
+            return { sourceRanges: [], sourceText: '' };
         }
+        const ranges = [];
+        const result = [];
+        const pushRange = (modelRange, append = '') => {
+            ranges.push(modelRange);
+            result.push(this.model.getValueInRange(modelRange, forceCRLF ? 2 /* EndOfLinePreference.CRLF */ : 0 /* EndOfLinePreference.TextDefined */) + append);
+        };
         if (hasEmptyRange && emptySelectionClipboard) {
             // some (maybe all) empty selections
-            const result = [];
             let prevModelLineNumber = 0;
             for (const modelRange of modelRanges) {
                 const modelLineNumber = modelRange.startLineNumber;
                 if (modelRange.isEmpty()) {
                     if (modelLineNumber !== prevModelLineNumber) {
-                        result.push(this.model.getLineContent(modelLineNumber) + newLineCharacter);
+                        pushRange(new Range(modelLineNumber, this.model.getLineMinColumn(modelLineNumber), modelLineNumber, this.model.getLineMaxColumn(modelLineNumber)), newLineCharacter);
                     }
                 }
                 else {
-                    result.push(this.model.getValueInRange(modelRange, forceCRLF ? 2 /* EndOfLinePreference.CRLF */ : 0 /* EndOfLinePreference.TextDefined */));
+                    pushRange(modelRange);
                 }
                 prevModelLineNumber = modelLineNumber;
             }
-            return result.length === 1 ? result[0] : result;
         }
-        const result = [];
-        for (const modelRange of modelRanges) {
-            if (!modelRange.isEmpty()) {
-                result.push(this.model.getValueInRange(modelRange, forceCRLF ? 2 /* EndOfLinePreference.CRLF */ : 0 /* EndOfLinePreference.TextDefined */));
+        else {
+            for (const modelRange of modelRanges) {
+                if (!modelRange.isEmpty()) {
+                    pushRange(modelRange);
+                }
             }
         }
-        return result.length === 1 ? result[0] : result;
+        return { sourceRanges: ranges, sourceText: result.length === 1 ? result[0] : result };
     }
     getRichTextToCopy(modelRanges, emptySelectionClipboard) {
         const languageId = this.model.getLanguageId();

package/esm/vs/editor/contrib/clipboard/browser/clipboard.js

@@ -180,7 +180,7 @@ function executeClipboardCopyWithWorkaround(editor, clipboardService) {
         // We have encountered the Electron bug!
         // As a workaround, we will write (only the plaintext data) to the clipboard in a different way
         // We will use the clipboard service (which in the native case will go to electron's clipboard API)
-        const { dataToCopy } = generateDataToCopyAndStoreInMemory(editor._getViewModel(), editor.getOptions(), undefined, isFirefox);
+        const { dataToCopy } = generateDataToCopyAndStoreInMemory(editor._getViewModel(), undefined, isFirefox);
         clipboardService.writeText(dataToCopy.text);
     }
 }
@@ -241,7 +241,7 @@ function logCopyCommand(editor) {
     if (editContextEnabled) {
         const nativeEditContext = NativeEditContextRegistry.get(editor.getId());
         if (nativeEditContext) {
-            nativeEditContext.onWillCopy();
+            nativeEditContext.handleWillCopy();
         }
     }
 }
@@ -262,7 +262,7 @@ if (PasteAction) {
             if (editContextEnabled) {
                 const nativeEditContext = NativeEditContextRegistry.get(focusedEditor.getId());
                 if (nativeEditContext) {
-                    nativeEditContext.onWillPaste();
+                    nativeEditContext.handleWillPaste();
                 }
             }
             logService.trace('registerExecCommandImpl (before triggerPaste)');

package/esm/vs/editor/contrib/dropOrPasteInto/browser/copyPasteController.js

@@ -1,13 +1,11 @@
-import { addDisposableListener } from '../../../../base/browser/dom.js';
 import { coalesce } from '../../../../base/common/arrays.js';
 import { createCancelablePromise, DeferredPromise, raceCancellation } from '../../../../base/common/async.js';
 import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
-import { matchesMimeType, createStringDataTransferItem, UriList } from '../../../../base/common/dataTransfer.js';
+import { VSDataTransfer, matchesMimeType, createStringDataTransferItem, UriList } from '../../../../base/common/dataTransfer.js';
 import { isCancellationError } from '../../../../base/common/errors.js';
 import { HierarchicalKind } from '../../../../base/common/hierarchicalKind.js';
 import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
 import { Mimes } from '../../../../base/common/mime.js';
-import { isWindows } from '../../../../base/common/platform.js';
 import { upcast } from '../../../../base/common/types.js';
 import { generateUuid } from '../../../../base/common/uuid.js';
 import { localize } from '../../../../nls.js';
@@ -19,10 +17,7 @@ import { IInstantiationService } from '../../../../platform/instantiation/common
 import { ILogService } from '../../../../platform/log/common/log.js';
 import { IProgressService } from '../../../../platform/progress/common/progress.js';
 import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
-import { ClipboardEventUtils, InMemoryClipboardMetadataManager } from '../../../browser/controller/editContext/clipboardUtils.js';
-import { toVSDataTransfer, toExternalVSDataTransfer } from '../../../browser/dataTransfer.js';
 import { IBulkEditService } from '../../../browser/services/bulkEditService.js';
-import { Range } from '../../../common/core/range.js';
 import { DocumentPasteTriggerKind } from '../../../common/languages.js';
 import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
 import { EditorStateCancellationTokenSource } from '../../editorState/browser/editorState.js';
@@ -67,10 +62,9 @@ let CopyPasteController = class CopyPasteController extends Disposable {
         this._quickInputService = _quickInputService;
         this._progressService = _progressService;
         this._editor = editor;
-        const container = editor.getContainerDomNode();
-        this._register(addDisposableListener(container, 'copy', e => this.handleCopy(e)));
-        this._register(addDisposableListener(container, 'cut', e => this.handleCopy(e)));
-        this._register(addDisposableListener(container, 'paste', e => this.handlePaste(e), true));
+        this._register(editor.onWillCopy(e => this.handleCopy(e)));
+        this._register(editor.onWillCut(e => this.handleCopy(e)));
+        this._register(editor.onWillPaste(e => this.handlePaste(e)));
         this._pasteProgressManager = this._register(new InlineProgressManager('pasteIntoEditor', editor, instantiationService));
         this._postPasteWidgetManager = this._register(instantiationService.createInstance(PostEditWidgetManager, 'pasteIntoEditor', editor, pasteWidgetVisibleCtx, { id: changePasteTypeCommandId, label: localize(927, "Show paste options...") }, () => CopyPasteController_1._configureDefaultAction ? [CopyPasteController_1._configureDefaultAction] : []));
     }
@@ -99,16 +93,7 @@ let CopyPasteController = class CopyPasteController extends Disposable {
         await this._currentPasteOperation;
     }
     handleCopy(e) {
-        let id = null;
-        if (e.clipboardData) {
-            const [text, metadata] = ClipboardEventUtils.getTextData(e.clipboardData);
-            const storedMetadata = metadata || InMemoryClipboardMetadataManager.INSTANCE.get(text);
-            id = storedMetadata?.id || null;
-            this._logService.trace('CopyPasteController#handleCopy for id : ', id, ' with text.length : ', text.length);
-        }
-        else {
-            this._logService.trace('CopyPasteController#handleCopy');
-        }
+        this._logService.trace('CopyPasteController#handleCopy');
         if (!this._editor.hasTextFocus()) {
             return;
         }
@@ -116,28 +101,18 @@ let CopyPasteController = class CopyPasteController extends Disposable {
         // This is needed because on web, the browser clipboard is faked out using an in-memory store.
         // This means the resources clipboard is not properly updated when copying from the editor.
         this._clipboardService.clearInternalState?.();
-        if (!e.clipboardData || !this.isPasteAsEnabled()) {
+        if (!this.isPasteAsEnabled()) {
             return;
         }
         const model = this._editor.getModel();
+        const viewModel = this._editor._getViewModel();
         const selections = this._editor.getSelections();
-        if (!model || !selections?.length) {
+        if (!model || !viewModel || !selections?.length) {
             return;
         }
-        const enableEmptySelectionClipboard = this._editor.getOption(45 /* EditorOption.emptySelectionClipboard */);
-        let ranges = selections;
-        const wasFromEmptySelection = selections.length === 1 && selections[0].isEmpty();
-        if (wasFromEmptySelection) {
-            if (!enableEmptySelectionClipboard) {
-                return;
-            }
-            ranges = [new Range(ranges[0].startLineNumber, 1, ranges[0].startLineNumber, 1 + model.getLineLength(ranges[0].startLineNumber))];
-        }
-        const toCopy = this._editor._getViewModel()?.getPlainTextToCopy(selections, enableEmptySelectionClipboard, isWindows);
-        const multicursorText = Array.isArray(toCopy) ? toCopy : null;
         const defaultPastePayload = {
-            multicursorText,
-            pasteOnNewLine: wasFromEmptySelection,
+            multicursorText: e.dataToCopy.multicursorText ?? null,
+            pasteOnNewLine: e.dataToCopy.isFromEmptySelection,
             mode: null
         };
         const providers = this._languageFeaturesService.documentPasteEditProvider
@@ -147,10 +122,10 @@ let CopyPasteController = class CopyPasteController extends Disposable {
             this.setCopyMetadata(e.clipboardData, { defaultPastePayload });
             return;
         }
-        const dataTransfer = toVSDataTransfer(e.clipboardData);
+        const dataTransfer = new VSDataTransfer();
         const providerCopyMimeTypes = providers.flatMap(x => x.copyMimeTypes ?? []);
         // Save off a handle pointing to data that VS Code maintains.
-        const handle = id ?? generateUuid();
+        const handle = generateUuid();
         this.setCopyMetadata(e.clipboardData, {
             id: handle,
             providerCopyMimeTypes,
@@ -159,7 +134,7 @@ let CopyPasteController = class CopyPasteController extends Disposable {
         const operations = providers.map((provider) => {
             return {
                 providerMimeTypes: provider.copyMimeTypes,
-                operation: createCancelablePromise(token => provider.prepareDocumentPaste(model, ranges, dataTransfer, token)
+                operation: createCancelablePromise(token => provider.prepareDocumentPaste(model, e.dataToCopy.sourceRanges, dataTransfer, token)
                     .catch(err => {
                     console.error(err);
                     return undefined;
@@ -170,17 +145,15 @@ let CopyPasteController = class CopyPasteController extends Disposable {
         CopyPasteController_1._currentCopyOperation = { handle, operations };
     }
     async handlePaste(e) {
-        if (e.clipboardData) {
-            const [text, metadata] = ClipboardEventUtils.getTextData(e.clipboardData);
-            const metadataComputed = metadata || InMemoryClipboardMetadataManager.INSTANCE.get(text);
-            this._logService.trace('CopyPasteController#handlePaste for id : ', metadataComputed?.id);
-        }
-        else {
-            this._logService.trace('CopyPasteController#handlePaste');
+        this._logService.trace('CopyPasteController#handlePaste for id : ', e.metadata?.id);
+        if (!this._editor.hasTextFocus()) {
+            return;
         }
-        if (!e.clipboardData || !this._editor.hasTextFocus()) {
+        const dataTransfer = e.toExternalVSDataTransfer();
+        if (!dataTransfer) {
             return;
         }
+        dataTransfer.delete(vscodeClipboardMime);
         MessageController.get(this._editor)?.closeMessage();
         this._currentPasteOperation?.cancel();
         this._currentPasteOperation = undefined;
@@ -196,8 +169,6 @@ let CopyPasteController = class CopyPasteController extends Disposable {
         }
         const metadata = this.fetchCopyMetadata(e);
         this._logService.trace('CopyPasteController#handlePaste with metadata : ', metadata?.id, ' and text.length : ', e.clipboardData.getData('text/plain').length);
-        const dataTransfer = toExternalVSDataTransfer(e.clipboardData);
-        dataTransfer.delete(vscodeClipboardMime);
         const fileTypes = Array.from(e.clipboardData.files).map(file => file.type);
         const allPotentialMimeTypes = [
             ...e.clipboardData.types,
@@ -225,21 +196,19 @@ let CopyPasteController = class CopyPasteController extends Disposable {
             if (this._pasteAsActionContext?.preferred) {
                 this.showPasteAsNoEditMessage(selections, this._pasteAsActionContext.preferred);
                 // Also prevent default paste from applying
-                e.preventDefault();
-                e.stopImmediatePropagation();
+                e.setHandled();
             }
             return;
         }
         // Prevent the editor's default paste handler from running.
         // Note that after this point, we are fully responsible for handling paste.
         // If we can't provider a paste for any reason, we need to explicitly delegate pasting back to the editor.
-        e.preventDefault();
-        e.stopImmediatePropagation();
+        e.setHandled();
         if (this._pasteAsActionContext) {
             this.showPasteAsPick(this._pasteAsActionContext.preferred, allProviders, selections, dataTransfer, metadata);
         }
         else {
-            this.doPasteInline(allProviders, selections, dataTransfer, metadata, e);
+            this.doPasteInline(allProviders, selections, dataTransfer, metadata, e.browserEvent);
         }
     }
     showPasteAsNoEditMessage(selections, preference) {
@@ -432,15 +401,12 @@ let CopyPasteController = class CopyPasteController extends Disposable {
             title: localize(934, "Running paste handlers"),
         }, () => p);
     }
-    setCopyMetadata(dataTransfer, metadata) {
+    setCopyMetadata(clipboardData, metadata) {
         this._logService.trace('CopyPasteController#setCopyMetadata new id : ', metadata.id);
-        dataTransfer.setData(vscodeClipboardMime, JSON.stringify(metadata));
+        clipboardData.setData(vscodeClipboardMime, JSON.stringify(metadata));
     }
     fetchCopyMetadata(e) {
         this._logService.trace('CopyPasteController#fetchCopyMetadata');
-        if (!e.clipboardData) {
-            return;
-        }
         // Prefer using the clipboard data we saved off
         const rawMetadata = e.clipboardData.getData(vscodeClipboardMime);
         if (rawMetadata) {
@@ -451,14 +417,12 @@ let CopyPasteController = class CopyPasteController extends Disposable {
                 return undefined;
             }
         }
-        // Otherwise try to extract the generic text editor metadata
-        const [_, metadata] = ClipboardEventUtils.getTextData(e.clipboardData);
-        if (metadata) {
+        if (e.metadata) {
             return {
                 defaultPastePayload: {
-                    mode: metadata.mode,
-                    multicursorText: metadata.multicursorText ?? null,
-                    pasteOnNewLine: !!metadata.isFromEmptySelection,
+                    mode: e.metadata.mode,
+                    multicursorText: e.metadata.multicursorText ?? null,
+                    pasteOnNewLine: !!e.metadata.isFromEmptySelection,
                 },
             };
         }

package/esm/vs/editor/contrib/floatingMenu/browser/floatingMenu.css

@@ -4,41 +4,48 @@
  *--------------------------------------------------------------------------------------------*/
 
 .floating-menu-overlay-widget {
-	padding: 0px;
-	color: var(--vscode-button-foreground);
-	background-color: var(--vscode-button-background);
-	border-radius: 2px;
+	padding: 2px 4px;
+	color: var(--vscode-foreground);
+	background-color: var(--vscode-editorWidget-background);
+	border-radius: 6px;
 	border: 1px solid var(--vscode-contrastBorder);
 	display: flex;
 	align-items: center;
+	justify-content: center;
+	gap: 4px;
 	z-index: 10;
 	box-shadow: 0 2px 8px var(--vscode-widget-shadow);
 	overflow: hidden;
 
-	.action-item > .action-label {
-		padding: 5px;
-		font-size: 12px;
-		border-radius: 2px;
+	.actions-container {
+		gap: 4px;
 	}
 
-	.action-item > .action-label.codicon, .action-item .codicon {
-		color: var(--vscode-button-foreground);
+	.action-item > .action-label {
+		padding: 4px 6px;
+		font-size: 11px;
+		line-height: 14px;
+		border-radius: 4px;
 	}
 
 	.action-item > .action-label.codicon:not(.separator) {
-		padding-top: 6px;
-		padding-bottom: 6px;
+		color: var(--vscode-foreground);
+		width: 22px;
+		height: 22px;
+		padding: 0;
+		font-size: 16px;
+		line-height: 22px;
+		display: flex;
+		align-items: center;
+		justify-content: center;
 	}
 
-	.action-item:first-child > .action-label {
-		padding-left: 7px;
-	}
-
-	.action-item:last-child > .action-label {
-		padding-right: 7px;
+	.action-item.primary > .action-label {
+		background-color: var(--vscode-button-background);
+		color: var(--vscode-button-foreground);
 	}
 
-	.action-item .action-label.separator {
-		background-color: var(--vscode-button-separator);
+	.action-item.primary > .action-label:hover {
+		background-color: var(--vscode-button-hoverBackground) !important;
 	}
 }

package/esm/vs/editor/contrib/floatingMenu/browser/floatingMenu.js

@@ -8,6 +8,7 @@ import { IInstantiationService } from '../../../../platform/instantiation/common
 import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
 import { observableCodeEditor } from '../../../browser/observableCodeEditor.js';
 import { observableFromEvent } from '../../../../base/common/observableInternal/observables/observableFromEvent.js';
+import { derived } from '../../../../base/common/observableInternal/observables/derived.js';
 import { autorun } from '../../../../base/common/observableInternal/reactions/autorun.js';
 import { constObservable } from '../../../../base/common/observableInternal/observables/constObservable.js';
 
@@ -30,30 +31,57 @@ let FloatingEditorToolbar = class FloatingEditorToolbar extends Disposable {
         super();
         const editorObs = this._register(observableCodeEditor(editor));
         const menu = this._register(menuService.createMenu(MenuId.EditorContent, editor.contextKeyService));
-        const menuIsEmptyObs = observableFromEvent(this, menu.onDidChange, () => menu.getActions().length === 0);
+        const menuActionsObs = observableFromEvent(this, menu.onDidChange, () => menu.getActions());
+        const menuPrimaryActionIdObs = derived(reader => {
+            const menuActions = menuActionsObs.read(reader);
+            if (menuActions.length === 0) {
+                return undefined;
+            }
+            // Navigation group
+            const navigationGroup = menuActions
+                .find((group) => group[0] === 'navigation');
+            // First action in navigation group
+            if (navigationGroup && navigationGroup[1].length > 0) {
+                return navigationGroup[1][0].id;
+            }
+            // Fallback to first group/action
+            for (const [, actions] of menuActions) {
+                if (actions.length > 0) {
+                    return actions[0].id;
+                }
+            }
+            return undefined;
+        });
         this._register(autorun(reader => {
-            const menuIsEmpty = menuIsEmptyObs.read(reader);
-            if (menuIsEmpty) {
+            const menuPrimaryActionId = menuPrimaryActionIdObs.read(reader);
+            if (!menuPrimaryActionId) {
                 return;
             }
             const container = h('div.floating-menu-overlay-widget');
             // Set height explicitly to ensure that the floating menu element
             // is rendered in the lower right corner at the correct position.
-            container.root.style.height = '28px';
+            container.root.style.height = '26px';
             // Toolbar
             const toolbar = instantiationService.createInstance(MenuWorkbenchToolBar, container.root, MenuId.EditorContent, {
                 actionViewItemProvider: (action, options) => {
                     if (!(action instanceof MenuItemAction)) {
                         return undefined;
                     }
-                    const keybinding = keybindingService.lookupKeybinding(action.id);
-                    if (!keybinding) {
-                        return undefined;
-                    }
                     return instantiationService.createInstance(class extends MenuEntryActionViewItem {
+                        render(container) {
+                            super.render(container);
+                            // Highlight primary action
+                            if (action.id === menuPrimaryActionId) {
+                                this.element?.classList.add('primary');
+                            }
+                        }
                         updateLabel() {
+                            const keybinding = keybindingService.lookupKeybinding(action.id);
+                            const keybindingLabel = keybinding ? keybinding.getLabel() : undefined;
                             if (this.options.label && this.label) {
-                                this.label.textContent = `${this._commandAction.label} (${keybinding.getLabel()})`;
+                                this.label.textContent = keybindingLabel
+                                    ? `${this._commandAction.label} (${keybindingLabel})`
+                                    : this._commandAction.label;
                             }
                         }
                     }, action, { ...options, keybindingNotRenderedWithLabel: true });

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

@@ -64,6 +64,13 @@
 	border-bottom: 4px double var(--vscode-editorWarning-border);
 }
 
+.monaco-editor .ghost-text-decoration.short-text,
+.monaco-editor .ghost-text-decoration-preview.short-text,
+.monaco-editor .suggest-preview-text .ghost-text.short-text {
+	text-decoration: underline dotted var(--vscode-editorGhostText-foreground);
+	text-underline-position: under;
+}
+
 .ghost-text-view-warning-widget-icon {
 	.codicon {
 		color: var(--vscode-editorWarning-foreground) !important;