@codingame/monaco-vscode-notebook-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/contrib/replNotebook/browser/repl.contribution.js

@@ -43,9 +43,9 @@ import { REPL_EDITOR_ID, NotebookSetting, NotebookWorkingCopyTypeIdentifier, Cel
 import { MOST_RECENT_REPL_EDITOR, IS_COMPOSITE_NOTEBOOK, NOTEBOOK_CELL_LIST_FOCUSED, NOTEBOOK_EDITOR_FOCUSED } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
 import { INotebookEditorModelResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService.service';
 import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
-import { ReplEditor, isReplEditorControl } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/replNotebook/browser/replEditor';
+import { ReplEditor, isReplEditorControl } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/replNotebook/browser/replEditor';
 import { ReplEditorInputAccessibilityHelp, ReplEditorHistoryAccessibilityHelp } from './replEditorAccessibilityHelp.js';
-import { ReplEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/replNotebook/browser/replEditorInput';
+import { ReplEditorInput } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/replNotebook/browser/replEditorInput';
 
 class ReplEditorSerializer {
     canSerialize(input) {
@@ -67,80 +67,123 @@ class ReplEditorSerializer {
         if (!data) {
             return undefined;
         }
-        const { resource, viewType } = data;
-        if (!data || !URI.isUri(resource) || typeof viewType !== 'string') {
+        const {
+            resource,
+            viewType
+        } = data;
+        if (!data || !URI.isUri(resource) || typeof viewType !== "string") {
             return undefined;
         }
         const input = instantiationService.createInstance(ReplEditorInput, resource, data.label);
         return input;
     }
 }
-( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(EditorPaneDescriptor.create(ReplEditor, REPL_EDITOR_ID, 'REPL Editor'), [
-    ( new SyncDescriptor(ReplEditorInput))
-]);
+( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(
+    EditorPaneDescriptor.create(ReplEditor, REPL_EDITOR_ID, "REPL Editor"),
+    [( new SyncDescriptor(ReplEditorInput))]
+);
 ( Registry.as(EditorExtensions.EditorFactory)).registerEditorSerializer(ReplEditorInput.ID, ReplEditorSerializer);
 let ReplDocumentContribution = class ReplDocumentContribution extends Disposable {
-    static { this.ID = 'workbench.contrib.replDocument'; }
-    constructor(notebookService, editorResolverService, notebookEditorModelResolverService, instantiationService, configurationService) {
+    static {
+        this.ID = "workbench.contrib.replDocument";
+    }
+    constructor(
+        notebookService,
+        editorResolverService,
+        notebookEditorModelResolverService,
+        instantiationService,
+        configurationService
+    ) {
         super();
         this.notebookEditorModelResolverService = notebookEditorModelResolverService;
         this.instantiationService = instantiationService;
         this.configurationService = configurationService;
         this.editorInputCache = ( new ResourceMap());
         editorResolverService.registerEditor(
-        ` `, {
-            id: 'repl',
-            label: 'repl Editor',
-            priority: RegisteredEditorPriority.option
-        }, {
-            canSupportResource: uri => notebookService.getNotebookTextModel(uri) !== undefined,
-            singlePerResource: true
-        }, {
-            createUntitledEditorInput: async ({ resource, options }) => {
-                if (resource) {
-                    const editor = this.editorInputCache.get(resource);
-                    if (editor && !editor.isDisposed()) {
-                        return { editor, options };
+            ` `,
+            {
+                id: "repl",
+                label: "repl Editor",
+                priority: RegisteredEditorPriority.option
+            },
+            {
+                canSupportResource: uri => notebookService.getNotebookTextModel(uri) !== undefined,
+                singlePerResource: true
+            },
+            {
+                createUntitledEditorInput: async (
+                    {
+                        resource,
+                        options
                     }
-                    else if (editor) {
-                        this.editorInputCache.delete(resource);
+                ) => {
+                    if (resource) {
+                        const editor = this.editorInputCache.get(resource);
+                        if (editor && !editor.isDisposed()) {
+                            return {
+                                editor,
+                                options
+                            };
+                        } else if (editor) {
+                            this.editorInputCache.delete(resource);
+                        }
                     }
+                    const scratchpad = this.configurationService.getValue(NotebookSetting.InteractiveWindowPromptToSave) !== true;
+                    const ref = await this.notebookEditorModelResolverService.resolve({
+                        untitledResource: resource
+                    }, "jupyter-notebook", {
+                        scratchpad,
+                        viewType: "repl"
+                    });
+                    const notebookUri = ref.object.notebook.uri;
+                    Event.once(ref.object.notebook.onWillDispose)(() => {
+                        ref.dispose();
+                    });
+                    const label = options?.label ?? undefined;
+                    const editor = this.instantiationService.createInstance(ReplEditorInput, notebookUri, label);
+                    this.editorInputCache.set(notebookUri, editor);
+                    Event.once(editor.onWillDispose)(() => this.editorInputCache.delete(notebookUri));
+                    return {
+                        editor,
+                        options
+                    };
+                },
+                createEditorInput: async (
+                    {
+                        resource,
+                        options
+                    }
+                ) => {
+                    if (( this.editorInputCache.has(resource))) {
+                        return {
+                            editor: this.editorInputCache.get(resource),
+                            options
+                        };
+                    }
+                    const label = options?.label ?? undefined;
+                    const editor = this.instantiationService.createInstance(ReplEditorInput, resource, label);
+                    this.editorInputCache.set(resource, editor);
+                    Event.once(editor.onWillDispose)(() => this.editorInputCache.delete(resource));
+                    return {
+                        editor,
+                        options
+                    };
                 }
-                const scratchpad = this.configurationService.getValue(NotebookSetting.InteractiveWindowPromptToSave) !== true;
-                const ref = await this.notebookEditorModelResolverService.resolve({ untitledResource: resource }, 'jupyter-notebook', { scratchpad, viewType: 'repl' });
-                const notebookUri = ref.object.notebook.uri;
-                Event.once(ref.object.notebook.onWillDispose)(() => {
-                    ref.dispose();
-                });
-                const label = options?.label ?? undefined;
-                const editor = this.instantiationService.createInstance(ReplEditorInput, notebookUri, label);
-                this.editorInputCache.set(notebookUri, editor);
-                Event.once(editor.onWillDispose)(() => this.editorInputCache.delete(notebookUri));
-                return { editor, options };
-            },
-            createEditorInput: async ({ resource, options }) => {
-                if (( this.editorInputCache.has(resource))) {
-                    return { editor: this.editorInputCache.get(resource), options };
-                }
-                const label = options?.label ?? undefined;
-                const editor = this.instantiationService.createInstance(ReplEditorInput, resource, label);
-                this.editorInputCache.set(resource, editor);
-                Event.once(editor.onWillDispose)(() => this.editorInputCache.delete(resource));
-                return { editor, options };
             }
-        });
+        );
     }
 };
-ReplDocumentContribution = ( __decorate([
-    ( __param(0, INotebookService)),
-    ( __param(1, IEditorResolverService)),
-    ( __param(2, INotebookEditorModelResolverService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IConfigurationService))
-], ReplDocumentContribution));
+ReplDocumentContribution = ( __decorate([( __param(0, INotebookService)), ( __param(1, IEditorResolverService)), ( __param(2, INotebookEditorModelResolverService)), ( __param(3, IInstantiationService)), ( __param(4, IConfigurationService))], ReplDocumentContribution));
 let ReplWindowWorkingCopyEditorHandler = class ReplWindowWorkingCopyEditorHandler extends Disposable {
-    static { this.ID = 'workbench.contrib.replWorkingCopyEditorHandler'; }
-    constructor(instantiationService, workingCopyEditorService, extensionService, notebookService) {
+    static {
+        this.ID = "workbench.contrib.replWorkingCopyEditorHandler";
+    }
+    constructor(
+        instantiationService,
+        workingCopyEditorService,
+        extensionService,
+        notebookService
+    ) {
         super();
         this.instantiationService = instantiationService;
         this.workingCopyEditorService = workingCopyEditorService;
@@ -153,7 +196,7 @@ let ReplWindowWorkingCopyEditorHandler = class ReplWindowWorkingCopyEditorHandle
         if (!notebookType) {
             return false;
         }
-        return !!notebookType && notebookType.viewType === 'repl' && (await this.notebookService.canResolve(notebookType.notebookType));
+        return !!notebookType && notebookType.viewType === "repl" && (await this.notebookService.canResolve(notebookType.notebookType));
     }
     isOpen(workingCopy, editor) {
         if (!this.handles(workingCopy)) {
@@ -172,31 +215,34 @@ let ReplWindowWorkingCopyEditorHandler = class ReplWindowWorkingCopyEditorHandle
         return NotebookWorkingCopyTypeIdentifier.parse(workingCopy.typeId);
     }
 };
-ReplWindowWorkingCopyEditorHandler = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IWorkingCopyEditorService)),
-    ( __param(2, IExtensionService)),
-    ( __param(3, INotebookService))
-], ReplWindowWorkingCopyEditorHandler));
-registerWorkbenchContribution2(ReplWindowWorkingCopyEditorHandler.ID, ReplWindowWorkingCopyEditorHandler, WorkbenchPhase.BlockRestore);
-registerWorkbenchContribution2(ReplDocumentContribution.ID, ReplDocumentContribution, WorkbenchPhase.BlockRestore);
+ReplWindowWorkingCopyEditorHandler = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IWorkingCopyEditorService)), ( __param(2, IExtensionService)), ( __param(3, INotebookService))], ReplWindowWorkingCopyEditorHandler));
+registerWorkbenchContribution2(
+    ReplWindowWorkingCopyEditorHandler.ID,
+    ReplWindowWorkingCopyEditorHandler,
+    WorkbenchPhase.BlockRestore
+);
+registerWorkbenchContribution2(
+    ReplDocumentContribution.ID,
+    ReplDocumentContribution,
+    WorkbenchPhase.BlockRestore
+);
 AccessibleViewRegistry.register(( new ReplEditorInputAccessibilityHelp()));
 AccessibleViewRegistry.register(( new ReplEditorHistoryAccessibilityHelp()));
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: 'repl.focusLastItemExecuted',
-            title: ( localize2(10416, 'Focus Most Recent REPL Execution')),
-            category: 'REPL',
+            id: "repl.focusLastItemExecuted",
+            title: ( localize2(10734, "Focus Most Recent REPL Execution")),
+            category: "REPL",
             menu: {
                 id: MenuId.CommandPalette,
-                when: MOST_RECENT_REPL_EDITOR,
+                when: MOST_RECENT_REPL_EDITOR
             },
             keybinding: [{
-                    primary: KeyChord(KeyMod.Alt | KeyCode.End, KeyMod.Alt | KeyCode.End),
-                    weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT,
-                    when: ( ContextKeyExpr.or(IS_COMPOSITE_NOTEBOOK, ( NOTEBOOK_CELL_LIST_FOCUSED.negate())))
-                }],
+                primary: KeyChord(KeyMod.Alt | KeyCode.End, KeyMod.Alt | KeyCode.End),
+                weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT,
+                when: ( ContextKeyExpr.or(IS_COMPOSITE_NOTEBOOK, ( NOTEBOOK_CELL_LIST_FOCUSED.negate())))
+            }],
             precondition: MOST_RECENT_REPL_EDITOR
         });
     }
