@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/contrib/chat/common/voiceChat.js

@@ -0,0 +1,139 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { rtrim } from '../../../../base/common/strings.js';
+import '../../../../platform/instantiation/common/instantiation.js';
+import { IChatAgentService } from './chatAgents.js';
+import { chatAgentLeader, chatSubcommandLeader } from './chatParserTypes.js';
+import { SpeechToTextStatus, ISpeechService } from '../../speech/common/speechService.js';
+var VoiceChatService_1;
+var PhraseTextType;
+( (function(PhraseTextType) {
+    PhraseTextType[PhraseTextType["AGENT"] = 1] = "AGENT";
+    PhraseTextType[PhraseTextType["COMMAND"] = 2] = "COMMAND";
+    PhraseTextType[PhraseTextType["AGENT_AND_COMMAND"] = 3] = "AGENT_AND_COMMAND";
+})(PhraseTextType || (PhraseTextType = {})));
+let VoiceChatService = class VoiceChatService extends Disposable {
+    static { VoiceChatService_1 = this; }
+    static { this.AGENT_PREFIX = chatAgentLeader; }
+    static { this.COMMAND_PREFIX = chatSubcommandLeader; }
+    static { this.PHRASES_LOWER = {
+        [VoiceChatService_1.AGENT_PREFIX]: 'at',
+        [VoiceChatService_1.COMMAND_PREFIX]: 'slash'
+    }; }
+    static { this.PHRASES_UPPER = {
+        [VoiceChatService_1.AGENT_PREFIX]: 'At',
+        [VoiceChatService_1.COMMAND_PREFIX]: 'Slash'
+    }; }
+    static { this.CHAT_AGENT_ALIAS = ( new Map([['vscode', 'code']])); }
+    constructor(speechService, chatAgentService) {
+        super();
+        this.speechService = speechService;
+        this.chatAgentService = chatAgentService;
+    }
+    createPhrases(model) {
+        const phrases = ( new Map());
+        for (const agent of this.chatAgentService.getActivatedAgents()) {
+            const agentPhrase = `${VoiceChatService_1.PHRASES_LOWER[VoiceChatService_1.AGENT_PREFIX]} ${VoiceChatService_1.CHAT_AGENT_ALIAS.get(agent.id) ?? agent.id}`.toLowerCase();
+            phrases.set(agentPhrase, { agent: agent.id });
+            for (const slashCommand of agent.slashCommands) {
+                const slashCommandPhrase = `${VoiceChatService_1.PHRASES_LOWER[VoiceChatService_1.COMMAND_PREFIX]} ${slashCommand.name}`.toLowerCase();
+                phrases.set(slashCommandPhrase, { agent: agent.id, command: slashCommand.name });
+                const agentSlashCommandPhrase = `${agentPhrase} ${slashCommandPhrase}`.toLowerCase();
+                phrases.set(agentSlashCommandPhrase, { agent: agent.id, command: slashCommand.name });
+            }
+        }
+        return phrases;
+    }
+    toText(value, type) {
+        switch (type) {
+            case PhraseTextType.AGENT:
+                return `${VoiceChatService_1.AGENT_PREFIX}${value.agent}`;
+            case PhraseTextType.COMMAND:
+                return `${VoiceChatService_1.COMMAND_PREFIX}${value.command}`;
+            case PhraseTextType.AGENT_AND_COMMAND:
+                return `${VoiceChatService_1.AGENT_PREFIX}${value.agent} ${VoiceChatService_1.COMMAND_PREFIX}${value.command}`;
+        }
+    }
+    async createVoiceChatSession(token, options) {
+        const disposables = ( new DisposableStore());
+        disposables.add(token.onCancellationRequested(() => disposables.dispose()));
+        let detectedAgent = false;
+        let detectedSlashCommand = false;
+        const emitter = disposables.add(( new Emitter()));
+        const session = await this.speechService.createSpeechToTextSession(token, 'chat');
+        const phrases = this.createPhrases(options.model);
+        disposables.add(session.onDidChange(e => {
+            switch (e.status) {
+                case SpeechToTextStatus.Recognizing:
+                case SpeechToTextStatus.Recognized:
+                    if (e.text) {
+                        const startsWithAgent = e.text.startsWith(VoiceChatService_1.PHRASES_UPPER[VoiceChatService_1.AGENT_PREFIX]) || e.text.startsWith(VoiceChatService_1.PHRASES_LOWER[VoiceChatService_1.AGENT_PREFIX]);
+                        const startsWithSlashCommand = e.text.startsWith(VoiceChatService_1.PHRASES_UPPER[VoiceChatService_1.COMMAND_PREFIX]) || e.text.startsWith(VoiceChatService_1.PHRASES_LOWER[VoiceChatService_1.COMMAND_PREFIX]);
+                        if (startsWithAgent || startsWithSlashCommand) {
+                            const originalWords = e.text.split(' ');
+                            let transformedWords;
+                            let waitingForInput = false;
+                            if (options.usesAgents && startsWithAgent && !detectedAgent && !detectedSlashCommand && originalWords.length >= 4) {
+                                const phrase = phrases.get(( originalWords.slice(0, 4).map(word => this.normalizeWord(word))).join(' '));
+                                if (phrase) {
+                                    transformedWords = [this.toText(phrase, PhraseTextType.AGENT_AND_COMMAND), ...originalWords.slice(4)];
+                                    waitingForInput = originalWords.length === 4;
+                                    if (e.status === SpeechToTextStatus.Recognized) {
+                                        detectedAgent = true;
+                                        detectedSlashCommand = true;
+                                    }
+                                }
+                            }
+                            if (options.usesAgents && startsWithAgent && !detectedAgent && !transformedWords && originalWords.length >= 2) {
+                                const phrase = phrases.get(( originalWords.slice(0, 2).map(word => this.normalizeWord(word))).join(' '));
+                                if (phrase) {
+                                    transformedWords = [this.toText(phrase, PhraseTextType.AGENT), ...originalWords.slice(2)];
+                                    waitingForInput = originalWords.length === 2;
+                                    if (e.status === SpeechToTextStatus.Recognized) {
+                                        detectedAgent = true;
+                                    }
+                                }
+                            }
+                            if (startsWithSlashCommand && !detectedSlashCommand && !transformedWords && originalWords.length >= 2) {
+                                const phrase = phrases.get(( originalWords.slice(0, 2).map(word => this.normalizeWord(word))).join(' '));
+                                if (phrase) {
+                                    transformedWords = [this.toText(phrase, options.usesAgents && !detectedAgent ?
+                                            PhraseTextType.AGENT_AND_COMMAND :
+                                            PhraseTextType.COMMAND
+                                        ), ...originalWords.slice(2)];
+                                    waitingForInput = originalWords.length === 2;
+                                    if (e.status === SpeechToTextStatus.Recognized) {
+                                        detectedSlashCommand = true;
+                                    }
+                                }
+                            }
+                            emitter.fire({
+                                status: e.status,
+                                text: (transformedWords ?? originalWords).join(' '),
+                                waitingForInput
+                            });
+                            break;
+                        }
+                    }
+                default:
+                    emitter.fire(e);
+                    break;
+            }
+        }));
+        return {
+            onDidChange: emitter.event
+        };
+    }
+    normalizeWord(word) {
+        word = rtrim(word, '.');
+        word = rtrim(word, ',');
+        word = rtrim(word, '?');
+        return word.toLowerCase();
+    }
+};
+VoiceChatService = VoiceChatService_1 = ( __decorate([
+    ( __param(0, ISpeechService)),
+    ( __param(1, IChatAgentService))
+], VoiceChatService));
+export { VoiceChatService };

