@codingame/monaco-vscode-katex-common 25.1.2 → 26.0.1

package/vscode/src/vs/workbench/contrib/inlineChat/common/inlineChat.js

@@ -18,118 +18,146 @@ import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/sear
 import { NOTEBOOK_IS_ACTIVE_EDITOR } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
 
 var InlineChatConfigKeys;
-(function (InlineChatConfigKeys) {
+(function(InlineChatConfigKeys) {
     InlineChatConfigKeys["FinishOnType"] = "inlineChat.finishOnType";
-    InlineChatConfigKeys["StartWithOverlayWidget"] = "inlineChat.startWithOverlayWidget";
     InlineChatConfigKeys["HoldToSpeech"] = "inlineChat.holdToSpeech";
     InlineChatConfigKeys["EnableV2"] = "inlineChat.enableV2";
     InlineChatConfigKeys["notebookAgent"] = "inlineChat.notebookAgent";
+    InlineChatConfigKeys["DefaultModel"] = "inlineChat.defaultModel";
+    InlineChatConfigKeys["Affordance"] = "inlineChat.affordance";
+    InlineChatConfigKeys["RenderMode"] = "inlineChat.renderMode";
 })(InlineChatConfigKeys || (InlineChatConfigKeys = {}));
 ( Registry.as(Extensions.Configuration)).registerConfiguration({
-    id: 'editor',
+    id: "editor",
     properties: {
         [InlineChatConfigKeys.FinishOnType]: {
             description: ( localize(
-                8356,
+                8661,
                 "Whether to finish an inline chat session when typing outside of changed regions."
             )),
             default: false,
-            type: 'boolean'
+            type: "boolean"
         },
         [InlineChatConfigKeys.HoldToSpeech]: {
             description: ( localize(
-                8357,
+                8662,
                 "Whether holding the inline chat keybinding will automatically enable speech recognition."
             )),
             default: true,
-            type: 'boolean'
+            type: "boolean"
         },
         [InlineChatConfigKeys.EnableV2]: {
-            description: ( localize(8358, "Whether to use the next version of inline chat.")),
+            description: ( localize(8663, "Whether to use the next version of inline chat.")),
             default: false,
-            type: 'boolean',
-            tags: ['preview'],
+            type: "boolean",
+            tags: ["preview"],
             experiment: {
-                mode: 'auto'
+                mode: "auto"
             }
         },
         [InlineChatConfigKeys.notebookAgent]: {
-            markdownDescription: ( localize(8359, "Enable agent-like behavior for inline chat widget in notebooks.")),
+            markdownDescription: ( localize(8664, "Enable agent-like behavior for inline chat widget in notebooks.")),
             default: false,
-            type: 'boolean',
-            tags: ['experimental'],
+            type: "boolean",
+            tags: ["experimental"],
             experiment: {
-                mode: 'startup'
+                mode: "startup"
             }
+        },
+        [InlineChatConfigKeys.Affordance]: {
+            description: ( localize(
+                8665,
+                "Controls whether an inline chat affordance is shown when text is selected."
+            )),
+            default: "off",
+            type: "string",
+            enum: ["off", "gutter", "editor"],
+            enumDescriptions: [( localize(8666, "No affordance is shown.")), ( localize(8667, "Show an affordance in the gutter.")), ( localize(8668, "Show an affordance in the editor at the cursor position."))],
+            tags: ["experimental"]
+        },
+        [InlineChatConfigKeys.RenderMode]: {
+            description: ( localize(8669, "Controls how inline chat is rendered.")),
+            default: "zone",
+            type: "string",
+            enum: ["zone", "hover"],
+            enumDescriptions: [( localize(8670, "Render inline chat as a zone widget below the current line.")), ( localize(8671, "Render inline chat as a hover overlay."))],
+            tags: ["experimental"]
         }
     }
 });
-const INLINE_CHAT_ID = 'interactiveEditor';
+const INLINE_CHAT_ID = "interactiveEditor";
 var InlineChatResponseType;
-(function (InlineChatResponseType) {
+(function(InlineChatResponseType) {
     InlineChatResponseType["None"] = "none";
     InlineChatResponseType["Messages"] = "messages";
     InlineChatResponseType["MessagesAndEdits"] = "messagesAndEdits";
 })(InlineChatResponseType || (InlineChatResponseType = {}));
-const CTX_INLINE_CHAT_POSSIBLE = ( new RawContextKey('inlineChatPossible', false, ( localize(
-    8360,
+const CTX_INLINE_CHAT_POSSIBLE = ( new RawContextKey("inlineChatPossible", false, ( localize(
+    8672,
     "Whether a provider for inline chat exists and whether an editor for inline chat is open"
 ))));
-const CTX_INLINE_CHAT_HAS_AGENT2 = ( new RawContextKey('inlineChatHasEditsAgent', false, ( localize(8361, "Whether an agent for inline for interactive editors exists"))));
-const CTX_INLINE_CHAT_HAS_NOTEBOOK_INLINE = ( new RawContextKey('inlineChatHasNotebookInline', false, ( localize(8362, "Whether an agent for notebook cells exists"))));
-const CTX_INLINE_CHAT_HAS_NOTEBOOK_AGENT = ( new RawContextKey('inlineChatHasNotebookAgent', false, ( localize(8363, "Whether an agent for notebook cells exists"))));
-const CTX_INLINE_CHAT_VISIBLE = ( new RawContextKey('inlineChatVisible', false, ( localize(8364, "Whether the interactive editor input is visible"))));
-const CTX_INLINE_CHAT_FOCUSED = ( new RawContextKey('inlineChatFocused', false, ( localize(8365, "Whether the interactive editor input is focused"))));
-const CTX_INLINE_CHAT_EDITING = ( new RawContextKey('inlineChatEditing', true, ( localize(
-    8366,
+const CTX_INLINE_CHAT_HAS_AGENT2 = ( new RawContextKey("inlineChatHasEditsAgent", false, ( localize(8673, "Whether an agent for inline for interactive editors exists"))));
+const CTX_INLINE_CHAT_HAS_NOTEBOOK_INLINE = ( new RawContextKey("inlineChatHasNotebookInline", false, ( localize(8674, "Whether an agent for notebook cells exists"))));
+const CTX_INLINE_CHAT_HAS_NOTEBOOK_AGENT = ( new RawContextKey("inlineChatHasNotebookAgent", false, ( localize(8675, "Whether an agent for notebook cells exists"))));
+const CTX_INLINE_CHAT_VISIBLE = ( new RawContextKey("inlineChatVisible", false, ( localize(8676, "Whether the interactive editor input is visible"))));
+const CTX_INLINE_CHAT_FOCUSED = ( new RawContextKey("inlineChatFocused", false, ( localize(8677, "Whether the interactive editor input is focused"))));
+const CTX_INLINE_CHAT_EDITING = ( new RawContextKey("inlineChatEditing", true, ( localize(
+    8678,
     "Whether the user is currently editing or generating code in the inline chat"
 ))));
-const CTX_INLINE_CHAT_RESPONSE_FOCUSED = ( new RawContextKey('inlineChatResponseFocused', false, ( localize(8367, "Whether the interactive widget's response is focused"))));
-const CTX_INLINE_CHAT_INNER_CURSOR_FIRST = ( new RawContextKey('inlineChatInnerCursorFirst', false, ( localize(
-    8368,
-    "Whether the cursor of the iteractive editor input is on the first line"
-))));
-const CTX_INLINE_CHAT_INNER_CURSOR_LAST = ( new RawContextKey('inlineChatInnerCursorLast', false, ( localize(
-    8369,
-    "Whether the cursor of the iteractive editor input is on the last line"
-))));
-const CTX_INLINE_CHAT_OUTER_CURSOR_POSITION = ( new RawContextKey('inlineChatOuterCursorPosition', '', ( localize(
-    8370,
+const CTX_INLINE_CHAT_RESPONSE_FOCUSED = ( new RawContextKey("inlineChatResponseFocused", false, ( localize(8679, "Whether the interactive widget's response is focused"))));
+const CTX_INLINE_CHAT_OUTER_CURSOR_POSITION = ( new RawContextKey("inlineChatOuterCursorPosition", "", ( localize(
+    8680,
     "Whether the cursor of the outer editor is above or below the interactive editor input"
 ))));
-const CTX_INLINE_CHAT_HAS_STASHED_SESSION = ( new RawContextKey('inlineChatHasStashedSession', false, ( localize(8371, "Whether interactive editor has kept a session for quick restore"))));
-const CTX_INLINE_CHAT_CHANGE_HAS_DIFF = ( new RawContextKey('inlineChatChangeHasDiff', false, ( localize(8372, "Whether the current change supports showing a diff"))));
-const CTX_INLINE_CHAT_CHANGE_SHOWS_DIFF = ( new RawContextKey('inlineChatChangeShowsDiff', false, ( localize(8373, "Whether the current change showing a diff"))));
-const CTX_INLINE_CHAT_REQUEST_IN_PROGRESS = ( new RawContextKey('inlineChatRequestInProgress', false, ( localize(8374, "Whether an inline chat request is currently in progress"))));
-const CTX_INLINE_CHAT_RESPONSE_TYPE = ( new RawContextKey('inlineChatResponseType', InlineChatResponseType.None, ( localize(
-    8375,
+const CTX_INLINE_CHAT_REQUEST_IN_PROGRESS = ( new RawContextKey("inlineChatRequestInProgress", false, ( localize(8681, "Whether an inline chat request is currently in progress"))));
+const CTX_INLINE_CHAT_RESPONSE_TYPE = ( new RawContextKey("inlineChatResponseType", InlineChatResponseType.None, ( localize(
+    8682,
     "What type was the responses have been receieved, nothing yet, just messages, or messaged and local edits"
 ))));
 const CTX_INLINE_CHAT_V1_ENABLED = ( ContextKeyExpr.or(( ContextKeyExpr.and(NOTEBOOK_IS_ACTIVE_EDITOR, CTX_INLINE_CHAT_HAS_NOTEBOOK_INLINE))));
 const CTX_INLINE_CHAT_V2_ENABLED = ( ContextKeyExpr.or(CTX_INLINE_CHAT_HAS_AGENT2, ( ContextKeyExpr.and(NOTEBOOK_IS_ACTIVE_EDITOR, CTX_INLINE_CHAT_HAS_NOTEBOOK_AGENT))));
-const ACTION_START = 'inlineChat.start';
-const ACTION_ACCEPT_CHANGES = 'inlineChat.acceptChanges';
-const ACTION_DISCARD_CHANGES = 'inlineChat.discardHunkChange';
-const ACTION_REGENERATE_RESPONSE = 'inlineChat.regenerate';
-const ACTION_VIEW_IN_CHAT = 'inlineChat.viewInChat';
-const ACTION_TOGGLE_DIFF = 'inlineChat.toggleDiff';
-const ACTION_REPORT_ISSUE = 'inlineChat.reportIssue';
-const MENU_INLINE_CHAT_WIDGET_STATUS = MenuId.for('inlineChatWidget.status');
-const MENU_INLINE_CHAT_WIDGET_SECONDARY = MenuId.for('inlineChatWidget.secondary');
-const MENU_INLINE_CHAT_ZONE = MenuId.for('inlineChatWidget.changesZone');
-const MENU_INLINE_CHAT_SIDE = MenuId.for('inlineChatWidget.side');
-const inlineChatForeground = registerColor('inlineChat.foreground', editorWidgetForeground, ( localize(8376, "Foreground color of the interactive editor widget")));
-const inlineChatBackground = registerColor('inlineChat.background', editorWidgetBackground, ( localize(8377, "Background color of the interactive editor widget")));
-registerColor('inlineChat.border', editorWidgetBorder, ( localize(8378, "Border color of the interactive editor widget")));
-registerColor('inlineChat.shadow', widgetShadow, ( localize(8379, "Shadow color of the interactive editor widget")));
-registerColor('inlineChatInput.border', editorWidgetBorder, ( localize(8380, "Border color of the interactive editor input")));
-registerColor('inlineChatInput.focusBorder', focusBorder, ( localize(8381, "Border color of the interactive editor input when focused")));
-registerColor('inlineChatInput.placeholderForeground', inputPlaceholderForeground, ( localize(8382, "Foreground color of the interactive editor input placeholder")));
-registerColor('inlineChatInput.background', inputBackground, ( localize(8383, "Background color of the interactive editor input")));
-registerColor('inlineChatDiff.inserted', ( transparent(diffInserted, .5)), ( localize(8384, "Background color of inserted text in the interactive editor input")));
-const overviewRulerInlineChatDiffInserted = registerColor('editorOverviewRuler.inlineChatInserted', { dark: ( transparent(diffInserted, 0.6)), light: ( transparent(diffInserted, 0.8)), hcDark: ( transparent(diffInserted, 0.6)), hcLight: ( transparent(diffInserted, 0.8)) }, ( localize(8385, 'Overview ruler marker color for inline chat inserted content.')));
-const minimapInlineChatDiffInserted = registerColor('editorMinimap.inlineChatInserted', { dark: ( transparent(diffInserted, 0.6)), light: ( transparent(diffInserted, 0.8)), hcDark: ( transparent(diffInserted, 0.6)), hcLight: ( transparent(diffInserted, 0.8)) }, ( localize(8386, 'Minimap marker color for inline chat inserted content.')));
-registerColor('inlineChatDiff.removed', ( transparent(diffRemoved, .5)), ( localize(8387, "Background color of removed text in the interactive editor input")));
-registerColor('editorOverviewRuler.inlineChatRemoved', { dark: ( transparent(diffRemoved, 0.6)), light: ( transparent(diffRemoved, 0.8)), hcDark: ( transparent(diffRemoved, 0.6)), hcLight: ( transparent(diffRemoved, 0.8)) }, ( localize(8388, 'Overview ruler marker color for inline chat removed content.')));
+const CTX_HOVER_MODE = ( ContextKeyExpr.equals("config.inlineChat.renderMode", "hover"));
+const ACTION_START = "inlineChat.start";
+const ACTION_ACCEPT_CHANGES = "inlineChat.acceptChanges";
+const ACTION_REGENERATE_RESPONSE = "inlineChat.regenerate";
+const ACTION_TOGGLE_DIFF = "inlineChat.toggleDiff";
+const ACTION_REPORT_ISSUE = "inlineChat.reportIssue";
+const MENU_INLINE_CHAT_WIDGET_STATUS = MenuId.for("inlineChatWidget.status");
+const MENU_INLINE_CHAT_WIDGET_SECONDARY = MenuId.for("inlineChatWidget.secondary");
+MenuId.for("inlineChatWidget.changesZone");
+const MENU_INLINE_CHAT_SIDE = MenuId.for("inlineChatWidget.side");
+const inlineChatForeground = registerColor("inlineChat.foreground", editorWidgetForeground, ( localize(8683, "Foreground color of the interactive editor widget")));
+const inlineChatBackground = registerColor("inlineChat.background", editorWidgetBackground, ( localize(8684, "Background color of the interactive editor widget")));
+registerColor("inlineChat.border", editorWidgetBorder, ( localize(8685, "Border color of the interactive editor widget")));
+registerColor("inlineChat.shadow", widgetShadow, ( localize(8686, "Shadow color of the interactive editor widget")));
+registerColor("inlineChatInput.border", editorWidgetBorder, ( localize(8687, "Border color of the interactive editor input")));
+registerColor("inlineChatInput.focusBorder", focusBorder, ( localize(8688, "Border color of the interactive editor input when focused")));
+registerColor(
+    "inlineChatInput.placeholderForeground",
+    inputPlaceholderForeground,
+    ( localize(8689, "Foreground color of the interactive editor input placeholder"))
+);
+registerColor("inlineChatInput.background", inputBackground, ( localize(8690, "Background color of the interactive editor input")));
+registerColor("inlineChatDiff.inserted", ( transparent(diffInserted, .5)), ( localize(8691, "Background color of inserted text in the interactive editor input")));
+registerColor("editorOverviewRuler.inlineChatInserted", {
+    dark: ( transparent(diffInserted, 0.6)),
+    light: ( transparent(diffInserted, 0.8)),
+    hcDark: ( transparent(diffInserted, 0.6)),
+    hcLight: ( transparent(diffInserted, 0.8))
+}, ( localize(8692, "Overview ruler marker color for inline chat inserted content.")));
+registerColor("editorMinimap.inlineChatInserted", {
+    dark: ( transparent(diffInserted, 0.6)),
+    light: ( transparent(diffInserted, 0.8)),
+    hcDark: ( transparent(diffInserted, 0.6)),
+    hcLight: ( transparent(diffInserted, 0.8))
+}, ( localize(8693, "Minimap marker color for inline chat inserted content.")));
+registerColor("inlineChatDiff.removed", ( transparent(diffRemoved, .5)), ( localize(8694, "Background color of removed text in the interactive editor input")));
+registerColor("editorOverviewRuler.inlineChatRemoved", {
+    dark: ( transparent(diffRemoved, 0.6)),
+    light: ( transparent(diffRemoved, 0.8)),
+    hcDark: ( transparent(diffRemoved, 0.6)),
+    hcLight: ( transparent(diffRemoved, 0.8))
+}, ( localize(8695, "Overview ruler marker color for inline chat removed content.")));
 
-export { ACTION_ACCEPT_CHANGES, ACTION_DISCARD_CHANGES, ACTION_REGENERATE_RESPONSE, ACTION_REPORT_ISSUE, ACTION_START, ACTION_TOGGLE_DIFF, ACTION_VIEW_IN_CHAT, CTX_INLINE_CHAT_CHANGE_HAS_DIFF, CTX_INLINE_CHAT_CHANGE_SHOWS_DIFF, CTX_INLINE_CHAT_EDITING, CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_HAS_AGENT2, CTX_INLINE_CHAT_HAS_NOTEBOOK_AGENT, CTX_INLINE_CHAT_HAS_NOTEBOOK_INLINE, CTX_INLINE_CHAT_HAS_STASHED_SESSION, CTX_INLINE_CHAT_INNER_CURSOR_FIRST, CTX_INLINE_CHAT_INNER_CURSOR_LAST, CTX_INLINE_CHAT_OUTER_CURSOR_POSITION, CTX_INLINE_CHAT_POSSIBLE, CTX_INLINE_CHAT_REQUEST_IN_PROGRESS, CTX_INLINE_CHAT_RESPONSE_FOCUSED, CTX_INLINE_CHAT_RESPONSE_TYPE, CTX_INLINE_CHAT_V1_ENABLED, CTX_INLINE_CHAT_V2_ENABLED, CTX_INLINE_CHAT_VISIBLE, INLINE_CHAT_ID, InlineChatConfigKeys, InlineChatResponseType, MENU_INLINE_CHAT_SIDE, MENU_INLINE_CHAT_WIDGET_SECONDARY, MENU_INLINE_CHAT_WIDGET_STATUS, MENU_INLINE_CHAT_ZONE, inlineChatBackground, inlineChatForeground, minimapInlineChatDiffInserted, overviewRulerInlineChatDiffInserted };
+export { ACTION_ACCEPT_CHANGES, ACTION_REGENERATE_RESPONSE, ACTION_REPORT_ISSUE, ACTION_START, ACTION_TOGGLE_DIFF, CTX_HOVER_MODE, CTX_INLINE_CHAT_EDITING, CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_HAS_AGENT2, CTX_INLINE_CHAT_HAS_NOTEBOOK_AGENT, CTX_INLINE_CHAT_HAS_NOTEBOOK_INLINE, CTX_INLINE_CHAT_OUTER_CURSOR_POSITION, CTX_INLINE_CHAT_POSSIBLE, CTX_INLINE_CHAT_REQUEST_IN_PROGRESS, CTX_INLINE_CHAT_RESPONSE_FOCUSED, CTX_INLINE_CHAT_RESPONSE_TYPE, CTX_INLINE_CHAT_V1_ENABLED, CTX_INLINE_CHAT_V2_ENABLED, CTX_INLINE_CHAT_VISIBLE, INLINE_CHAT_ID, InlineChatConfigKeys, InlineChatResponseType, MENU_INLINE_CHAT_SIDE, MENU_INLINE_CHAT_WIDGET_SECONDARY, MENU_INLINE_CHAT_WIDGET_STATUS, inlineChatBackground, inlineChatForeground };

package/vscode/src/vs/workbench/contrib/interactive/browser/interactiveCommon.d.ts

@@ -0,0 +1,7 @@
+import { RawContextKey } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey";
+export declare const INTERACTIVE_INPUT_CURSOR_BOUNDARY: RawContextKey<"top" | "none" | "bottom" | "both">;
+export declare const ReplEditorSettings: {
+    interactiveWindowAlwaysScrollOnNewCell: string;
+    executeWithShiftEnter: string;
+    showExecutionHint: string;
+};

package/vscode/src/vs/workbench/contrib/interactive/browser/interactiveCommon.js

@@ -0,0 +1,11 @@
+
+import { RawContextKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+
+const INTERACTIVE_INPUT_CURSOR_BOUNDARY = ( new RawContextKey("interactiveInputCursorAtBoundary", "none"));
+const ReplEditorSettings = {
+    interactiveWindowAlwaysScrollOnNewCell: "interactiveWindow.alwaysScrollOnNewCell",
+    executeWithShiftEnter: "interactiveWindow.executeWithShiftEnter",
+    showExecutionHint: "interactiveWindow.showExecutionHint"
+};
+
+export { INTERACTIVE_INPUT_CURSOR_BOUNDARY, ReplEditorSettings };

package/vscode/src/vs/workbench/contrib/interactive/browser/replInputHintContentWidget.d.ts

@@ -0,0 +1,20 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ICodeEditor, IContentWidget, IContentWidgetPosition } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
+export declare class ReplInputHintContentWidget extends Disposable implements IContentWidget {
+    private readonly editor;
+    private readonly configurationService;
+    private readonly keybindingService;
+    private static readonly ID;
+    private domNode;
+    private ariaLabel;
+    private label;
+    constructor(editor: ICodeEditor, configurationService: IConfigurationService, keybindingService: IKeybindingService);
+    getId(): string;
+    getPosition(): IContentWidgetPosition | null;
+    getDomNode(): HTMLElement;
+    private setHint;
+    private getKeybinding;
+    dispose(): void;
+}

package/vscode/src/vs/workbench/contrib/interactive/browser/replInputHintContentWidget.js

@@ -0,0 +1,150 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { $, addDisposableListener } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { status } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/aria/aria';
+import { KeybindingLabel } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/keybindingLabel/keybindingLabel';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { OS } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { ContentWidgetPositionPreference } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser';
+import { EditorOption } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/config/editorOptions';
+import { Position } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { AccessibilityVerbositySettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
+import { AccessibilityCommandId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/common/accessibilityCommands';
+import { ReplEditorSettings } from './interactiveCommon.js';
+
+var ReplInputHintContentWidget_1;
+let ReplInputHintContentWidget = class ReplInputHintContentWidget extends Disposable {
+    static {
+        ReplInputHintContentWidget_1 = this;
+    }
+    static {
+        this.ID = "replInput.widget.emptyHint";
+    }
+    constructor(editor, configurationService, keybindingService) {
+        super();
+        this.editor = editor;
+        this.configurationService = configurationService;
+        this.keybindingService = keybindingService;
+        this.ariaLabel = "";
+        this._register(this.editor.onDidChangeConfiguration(e => {
+            if (this.domNode && e.hasChanged(EditorOption.fontInfo)) {
+                this.editor.applyFontInfo(this.domNode);
+            }
+        }));
+        const onDidFocusEditorText = Event.debounce(this.editor.onDidFocusEditorText, () => undefined, 500);
+        this._register(onDidFocusEditorText(() => {
+            if (this.editor.hasTextFocus() && this.ariaLabel && configurationService.getValue(AccessibilityVerbositySettingId.ReplEditor)) {
+                status(this.ariaLabel);
+            }
+        }));
+        this._register(configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(ReplEditorSettings.executeWithShiftEnter)) {
+                this.setHint();
+            }
+        }));
+        this.editor.addContentWidget(this);
+    }
+    getId() {
+        return ReplInputHintContentWidget_1.ID;
+    }
+    getPosition() {
+        return {
+            position: {
+                lineNumber: 1,
+                column: 1
+            },
+            preference: [ContentWidgetPositionPreference.EXACT]
+        };
+    }
+    getDomNode() {
+        if (!this.domNode) {
+            this.domNode = $(".empty-editor-hint");
+            this.domNode.style.width = "max-content";
+            this.domNode.style.paddingLeft = "4px";
+            this.setHint();
+            this._register(addDisposableListener(this.domNode, "click", () => {
+                this.editor.focus();
+            }));
+            this.editor.applyFontInfo(this.domNode);
+            const lineHeight = this.editor.getLineHeightForPosition(( new Position(1, 1)));
+            this.domNode.style.lineHeight = lineHeight + "px";
+        }
+        return this.domNode;
+    }
+    setHint() {
+        if (!this.domNode) {
+            return;
+        }
+        while (this.domNode.firstChild) {
+            this.domNode.removeChild(this.domNode.firstChild);
+        }
+        const hintElement = $("div.empty-hint-text");
+        hintElement.style.cursor = "text";
+        hintElement.style.whiteSpace = "nowrap";
+        const keybinding = this.getKeybinding();
+        const keybindingHintLabel = keybinding?.getLabel();
+        if (keybinding && keybindingHintLabel) {
+            const actionPart = ( localize(8712, "Press {0} to execute. ", keybindingHintLabel));
+            const [before, after] = ( actionPart.split(keybindingHintLabel).map(fragment => {
+                const hintPart = $("span", undefined, fragment);
+                hintPart.style.fontStyle = "italic";
+                return hintPart;
+            }));
+            hintElement.appendChild(before);
+            if (this.label) {
+                this.label.dispose();
+            }
+            this.label = this._register(( new KeybindingLabel(hintElement, OS)));
+            this.label.set(keybinding);
+            this.label.element.style.width = "min-content";
+            this.label.element.style.display = "inline";
+            hintElement.appendChild(after);
+            this.domNode.append(hintElement);
+            const helpKeybinding = this.keybindingService.lookupKeybinding(AccessibilityCommandId.OpenAccessibilityHelp)?.getLabel();
+            const helpInfo = helpKeybinding ? ( localize(8713, "Use {0} for accessibility help. ", helpKeybinding)) : ( localize(8714, "Run the Open Accessibility Help command for more information. "));
+            this.ariaLabel = actionPart.concat(helpInfo, ( localize(
+                8715,
+                " Toggle {0} in settings to disable this hint.",
+                AccessibilityVerbositySettingId.ReplEditor
+            )));
+        }
+    }
+    getKeybinding() {
+        const keybindings = this.keybindingService.lookupKeybindings("interactive.execute");
+        const shiftEnterConfig = this.configurationService.getValue(ReplEditorSettings.executeWithShiftEnter);
+        const hasEnterChord = (kb, modifier = "") => {
+            const chords = kb.getDispatchChords();
+            const chord = modifier + "Enter";
+            const chordAlt = modifier + "[Enter]";
+            return chords.length === 1 && (chords[0] === chord || chords[0] === chordAlt);
+        };
+        if (shiftEnterConfig) {
+            const keybinding = keybindings.find(kb => hasEnterChord(kb, "shift+"));
+            if (keybinding) {
+                return keybinding;
+            }
+        } else {
+            let keybinding = keybindings.find(kb => hasEnterChord(kb));
+            if (keybinding) {
+                return keybinding;
+            }
+            keybinding = this.keybindingService.lookupKeybindings("python.execInREPLEnter").find(kb => hasEnterChord(kb));
+            if (keybinding) {
+                return keybinding;
+            }
+        }
+        return keybindings?.[0];
+    }
+    dispose() {
+        super.dispose();
+        this.editor.removeContentWidget(this);
+        this.label?.dispose();
+    }
+};
+ReplInputHintContentWidget = ReplInputHintContentWidget_1 = ( __decorate([( __param(1, IConfigurationService)), ( __param(2, IKeybindingService))], ReplInputHintContentWidget));
+
+export { ReplInputHintContentWidget };