@@ -207,8 +253,7 @@ registerAction2(class extends Action2 {
         let notebookEditor;
         if (editorControl && isReplEditorControl(editorControl)) {
             notebookEditor = editorControl.notebookEditor;
-        }
-        else {
+        } else {
             const uriString = MOST_RECENT_REPL_EDITOR.getValue(contextKeyService);
             const uri = uriString ? ( URI.parse(uriString)) : undefined;
             if (!uri) {
@@ -228,7 +273,7 @@ registerAction2(class extends Action2 {
             const lastCellIndex = viewModel.length - 1;
             if (lastCellIndex >= 0) {
                 const cell = viewModel.viewCells[lastCellIndex];
-                notebookEditor.focusNotebookCell(cell, 'container');
+                notebookEditor.focusNotebookCell(cell, "container");
             }
         }
     }
@@ -236,22 +281,22 @@ registerAction2(class extends Action2 {
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: 'repl.input.focus',
-            title: ( localize2(10417, 'Focus Input Editor')),
-            category: 'REPL',
+            id: "repl.input.focus",
+            title: ( localize2(10735, "Focus Input Editor")),
+            category: "REPL",
             menu: {
                 id: MenuId.CommandPalette,
-                when: MOST_RECENT_REPL_EDITOR,
+                when: MOST_RECENT_REPL_EDITOR
             },
             keybinding: [{
-                    when: ( ContextKeyExpr.and(IS_COMPOSITE_NOTEBOOK, NOTEBOOK_EDITOR_FOCUSED)),
-                    weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT,
-                    primary: KeyMod.CtrlCmd | KeyCode.DownArrow
-                }, {
-                    when: ( ContextKeyExpr.and(MOST_RECENT_REPL_EDITOR)),
-                    weight: KeybindingWeight.WorkbenchContrib + 5,
-                    primary: KeyChord(KeyMod.Alt | KeyCode.Home, KeyMod.Alt | KeyCode.Home),
-                }]
+                when: ( ContextKeyExpr.and(IS_COMPOSITE_NOTEBOOK, NOTEBOOK_EDITOR_FOCUSED)),
+                weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT,
+                primary: KeyMod.CtrlCmd | KeyCode.DownArrow
+            }, {
+                when: ( ContextKeyExpr.and(MOST_RECENT_REPL_EDITOR)),
+                weight: KeybindingWeight.WorkbenchContrib + 5,
+                primary: KeyChord(KeyMod.Alt | KeyCode.Home, KeyMod.Alt | KeyCode.Home)
+            }]
         });
     }
     async run(accessor) {
@@ -260,8 +305,7 @@ registerAction2(class extends Action2 {
         const contextKeyService = accessor.get(IContextKeyService);
         if (editorControl && isReplEditorControl(editorControl) && editorControl.notebookEditor) {
             editorService.activeEditorPane?.focus();
-        }
-        else {
+        } else {
             const uriString = MOST_RECENT_REPL_EDITOR.getValue(contextKeyService);
             const uri = uriString ? ( URI.parse(uriString)) : undefined;
             if (!uri) {
@@ -269,7 +313,12 @@ registerAction2(class extends Action2 {
             }
             const replEditor = editorService.findEditors(uri)[0];
             if (replEditor) {
-                await editorService.openEditor({ resource: uri, options: { preserveFocus: false } }, replEditor.groupId);
+                await editorService.openEditor({
+                    resource: uri,
+                    options: {
+                        preserveFocus: false
+                    }
+                }, replEditor.groupId);
             }
         }
     }
@@ -277,38 +326,34 @@ registerAction2(class extends Action2 {
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: 'repl.execute',
-            title: ( localize2(10418, 'Execute REPL input')),
-            category: 'REPL',
+            id: "repl.execute",
+            title: ( localize2(10736, "Execute REPL input")),
+            category: "REPL",
             keybinding: [{
-                    when: ( ContextKeyExpr.and(IS_COMPOSITE_NOTEBOOK, ( ContextKeyExpr.equals('activeEditor', 'workbench.editor.repl')), ( NOTEBOOK_CELL_LIST_FOCUSED.negate()))),
-                    primary: KeyMod.CtrlCmd | KeyCode.Enter,
-                    weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT
-                }, {
-                    when: ( ContextKeyExpr.and(IS_COMPOSITE_NOTEBOOK, ( ContextKeyExpr.equals('activeEditor', 'workbench.editor.repl')), ( ContextKeyExpr.equals('config.interactiveWindow.executeWithShiftEnter', true)), ( NOTEBOOK_CELL_LIST_FOCUSED.negate()))),
-                    primary: KeyMod.Shift | KeyCode.Enter,
-                    weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT
-                }, {
-                    when: ( ContextKeyExpr.and(IS_COMPOSITE_NOTEBOOK, ( ContextKeyExpr.equals('activeEditor', 'workbench.editor.repl')), ( ContextKeyExpr.equals('config.interactiveWindow.executeWithShiftEnter', false)), ( NOTEBOOK_CELL_LIST_FOCUSED.negate()))),
-                    primary: KeyCode.Enter,
-                    weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT
-                }],
-            menu: [
-                {
-                    id: MenuId.ReplInputExecute
-                }
-            ],
+                when: ( ContextKeyExpr.and(IS_COMPOSITE_NOTEBOOK, ( ContextKeyExpr.equals("activeEditor", "workbench.editor.repl")), ( NOTEBOOK_CELL_LIST_FOCUSED.negate()))),
+                primary: KeyMod.CtrlCmd | KeyCode.Enter,
+                weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT
+            }, {
+                when: ( ContextKeyExpr.and(IS_COMPOSITE_NOTEBOOK, ( ContextKeyExpr.equals("activeEditor", "workbench.editor.repl")), ( ContextKeyExpr.equals("config.interactiveWindow.executeWithShiftEnter", true)), ( NOTEBOOK_CELL_LIST_FOCUSED.negate()))),
+                primary: KeyMod.Shift | KeyCode.Enter,
+                weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT
+            }, {
+                when: ( ContextKeyExpr.and(IS_COMPOSITE_NOTEBOOK, ( ContextKeyExpr.equals("activeEditor", "workbench.editor.repl")), ( ContextKeyExpr.equals("config.interactiveWindow.executeWithShiftEnter", false)), ( NOTEBOOK_CELL_LIST_FOCUSED.negate()))),
+                primary: KeyCode.Enter,
+                weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT
+            }],
+            menu: [{
+                id: MenuId.ReplInputExecute
+            }],
             icon: executeIcon,
             f1: false,
             metadata: {
-                description: 'Execute the Contents of the Input Box',
-                args: [
-                    {
-                        name: 'resource',
-                        description: 'Interactive resource Uri',
-                        isOptional: true
-                    }
-                ]
+                description: "Execute the Contents of the Input Box",
+                args: [{
+                    name: "resource",
+                    description: "Interactive resource Uri",
+                    isOptional: true
+                }]
             }
         });
     }
@@ -328,8 +373,7 @@ registerAction2(class extends Action2 {
                     break;
                 }
             }
-        }
-        else {
+        } else {
             editorControl = editorService.activeEditorPane?.getControl();
         }
         if (isReplEditorControl(editorControl)) {
@@ -354,34 +398,36 @@ async function executeReplInput(bulkEditService, historyService, notebookEditorS
                 ctrl.acceptSession();
             }
             historyService.replaceLast(notebookDocument.uri, value);
-            historyService.addToHistory(notebookDocument.uri, '');
-            textModel.setValue('');
+            historyService.addToHistory(notebookDocument.uri, "");
+            textModel.setValue("");
             notebookDocument.cells[index].resetTextBuffer(textModel.getTextBuffer());
-            const collapseState = editorControl.notebookEditor.notebookOptions.getDisplayOptions().interactiveWindowCollapseCodeCells === 'fromEditor' ?
-                {
-                    inputCollapsed: false,
-                    outputCollapsed: false
-                } :
-                undefined;
-            await bulkEditService.apply([
-                ( new ResourceNotebookCellEdit(notebookDocument.uri, {
-                    editType: CellEditType.Replace,
-                    index: index,
-                    count: 0,
-                    cells: [{
-                            cellKind: CellKind.Code,
-                            mime: undefined,
-                            language,
-                            source: value,
-                            outputs: [],
-                            metadata: {},
-                            collapseState
-                        }]
-                }))
-            ]);
-            const range = { start: index, end: index + 1 };
+            const collapseState = editorControl.notebookEditor.notebookOptions.getDisplayOptions().interactiveWindowCollapseCodeCells === "fromEditor" ? {
+                inputCollapsed: false,
+                outputCollapsed: false
+            } : undefined;
+            await bulkEditService.apply([( new ResourceNotebookCellEdit(notebookDocument.uri, {
+                editType: CellEditType.Replace,
+                index: index,
+                count: 0,
+                cells: [{
+                    cellKind: CellKind.Code,
+                    mime: undefined,
+                    language,
+                    source: value,
+                    outputs: [],
+                    metadata: {},
+                    collapseState
+                }]
+            }))]);
+            const range = {
+                start: index,
+                end: index + 1
+            };
             editorControl.notebookEditor.revealCellRangeInView(range);
-            await editorControl.notebookEditor.executeNotebookCells(editorControl.notebookEditor.getCellsInRange({ start: index, end: index + 1 }));
+            await editorControl.notebookEditor.executeNotebookCells(editorControl.notebookEditor.getCellsInRange({
+                start: index,
+                end: index + 1
+            }));
             const editor = notebookEditorService.getNotebookEditor(editorControl.notebookEditor.getId());
             if (editor) {
                 editor.setSelections([range]);
@@ -392,12 +438,12 @@ async function executeReplInput(bulkEditService, historyService, notebookEditorS
 }
 AccessibleViewRegistry.register(( new ReplEditorAccessibleView()));
 KeybindingsRegistry.registerCommandAndKeybindingRule({
-    id: 'list.find.replInputFocus',
+    id: "list.find.replInputFocus",
     weight: KeybindingWeight.WorkbenchContrib + 1,
-    when: ( ContextKeyExpr.equals('view', REPL_VIEW_ID)),
+    when: ( ContextKeyExpr.equals("view", REPL_VIEW_ID)),
     primary: KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.KeyF,
     secondary: [KeyCode.F3],
-    handler: (accessor) => {
+    handler: accessor => {
         getReplView(accessor.get(IViewsService))?.openFind();
     }
 });

package/vscode/src/vs/workbench/contrib/replNotebook/browser/replEditorAccessibilityHelp.js

@@ -9,7 +9,7 @@ import { IS_COMPOSITE_NOTEBOOK, NOTEBOOK_CELL_LIST_FOCUSED } from '@codingame/mo
 class ReplEditorInputAccessibilityHelp {
     constructor() {
         this.priority = 105;
-        this.name = 'REPL Editor Input';
+        this.name = "REPL Editor Input";
         this.when = ( ContextKeyExpr.and(IS_COMPOSITE_NOTEBOOK, ( NOTEBOOK_CELL_LIST_FOCUSED.negate())));
         this.type = AccessibleViewType.Help;
     }
@@ -18,45 +18,37 @@ class ReplEditorInputAccessibilityHelp {
     }
 }
 function getAccessibilityInputHelpText() {
-    return [
-        ( localize(
-        10420,
-        'You are in a REPL Editor Input box which will accept code to be executed in the REPL.'
-    )),
-        ( localize(
-        10421,
-        'The Execute command{0} will evaluate the expression in the input box.',
-        '<keybinding:repl.execute>'
-    )),
-        ( localize(
-        10422,
-        'The setting `accessibility.replEditor.readLastExecutionOutput` controls if output will be automatically read when execution completes.'
-    )),
-        ( localize(
-        10423,
-        'The setting `accessibility.replEditor.autoFocusReplExecution` controls if focus will automatically move to the REPL after executing code.'
-    )),
-        ( localize(
-        10424,
-        'The Focus Last executed command{0} will move focus to the last executed item in the REPL history.',
-        '<keybinding:repl.focusLastItemExecuted>'
-    )),
-        ( localize(
-        10425,
-        'When you run the Open Accessbility View command{0} from this input box, the output from the last execution will be shown in the accessibility view.',
-        '<keybinding:editor.action.accessibleView>'
-    )),
-        ( localize(
-        10426,
-        'The Focus Input Editor command{0} will bring the focus back to this editor.',
-        '<keybinding:repl.input.focus>'
-    )),
-    ].join('\n');
+    return [( localize(
+        10738,
+        "You are in a REPL Editor Input box which will accept code to be executed in the REPL."
+    )), ( localize(
+        10739,
+        "The Execute command{0} will evaluate the expression in the input box.",
+        "<keybinding:repl.execute>"
+    )), ( localize(
+        10740,
+        "The setting `accessibility.replEditor.readLastExecutionOutput` controls if output will be automatically read when execution completes."
+    )), ( localize(
+        10741,
+        "The setting `accessibility.replEditor.autoFocusReplExecution` controls if focus will automatically move to the REPL after executing code."
+    )), ( localize(
+        10742,
+        "The Focus Last executed command{0} will move focus to the last executed item in the REPL history.",
+        "<keybinding:repl.focusLastItemExecuted>"
+    )), ( localize(
+        10743,
+        "When you run the Open Accessbility View command{0} from this input box, the output from the last execution will be shown in the accessibility view.",
+        "<keybinding:editor.action.accessibleView>"
+    )), ( localize(
+        10744,
+        "The Focus Input Editor command{0} will bring the focus back to this editor.",
+        "<keybinding:repl.input.focus>"
+    ))].join("\n");
 }
 class ReplEditorHistoryAccessibilityHelp {
     constructor() {
         this.priority = 105;
-        this.name = 'REPL Editor History';
+        this.name = "REPL Editor History";
         this.when = ( ContextKeyExpr.and(IS_COMPOSITE_NOTEBOOK, NOTEBOOK_CELL_LIST_FOCUSED));
         this.type = AccessibleViewType.Help;
     }
@@ -65,56 +57,43 @@ class ReplEditorHistoryAccessibilityHelp {
     }
 }
 function getAccessibilityHistoryHelpText() {
-    return [
-        ( localize(
-        10427,
-        'You are in a REPL History which is a list of cells that have been executed in the REPL. Each cell has an input, an output, and the cell container.'
-    )),
-        ( localize(
-        10428,
-        'The Edit Cell command{0} will move focus to the read-only editor for the input of the cell.',
-        '<keybinding:notebook.cell.edit>'
-    )),
-        ( localize(
-        10429,
-        'The Quit Edit command{0} will move focus to the cell container, where the up and down arrows will also move focus between cells in the history.',
-        '<keybinding:notebook.cell.quitEdit>'
-    )),
-        ( localize(
-        10430,
-        'Run the Open Accessbility View command{0} while navigating the history for an accessible view of the item\'s output.',
-        '<keybinding:editor.action.accessibleView>'
-    )),
-        ( localize(
-        10431,
-        'The Focus Output command{0} will set focus on the output when focused on a previously executed item.',
-        '<keybinding:notebook.cell.focusInOutput>'
-    )),
-        ( localize(
-        10432,
-        'The Focus Input Editor command{0} will move focus to the REPL input box.',
-        '<keybinding:repl.input.focus>'
-    )),
-        ( localize(
-        10424,
-        'The Focus Last executed command{0} will move focus to the last executed item in the REPL history.',
-        '<keybinding:repl.focusLastItemExecuted>'
-    )),
-    ].join('\n');
+    return [( localize(
+        10745,
+        "You are in a REPL History which is a list of cells that have been executed in the REPL. Each cell has an input, an output, and the cell container."
+    )), ( localize(
+        10746,
+        "The Edit Cell command{0} will move focus to the read-only editor for the input of the cell.",
+        "<keybinding:notebook.cell.edit>"
+    )), ( localize(
+        10747,
+        "The Quit Edit command{0} will move focus to the cell container, where the up and down arrows will also move focus between cells in the history.",
+        "<keybinding:notebook.cell.quitEdit>"
+    )), ( localize(
+        10748,
+        "Run the Open Accessbility View command{0} while navigating the history for an accessible view of the item's output.",
+        "<keybinding:editor.action.accessibleView>"
+    )), ( localize(
+        10749,
+        "The Focus Output command{0} will set focus on the output when focused on a previously executed item.",
+        "<keybinding:notebook.cell.focusInOutput>"
+    )), ( localize(
+        10750,
+        "The Focus Input Editor command{0} will move focus to the REPL input box.",
+        "<keybinding:repl.input.focus>"
+    )), ( localize(
+        10742,
+        "The Focus Last executed command{0} will move focus to the last executed item in the REPL history.",
+        "<keybinding:repl.focusLastItemExecuted>"
+    ))].join("\n");
 }
 function getAccessibilityHelpProvider(editorService, helpText) {
-    const activeEditor = editorService.getActiveCodeEditor()
-        || editorService.getFocusedCodeEditor();
+    const activeEditor = editorService.getActiveCodeEditor() || editorService.getFocusedCodeEditor();
     if (!activeEditor) {
         return;
     }
-    return ( new AccessibleContentProvider(
-        AccessibleViewProviderId.ReplEditor,
-        { type: AccessibleViewType.Help },
-        () => helpText,
-        () => activeEditor.focus(),
-        AccessibilityVerbositySettingId.ReplEditor
-    ));
+    return ( new AccessibleContentProvider(AccessibleViewProviderId.ReplEditor, {
+        type: AccessibleViewType.Help
+    }, () => helpText, () => activeEditor.focus(), AccessibilityVerbositySettingId.ReplEditor));
 }
 
 export { ReplEditorHistoryAccessibilityHelp, ReplEditorInputAccessibilityHelp };