package/vscode/src/vs/workbench/contrib/codeEditor/browser/accessibility/accessibility.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".accessible-view{background-color:var(--vscode-editorWidget-background);border:2px solid var(--vscode-focusBorder);border-radius:6px;box-shadow:0 2px 8px var(--vscode-widget-shadow);color:var(--vscode-editorWidget-foreground);margin-top:-1px;position:absolute;z-index:2550}.accessible-view-container .actions-container{display:flex;justify-content:flex-end;margin:0 auto;padding:0;width:100%}.accessible-view-title-bar{align-items:center;border-top-left-radius:5px;border-top-right-radius:5px;display:flex}.accessible-view-title{overflow:hidden;padding:3px 0;text-align:center;text-overflow:ellipsis;width:100%}.accessible-view-action-bar{flex:1;justify-content:flex-end;margin-right:4px}.accessible-view-action-bar>.actions-container{justify-content:flex-end}.accessible-view-title-bar .monaco-action-bar .action-label.codicon{background-position:50%;background-repeat:no-repeat;padding:2px}.accessible-view.hide{left:-2000px;pointer-events:none;position:fixed;top:-2000px}";
+n(css,{});
+export { css, css as default };

package/vscode/src/vs/workbench/contrib/codeEditor/browser/accessibility/accessibility.js

