@codingame/monaco-vscode-api 24.3.0 → 25.0.0

package/vscode/src/vs/editor/contrib/stickyScroll/browser/stickyScrollActions.js

@@ -15,20 +15,20 @@ class ToggleStickyScroll extends EditorAction2 {
         super({
             id: 'editor.action.toggleStickyScroll',
             title: {
-                ...( localize2(1542, "Toggle Editor Sticky Scroll")),
-                mnemonicTitle: ( localize(1543, "&&Toggle Editor Sticky Scroll")),
+                ...( localize2(1545, "Toggle Editor Sticky Scroll")),
+                mnemonicTitle: ( localize(1546, "&&Toggle Editor Sticky Scroll")),
             },
             metadata: {
                 description: ( localize2(
-                    1544,
+                    1547,
                     "Toggle/enable the editor sticky scroll which shows the nested scopes at the top of the viewport"
                 )),
             },
             category: Categories.View,
             toggled: {
                 condition: ( ContextKeyExpr.equals('config.editor.stickyScroll.enabled', true)),
-                title: ( localize(1545, "Sticky Scroll")),
-                mnemonicTitle: ( localize(1546, "&&Sticky Scroll")),
+                title: ( localize(1548, "Sticky Scroll")),
+                mnemonicTitle: ( localize(1549, "&&Sticky Scroll")),
             },
             menu: [
                 { id: MenuId.CommandPalette },
@@ -53,8 +53,8 @@ class FocusStickyScroll extends EditorAction2 {
         super({
             id: 'editor.action.focusStickyScroll',
             title: {
-                ...( localize2(1547, "Focus Editor Sticky Scroll")),
-                mnemonicTitle: ( localize(1548, "&&Focus Editor Sticky Scroll")),
+                ...( localize2(1550, "Focus Editor Sticky Scroll")),
+                mnemonicTitle: ( localize(1551, "&&Focus Editor Sticky Scroll")),
             },
             precondition: ( ContextKeyExpr.and(( ContextKeyExpr.has('config.editor.stickyScroll.enabled')), EditorContextKeys.stickyScrollVisible)),
             menu: [
@@ -70,7 +70,7 @@ class SelectNextStickyScrollLine extends EditorAction2 {
     constructor() {
         super({
             id: 'editor.action.selectNextStickyScrollLine',
-            title: ( localize2(1549, "Select the next editor sticky scroll line")),
+            title: ( localize2(1552, "Select the next editor sticky scroll line")),
             precondition: ( EditorContextKeys.stickyScrollFocused.isEqualTo(true)),
             keybinding: {
                 weight,
@@ -86,7 +86,7 @@ class SelectPreviousStickyScrollLine extends EditorAction2 {
     constructor() {
         super({
             id: 'editor.action.selectPreviousStickyScrollLine',
-            title: ( localize2(1550, "Select the previous sticky scroll line")),
+            title: ( localize2(1553, "Select the previous sticky scroll line")),
             precondition: ( EditorContextKeys.stickyScrollFocused.isEqualTo(true)),
             keybinding: {
                 weight,
@@ -102,7 +102,7 @@ class GoToStickyScrollLine extends EditorAction2 {
     constructor() {
         super({
             id: 'editor.action.goToFocusedStickyScrollLine',
-            title: ( localize2(1551, "Go to the focused sticky scroll line")),
+            title: ( localize2(1554, "Go to the focused sticky scroll line")),
             precondition: ( EditorContextKeys.stickyScrollFocused.isEqualTo(true)),
             keybinding: {
                 weight,
@@ -118,7 +118,7 @@ class SelectEditor extends EditorAction2 {
     constructor() {
         super({
             id: 'editor.action.selectEditor',
-            title: ( localize2(1552, "Select Editor")),
+            title: ( localize2(1555, "Select Editor")),
             precondition: ( EditorContextKeys.stickyScrollFocused.isEqualTo(true)),
             keybinding: {
                 weight,

package/vscode/src/vs/editor/contrib/stickyScroll/browser/stickyScrollController.d.ts

@@ -53,6 +53,7 @@ export declare class StickyScrollController extends Disposable implements IEdito
     private _showEndForLine;
     private _minRebuildFromLine;
     private _mouseTarget;
+    private _cursorPositionListener;
     private readonly _onDidChangeStickyScrollHeight;
     readonly onDidChangeStickyScrollHeight: Event<{
         height: number;

package/vscode/src/vs/editor/contrib/stickyScroll/browser/stickyScrollController.js

@@ -335,6 +335,7 @@ let StickyScrollController = class StickyScrollController extends Disposable {
         this._contextMenuService.showContextMenu({
             menuId: MenuId.StickyScrollContext,
             getAnchor: () => event,
+            menuActionOptions: { renderShortTitle: true },
         });
     }
     _onMouseMoveOrKeyDown(mouseEvent) {
@@ -396,10 +397,18 @@ let StickyScrollController = class StickyScrollController extends Disposable {
         }
         const lineNumberOption = this._editor.getOption(EditorOption.lineNumbers);
         if (lineNumberOption.renderType === RenderLineNumbersType.Relative) {
-            this._sessionStore.add(this._editor.onDidChangeCursorPosition(() => {
-                this._showEndForLine = undefined;
-                this._renderStickyScroll(0);
-            }));
+            if (!this._cursorPositionListener) {
+                this._cursorPositionListener = this._editor.onDidChangeCursorPosition(() => {
+                    this._showEndForLine = undefined;
+                    this._renderStickyScroll(0);
+                });
+                this._sessionStore.add(this._cursorPositionListener);
+            }
+        }
+        else if (this._cursorPositionListener) {
+            this._sessionStore.delete(this._cursorPositionListener);
+            this._cursorPositionListener.dispose();
+            this._cursorPositionListener = undefined;
         }
     }
     _readConfigurationChange(event) {

package/vscode/src/vs/editor/contrib/stickyScroll/browser/stickyScrollWidget.d.ts

@@ -1,8 +1,10 @@
 import { Disposable } from "../../../../base/common/lifecycle.js";
 import { ICodeEditor, IOverlayWidget, IOverlayWidgetPosition } from "../../../browser/editorBrowser.js";
+import { EditorLayoutInfo } from "../../../common/config/editorOptions.js";
 import { Position } from "../../../common/core/position.js";
 import { CharacterMapping } from "../../../common/viewLayout/viewLineRenderer.js";
 import { FoldingModel } from "../../folding/browser/foldingModel.js";
+import { IViewModel } from "../../../common/viewModel.js";
 export declare class StickyScrollWidgetState {
     readonly startLineNumbers: number[];
     readonly endLineNumbers: number[];
@@ -20,7 +22,6 @@ export declare class StickyScrollWidget extends Disposable implements IOverlayWi
     private readonly _linesDomNode;
     private readonly _editor;
     private _state;
-    private _lineHeight;
     private _renderedStickyLines;
     private _lineNumbers;
     private _lastLineRelativePosition;
@@ -49,7 +50,6 @@ export declare class StickyScrollWidget extends Disposable implements IOverlayWi
     private _setFoldingHoverListeners;
     private _renderChildNode;
     private _updatePosition;
-    private _renderFoldingIconForLine;
     getId(): string;
     getDomNode(): HTMLElement;
     getPosition(): IOverlayWidgetPosition | null;
@@ -91,7 +91,8 @@ declare class RenderedStickyLine {
     readonly characterMapping: CharacterMapping;
     readonly scrollWidth: number;
     readonly height: number;
-    constructor(index: number, lineNumber: number, lineDomNode: HTMLElement, lineNumberDomNode: HTMLElement, foldingIcon: StickyFoldingIcon | undefined, characterMapping: CharacterMapping, scrollWidth: number, height: number);
+    constructor(editor: ICodeEditor, viewModel: IViewModel, layoutInfo: EditorLayoutInfo, foldingModel: FoldingModel | undefined, isOnGlyphMargin: boolean, index: number, lineNumber: number);
+    private _renderFoldingIconForLine;
 }
 declare class StickyFoldingIcon {
     isCollapsed: boolean;

package/vscode/src/vs/editor/contrib/stickyScroll/browser/stickyScrollWidget.js

@@ -59,7 +59,6 @@ class StickyScrollWidget extends Disposable {
         this._onDidChangeStickyScrollHeight = this._register(( new Emitter()));
         this.onDidChangeStickyScrollHeight = this._onDidChangeStickyScrollHeight.event;
         this._editor = editor;
-        this._lineHeight = editor.getOption(EditorOption.lineHeight);
         this._lineNumbersDomNode.className = 'sticky-widget-line-numbers';
         this._lineNumbersDomNode.setAttribute('role', 'none');
         this._linesDomNode.className = 'sticky-widget-lines';
@@ -78,9 +77,6 @@ class StickyScrollWidget extends Disposable {
             if (e.hasChanged(EditorOption.stickyScroll)) {
                 updateScrollLeftPosition();
             }
-            if (e.hasChanged(EditorOption.lineHeight)) {
-                this._lineHeight = this._editor.getOption(EditorOption.lineHeight);
-            }
         }));
         this._register(this._editor.onDidScrollChange((e) => {
             if (e.scrollLeftChanged) {
@@ -239,6 +235,7 @@ class StickyScrollWidget extends Disposable {
         this._onDidChangeStickyScrollHeight.fire({ height: this._height });
     }
     _setFoldingHoverListeners() {
+        this._foldingIconStore.clear();
         const showFoldingControls = this._editor.getOption(EditorOption.showFoldingControls);
         if (showFoldingControls !== 'mouseover') {
             return;
@@ -255,99 +252,14 @@ class StickyScrollWidget extends Disposable {
         }));
     }
     _renderChildNode(viewModel, index, line, top, isLastLine, foldingModel, layoutInfo) {
-        const viewLineNumber = viewModel.coordinatesConverter.convertModelPositionToViewPosition(( new Position(line, 1))).lineNumber;
-        const lineRenderingData = viewModel.getViewLineRenderingData(viewLineNumber);
-        const lineNumberOption = this._editor.getOption(EditorOption.lineNumbers);
-        const verticalScrollbarSize = this._editor.getOption(EditorOption.scrollbar).verticalScrollbarSize;
-        let actualInlineDecorations;
-        try {
-            actualInlineDecorations = LineDecoration.filter(lineRenderingData.inlineDecorations, viewLineNumber, lineRenderingData.minColumn, lineRenderingData.maxColumn);
-        }
-        catch (err) {
-            actualInlineDecorations = [];
-        }
-        const lineHeight = this._editor.getLineHeightForPosition(( new Position(line, 1)));
-        const textDirection = viewModel.getTextDirection(line);
-        const renderLineInput = ( new RenderLineInput(
-            true,
-            true,
-            lineRenderingData.content,
-            lineRenderingData.continuesWithWrappedLine,
-            lineRenderingData.isBasicASCII,
-            lineRenderingData.containsRTL,
-            0,
-            lineRenderingData.tokens,
-            actualInlineDecorations,
-            lineRenderingData.tabSize,
-            lineRenderingData.startVisibleColumn,
-            1,
-            1,
-            1,
-            500,
-            'none',
-            true,
-            true,
-            null,
-            textDirection,
-            verticalScrollbarSize
-        ));
-        const sb = ( new StringBuilder(2000));
-        const renderOutput = renderViewLine(renderLineInput, sb);
-        let newLine;
-        if (_ttPolicy) {
-            newLine = _ttPolicy.createHTML(sb.build());
-        }
-        else {
-            newLine = sb.build();
-        }
-        const lineHTMLNode = createElement('span');
-        lineHTMLNode.setAttribute(STICKY_INDEX_ATTR, String(index));
-        lineHTMLNode.setAttribute(STICKY_IS_LINE_ATTR, '');
-        lineHTMLNode.setAttribute('role', 'listitem');
-        lineHTMLNode.tabIndex = 0;
-        lineHTMLNode.className = 'sticky-line-content';
-        lineHTMLNode.classList.add(`stickyLine${line}`);
-        lineHTMLNode.style.lineHeight = `${lineHeight}px`;
-        lineHTMLNode.innerHTML = newLine;
-        const lineNumberHTMLNode = createElement('span');
-        lineNumberHTMLNode.setAttribute(STICKY_INDEX_ATTR, String(index));
-        lineNumberHTMLNode.setAttribute(STICKY_IS_LINE_NUMBER_ATTR, '');
-        lineNumberHTMLNode.className = 'sticky-line-number';
-        lineNumberHTMLNode.style.lineHeight = `${lineHeight}px`;
-        const lineNumbersWidth = layoutInfo.contentLeft;
-        lineNumberHTMLNode.style.width = `${lineNumbersWidth}px`;
-        const innerLineNumberHTML = createElement('span');
-        if (lineNumberOption.renderType === RenderLineNumbersType.On || lineNumberOption.renderType === RenderLineNumbersType.Interval && line % 10 === 0) {
-            innerLineNumberHTML.innerText = ( line.toString());
-        }
-        else if (lineNumberOption.renderType === RenderLineNumbersType.Relative) {
-            innerLineNumberHTML.innerText = ( Math.abs(line - this._editor.getPosition().lineNumber).toString());
-        }
-        innerLineNumberHTML.className = 'sticky-line-number-inner';
-        innerLineNumberHTML.style.width = `${layoutInfo.lineNumbersWidth}px`;
-        innerLineNumberHTML.style.paddingLeft = `${layoutInfo.lineNumbersLeft}px`;
-        lineNumberHTMLNode.appendChild(innerLineNumberHTML);
-        const foldingIcon = this._renderFoldingIconForLine(foldingModel, line);
-        if (foldingIcon) {
-            lineNumberHTMLNode.appendChild(foldingIcon.domNode);
-            foldingIcon.domNode.style.left = `${layoutInfo.lineNumbersWidth + layoutInfo.lineNumbersLeft}px`;
-            foldingIcon.domNode.style.lineHeight = `${lineHeight}px`;
-        }
-        this._editor.applyFontInfo(lineHTMLNode);
-        this._editor.applyFontInfo(lineNumberHTMLNode);
-        lineNumberHTMLNode.style.lineHeight = `${lineHeight}px`;
-        lineHTMLNode.style.lineHeight = `${lineHeight}px`;
-        lineNumberHTMLNode.style.height = `${lineHeight}px`;
-        lineHTMLNode.style.height = `${lineHeight}px`;
         const renderedLine = ( new RenderedStickyLine(
+            this._editor,
+            viewModel,
+            layoutInfo,
+            foldingModel,
+            this._isOnGlyphMargin,
             index,
-            line,
-            lineHTMLNode,
-            lineNumberHTMLNode,
-            foldingIcon,
-            renderOutput.characterMapping,
-            lineHTMLNode.scrollWidth,
-            lineHeight
+            line
         ));
         return this._updatePosition(renderedLine, top, isLastLine);
     }
@@ -371,29 +283,6 @@ class StickyScrollWidget extends Disposable {
         }
         return stickyLine;
     }
-    _renderFoldingIconForLine(foldingModel, line) {
-        const showFoldingControls = this._editor.getOption(EditorOption.showFoldingControls);
-        if (!foldingModel || showFoldingControls === 'never') {
-            return;
-        }
-        const foldingRegions = foldingModel.regions;
-        const indexOfFoldingRegion = foldingRegions.findRange(line);
-        const startLineNumber = foldingRegions.getStartLineNumber(indexOfFoldingRegion);
-        const isFoldingScope = line === startLineNumber;
-        if (!isFoldingScope) {
-            return;
-        }
-        const isCollapsed = foldingRegions.isCollapsed(indexOfFoldingRegion);
-        const foldingIcon = ( new StickyFoldingIcon(
-            isCollapsed,
-            startLineNumber,
-            foldingRegions.getEndLineNumber(indexOfFoldingRegion),
-            this._lineHeight
-        ));
-        foldingIcon.setVisible(this._isOnGlyphMargin ? true : (isCollapsed || showFoldingControls === 'always'));
-        foldingIcon.domNode.setAttribute(STICKY_IS_FOLDING_ICON_ATTR, '');
-        return foldingIcon;
-    }
     getId() {
         return 'editor.contrib.stickyScrollWidget';
     }
@@ -459,15 +348,121 @@ class StickyScrollWidget extends Disposable {
     }
 }
 class RenderedStickyLine {
-    constructor(index, lineNumber, lineDomNode, lineNumberDomNode, foldingIcon, characterMapping, scrollWidth, height) {
+    constructor(editor, viewModel, layoutInfo, foldingModel, isOnGlyphMargin, index, lineNumber) {
         this.index = index;
         this.lineNumber = lineNumber;
-        this.lineDomNode = lineDomNode;
-        this.lineNumberDomNode = lineNumberDomNode;
-        this.foldingIcon = foldingIcon;
-        this.characterMapping = characterMapping;
-        this.scrollWidth = scrollWidth;
-        this.height = height;
+        const viewLineNumber = viewModel.coordinatesConverter.convertModelPositionToViewPosition(( new Position(lineNumber, 1))).lineNumber;
+        const lineRenderingData = viewModel.getViewLineRenderingData(viewLineNumber);
+        const lineNumberOption = editor.getOption(EditorOption.lineNumbers);
+        const verticalScrollbarSize = editor.getOption(EditorOption.scrollbar).verticalScrollbarSize;
+        let actualInlineDecorations;
+        try {
+            actualInlineDecorations = LineDecoration.filter(lineRenderingData.inlineDecorations, viewLineNumber, lineRenderingData.minColumn, lineRenderingData.maxColumn);
+        }
+        catch (err) {
+            actualInlineDecorations = [];
+        }
+        const lineHeight = editor.getLineHeightForPosition(( new Position(lineNumber, 1)));
+        const textDirection = viewModel.getTextDirection(lineNumber);
+        const renderLineInput = ( new RenderLineInput(
+            true,
+            true,
+            lineRenderingData.content,
+            lineRenderingData.continuesWithWrappedLine,
+            lineRenderingData.isBasicASCII,
+            lineRenderingData.containsRTL,
+            0,
+            lineRenderingData.tokens,
+            actualInlineDecorations,
+            lineRenderingData.tabSize,
+            lineRenderingData.startVisibleColumn,
+            1,
+            1,
+            1,
+            500,
+            'none',
+            true,
+            true,
+            null,
+            textDirection,
+            verticalScrollbarSize
+        ));
+        const sb = ( new StringBuilder(2000));
+        const renderOutput = renderViewLine(renderLineInput, sb);
+        this.characterMapping = renderOutput.characterMapping;
+        let newLine;
+        if (_ttPolicy) {
+            newLine = _ttPolicy.createHTML(sb.build());
+        }
+        else {
+            newLine = sb.build();
+        }
+        const lineHTMLNode = createElement('span');
+        lineHTMLNode.setAttribute(STICKY_INDEX_ATTR, String(index));
+        lineHTMLNode.setAttribute(STICKY_IS_LINE_ATTR, '');
+        lineHTMLNode.setAttribute('role', 'listitem');
+        lineHTMLNode.tabIndex = 0;
+        lineHTMLNode.className = 'sticky-line-content';
+        lineHTMLNode.classList.add(`stickyLine${lineNumber}`);
+        lineHTMLNode.style.lineHeight = `${lineHeight}px`;
+        lineHTMLNode.innerHTML = newLine;
+        const lineNumberHTMLNode = createElement('span');
+        lineNumberHTMLNode.setAttribute(STICKY_INDEX_ATTR, String(index));
+        lineNumberHTMLNode.setAttribute(STICKY_IS_LINE_NUMBER_ATTR, '');
+        lineNumberHTMLNode.className = 'sticky-line-number';
+        lineNumberHTMLNode.style.lineHeight = `${lineHeight}px`;
+        const lineNumbersWidth = layoutInfo.contentLeft;
+        lineNumberHTMLNode.style.width = `${lineNumbersWidth}px`;
+        const innerLineNumberHTML = createElement('span');
+        if (lineNumberOption.renderType === RenderLineNumbersType.On || lineNumberOption.renderType === RenderLineNumbersType.Interval && lineNumber % 10 === 0) {
+            innerLineNumberHTML.innerText = ( lineNumber.toString());
+        }
+        else if (lineNumberOption.renderType === RenderLineNumbersType.Relative) {
+            innerLineNumberHTML.innerText = ( Math.abs(lineNumber - editor.getPosition().lineNumber).toString());
+        }
+        innerLineNumberHTML.className = 'sticky-line-number-inner';
+        innerLineNumberHTML.style.width = `${layoutInfo.lineNumbersWidth}px`;
+        innerLineNumberHTML.style.paddingLeft = `${layoutInfo.lineNumbersLeft}px`;
+        lineNumberHTMLNode.appendChild(innerLineNumberHTML);
+        const foldingIcon = this._renderFoldingIconForLine(editor, foldingModel, lineNumber, lineHeight, isOnGlyphMargin);
+        if (foldingIcon) {
+            lineNumberHTMLNode.appendChild(foldingIcon.domNode);
+            foldingIcon.domNode.style.left = `${layoutInfo.lineNumbersWidth + layoutInfo.lineNumbersLeft}px`;
+            foldingIcon.domNode.style.lineHeight = `${lineHeight}px`;
+        }
+        editor.applyFontInfo(lineHTMLNode);
+        editor.applyFontInfo(lineNumberHTMLNode);
+        lineNumberHTMLNode.style.lineHeight = `${lineHeight}px`;
+        lineHTMLNode.style.lineHeight = `${lineHeight}px`;
+        lineNumberHTMLNode.style.height = `${lineHeight}px`;
+        lineHTMLNode.style.height = `${lineHeight}px`;
+        this.scrollWidth = lineHTMLNode.scrollWidth;
+        this.lineDomNode = lineHTMLNode;
+        this.lineNumberDomNode = lineNumberHTMLNode;
+        this.height = lineHeight;
+    }
+    _renderFoldingIconForLine(editor, foldingModel, line, lineHeight, isOnGlyphMargin) {
+        const showFoldingControls = editor.getOption(EditorOption.showFoldingControls);
+        if (!foldingModel || showFoldingControls === 'never') {
+            return;
+        }
+        const foldingRegions = foldingModel.regions;
+        const indexOfFoldingRegion = foldingRegions.findRange(line);
+        const startLineNumber = foldingRegions.getStartLineNumber(indexOfFoldingRegion);
+        const isFoldingScope = line === startLineNumber;
+        if (!isFoldingScope) {
+            return;
+        }
+        const isCollapsed = foldingRegions.isCollapsed(indexOfFoldingRegion);
+        const foldingIcon = ( new StickyFoldingIcon(
+            isCollapsed,
+            startLineNumber,
+            foldingRegions.getEndLineNumber(indexOfFoldingRegion),
+            lineHeight
+        ));
+        foldingIcon.setVisible(isOnGlyphMargin ? true : (isCollapsed || showFoldingControls === 'always'));
+        foldingIcon.domNode.setAttribute(STICKY_IS_FOLDING_ICON_ATTR, '');
+        return foldingIcon;
     }
 }
 class StickyFoldingIcon {

package/vscode/src/vs/editor/contrib/suggest/browser/suggest.d.ts

@@ -15,6 +15,7 @@ export declare const Context: {
     Visible: RawContextKey<boolean>;
     HasFocusedSuggestion: RawContextKey<boolean>;
     DetailsVisible: RawContextKey<boolean>;
+    DetailsFocused: RawContextKey<boolean>;
     MultipleSuggestions: RawContextKey<boolean>;
     MakesTextEdit: RawContextKey<boolean>;
     AcceptSuggestionsOnEnter: RawContextKey<boolean>;

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

@@ -21,21 +21,22 @@ import { StandardTokenType } from '../../../common/encodedTokenAttributes.js';
 
 const Context = {
     Visible: historyNavigationVisible,
-    HasFocusedSuggestion: ( new RawContextKey('suggestWidgetHasFocusedSuggestion', false, ( localize(1553, "Whether any suggestion is focused")))),
-    DetailsVisible: ( new RawContextKey('suggestWidgetDetailsVisible', false, ( localize(1554, "Whether suggestion details are visible")))),
-    MultipleSuggestions: ( new RawContextKey('suggestWidgetMultipleSuggestions', false, ( localize(1555, "Whether there are multiple suggestions to pick from")))),
+    HasFocusedSuggestion: ( new RawContextKey('suggestWidgetHasFocusedSuggestion', false, ( localize(1556, "Whether any suggestion is focused")))),
+    DetailsVisible: ( new RawContextKey('suggestWidgetDetailsVisible', false, ( localize(1557, "Whether suggestion details are visible")))),
+    DetailsFocused: ( new RawContextKey('suggestWidgetDetailsFocused', false, ( localize(1558, "Whether the details pane of the suggest widget has focus")))),
+    MultipleSuggestions: ( new RawContextKey('suggestWidgetMultipleSuggestions', false, ( localize(1559, "Whether there are multiple suggestions to pick from")))),
     MakesTextEdit: ( new RawContextKey('suggestionMakesTextEdit', true, ( localize(
-        1556,
+        1560,
         "Whether inserting the current suggestion yields in a change or has everything already been typed"
     )))),
-    AcceptSuggestionsOnEnter: ( new RawContextKey('acceptSuggestionOnEnter', true, ( localize(1557, "Whether suggestions are inserted when pressing Enter")))),
-    HasInsertAndReplaceRange: ( new RawContextKey('suggestionHasInsertAndReplaceRange', false, ( localize(1558, "Whether the current suggestion has insert and replace behaviour")))),
+    AcceptSuggestionsOnEnter: ( new RawContextKey('acceptSuggestionOnEnter', true, ( localize(1561, "Whether suggestions are inserted when pressing Enter")))),
+    HasInsertAndReplaceRange: ( new RawContextKey('suggestionHasInsertAndReplaceRange', false, ( localize(1562, "Whether the current suggestion has insert and replace behaviour")))),
     InsertMode: ( new RawContextKey(
         'suggestionInsertMode',
         undefined,
-        { type: 'string', description: ( localize(1559, "Whether the default behaviour is to insert or replace")) }
+        { type: 'string', description: ( localize(1563, "Whether the default behaviour is to insert or replace")) }
     )),
-    CanResolve: ( new RawContextKey('suggestionCanResolve', false, ( localize(1560, "Whether the current suggestion supports to resolve further details")))),
+    CanResolve: ( new RawContextKey('suggestionCanResolve', false, ( localize(1564, "Whether the current suggestion supports to resolve further details")))),
 };
 const suggestWidgetStatusbarMenu = ( new MenuId('suggestWidgetStatusBar'));
 class CompletionItem {

package/vscode/src/vs/editor/contrib/suggest/browser/suggestController.js

@@ -5,10 +5,8 @@ import { isNonEmptyArray } from '../../../../base/common/arrays.js';
 import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
 import { onUnexpectedExternalError, onUnexpectedError } from '../../../../base/common/errors.js';
 import { Emitter, Event } from '../../../../base/common/event.js';
-import { KeyCode, KeyMod as KeyMod$1 } from '../../../../base/common/keyCodes.js';
-import { KeyCodeChord } from '../../../../base/common/keybindings.js';
+import { KeyMod as KeyMod$1, KeyCode } from '../../../../base/common/keyCodes.js';
 import { MutableDisposable, DisposableStore, toDisposable, dispose } from '../../../../base/common/lifecycle.js';
-import { isMacintosh } from '../../../../base/common/platform.js';
 import { StopWatch } from '../../../../base/common/stopwatch.js';
 import { assertType, isObject } from '../../../../base/common/types.js';
 import { StableEditorScrollState } from '../../../browser/stableEditorScroll.js';
@@ -166,16 +164,6 @@ let SuggestController = class SuggestController {
                 ctxHasInsertAndReplace.set(!Position.equals(item.editInsertEnd, item.editReplaceEnd));
                 ctxCanResolve.set(Boolean(item.provider.resolveCompletionItem) || Boolean(item.completion.documentation) || item.completion.detail !== item.completion.label);
             }));
-            this._toDispose.add(widget.onDetailsKeyDown(e => {
-                if (e.toKeyCodeChord().equals(( new KeyCodeChord(true, false, false, false, KeyCode.KeyC))) ||
-                    (isMacintosh && e.toKeyCodeChord().equals(( new KeyCodeChord(false, false, false, true, KeyCode.KeyC))))) {
-                    e.stopPropagation();
-                    return;
-                }
-                if (!e.toKeyCodeChord().isModifierKey()) {
-                    this.editor.focus();
-                }
-            }));
             if (this._wantsForceRenderingAbove) {
                 widget.forceRenderingAbove();
             }
@@ -455,7 +443,7 @@ let SuggestController = class SuggestController {
     _alertCompletionItem(item) {
         if (isNonEmptyArray(item.completion.additionalTextEdits)) {
             const msg = ( localize(
-                1561,
+                1565,
                 "Accepting '{0}' made {1} additional edits",
                 item.textLabel,
                 item.completion.additionalTextEdits.length
@@ -639,7 +627,7 @@ class TriggerSuggestAction extends EditorAction {
     constructor() {
         super({
             id: TriggerSuggestAction.id,
-            label: ( localize2(1562, "Trigger Suggest")),
+            label: ( localize2(1566, "Trigger Suggest")),
             precondition: ( ContextKeyExpr.and(
                 EditorContextKeys.writable,
                 EditorContextKeys.hasCompletionItemProvider,
@@ -694,22 +682,30 @@ registerEditorCommand(( new SuggestCommand({
         }],
     menuOpts: [{
             menuId: suggestWidgetStatusbarMenu,
-            title: ( localize(1563, "Insert")),
+            title: ( localize(1567, "Insert")),
             group: 'left',
             order: 1,
-            when: ( Context.HasInsertAndReplaceRange.toNegated())
+            when: ( ContextKeyExpr.and(Context.HasFocusedSuggestion, ( Context.HasInsertAndReplaceRange.toNegated())))
         }, {
             menuId: suggestWidgetStatusbarMenu,
-            title: ( localize(1563, "Insert")),
+            title: ( localize(1567, "Insert")),
             group: 'left',
             order: 1,
-            when: ( ContextKeyExpr.and(Context.HasInsertAndReplaceRange, ( Context.InsertMode.isEqualTo('insert'))))
+            when: ( ContextKeyExpr.and(
+                Context.HasFocusedSuggestion,
+                Context.HasInsertAndReplaceRange,
+                ( Context.InsertMode.isEqualTo('insert'))
+            ))
         }, {
             menuId: suggestWidgetStatusbarMenu,
-            title: ( localize(1564, "Replace")),
+            title: ( localize(1568, "Replace")),
             group: 'left',
             order: 1,
-            when: ( ContextKeyExpr.and(Context.HasInsertAndReplaceRange, ( Context.InsertMode.isEqualTo('replace'))))
+            when: ( ContextKeyExpr.and(
+                Context.HasFocusedSuggestion,
+                Context.HasInsertAndReplaceRange,
+                ( Context.InsertMode.isEqualTo('replace'))
+            ))
         }]
 })));
 registerEditorCommand(( new SuggestCommand({
@@ -732,14 +728,22 @@ registerEditorCommand(( new SuggestCommand({
             menuId: suggestWidgetStatusbarMenu,
             group: 'left',
             order: 2,
-            when: ( ContextKeyExpr.and(Context.HasInsertAndReplaceRange, ( Context.InsertMode.isEqualTo('insert')))),
-            title: ( localize(1564, "Replace"))
+            when: ( ContextKeyExpr.and(
+                Context.HasFocusedSuggestion,
+                Context.HasInsertAndReplaceRange,
+                ( Context.InsertMode.isEqualTo('insert'))
+            )),
+            title: ( localize(1568, "Replace"))
         }, {
             menuId: suggestWidgetStatusbarMenu,
             group: 'left',
             order: 2,
-            when: ( ContextKeyExpr.and(Context.HasInsertAndReplaceRange, ( Context.InsertMode.isEqualTo('replace')))),
-            title: ( localize(1563, "Insert"))
+            when: ( ContextKeyExpr.and(
+                Context.HasFocusedSuggestion,
+                Context.HasInsertAndReplaceRange,
+                ( Context.InsertMode.isEqualTo('replace'))
+            )),
+            title: ( localize(1567, "Insert"))
         }]
 })));
 CommandsRegistry.registerCommandAlias('acceptSelectedSuggestionOnEnter', 'acceptSelectedSuggestion');
@@ -764,6 +768,13 @@ registerEditorCommand(( new SuggestCommand({
         primary: KeyCode.DownArrow,
         secondary: [KeyMod$1.CtrlCmd | KeyCode.DownArrow],
         mac: { primary: KeyCode.DownArrow, secondary: [KeyMod$1.CtrlCmd | KeyCode.DownArrow, KeyMod$1.WinCtrl | KeyCode.KeyN] }
+    },
+    menuOpts: {
+        menuId: suggestWidgetStatusbarMenu,
+        group: 'left',
+        order: 0,
+        when: ( Context.HasFocusedSuggestion.toNegated()),
+        title: ( localize(1569, "Select"))
     }
 })));
 registerEditorCommand(( new SuggestCommand({
@@ -846,13 +857,13 @@ registerEditorCommand(( new SuggestCommand({
             group: 'right',
             order: 1,
             when: ( ContextKeyExpr.and(Context.DetailsVisible, Context.CanResolve)),
-            title: ( localize(1565, "Show Less"))
+            title: ( localize(1570, "Show Less"))
         }, {
             menuId: suggestWidgetStatusbarMenu,
             group: 'right',
             order: 1,
             when: ( ContextKeyExpr.and(( Context.DetailsVisible.toNegated()), Context.CanResolve)),
-            title: ( localize(1566, "Show More"))
+            title: ( localize(1571, "Show More"))
         }]
 })));
 registerEditorCommand(( new SuggestCommand({
@@ -906,11 +917,28 @@ registerEditorCommand(( new SuggestCommand({
         primary: KeyMod$1.Shift | KeyCode.Tab
     }
 })));
+registerEditorCommand(new (class extends EditorCommand {
+    constructor() {
+        super({
+            id: 'suggestWidgetCopy',
+            precondition: Context.DetailsFocused,
+            kbOpts: {
+                weight: weight + 10,
+                kbExpr: Context.DetailsFocused,
+                primary: KeyMod$1.CtrlCmd | KeyCode.KeyC,
+                win: { primary: KeyMod$1.CtrlCmd | KeyCode.KeyC, secondary: [KeyMod$1.CtrlCmd | KeyCode.Insert] }
+            }
+        });
+    }
+    runEditorCommand(_accessor, editor) {
+        getWindow(editor.getDomNode()).document.execCommand('copy');
+    }
+})());
 registerEditorAction(class extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.resetSuggestSize',
-            label: ( localize2(1567, "Reset Suggest Widget Size")),
+            label: ( localize2(1572, "Reset Suggest Widget Size")),
             precondition: undefined
         });
     }

package/vscode/src/vs/editor/contrib/suggest/browser/suggestWidget.d.ts

@@ -47,6 +47,7 @@ export declare class SuggestWidget implements IDisposable {
     private readonly _ctxSuggestWidgetDetailsVisible;
     private readonly _ctxSuggestWidgetMultipleSuggestions;
     private readonly _ctxSuggestWidgetHasFocusedSuggestion;
+    private readonly _ctxSuggestWidgetDetailsFocused;
     private readonly _showTimeout;
     private readonly _disposables;
     private readonly _onDidSelect;