@codingame/monaco-vscode-notebook-service-override 1.85.1

package/external/rollup-plugin-styles/dist/runtime/inject-css.js

@@ -0,0 +1,3 @@
+var e=[],t=[];function n(n,r){if(n&&"undefined"!=typeof document){var a,s=!0===r.prepend?"prepend":"append",d=!0===r.singleTag,i="string"==typeof r.container?document.querySelector(r.container):document.getElementsByTagName("head")[0];if(d){var u=e.indexOf(i);-1===u&&(u=e.push(i)-1,t[u]={}),a=t[u]&&t[u][s]?t[u][s]:t[u][s]=c();}else a=c();65279===n.charCodeAt(0)&&(n=n.substring(1)),a.styleSheet?a.styleSheet.cssText+=n:a.appendChild(document.createTextNode(n));}function c(){var e=document.createElement("style");if(e.setAttribute("type","text/css"),r.attributes)for(var t=( Object.keys(r.attributes)),n=0;n<t.length;n++)e.setAttribute(t[n],r.attributes[t[n]]);var a="prepend"===s?"afterbegin":"beforeend";return i.insertAdjacentElement(a,e),e}}
+
+export { n as default };

package/external/tslib/tslib.es6.js

@@ -0,0 +1,11 @@
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+export { __decorate, __param };

package/index.d.ts

@@ -0,0 +1 @@
+export { default } from './notebook.js';

package/index.js

@@ -0,0 +1 @@
+export { default } from './notebook.js';

package/notebook.d.ts

@@ -0,0 +1,5 @@
+import { IEditorOverrideServices } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
+
+declare function getServiceOverride(): IEditorOverrideServices;
+
+export { getServiceOverride as default };

package/notebook.js