@@ -0,0 +1,39 @@
+import './accessibility.css.js';
+import { localize2WithPath } from '../../../../../nls.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';
+import { IAccessibilityService } from '../../../../../platform/accessibility/common/accessibility.js';
+import { registerAction2, Action2 } from '../../../../../platform/actions/common/actions.js';
+import { accessibilityHelpIsShown } from '../../../accessibility/browser/accessibilityConfiguration.js';
+import { alert } from '../../../../../base/browser/ui/aria/aria.js';
+import { AccessibilityHelpNLS } from '../../../../../editor/common/standaloneStrings.js';
+class ToggleScreenReaderMode extends Action2 {
+    constructor() {
+        super({
+            id: 'editor.action.toggleScreenReaderAccessibilityMode',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/codeEditor/browser/accessibility/accessibility',
+                'toggleScreenReaderMode',
+                "Toggle Screen Reader Accessibility Mode"
+            )),
+            f1: true,
+            keybinding: [{
+                    primary: 2048  | 35 ,
+                    weight: 200  + 10,
+                    when: accessibilityHelpIsShown
+                },
+                {
+                    primary: 512  | 59  | 1024 ,
+                    linux: { primary: 512  | 62  | 1024  },
+                    weight: 200  + 10,
+                }]
+        });
+    }
+    async run(accessor) {
+        const accessibiiltyService = accessor.get(IAccessibilityService);
+        const configurationService = accessor.get(IConfigurationService);
+        const isScreenReaderOptimized = accessibiiltyService.isScreenReaderOptimized();
+        configurationService.updateValue('editor.accessibilitySupport', isScreenReaderOptimized ? 'off' : 'on', 2 );
+        alert(isScreenReaderOptimized ? AccessibilityHelpNLS.screenReaderModeDisabled : AccessibilityHelpNLS.screenReaderModeEnabled);
+    }
+}
+registerAction2(ToggleScreenReaderMode);

package/vscode/src/vs/workbench/contrib/codeEditor/browser/emptyTextEditorHint/emptyTextEditorHint.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-editor .contentWidgets .empty-editor-hint{color:var(--vscode-input-placeholderForeground)}.monaco-editor .contentWidgets .empty-editor-hint a{color:var(--vscode-textLink-foreground)}";
+n(css,{});
+export { css, css as default };

package/vscode/src/vs/workbench/contrib/codeEditor/browser/emptyTextEditorHint/emptyTextEditorHint.js

