@codingame/monaco-vscode-api 1.82.6 → 1.83.1

package/vscode/src/vs/workbench/common/views.d.ts

@@ -36,7 +36,7 @@ interface IViewContainerDescriptor {
     /**
      * The title of the view container
      */
-    readonly title: ILocalizedString | string;
+    readonly title: ILocalizedString;
     /**
      * Icon representation of the View container
      */

package/vscode/src/vs/workbench/common/views.js

@@ -2,10 +2,9 @@ import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { getOrSet } from 'monaco-editor/esm/vs/base/common/map.js';
+import { getOrSet, SetMap } from 'monaco-editor/esm/vs/base/common/map.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { flatten } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { SetMap } from 'monaco-editor/esm/vs/base/common/collections.js';
 import { mixin } from 'monaco-editor/esm/vs/base/common/objects.js';
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';

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

@@ -8,6 +8,7 @@ const accessibleViewIsShown = ( new RawContextKey('accessibleViewIsShown', false
 const accessibleViewSupportsNavigation = ( new RawContextKey('accessibleViewSupportsNavigation', false, true));
 const accessibleViewVerbosityEnabled = ( new RawContextKey('accessibleViewVerbosityEnabled', false, true));
 const accessibleViewGoToSymbolSupported = ( new RawContextKey('accessibleViewGoToSymbolSupported', false, true));
+const accessibleViewOnLastLine = ( new RawContextKey('accessibleViewOnLastLine', false, true));
 const accessibleViewCurrentProviderId = ( new RawContextKey('accessibleViewCurrentProviderId', undefined, undefined));
 const baseProperty = {
     type: 'boolean',
@@ -82,10 +83,17 @@ const configuration = {
             )),
             ...baseProperty
         },
-        ["accessibility.verbosity.untitledHint" ]: {
+        ["accessibility.verbosity.emptyEditorHint" ]: {
             description: ( localize(
-                'verbosity.untitledhint',
-                'Provide information about relevant actions in an untitled text editor.'
+                'verbosity.emptyEditorHint',
+                'Provide information about relevant actions in an empty text editor.'
+            )),
+            ...baseProperty
+        },
+        ["accessibility.verbosity.comments" ]: {
+            description: ( localize(
+                'verbosity.comments',
+                'Provide information about actions that can be taken in the comment widget or in a file which contains comments.'
             )),
             ...baseProperty
         }
@@ -123,4 +131,4 @@ function registerAccessibilityConfiguration() {
         }
     });
 }
-export { accessibilityHelpIsShown, accessibleViewCurrentProviderId, accessibleViewGoToSymbolSupported, accessibleViewIsShown, accessibleViewSupportsNavigation, accessibleViewVerbosityEnabled, registerAccessibilityConfiguration };
+export { accessibilityHelpIsShown, accessibleViewCurrentProviderId, accessibleViewGoToSymbolSupported, accessibleViewIsShown, accessibleViewOnLastLine, accessibleViewSupportsNavigation, accessibleViewVerbosityEnabled, registerAccessibilityConfiguration };

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