@@ -0,0 +1,44 @@
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
+import { NotebookService } from './vscode/src/vs/workbench/contrib/notebook/browser/services/notebookServiceImpl.js';
+import { INotebookEditorModelResolverService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService';
+import { INotebookEditorWorkerService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/services/notebookWorkerService';
+import { NotebookEditorWorkerServiceImpl } from './vscode/src/vs/workbench/contrib/notebook/browser/services/notebookWorkerServiceImpl.js';
+import { INotebookCellStatusBarService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCellStatusBarService';
+import { NotebookCellStatusBarService } from './vscode/src/vs/workbench/contrib/notebook/browser/services/notebookCellStatusBarServiceImpl.js';
+import { INotebookEditorService } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService';
+import { NotebookEditorWidgetService } from './vscode/src/vs/workbench/contrib/notebook/browser/services/notebookEditorServiceImpl.js';
+import { NotebookModelResolverServiceImpl } from './vscode/src/vs/workbench/contrib/notebook/common/notebookEditorModelResolverServiceImpl.js';
+import { INotebookKernelService, INotebookKernelHistoryService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService';
+import { NotebookKernelService } from './vscode/src/vs/workbench/contrib/notebook/browser/services/notebookKernelServiceImpl.js';
+import { NotebookRendererMessagingService } from './vscode/src/vs/workbench/contrib/notebook/browser/services/notebookRendererMessagingServiceImpl.js';
+import { INotebookRendererMessagingService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookRendererMessagingService';
+import { NotebookExecutionStateService } from './vscode/src/vs/workbench/contrib/notebook/browser/services/notebookExecutionStateServiceImpl.js';
+import { NotebookExecutionService } from './vscode/src/vs/workbench/contrib/notebook/browser/services/notebookExecutionServiceImpl.js';
+import { INotebookExecutionService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionService';
+import { INotebookKeymapService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKeymapService';
+import { NotebookKeymapService } from './vscode/src/vs/workbench/contrib/notebook/browser/services/notebookKeymapServiceImpl.js';
+import { INotebookExecutionStateService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService';
+import { NotebookKernelHistoryService } from './vscode/src/vs/workbench/contrib/notebook/browser/services/notebookKernelHistoryServiceImpl.js';
+import { INotebookLoggingService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookLoggingService';
+import { NotebookLoggingService } from './vscode/src/vs/workbench/contrib/notebook/browser/services/notebookLoggingServiceImpl.js';
+import './vscode/src/vs/workbench/contrib/notebook/browser/notebook.contribution.js';
+
+function getServiceOverride() {
+    return {
+        [( INotebookService.toString())]: new SyncDescriptor(NotebookService, [], true),
+        [( INotebookEditorWorkerService.toString())]: new SyncDescriptor(NotebookEditorWorkerServiceImpl, [], true),
+        [( INotebookEditorModelResolverService.toString())]: new SyncDescriptor(NotebookModelResolverServiceImpl, [], true),
+        [( INotebookCellStatusBarService.toString())]: new SyncDescriptor(NotebookCellStatusBarService, [], true),
+        [( INotebookEditorService.toString())]: new SyncDescriptor(NotebookEditorWidgetService, [], true),
+        [( INotebookKernelService.toString())]: new SyncDescriptor(NotebookKernelService, [], true),
+        [( INotebookKernelHistoryService.toString())]: new SyncDescriptor(NotebookKernelHistoryService, [], true),
+        [( INotebookExecutionService.toString())]: new SyncDescriptor(NotebookExecutionService, [], true),
+        [( INotebookExecutionStateService.toString())]: new SyncDescriptor(NotebookExecutionStateService, [], true),
+        [( INotebookRendererMessagingService.toString())]: new SyncDescriptor(NotebookRendererMessagingService, [], true),
+        [( INotebookKeymapService.toString())]: new SyncDescriptor(NotebookKeymapService, [], true),
+        [( INotebookLoggingService.toString())]: new SyncDescriptor(NotebookLoggingService, [], true)
+    };
+}
+
+export { getServiceOverride as default };

package/override/vs/platform/dialogs/common/dialogs.js

@@ -0,0 +1,8 @@
+var ConfirmResult;
+( (function(ConfirmResult) {
+    ConfirmResult[ConfirmResult["SAVE"] = 0] = "SAVE";
+    ConfirmResult[ConfirmResult["DONT_SAVE"] = 1] = "DONT_SAVE";
+    ConfirmResult[ConfirmResult["CANCEL"] = 2] = "CANCEL";
+})(ConfirmResult || (ConfirmResult = {})));
+
+export { ConfirmResult };

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@codingame/monaco-vscode-notebook-service-override",
+  "version": "1.85.1",
+  "keywords": [],
+  "author": {
+    "name": "CodinGame",
+    "url": "http://www.codingame.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CodinGame/monaco-vscode-api.git"
+  },
+  "type": "module",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - notebook service-override",
+  "main": "index.js",
+  "module": "index.js",
+  "types": "index.d.ts",
+  "dependencies": {
+    "vscode": "npm:@codingame/monaco-vscode-api@1.85.1",
+    "monaco-editor": "0.45.0"
+  },
+  "exports": {
+    ".": {
+      "default": "./index.js"
+    },
+    "./worker": {
+      "default": "./worker.js"
+    }
+  }
+}

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

@@ -0,0 +1,6 @@
+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,387 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import './emptyTextEditorHint.css.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { dispose, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { ChangeLanguageAction } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorStatus';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { PLAINTEXT_LANGUAGE_ID } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { registerEditorContribution } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+import { renderFormattedText } from 'monaco-editor/esm/vs/base/browser/formattedTextRenderer.js';
+import { ApplyFileSnippetAction } from 'vscode/vscode/vs/workbench/contrib/snippets/browser/commands/fileTemplateSnippets';
+import { IInlineChatSessionService } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSession';
+import { IInlineChatService } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { KeybindingLabel } from 'monaco-editor/esm/vs/base/browser/ui/keybindingLabel/keybindingLabel.js';
+import { OS } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { status } from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/configuration';
+import { OUTPUT_MODE_ID, LOG_MODE_ID } from 'vscode/vscode/vs/workbench/services/output/common/output';
+import { SEARCH_RESULT_LANGUAGE_ID } from 'vscode/vscode/vs/workbench/services/search/common/search';
+
+const $ = dom.$;
+( 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.onDidChangeModelDecorations(() => 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(editor => {
+            if (this.editor === editor) {
+                this.update();
+            }
+        }));
+    }
+    _getOptions() {
+        return { clickable: true };
+    }
+    _shouldRenderHint() {
+        const configValue = this.configurationService.getValue(emptyTextEditorHintSetting);
+        if (configValue === 'hidden') {
+            return false;
+        }
+        if (this.editor.getOption(90 )) {
+            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;
+        }
+        const inlineChatProviders = [...this.inlineChatService.getAllProvider()];
+        const shouldRenderDefaultHint = model?.uri.scheme === Schemas.untitled && languageId === PLAINTEXT_LANGUAGE_ID && !inlineChatProviders.length;
+        return inlineChatProviders.length > 0 || shouldRenderDefaultHint;
+    }
+    update() {
+        this.textHintContentWidget?.dispose();
+        if (this._shouldRenderHint()) {
+            this.textHintContentWidget = ( new EmptyTextEditorHintContentWidget(
+                this.editor,
+                this._getOptions(),
+                this.editorGroupsService,
+                this.commandService,
+                this.configurationService,
+                this.keybindingService,
+                this.inlineChatService,
+                this.telemetryService,
+                this.productService
+            ));
+        }
+    }
+    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.inlineChatService.onDidChangeProviders(() => this.onDidChangeModelContent()));
+        this.toDispose.add(this.editor.onDidChangeModelContent(() => this.onDidChangeModelContent()));
+        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.onDidChangeModelContent();
+    }
+    onDidChangeModelContent() {
+        if (!this.editor.getModel()?.getValueLength() && !this.hasConflictingDecorations()) {
+            this.editor.addContentWidget(this);
+            this.isVisible = true;
+        }
+        else {
+            this.editor.removeContentWidget(this);
+            this.isVisible = false;
+        }
+    }
+    hasConflictingDecorations() {
+        const res = Boolean(this.editor.getLineDecorations(1)?.find((d) => d.options.beforeContentClassName
+            || d.options.afterContentClassName
+            || d.options.before?.content
+            || d.options.after?.content));
+        return res;
+    }
+    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'
+            });
+            void 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';
+                    hintPart.onclick = handleClick;
+                    return hintPart;
+                }
+                else {
+                    const hintPart = $('span', undefined, fragment);
+                    hintPart.style.fontStyle = 'italic';
+                    return hintPart;
+                }
+            }));
+            hintElement.appendChild(before);
+            const label = ( 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';
+                label.element.onclick = 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();
+            anchor.title = 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(dom.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 };