@@ -0,0 +1,389 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import './emptyTextEditorHint.css.js';
+import { addDisposableListener, $ as $$1, EventType } from '../../../../../base/browser/dom.js';
+import { dispose, DisposableStore } from '../../../../../base/common/lifecycle.js';
+import { localizeWithPath } from '../../../../../nls.js';
+import { ChangeLanguageAction } from '../../../../browser/parts/editor/editorStatus.js';
+import { ICommandService } from '../../../../../platform/commands/common/commands.js';
+import { PLAINTEXT_LANGUAGE_ID } from '../../../../../editor/common/languages/modesRegistry.js';
+import { Schemas } from '../../../../../base/common/network.js';
+import { Event } from '../../../../../base/common/event.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';
+import { registerEditorContribution } from '../../../../../editor/browser/editorExtensions.js';
+import { IKeybindingService } from '../../../../../platform/keybinding/common/keybinding.js';
+import { IEditorGroupsService } from '../../../../services/editor/common/editorGroupsService.js';
+import { renderFormattedText } from '../../../../../base/browser/formattedTextRenderer.js';
+import { ApplyFileSnippetAction } from '../../../snippets/browser/commands/fileTemplateSnippets.js';
+import { IInlineChatSessionService } from '../../../inlineChat/browser/inlineChatSessionService.js';
+import { IInlineChatService } from '../../../inlineChat/common/inlineChat.js';
+import { ITelemetryService } from '../../../../../platform/telemetry/common/telemetry.js';
+import { IProductService } from '../../../../../platform/product/common/productService.js';
+import { KeybindingLabel } from '../../../../../base/browser/ui/keybindingLabel/keybindingLabel.js';
+import { OS } from '../../../../../base/common/platform.js';
+import { status } from '../../../../../base/browser/ui/aria/aria.js';
+import { Registry } from '../../../../../platform/registry/common/platform.js';
+import { Extensions } from '../../../../common/configuration.js';
+import { OUTPUT_MODE_ID, LOG_MODE_ID } from '../../../../services/output/common/output.js';
+import { SEARCH_RESULT_LANGUAGE_ID } from '../../../../services/search/common/search.js';
+import { setupCustomHover } from '../../../../../base/browser/ui/hover/updatableHoverWidget.js';
+import { getDefaultHoverDelegate } from '../../../../../base/browser/ui/hover/hoverDelegateFactory.js';
+const $ = $$1;
+( Registry.as(Extensions.ConfigurationMigration))
+    .registerConfigurationMigrations([{
+        key: 'workbench.editor.untitled.hint',
+        migrateFn: (value, _accessor) => ([
+            [emptyTextEditorHintSetting, { value }],
+            ['workbench.editor.untitled.hint', { value: undefined }]
+        ])
+    },
+    {
+        key: 'accessibility.verbosity.untitledHint',
+        migrateFn: (value, _accessor) => ([
+            ["accessibility.verbosity.emptyEditorHint" , { value }],
+            ['accessibility.verbosity.untitledHint', { value: undefined }]
+        ])
+    }]);
+const emptyTextEditorHintSetting = 'workbench.editor.empty.hint';
+let EmptyTextEditorHintContribution = class EmptyTextEditorHintContribution {
+    static { this.ID = 'editor.contrib.emptyTextEditorHint'; }
+    constructor(editor, editorGroupsService, commandService, configurationService, keybindingService, inlineChatSessionService, inlineChatService, telemetryService, productService) {
+        this.editor = editor;
+        this.editorGroupsService = editorGroupsService;
+        this.commandService = commandService;
+        this.configurationService = configurationService;
+        this.keybindingService = keybindingService;
+        this.inlineChatSessionService = inlineChatSessionService;
+        this.inlineChatService = inlineChatService;
+        this.telemetryService = telemetryService;
+        this.productService = productService;
+        this.toDispose = [];
+        this.toDispose.push(this.editor.onDidChangeModel(() => this.update()));
+        this.toDispose.push(this.editor.onDidChangeModelLanguage(() => this.update()));
+        this.toDispose.push(this.editor.onDidChangeModelContent(() => this.update()));
+        this.toDispose.push(this.inlineChatService.onDidChangeProviders(() => this.update()));
+        this.toDispose.push(this.editor.onDidChangeModelDecorations(() => this.update()));
+        this.toDispose.push(this.editor.onDidChangeConfiguration((e) => {
+            if (e.hasChanged(91 )) {
+                this.update();
+            }
+        }));
+        this.toDispose.push(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(emptyTextEditorHintSetting)) {
+                this.update();
+            }
+        }));
+        this.toDispose.push(inlineChatSessionService.onWillStartSession(editor => {
+            if (this.editor === editor) {
+                this.textHintContentWidget?.dispose();
+            }
+        }));
+        this.toDispose.push(inlineChatSessionService.onDidEndSession(e => {
+            if (this.editor === e.editor) {
+                this.update();
+            }
+        }));
+    }
+    _getOptions() {
+        return { clickable: true };
+    }
+    _shouldRenderHint() {
+        const configValue = this.configurationService.getValue(emptyTextEditorHintSetting);
+        if (configValue === 'hidden') {
+            return false;
+        }
+        if (this.editor.getOption(91 )) {
+            return false;
+        }
+        const model = this.editor.getModel();
+        const languageId = model?.getLanguageId();
+        if (!model || languageId === OUTPUT_MODE_ID || languageId === LOG_MODE_ID || languageId === SEARCH_RESULT_LANGUAGE_ID) {
+            return false;
+        }
+        if (this.inlineChatSessionService.getSession(this.editor, model.uri)) {
+            return false;
+        }
+        if (this.editor.getModel()?.getValueLength()) {
+            return false;
+        }
+        const hasConflictingDecorations = Boolean(this.editor.getLineDecorations(1)?.find((d) => d.options.beforeContentClassName
+            || d.options.afterContentClassName
+            || d.options.before?.content
+            || d.options.after?.content));
+        if (hasConflictingDecorations) {
+            return false;
+        }
+        const inlineChatProviders = [...this.inlineChatService.getAllProvider()];
+        const shouldRenderDefaultHint = model?.uri.scheme === Schemas.untitled && languageId === PLAINTEXT_LANGUAGE_ID && !inlineChatProviders.length;
+        return inlineChatProviders.length > 0 || shouldRenderDefaultHint;
+    }
+    update() {
+        const shouldRenderHint = this._shouldRenderHint();
+        if (shouldRenderHint && !this.textHintContentWidget) {
+            this.textHintContentWidget = ( new EmptyTextEditorHintContentWidget(
+                this.editor,
+                this._getOptions(),
+                this.editorGroupsService,
+                this.commandService,
+                this.configurationService,
+                this.keybindingService,
+                this.inlineChatService,
+                this.telemetryService,
+                this.productService
+            ));
+        }
+        else if (!shouldRenderHint && this.textHintContentWidget) {
+            this.textHintContentWidget.dispose();
+            this.textHintContentWidget = undefined;
+        }
+    }
+    dispose() {
+        dispose(this.toDispose);
+        this.textHintContentWidget?.dispose();
+    }
+};
+EmptyTextEditorHintContribution = ( __decorate([
+    ( __param(1, IEditorGroupsService)),
+    ( __param(2, ICommandService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IKeybindingService)),
+    ( __param(5, IInlineChatSessionService)),
+    ( __param(6, IInlineChatService)),
+    ( __param(7, ITelemetryService)),
+    ( __param(8, IProductService))
+], EmptyTextEditorHintContribution));
+class EmptyTextEditorHintContentWidget {
+    static { this.ID = 'editor.widget.emptyHint'; }
+    constructor(editor, options, editorGroupsService, commandService, configurationService, keybindingService, inlineChatService, telemetryService, productService) {
+        this.editor = editor;
+        this.options = options;
+        this.editorGroupsService = editorGroupsService;
+        this.commandService = commandService;
+        this.configurationService = configurationService;
+        this.keybindingService = keybindingService;
+        this.inlineChatService = inlineChatService;
+        this.telemetryService = telemetryService;
+        this.productService = productService;
+        this.isVisible = false;
+        this.ariaLabel = '';
+        this.toDispose = ( new DisposableStore());
+        this.toDispose.add(this.editor.onDidChangeConfiguration((e) => {
+            if (this.domNode && e.hasChanged(50 )) {
+                this.editor.applyFontInfo(this.domNode);
+            }
+        }));
+        const onDidFocusEditorText = Event.debounce(this.editor.onDidFocusEditorText, () => undefined, 500);
+        this.toDispose.add(onDidFocusEditorText(() => {
+            if (this.editor.hasTextFocus() && this.isVisible && this.ariaLabel && this.configurationService.getValue("accessibility.verbosity.emptyEditorHint" )) {
+                status(this.ariaLabel);
+            }
+        }));
+        this.editor.addContentWidget(this);
+    }
+    getId() {
+        return EmptyTextEditorHintContentWidget.ID;
+    }
+    _getHintInlineChat(providers) {
+        const providerName = (providers.length === 1 ? providers[0].label : undefined) ?? this.productService.nameShort;
+        const inlineChatId = 'inlineChat.start';
+        let ariaLabel = `Ask ${providerName} something or start typing to dismiss.`;
+        const handleClick = () => {
+            this.telemetryService.publicLog2('workbenchActionExecuted', {
+                id: 'inlineChat.hintAction',
+                from: 'hint'
+            });
+            this.commandService.executeCommand(inlineChatId, { from: 'hint' });
+        };
+        const hintHandler = {
+            disposables: this.toDispose,
+            callback: (index, _event) => {
+                switch (index) {
+                    case '0':
+                        handleClick();
+                        break;
+                }
+            }
+        };
+        const hintElement = $('empty-hint-text');
+        hintElement.style.display = 'block';
+        const keybindingHint = this.keybindingService.lookupKeybinding(inlineChatId);
+        const keybindingHintLabel = keybindingHint?.getLabel();
+        if (keybindingHint && keybindingHintLabel) {
+            const actionPart = ( localizeWithPath(
+                'vs/workbench/contrib/codeEditor/browser/emptyTextEditorHint/emptyTextEditorHint',
+                'emptyHintText',
+                'Press {0} to ask {1} to do something. ',
+                keybindingHintLabel,
+                providerName
+            ));
+            const [before, after] = ( actionPart.split(keybindingHintLabel).map((fragment) => {
+                if (this.options.clickable) {
+                    const hintPart = $('a', undefined, fragment);
+                    hintPart.style.fontStyle = 'italic';
+                    hintPart.style.cursor = 'pointer';
+                    this.toDispose.add(addDisposableListener(hintPart, EventType.CLICK, handleClick));
+                    return hintPart;
+                }
+                else {
+                    const hintPart = $('span', undefined, fragment);
+                    hintPart.style.fontStyle = 'italic';
+                    return hintPart;
+                }
+            }));
+            hintElement.appendChild(before);
+            const label = hintHandler.disposables.add(( new KeybindingLabel(hintElement, OS)));
+            label.set(keybindingHint);
+            label.element.style.width = 'min-content';
+            label.element.style.display = 'inline';
+            if (this.options.clickable) {
+                label.element.style.cursor = 'pointer';
+                this.toDispose.add(addDisposableListener(label.element, EventType.CLICK, handleClick));
+            }
+            hintElement.appendChild(after);
+            const typeToDismiss = ( localizeWithPath(
+                'vs/workbench/contrib/codeEditor/browser/emptyTextEditorHint/emptyTextEditorHint',
+                'emptyHintTextDismiss',
+                'Start typing to dismiss.'
+            ));
+            const textHint2 = $('span', undefined, typeToDismiss);
+            textHint2.style.fontStyle = 'italic';
+            hintElement.appendChild(textHint2);
+            ariaLabel = actionPart.concat(typeToDismiss);
+        }
+        else {
+            const hintMsg = ( localizeWithPath(
+                'vs/workbench/contrib/codeEditor/browser/emptyTextEditorHint/emptyTextEditorHint',
+                {
+                    key: 'inlineChatHint',
+                    comment: [
+                        'Preserve double-square brackets and their order',
+                    ]
+                },
+                '[[Ask {0} to do something]] or start typing to dismiss.',
+                providerName
+            ));
+            const rendered = renderFormattedText(hintMsg, { actionHandler: hintHandler });
+            hintElement.appendChild(rendered);
+        }
+        return { ariaLabel, hintHandler, hintElement };
+    }
+    _getHintDefault() {
+        const hintHandler = {
+            disposables: this.toDispose,
+            callback: (index, event) => {
+                switch (index) {
+                    case '0':
+                        languageOnClickOrTap(event.browserEvent);
+                        break;
+                    case '1':
+                        snippetOnClickOrTap(event.browserEvent);
+                        break;
+                    case '2':
+                        chooseEditorOnClickOrTap(event.browserEvent);
+                        break;
+                    case '3':
+                        dontShowOnClickOrTap();
+                        break;
+                }
+            }
+        };
+        const languageOnClickOrTap = async (e) => {
+            e.stopPropagation();
+            this.editor.focus();
+            this.telemetryService.publicLog2('workbenchActionExecuted', {
+                id: ChangeLanguageAction.ID,
+                from: 'hint'
+            });
+            await this.commandService.executeCommand(ChangeLanguageAction.ID, { from: 'hint' });
+            this.editor.focus();
+        };
+        const snippetOnClickOrTap = async (e) => {
+            e.stopPropagation();
+            this.telemetryService.publicLog2('workbenchActionExecuted', {
+                id: ApplyFileSnippetAction.Id,
+                from: 'hint'
+            });
+            await this.commandService.executeCommand(ApplyFileSnippetAction.Id);
+        };
+        const chooseEditorOnClickOrTap = async (e) => {
+            e.stopPropagation();
+            const activeEditorInput = this.editorGroupsService.activeGroup.activeEditor;
+            this.telemetryService.publicLog2('workbenchActionExecuted', {
+                id: 'welcome.showNewFileEntries',
+                from: 'hint'
+            });
+            const newEditorSelected = await this.commandService.executeCommand('welcome.showNewFileEntries', { from: 'hint' });
+            if (newEditorSelected && activeEditorInput !== null && activeEditorInput.resource?.scheme === Schemas.untitled) {
+                this.editorGroupsService.activeGroup.closeEditor(activeEditorInput, { preserveFocus: true });
+            }
+        };
+        const dontShowOnClickOrTap = () => {
+            this.configurationService.updateValue(emptyTextEditorHintSetting, 'hidden');
+            this.dispose();
+            this.editor.focus();
+        };
+        const hintMsg = ( localizeWithPath(
+            'vs/workbench/contrib/codeEditor/browser/emptyTextEditorHint/emptyTextEditorHint',
+            {
+                key: 'message',
+                comment: [
+                    'Preserve double-square brackets and their order',
+                    'language refers to a programming language'
+                ]
+            },
+            '[[Select a language]], or [[fill with template]], or [[open a different editor]] to get started.\nStart typing to dismiss or [[don\'t show]] this again.'
+        ));
+        const hintElement = renderFormattedText(hintMsg, {
+            actionHandler: hintHandler,
+            renderCodeSegments: false,
+        });
+        hintElement.style.fontStyle = 'italic';
+        const keybindingsLookup = [ChangeLanguageAction.ID, ApplyFileSnippetAction.Id, 'welcome.showNewFileEntries'];
+        const keybindingLabels = ( keybindingsLookup.map((id) => this.keybindingService.lookupKeybinding(id)?.getLabel() ?? id));
+        const ariaLabel = ( localizeWithPath(
+            'vs/workbench/contrib/codeEditor/browser/emptyTextEditorHint/emptyTextEditorHint',
+            'defaultHintAriaLabel',
+            'Execute {0} to select a language, execute {1} to fill with template, or execute {2} to open a different editor and get started. Start typing to dismiss.',
+            ...keybindingLabels
+        ));
+        for (const anchor of hintElement.querySelectorAll('a')) {
+            anchor.style.cursor = 'pointer';
+            const id = keybindingsLookup.shift();
+            const title = id && this.keybindingService.lookupKeybinding(id)?.getLabel();
+            hintHandler.disposables.add(setupCustomHover(getDefaultHoverDelegate('mouse'), anchor, title ?? ''));
+        }
+        return { hintElement, ariaLabel };
+    }
+    getDomNode() {
+        if (!this.domNode) {
+            this.domNode = $('.empty-editor-hint');
+            this.domNode.style.width = 'max-content';
+            this.domNode.style.paddingLeft = '4px';
+            const inlineChatProviders = [...this.inlineChatService.getAllProvider()];
+            const { hintElement, ariaLabel } = !inlineChatProviders.length ? this._getHintDefault() : this._getHintInlineChat(inlineChatProviders);
+            this.domNode.append(hintElement);
+            this.ariaLabel = ariaLabel.concat(( localizeWithPath(
+                'vs/workbench/contrib/codeEditor/browser/emptyTextEditorHint/emptyTextEditorHint',
+                'disableHint',
+                ' Toggle {0} in settings to disable this hint.',
+                "accessibility.verbosity.emptyEditorHint"
+            )));
+            this.toDispose.add(addDisposableListener(this.domNode, 'click', () => {
+                this.editor.focus();
+            }));
+            this.editor.applyFontInfo(this.domNode);
+        }
+        return this.domNode;
+    }
+    getPosition() {
+        return {
+            position: { lineNumber: 1, column: 1 },
+            preference: [0 ]
+        };
+    }
+    dispose() {
+        this.editor.removeContentWidget(this);
+        dispose(this.toDispose);
+    }
+}
+registerEditorContribution(EmptyTextEditorHintContribution.ID, EmptyTextEditorHintContribution, 0 );
+export { EmptyTextEditorHintContribution, emptyTextEditorHintSetting };