@@ -0,0 +1,335 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { AccessibilityHelpNLS } from 'monaco-editor/esm/vs/editor/common/standaloneStrings.js';
+import { ToggleTabFocusModeAction } from 'monaco-editor/esm/vs/editor/contrib/toggleTabFocusMode/browser/toggleTabFocusMode.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { accessibleViewIsShown } from './accessibilityConfiguration.js';
+import * as strings from 'monaco-editor/esm/vs/base/common/strings.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { NEW_UNTITLED_FILE_COMMAND_ID } from '../../files/browser/fileConstants.js';
+import { ModesHoverController } from 'monaco-editor/esm/vs/editor/contrib/hover/browser/hover.js';
+import { IContextViewService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
+import { getNotificationFromContext } from '../../../browser/parts/notifications/notificationsCommands.js';
+import { IListService, WorkbenchList } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { NotificationFocusedContext } from '../../../common/contextkeys.js';
+import { IAccessibleViewService } from './accessibleView.js';
+import { IHoverService } from '../../../services/hover/browser/hover.js';
+import { alert } from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
+import { AccessibilityHelpAction, AccessibleViewAction } from './accessibleViewActions.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { InlineCompletionsController } from 'monaco-editor/esm/vs/editor/contrib/inlineCompletions/browser/inlineCompletionsController.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { CommentContextKeys } from '../../comments/common/commentContextKeys.js';
+import { CommentAccessibilityHelpNLS } from '../../comments/browser/comments.contribution.js';
+class EditorAccessibilityHelpContribution extends Disposable {
+    constructor() {
+        super();
+        this._register(AccessibilityHelpAction.addImplementation(95, 'editor', async (accessor) => {
+            const codeEditorService = accessor.get(ICodeEditorService);
+            const accessibleViewService = accessor.get(IAccessibleViewService);
+            const instantiationService = accessor.get(IInstantiationService);
+            const commandService = accessor.get(ICommandService);
+            let codeEditor = codeEditorService.getActiveCodeEditor() || codeEditorService.getFocusedCodeEditor();
+            if (!codeEditor) {
+                await commandService.executeCommand(NEW_UNTITLED_FILE_COMMAND_ID);
+                codeEditor = codeEditorService.getActiveCodeEditor();
+            }
+            accessibleViewService.show(instantiationService.createInstance(EditorAccessibilityHelpProvider, codeEditor));
+        }, EditorContextKeys.focus));
+    }
+}
+let EditorAccessibilityHelpProvider = class EditorAccessibilityHelpProvider {
+    onClose() {
+        this._editor.focus();
+    }
+    constructor(_editor, _keybindingService, _contextKeyService) {
+        this._editor = _editor;
+        this._keybindingService = _keybindingService;
+        this._contextKeyService = _contextKeyService;
+        this.options = { type: "help" , readMoreUrl: 'https://go.microsoft.com/fwlink/?linkid=851010' };
+        this.verbositySettingKey = "accessibility.verbosity.editor" ;
+    }
+    provideContent() {
+        const options = this._editor.getOptions();
+        const content = [];
+        if (options.get(61 )) {
+            if (options.get(90 )) {
+                content.push(AccessibilityHelpNLS.readonlyDiffEditor);
+            }
+            else {
+                content.push(AccessibilityHelpNLS.editableDiffEditor);
+            }
+        }
+        else {
+            if (options.get(90 )) {
+                content.push(AccessibilityHelpNLS.readonlyEditor);
+            }
+            else {
+                content.push(AccessibilityHelpNLS.editableEditor);
+            }
+        }
+        const commentCommandInfo = getCommentCommandInfo(this._keybindingService, this._contextKeyService, this._editor);
+        if (commentCommandInfo) {
+            content.push(commentCommandInfo);
+        }
+        if (options.get(114 ).enabled) {
+            content.push(descriptionForCommand('editor.action.focusStickyScroll', AccessibilityHelpNLS.stickScrollKb, AccessibilityHelpNLS.stickScrollNoKb, this._keybindingService));
+        }
+        if (options.get(142 )) {
+            content.push(descriptionForCommand(ToggleTabFocusModeAction.ID, AccessibilityHelpNLS.tabFocusModeOnMsg, AccessibilityHelpNLS.tabFocusModeOnMsgNoKb, this._keybindingService));
+        }
+        else {
+            content.push(descriptionForCommand(ToggleTabFocusModeAction.ID, AccessibilityHelpNLS.tabFocusModeOffMsg, AccessibilityHelpNLS.tabFocusModeOffMsgNoKb, this._keybindingService));
+        }
+        return content.join('\n\n');
+    }
+};
+EditorAccessibilityHelpProvider = ( __decorate([
+    ( __param(1, IKeybindingService)),
+    ( __param(2, IContextKeyService))
+], EditorAccessibilityHelpProvider));
+function getCommentCommandInfo(keybindingService, contextKeyService, editor) {
+    const editorContext = contextKeyService.getContext(editor.getDomNode());
+    if (editorContext.getValue(CommentContextKeys.activeEditorHasCommentingRange.key)) {
+        const commentCommandInfo = [];
+        commentCommandInfo.push(CommentAccessibilityHelpNLS.intro);
+        commentCommandInfo.push(descriptionForCommand("workbench.action.addComment" , CommentAccessibilityHelpNLS.addComment, CommentAccessibilityHelpNLS.addCommentNoKb, keybindingService));
+        commentCommandInfo.push(descriptionForCommand("editor.action.nextCommentThreadAction" , CommentAccessibilityHelpNLS.nextCommentThreadKb, CommentAccessibilityHelpNLS.nextCommentThreadNoKb, keybindingService));
+        commentCommandInfo.push(descriptionForCommand("editor.action.previousCommentThreadAction" , CommentAccessibilityHelpNLS.previousCommentThreadKb, CommentAccessibilityHelpNLS.previousCommentThreadNoKb, keybindingService));
+        commentCommandInfo.push(descriptionForCommand("editor.action.nextCommentingRange" , CommentAccessibilityHelpNLS.nextRange, CommentAccessibilityHelpNLS.nextRangeNoKb, keybindingService));
+        commentCommandInfo.push(descriptionForCommand("editor.action.previousCommentingRange" , CommentAccessibilityHelpNLS.previousRange, CommentAccessibilityHelpNLS.previousRangeNoKb, keybindingService));
+        return commentCommandInfo.join('\n');
+    }
+    return;
+}
+function descriptionForCommand(commandId, msg, noKbMsg, keybindingService) {
+    const kb = keybindingService.lookupKeybinding(commandId);
+    if (kb) {
+        return strings.format(msg, kb.getAriaLabel());
+    }
+    return strings.format(noKbMsg, commandId);
+}
+class HoverAccessibleViewContribution extends Disposable {
+    constructor() {
+        super();
+        this._options = { language: 'typescript', type: "view"  };
+        this._register(AccessibleViewAction.addImplementation(95, 'hover', accessor => {
+            const accessibleViewService = accessor.get(IAccessibleViewService);
+            const codeEditorService = accessor.get(ICodeEditorService);
+            const editor = codeEditorService.getActiveCodeEditor() || codeEditorService.getFocusedCodeEditor();
+            const editorHoverContent = editor ? ModesHoverController.get(editor)?.getWidgetContent() ?? undefined : undefined;
+            if (!editor || !editorHoverContent) {
+                return false;
+            }
+            this._options.language = editor?.getModel()?.getLanguageId() ?? undefined;
+            accessibleViewService.show({
+                verbositySettingKey: "accessibility.verbosity.hover" ,
+                provideContent() { return editorHoverContent; },
+                onClose() {
+                    ModesHoverController.get(editor)?.focus();
+                },
+                options: this._options
+            });
+            return true;
+        }, EditorContextKeys.hoverFocused));
+        this._register(AccessibleViewAction.addImplementation(90, 'extension-hover', accessor => {
+            const accessibleViewService = accessor.get(IAccessibleViewService);
+            const contextViewService = accessor.get(IContextViewService);
+            const contextViewElement = contextViewService.getContextViewElement();
+            const extensionHoverContent = contextViewElement?.textContent ?? undefined;
+            const hoverService = accessor.get(IHoverService);
+            if (contextViewElement.classList.contains('accessible-view-container') || !extensionHoverContent) {
+                return false;
+            }
+            accessibleViewService.show({
+                verbositySettingKey: "accessibility.verbosity.hover" ,
+                provideContent() { return extensionHoverContent; },
+                onClose() {
+                    hoverService.showAndFocusLastHover();
+                },
+                options: this._options
+            });
+            return true;
+        }));
+        this._register(AccessibilityHelpAction.addImplementation(115, 'accessible-view', accessor => {
+            accessor.get(IAccessibleViewService).showAccessibleViewHelp();
+            return true;
+        }, accessibleViewIsShown));
+    }
+}
+class NotificationAccessibleViewContribution extends Disposable {
+    constructor() {
+        super();
+        this._register(AccessibleViewAction.addImplementation(90, 'notifications', accessor => {
+            const accessibleViewService = accessor.get(IAccessibleViewService);
+            const listService = accessor.get(IListService);
+            const commandService = accessor.get(ICommandService);
+            function renderAccessibleView() {
+                const notification = getNotificationFromContext(listService);
+                if (!notification) {
+                    return false;
+                }
+                commandService.executeCommand('notifications.showList');
+                let notificationIndex;
+                let length;
+                const list = listService.lastFocusedList;
+                if (list instanceof WorkbenchList) {
+                    notificationIndex = list.indexOf(notification);
+                    length = list.length;
+                }
+                if (notificationIndex === undefined) {
+                    return false;
+                }
+                function focusList() {
+                    commandService.executeCommand('notifications.showList');
+                    if (list && notificationIndex !== undefined) {
+                        list.domFocus();
+                        try {
+                            list.setFocus([notificationIndex]);
+                        }
+                        catch { }
+                    }
+                }
+                const message = ( notification.message.original.toString());
+                if (!message) {
+                    return false;
+                }
+                notification.onDidClose(() => accessibleViewService.next());
+                accessibleViewService.show({
+                    provideContent: () => {
+                        return notification.source ? ( localize(
+                            'notification.accessibleViewSrc',
+                            '{0} Source: {1}',
+                            message,
+                            notification.source
+                        )) : ( localize('notification.accessibleView', '{0}', message));
+                    },
+                    onClose() {
+                        focusList();
+                    },
+                    next() {
+                        if (!list) {
+                            return;
+                        }
+                        focusList();
+                        list.focusNext();
+                        alertFocusChange(notificationIndex, length, 'next');
+                        renderAccessibleView();
+                    },
+                    previous() {
+                        if (!list) {
+                            return;
+                        }
+                        focusList();
+                        list.focusPrevious();
+                        alertFocusChange(notificationIndex, length, 'previous');
+                        renderAccessibleView();
+                    },
+                    verbositySettingKey: "accessibility.verbosity.notification" ,
+                    options: { type: "view"  },
+                    actions: getActionsFromNotification(notification)
+                });
+                return true;
+            }
+            return renderAccessibleView();
+        }, NotificationFocusedContext));
+    }
+}
+function getActionsFromNotification(notification) {
+    let actions = undefined;
+    if (notification.actions) {
+        actions = [];
+        if (notification.actions.primary) {
+            actions.push(...notification.actions.primary);
+        }
+        if (notification.actions.secondary) {
+            actions.push(...notification.actions.secondary);
+        }
+    }
+    if (actions) {
+        for (const action of actions) {
+            action.class = ThemeIcon.asClassName(Codicon.bell);
+            const initialAction = action.run;
+            action.run = () => {
+                initialAction();
+                notification.close();
+            };
+        }
+    }
+    const manageExtension = actions?.find(a => a.label.includes('Manage Extension'));
+    if (manageExtension) {
+        manageExtension.class = ThemeIcon.asClassName(Codicon.gear);
+    }
+    if (actions) {
+        actions.push({ id: 'clearNotification', label: ( localize('clearNotification', "Clear Notification")), tooltip: ( localize('clearNotification', "Clear Notification")), run: () => notification.close(), enabled: true, class: ThemeIcon.asClassName(Codicon.clearAll) });
+    }
+    return actions;
+}
+function alertFocusChange(index, length, type) {
+    if (index === undefined || length === undefined) {
+        return;
+    }
+    const number = index + 1;
+    if (type === 'next' && number + 1 <= length) {
+        alert(`Focused ${number + 1} of ${length}`);
+    }
+    else if (type === 'previous' && number - 1 > 0) {
+        alert(`Focused ${number - 1} of ${length}`);
+    }
+    return;
+}
+class InlineCompletionsAccessibleViewContribution extends Disposable {
+    constructor() {
+        super();
+        this._options = { type: "view"  };
+        this._register(AccessibleViewAction.addImplementation(95, 'inline-completions', accessor => {
+            const accessibleViewService = accessor.get(IAccessibleViewService);
+            const codeEditorService = accessor.get(ICodeEditorService);
+            const show = () => {
+                const editor = codeEditorService.getActiveCodeEditor() || codeEditorService.getFocusedCodeEditor();
+                if (!editor) {
+                    return false;
+                }
+                const model = InlineCompletionsController.get(editor)?.model.get();
+                const state = model?.state.get();
+                if (!model || !state) {
+                    return false;
+                }
+                const lineText = model.textModel.getLineContent(state.ghostText.lineNumber);
+                if (!lineText) {
+                    return false;
+                }
+                const ghostText = state.ghostText.renderForScreenReader(lineText);
+                if (!ghostText) {
+                    return false;
+                }
+                this._options.language = editor.getModel()?.getLanguageId() ?? undefined;
+                accessibleViewService.show({
+                    verbositySettingKey: "accessibility.verbosity.inlineCompletions" ,
+                    provideContent() { return lineText + ghostText; },
+                    onClose() {
+                        model.stop();
+                        editor.focus();
+                    },
+                    next() {
+                        model.next();
+                        setTimeout(() => show(), 50);
+                    },
+                    previous() {
+                        model.previous();
+                        setTimeout(() => show(), 50);
+                    },
+                    options: this._options
+                });
+                return true;
+            };
+            return show();
+        }));
+    }
+}
+export { EditorAccessibilityHelpContribution, HoverAccessibleViewContribution, InlineCompletionsAccessibleViewContribution, NotificationAccessibleViewContribution, alertFocusChange, getCommentCommandInfo };

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

@@ -10,6 +10,7 @@ import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { EditorExtensionsRegistry } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
 import { CodeEditorWidget } from 'monaco-editor/esm/vs/editor/browser/widget/codeEditorWidget.js';
+import { Position } from 'monaco-editor/esm/vs/editor/common/core/position.js';
 import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
 import { AccessibilityHelpNLS } from 'monaco-editor/esm/vs/editor/common/standaloneStrings.js';
 import { CodeActionController } from 'monaco-editor/esm/vs/editor/contrib/codeAction/browser/codeActionController.js';
@@ -26,7 +27,7 @@ import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/com
 import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
 import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
 import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
-import { accessibilityHelpIsShown, accessibleViewIsShown, accessibleViewSupportsNavigation, accessibleViewVerbosityEnabled, accessibleViewGoToSymbolSupported, accessibleViewCurrentProviderId } from './accessibilityConfiguration.js';
+import { accessibilityHelpIsShown, accessibleViewIsShown, accessibleViewSupportsNavigation, accessibleViewVerbosityEnabled, accessibleViewGoToSymbolSupported, accessibleViewCurrentProviderId, accessibleViewOnLastLine } from './accessibilityConfiguration.js';
 import { getSimpleEditorOptions } from '../../codeEditor/browser/simpleEditorOptions.js';
 const IAccessibleViewService = ( createDecorator('accessibleViewService'));
 let AccessibleView = class AccessibleView extends Disposable {
@@ -49,6 +50,7 @@ let AccessibleView = class AccessibleView extends Disposable {
         this._accessibleViewVerbosityEnabled = accessibleViewVerbosityEnabled.bindTo(this._contextKeyService);
         this._accessibleViewGoToSymbolSupported = accessibleViewGoToSymbolSupported.bindTo(this._contextKeyService);
         this._accessibleViewCurrentProviderId = accessibleViewCurrentProviderId.bindTo(this._contextKeyService);
+        this._onLastLine = accessibleViewOnLastLine.bindTo(this._contextKeyService);
         this._container = document.createElement('div');
         this._container.classList.add('accessible-view');
         const codeEditorWidgetOptions = {
@@ -97,6 +99,9 @@ let AccessibleView = class AccessibleView extends Disposable {
             }
         }));
         this._register(this._editorWidget.onDidDispose(() => this._resetContextKeys()));
+        this._register(this._editorWidget.onDidChangeCursorPosition(() => {
+            this._onLastLine.set(this._editorWidget.getPosition()?.lineNumber === this._editorWidget.getModel()?.getLineCount());
+        }));
     }
     _resetContextKeys() {
         this._accessiblityHelpIsShown.reset();
@@ -106,7 +111,7 @@ let AccessibleView = class AccessibleView extends Disposable {
         this._accessibleViewGoToSymbolSupported.reset();
         this._accessibleViewCurrentProviderId.reset();
     }
-    show(provider, symbol, showAccessibleViewHelp) {
+    show(provider, symbol, showAccessibleViewHelp, lineNumber) {
         provider = provider ?? this._currentProvider;
         if (!provider) {
             return;
@@ -125,6 +130,12 @@ let AccessibleView = class AccessibleView extends Disposable {
             }
         };
         this._contextViewService.showContextView(delegate);
+        if (lineNumber) {
+            setTimeout(() => {
+                this._editorWidget.revealLine(lineNumber);
+                this._editorWidget.setSelection({ startLineNumber: lineNumber, startColumn: 1, endLineNumber: lineNumber, endColumn: 1 });
+            }, 50);
+        }
         if (symbol && this._currentProvider) {
             this.showSymbol(this._currentProvider, symbol);
         }
@@ -151,11 +162,21 @@ let AccessibleView = class AccessibleView extends Disposable {
         if (!this._currentProvider || !this._currentContent) {
             return;
         }
-        const tokens = this._currentProvider.options.language && this._currentProvider.options.language !== 'markdown' ? this._currentProvider.getSymbols?.() : marked.lexer(this._currentContent);
-        if (!tokens) {
+        const symbols = this._currentProvider.getSymbols?.() || [];
+        if (symbols?.length) {
+            return symbols;
+        }
+        if (this._currentProvider.options.language && this._currentProvider.options.language !== 'markdown') {
+            return;
+        }
+        const markdownTokens = marked.lexer(this._currentContent);
+        if (!markdownTokens) {
             return;
         }
-        const symbols = [];
+        this._convertTokensToSymbols(markdownTokens, symbols);
+        return symbols.length ? symbols : undefined;
+    }
+    _convertTokensToSymbols(tokens, symbols) {
         let firstListItem;
         for (const token of tokens) {
             let label = undefined;
@@ -177,26 +198,31 @@ let AccessibleView = class AccessibleView extends Disposable {
                     }
                 }
             }
-            else {
-                label = token.label;
-            }
             if (label) {
-                symbols.push({ info: label, label: ( localize('symbolLabel', "({0}) {1}", token.type, label)), ariaLabel: ( localize('symbolLabelAria', "({0}) {1}", token.type, label)), firstListItem });
+                symbols.push({ markdownToParse: label, label: ( localize('symbolLabel', "({0}) {1}", token.type, label)), ariaLabel: ( localize('symbolLabelAria', "({0}) {1}", token.type, label)), firstListItem });
                 firstListItem = undefined;
             }
         }
-        return symbols;
     }
     showSymbol(provider, symbol) {
         if (!this._currentContent) {
             return;
         }
-        const index = this._currentContent.split('\n').findIndex(line => line.includes(symbol.info.split('\n')[0]) || (symbol.firstListItem && line.includes(symbol.firstListItem))) ?? -1;
-        if (index >= 0) {
-            this.show(provider);
-            this._editorWidget.revealLine(index + 1);
-            this._editorWidget.setSelection({ startLineNumber: index + 1, startColumn: 1, endLineNumber: index + 1, endColumn: 1 });
+        let lineNumber = symbol.lineNumber;
+        const markdownToParse = symbol.markdownToParse;
+        if (lineNumber === undefined && markdownToParse === undefined) {
+            return;
         }
+        if (lineNumber === undefined && markdownToParse) {
+            const index = this._currentContent.split('\n').findIndex(line => line.includes(markdownToParse.split('\n')[0]) || (symbol.firstListItem && line.includes(symbol.firstListItem))) ?? -1;
+            if (index >= 0) {
+                lineNumber = index + 1;
+            }
+        }
+        if (lineNumber === undefined) {
+            return;
+        }
+        this.show(provider, undefined, undefined, lineNumber);
         this._updateContextKeys(provider, true);
     }
     disableHint() {
@@ -237,7 +263,7 @@ let AccessibleView = class AccessibleView extends Disposable {
         const value = this._configurationService.getValue(provider.verbositySettingKey);
         const readMoreLink = provider.options.readMoreUrl ? ( localize(
             "openDoc",
-            "\n\nPress H now to open a browser window with more information related to accessibility.\n\n"
+            "\n\nOpen a browser window with more information related to accessibility (H)."
         )) : '';
         let disableHelpHint = '';
         if (provider.options.type === "help"  && !!value) {
@@ -258,7 +284,9 @@ let AccessibleView = class AccessibleView extends Disposable {
                 message += '\n';
             }
         }
-        this._currentContent = message + provider.provideContent() + readMoreLink + disableHelpHint + ( localize('exit-tip', '\nExit this dialog via the Escape key.'));
+        const verbose = this._configurationService.getValue(provider.verbositySettingKey);
+        const exitThisDialogHint = verbose && !provider.options.positionBottom ? ( localize('exit', '\n\nExit this dialog (Escape).')) : '';
+        this._currentContent = message + provider.provideContent() + readMoreLink + disableHelpHint + exitThisDialogHint;
         this._updateContextKeys(provider, true);
         this._getTextModel(( URI.from(
             { path: `accessible-view-${provider.verbositySettingKey}`, scheme: 'accessible-view', fragment: this._currentContent }
@@ -277,9 +305,12 @@ let AccessibleView = class AccessibleView extends Disposable {
             const verbose = this._configurationService.getValue(provider.verbositySettingKey);
             const hasActions = this._accessibleViewSupportsNavigation.get() || this._accessibleViewVerbosityEnabled.get() || this._accessibleViewGoToSymbolSupported.get() || this._currentProvider?.actions;
             if (verbose && !showAccessibleViewHelp && hasActions) {
-                actionsHint = ( localize(
+                actionsHint = provider.options.positionBottom ? ( localize(
+                    'ariaAccessibleViewActionsBottom',
+                    'Explore actions such as disabling this hint (Shift+Tab), use Escape to exit this dialog.'
+                )) : ( localize(
                     'ariaAccessibleViewActions',
-                    "Use Shift+Tab to explore actions such as disabling this hint."
+                    'Explore actions such as disabling this hint (Shift+Tab).'
                 ));
             }
             let ariaLabel = provider.options.type === "help"  ? ( localize('accessibility-help', "Accessibility Help")) : ( localize('accessible-view', "Accessible View"));
@@ -292,6 +323,14 @@ let AccessibleView = class AccessibleView extends Disposable {
             }
             this._editorWidget.updateOptions({ ariaLabel });
             this._editorWidget.focus();
+            if (this._currentProvider?.options.positionBottom) {
+                const lastLine = this.editorWidget.getModel()?.getLineCount();
+                const position = lastLine !== undefined && lastLine > 0 ? ( new Position(lastLine, 1)) : undefined;
+                if (position) {
+                    this._editorWidget.setPosition(position);
+                    this._editorWidget.revealLine(position.lineNumber);
+                }
+            }
         });
         this._updateToolbar(provider.actions, provider.options.type);
         const handleEscape = (e) => {
@@ -363,16 +402,17 @@ let AccessibleView = class AccessibleView extends Disposable {
         if (!this._currentProvider) {
             return false;
         }
-        return this._currentProvider.options.type === "help"  || this._currentProvider.options.language === 'markdown' || this._currentProvider.options.language === undefined || !!this._currentProvider.getSymbols;
+        return this._currentProvider.options.type === "help"  || this._currentProvider.options.language === 'markdown' || this._currentProvider.options.language === undefined || !!this._currentProvider.getSymbols?.();
     }
     showAccessibleViewHelp() {
         if (!this._currentProvider) {
             return;
         }
         const currentProvider = Object.assign({}, this._currentProvider);
+        currentProvider.provideContent = this._currentProvider.provideContent.bind(currentProvider);
         currentProvider.options = Object.assign({}, currentProvider.options);
         const accessibleViewHelpProvider = {
-            provideContent: () => this._getAccessibleViewHelpDialogContent(this._goToSymbolsSupported()),
+            provideContent: () => currentProvider.options.customHelp ? currentProvider?.options.customHelp() : this._getAccessibleViewHelpDialogContent(this._goToSymbolsSupported()),
             onClose: () => this.show(currentProvider),
             options: { type: "help"  },
             verbositySettingKey: this._currentProvider.verbositySettingKey
@@ -383,7 +423,7 @@ let AccessibleView = class AccessibleView extends Disposable {
     _getAccessibleViewHelpDialogContent(providerHasSymbols) {
         const navigationHint = this._getNavigationHint();
         const goToSymbolHint = this._getGoToSymbolHint(providerHasSymbols);
-        const toolbarHint = ( localize('toolbar', "Navigate to the toolbar (Shift+Tab))"));
+        const toolbarHint = ( localize('toolbar', "Navigate to the toolbar (Shift+Tab))."));
         let hint = ( localize('intro', "In the accessible view, you can:\n"));
         if (navigationHint) {
             hint += ' - ' + navigationHint + '\n';
@@ -403,7 +443,7 @@ let AccessibleView = class AccessibleView extends Disposable {
         if (nextKeybinding && previousKeybinding) {
             hint = ( localize(
                 'accessibleViewNextPreviousHint',
-                "Show the next ({0}) or previous ({1}) item",
+                "Show the next ({0}) or previous ({1}) item.",
                 nextKeybinding,
                 previousKeybinding
             ));
@@ -411,7 +451,7 @@ let AccessibleView = class AccessibleView extends Disposable {
         else {
             hint = ( localize(
                 'chatAccessibleViewNextPreviousHintNoKb',
-                "Show the next or previous item by configuring keybindings for the Show Next & Previous in Accessible View commands"
+                "Show the next or previous item by configuring keybindings for the Show Next & Previous in Accessible View commands."
             ));
         }
         return hint;
@@ -425,14 +465,14 @@ let AccessibleView = class AccessibleView extends Disposable {
         if (disableKeybinding) {
             hint = ( localize(
                 'acessibleViewDisableHint',
-                "Disable accessibility verbosity for this feature ({0}). This will disable the hint to open the accessible view for example.\n",
+                "\n\nDisable accessibility verbosity for this feature ({0}).",
                 disableKeybinding
             ));
         }
         else {
             hint = ( localize(
                 'accessibleViewDisableHintNoKb',
-                "Add a keybinding for the command Disable Accessible View Hint, which disables accessibility verbosity for this feature.\n"
+                "\n\nAdd a keybinding for the command Disable Accessible View Hint, which disables accessibility verbosity for this feature.s"
             ));
         }
         return hint;
@@ -515,6 +555,20 @@ let AccessibleViewService = class AccessibleViewService extends Disposable {
     showAccessibleViewHelp() {
         this._accessibleView?.showAccessibleViewHelp();
     }
+    getPosition() {
+        return this._accessibleView?.editorWidget.getPosition() ?? undefined;
+    }
+    getLastPosition() {
+        const lastLine = this._accessibleView?.editorWidget.getModel()?.getLineCount();
+        return lastLine !== undefined && lastLine > 0 ? ( new Position(lastLine, 1)) : undefined;
+    }
+    setPosition(position, reveal) {
+        const editorWidget = this._accessibleView?.editorWidget;
+        editorWidget?.setPosition(position);
+        if (reveal) {
+            editorWidget?.revealLine(position.lineNumber);
+        }
+    }
 };
 AccessibleViewService = ( __decorate([
     ( __param(0, IInstantiationService)),
@@ -553,4 +607,4 @@ let AccessibleViewSymbolQuickPick = class AccessibleViewSymbolQuickPick {
 AccessibleViewSymbolQuickPick = ( __decorate([
     ( __param(1, IQuickInputService))
 ], AccessibleViewSymbolQuickPick));
-export { AccessibleViewService, IAccessibleViewService };
+export { AccessibleView, AccessibleViewService, IAccessibleViewService };