@codingame/monaco-vscode-accessibility-service-override 5.2.0 → 6.0.0

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

@@ -0,0 +1,864 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { getActiveWindow, addDisposableListener, EventType, isActiveElement } from 'vscode/vscode/vs/base/browser/dom';
+import { StandardKeyboardEvent } from 'vscode/vscode/vs/base/browser/keyboardEvent';
+import { ActionsOrientation } from 'vscode/vscode/vs/base/browser/ui/actionbar/actionbar';
+import { alert } from 'vscode/vscode/vs/base/browser/ui/aria/aria';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import { KeyCode } from 'vscode/vscode/vs/base/common/keyCodes';
+import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import marked_1 from 'vscode/external/vscode-marked/lib/marked.esm.js';
+import { isMacintosh, isWindows } from 'vscode/vscode/vs/base/common/platform';
+import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { EditorExtensionsRegistry } from 'vscode/vscode/vs/editor/browser/editorExtensions';
+import { CodeEditorWidget } from 'vscode/vscode/vs/editor/browser/widget/codeEditor/codeEditorWidget';
+import { Position } from 'vscode/vscode/vs/editor/common/core/position';
+import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
+import { AccessibilityHelpNLS } from 'vscode/vscode/vs/editor/common/standaloneStrings';
+import { CodeActionController } from 'vscode/vscode/vs/editor/contrib/codeAction/browser/codeActionController';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { AdvancedContentProvider, AccessibleViewProviderId, ExtensionContentProvider, AccessibleViewType } from 'vscode/vscode/vs/platform/accessibility/browser/accessibleView';
+import { ACCESSIBLE_VIEW_SHOWN_STORAGE_PREFIX } from 'vscode/vscode/vs/platform/accessibility/common/accessibility';
+import { IAccessibilityService } from 'vscode/vscode/vs/platform/accessibility/common/accessibility.service';
+import { createAndFillInActionBarActions } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { WorkbenchToolBar } from 'vscode/vscode/vs/platform/actions/browser/toolbar';
+import { MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions.service';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IContextViewService } from 'vscode/vscode/vs/platform/contextview/browser/contextView.service';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding.service';
+import { ResultKind } from 'vscode/vscode/vs/platform/keybinding/common/keybindingResolver';
+import { ILayoutService } from 'vscode/vscode/vs/platform/layout/browser/layoutService.service';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener.service';
+import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput.service';
+import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { accessibilityHelpIsShown, accessibleViewIsShown, accessibleViewSupportsNavigation, accessibleViewVerbosityEnabled, accessibleViewGoToSymbolSupported, accessibleViewCurrentProviderId, accessibleViewInCodeBlock, accessibleViewContainsCodeBlocks, accessibleViewOnLastLine, AccessibilityWorkbenchSettingId, AccessibilityVerbositySettingId } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
+import { resolveContentAndKeybindingItems } from './accessibleViewKeybindingResolver.js';
+import { AccessibilityCommandId } from 'vscode/vscode/vs/workbench/contrib/accessibility/common/accessibilityCommands';
+import { IChatCodeBlockContextProviderService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { getSimpleEditorOptions } from 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/simpleEditorOptions';
+
+const _moduleId = "vs/workbench/contrib/accessibility/browser/accessibleView";
+var DIMENSIONS;
+( ((function(DIMENSIONS) {
+    DIMENSIONS[DIMENSIONS["MAX_WIDTH"] = 600] = "MAX_WIDTH";
+})(DIMENSIONS || (DIMENSIONS = {}))));
+let AccessibleView = class AccessibleView extends Disposable {
+    get editorWidget() { return this._editorWidget; }
+    constructor(_openerService, _instantiationService, _configurationService, _modelService, _contextViewService, _contextKeyService, _accessibilityService, _keybindingService, _layoutService, _menuService, _commandService, _codeBlockContextProviderService, _storageService, _quickInputService) {
+        super();
+        this._openerService = _openerService;
+        this._instantiationService = _instantiationService;
+        this._configurationService = _configurationService;
+        this._modelService = _modelService;
+        this._contextViewService = _contextViewService;
+        this._contextKeyService = _contextKeyService;
+        this._accessibilityService = _accessibilityService;
+        this._keybindingService = _keybindingService;
+        this._layoutService = _layoutService;
+        this._menuService = _menuService;
+        this._commandService = _commandService;
+        this._codeBlockContextProviderService = _codeBlockContextProviderService;
+        this._storageService = _storageService;
+        this._quickInputService = _quickInputService;
+        this._inQuickPick = false;
+        this._accessiblityHelpIsShown = accessibilityHelpIsShown.bindTo(this._contextKeyService);
+        this._accessibleViewIsShown = accessibleViewIsShown.bindTo(this._contextKeyService);
+        this._accessibleViewSupportsNavigation = accessibleViewSupportsNavigation.bindTo(this._contextKeyService);
+        this._accessibleViewVerbosityEnabled = accessibleViewVerbosityEnabled.bindTo(this._contextKeyService);
+        this._accessibleViewGoToSymbolSupported = accessibleViewGoToSymbolSupported.bindTo(this._contextKeyService);
+        this._accessibleViewCurrentProviderId = accessibleViewCurrentProviderId.bindTo(this._contextKeyService);
+        this._accessibleViewInCodeBlock = accessibleViewInCodeBlock.bindTo(this._contextKeyService);
+        this._accessibleViewContainsCodeBlocks = accessibleViewContainsCodeBlocks.bindTo(this._contextKeyService);
+        this._onLastLine = accessibleViewOnLastLine.bindTo(this._contextKeyService);
+        this._container = document.createElement('div');
+        this._container.classList.add('accessible-view');
+        if (this._configurationService.getValue(AccessibilityWorkbenchSettingId.HideAccessibleView)) {
+            this._container.classList.add('hide');
+        }
+        const codeEditorWidgetOptions = {
+            contributions: EditorExtensionsRegistry.getEditorContributions().filter(c => c.id !== CodeActionController.ID)
+        };
+        const titleBar = document.createElement('div');
+        titleBar.classList.add('accessible-view-title-bar');
+        this._title = document.createElement('div');
+        this._title.classList.add('accessible-view-title');
+        titleBar.appendChild(this._title);
+        const actionBar = document.createElement('div');
+        actionBar.classList.add('accessible-view-action-bar');
+        titleBar.appendChild(actionBar);
+        this._container.appendChild(titleBar);
+        this._toolbar = this._register(_instantiationService.createInstance(WorkbenchToolBar, actionBar, { orientation: ActionsOrientation.HORIZONTAL }));
+        this._toolbar.context = { viewId: 'accessibleView' };
+        const toolbarElt = this._toolbar.getElement();
+        toolbarElt.tabIndex = 0;
+        const editorOptions = {
+            ...getSimpleEditorOptions(this._configurationService),
+            lineDecorationsWidth: 6,
+            dragAndDrop: false,
+            cursorWidth: 1,
+            wrappingStrategy: 'advanced',
+            wrappingIndent: 'none',
+            padding: { top: 2, bottom: 2 },
+            quickSuggestions: false,
+            renderWhitespace: 'none',
+            dropIntoEditor: { enabled: false },
+            readOnly: true,
+            fontFamily: 'var(--monaco-monospace-font)'
+        };
+        this._editorWidget = this._register(this._instantiationService.createInstance(CodeEditorWidget, this._container, editorOptions, codeEditorWidgetOptions));
+        this._register(this._accessibilityService.onDidChangeScreenReaderOptimized(() => {
+            if (this._currentProvider && this._accessiblityHelpIsShown.get()) {
+                this.show(this._currentProvider);
+            }
+        }));
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (this._currentProvider instanceof AdvancedContentProvider && e.affectsConfiguration(this._currentProvider.verbositySettingKey)) {
+                if (this._accessiblityHelpIsShown.get()) {
+                    this.show(this._currentProvider);
+                }
+                this._accessibleViewVerbosityEnabled.set(this._configurationService.getValue(this._currentProvider.verbositySettingKey));
+                this._updateToolbar(this._currentProvider.actions, this._currentProvider.options.type);
+            }
+            if (e.affectsConfiguration(AccessibilityWorkbenchSettingId.HideAccessibleView)) {
+                this._container.classList.toggle('hide', this._configurationService.getValue(AccessibilityWorkbenchSettingId.HideAccessibleView));
+            }
+        }));
+        this._register(this._editorWidget.onDidDispose(() => this._resetContextKeys()));
+        this._register(this._editorWidget.onDidChangeCursorPosition(() => {
+            this._onLastLine.set(this._editorWidget.getPosition()?.lineNumber === this._editorWidget.getModel()?.getLineCount());
+        }));
+        this._register(this._editorWidget.onDidChangeCursorPosition(() => {
+            const cursorPosition = this._editorWidget.getPosition()?.lineNumber;
+            if (this._codeBlocks && cursorPosition !== undefined) {
+                const inCodeBlock = this._codeBlocks.find(c => c.startLine <= cursorPosition && c.endLine >= cursorPosition) !== undefined;
+                this._accessibleViewInCodeBlock.set(inCodeBlock);
+            }
+        }));
+    }
+    _resetContextKeys() {
+        this._accessiblityHelpIsShown.reset();
+        this._accessibleViewIsShown.reset();
+        this._accessibleViewSupportsNavigation.reset();
+        this._accessibleViewVerbosityEnabled.reset();
+        this._accessibleViewGoToSymbolSupported.reset();
+        this._accessibleViewCurrentProviderId.reset();
+    }
+    getPosition(id) {
+        if (!id || !this._lastProvider || this._lastProvider.id !== id) {
+            return undefined;
+        }
+        return this._editorWidget.getPosition() || undefined;
+    }
+    setPosition(position, reveal) {
+        this._editorWidget.setPosition(position);
+        if (reveal) {
+            this._editorWidget.revealPosition(position);
+        }
+    }
+    getCodeBlockContext() {
+        const position = this._editorWidget.getPosition();
+        if (!this._codeBlocks?.length || !position) {
+            return;
+        }
+        const codeBlockIndex = this._codeBlocks?.findIndex(c => c.startLine <= position?.lineNumber && c.endLine >= position?.lineNumber);
+        const codeBlock = codeBlockIndex !== undefined && codeBlockIndex > -1 ? this._codeBlocks[codeBlockIndex] : undefined;
+        if (!codeBlock || codeBlockIndex === undefined) {
+            return;
+        }
+        return { code: codeBlock.code, languageId: codeBlock.languageId, codeBlockIndex, element: undefined };
+    }
+    navigateToCodeBlock(type) {
+        const position = this._editorWidget.getPosition();
+        if (!this._codeBlocks?.length || !position) {
+            return;
+        }
+        let codeBlock;
+        const codeBlocks = this._codeBlocks.slice();
+        if (type === 'previous') {
+            codeBlock = codeBlocks.reverse().find(c => c.endLine < position.lineNumber);
+        }
+        else {
+            codeBlock = codeBlocks.find(c => c.startLine > position.lineNumber);
+        }
+        if (!codeBlock) {
+            return;
+        }
+        this.setPosition(( (new Position(codeBlock.startLine, 1))), true);
+    }
+    showLastProvider(id) {
+        if (!this._lastProvider || this._lastProvider.options.id !== id) {
+            return;
+        }
+        this.show(this._lastProvider);
+    }
+    show(provider, symbol, showAccessibleViewHelp, position) {
+        provider = provider ?? this._currentProvider;
+        if (!provider) {
+            return;
+        }
+        provider.onOpen?.();
+        let viewContainer;
+        const delegate = {
+            getAnchor: () => { return { x: (getActiveWindow().innerWidth / 2) - ((Math.min(this._layoutService.activeContainerDimension.width * 0.62 , DIMENSIONS.MAX_WIDTH)) / 2), y: this._layoutService.activeContainerOffset.quickPickTop }; },
+            render: (container) => {
+                viewContainer = container;
+                viewContainer.classList.add('accessible-view-container');
+                return this._render(provider, container, showAccessibleViewHelp);
+            },
+            onHide: () => {
+                if (!showAccessibleViewHelp) {
+                    this._updateLastProvider();
+                    this._currentProvider = undefined;
+                    this._resetContextKeys();
+                }
+            }
+        };
+        this._contextViewService.showContextView(delegate);
+        if (position) {
+            queueMicrotask(() => {
+                this._editorWidget.revealLine(position.lineNumber);
+                this._editorWidget.setSelection({ startLineNumber: position.lineNumber, startColumn: position.column, endLineNumber: position.lineNumber, endColumn: position.column });
+            });
+        }
+        if (symbol && this._currentProvider) {
+            this.showSymbol(this._currentProvider, symbol);
+        }
+        if (provider instanceof AdvancedContentProvider && provider.onDidRequestClearLastProvider) {
+            this._register(provider.onDidRequestClearLastProvider((id) => {
+                if (this._lastProvider?.options.id === id) {
+                    this._lastProvider = undefined;
+                }
+            }));
+        }
+        if (provider.options.id) {
+            this._lastProvider = provider;
+        }
+        if (provider.id === AccessibleViewProviderId.Chat) {
+            this._register(this._codeBlockContextProviderService.registerProvider({ getCodeBlockContext: () => this.getCodeBlockContext() }, 'accessibleView'));
+        }
+        if (provider instanceof ExtensionContentProvider) {
+            this._storageService.store(`${ACCESSIBLE_VIEW_SHOWN_STORAGE_PREFIX}${provider.id}`, true, StorageScope.APPLICATION, StorageTarget.USER);
+        }
+        if (provider.onDidChangeContent) {
+            this._register(provider.onDidChangeContent(() => {
+                if (viewContainer) {
+                    this._render(provider, viewContainer, showAccessibleViewHelp);
+                }
+            }));
+        }
+    }
+    previous() {
+        this._currentProvider?.previous?.();
+    }
+    next() {
+        this._currentProvider?.next?.();
+    }
+    _verbosityEnabled() {
+        if (!this._currentProvider) {
+            return false;
+        }
+        return this._currentProvider instanceof AdvancedContentProvider ? this._configurationService.getValue(this._currentProvider.verbositySettingKey) === true : this._storageService.getBoolean(`${ACCESSIBLE_VIEW_SHOWN_STORAGE_PREFIX}${this._currentProvider.id}`, StorageScope.APPLICATION, false);
+    }
+    goToSymbol() {
+        if (!this._currentProvider) {
+            return;
+        }
+        this._instantiationService.createInstance(AccessibleViewSymbolQuickPick, this).show(this._currentProvider);
+    }
+    calculateCodeBlocks(markdown) {
+        if (this._currentProvider?.id !== AccessibleViewProviderId.Chat) {
+            return;
+        }
+        if (this._currentProvider.options.language && this._currentProvider.options.language !== 'markdown') {
+            return;
+        }
+        const lines = markdown.split('\n');
+        this._codeBlocks = [];
+        let inBlock = false;
+        let startLine = 0;
+        let languageId;
+        lines.forEach((line, i) => {
+            if (!inBlock && line.startsWith('```')) {
+                inBlock = true;
+                startLine = i + 1;
+                languageId = line.substring(3).trim();
+            }
+            else if (inBlock && line.endsWith('```')) {
+                inBlock = false;
+                const endLine = i;
+                const code = lines.slice(startLine, endLine).join('\n');
+                this._codeBlocks?.push({ startLine, endLine, code, languageId });
+            }
+        });
+        this._accessibleViewContainsCodeBlocks.set(this._codeBlocks.length > 0);
+    }
+    getSymbols() {
+        const provider = this._currentProvider instanceof AdvancedContentProvider ? this._currentProvider : undefined;
+        if (!this._currentContent || !provider) {
+            return;
+        }
+        const symbols = provider.getSymbols?.() || [];
+        if (symbols?.length) {
+            return symbols;
+        }
+        if (provider.options.language && provider.options.language !== 'markdown') {
+            return;
+        }
+        const markdownTokens = marked_1.lexer(this._currentContent);
+        if (!markdownTokens) {
+            return;
+        }
+        this._convertTokensToSymbols(markdownTokens, symbols);
+        return symbols.length ? symbols : undefined;
+    }
+    openHelpLink() {
+        if (!this._currentProvider?.options.readMoreUrl) {
+            return;
+        }
+        this._openerService.open(( (URI.parse(this._currentProvider.options.readMoreUrl))));
+    }
+    configureKeybindings() {
+        this._inQuickPick = true;
+        const provider = this._updateLastProvider();
+        const items = provider?.options?.configureKeybindingItems;
+        if (!items) {
+            return;
+        }
+        const quickPick = this._quickInputService.createQuickPick();
+        this._register(quickPick);
+        quickPick.items = items;
+        quickPick.title = ( localizeWithPath(_moduleId, 0, 'Configure keybindings'));
+        quickPick.placeholder = ( localizeWithPath(_moduleId, 1, 'Select a command ID to configure a keybinding for it'));
+        quickPick.show();
+        quickPick.onDidAccept(async () => {
+            const item = quickPick.selectedItems[0];
+            if (item) {
+                await this._commandService.executeCommand('workbench.action.openGlobalKeybindings', item.id);
+            }
+            quickPick.dispose();
+        });
+        quickPick.onDidHide(() => {
+            if (!quickPick.selectedItems.length && provider) {
+                this.show(provider);
+            }
+            quickPick.dispose();
+            this._inQuickPick = false;
+        });
+    }
+    _convertTokensToSymbols(tokens, symbols) {
+        let firstListItem;
+        for (const token of tokens) {
+            let label = undefined;
+            if ('type' in token) {
+                switch (token.type) {
+                    case 'heading':
+                    case 'paragraph':
+                    case 'code':
+                        label = token.text;
+                        break;
+                    case 'list': {
+                        const firstItem = token.items?.[0];
+                        if (!firstItem) {
+                            break;
+                        }
+                        firstListItem = `- ${firstItem.text}`;
+                        label = token.items?.map(i => i.text).join(', ');
+                        break;
+                    }
+                }
+            }
+            if (label) {
+                symbols.push({ markdownToParse: label, label: ( localizeWithPath(_moduleId, 2, "({0}) {1}", token.type, label)), ariaLabel: ( localizeWithPath(_moduleId, 3, "({0}) {1}", token.type, label)), firstListItem });
+                firstListItem = undefined;
+            }
+        }
+    }
+    showSymbol(provider, symbol) {
+        if (!this._currentContent) {
+            return;
+        }
+        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, column: 1 });
+        this._updateContextKeys(provider, true);
+    }
+    disableHint() {
+        if (!(this._currentProvider instanceof AdvancedContentProvider)) {
+            return;
+        }
+        this._configurationService.updateValue(this._currentProvider?.verbositySettingKey, false);
+        alert(( localizeWithPath(
+            _moduleId,
+            4,
+            '{0} accessibility verbosity is now disabled',
+            this._currentProvider.verbositySettingKey
+        )));
+    }
+    _updateContextKeys(provider, shown) {
+        if (provider.options.type === AccessibleViewType.Help) {
+            this._accessiblityHelpIsShown.set(shown);
+            this._accessibleViewIsShown.reset();
+        }
+        else {
+            this._accessibleViewIsShown.set(shown);
+            this._accessiblityHelpIsShown.reset();
+        }
+        this._accessibleViewSupportsNavigation.set(provider.next !== undefined || provider.previous !== undefined);
+        this._accessibleViewVerbosityEnabled.set(this._verbosityEnabled());
+        this._accessibleViewGoToSymbolSupported.set(this._goToSymbolsSupported() ? this.getSymbols()?.length > 0 : false);
+    }
+    _render(provider, container, showAccessibleViewHelp) {
+        this._currentProvider = provider;
+        this._accessibleViewCurrentProviderId.set(provider.id);
+        const verbose = this._verbosityEnabled();
+        const readMoreLink = provider.options.readMoreUrl ? ( localizeWithPath(
+            _moduleId,
+            5,
+            "\n\nOpen a browser window with more information related to accessibility<keybinding:{0}>.",
+            AccessibilityCommandId.AccessibilityHelpOpenHelpLink
+        )) : '';
+        let disableHelpHint = '';
+        if (provider instanceof AdvancedContentProvider && provider.options.type === AccessibleViewType.Help && verbose) {
+            disableHelpHint = this._getDisableVerbosityHint();
+        }
+        const accessibilitySupport = this._accessibilityService.isScreenReaderOptimized();
+        let message = '';
+        if (provider.options.type === AccessibleViewType.Help) {
+            const turnOnMessage = (isMacintosh
+                ? AccessibilityHelpNLS.changeConfigToOnMac
+                : AccessibilityHelpNLS.changeConfigToOnWinLinux);
+            if (accessibilitySupport && provider instanceof AdvancedContentProvider && provider.verbositySettingKey === AccessibilityVerbositySettingId.Editor) {
+                message = AccessibilityHelpNLS.auto_on;
+                message += '\n';
+            }
+            else if (!accessibilitySupport) {
+                message = AccessibilityHelpNLS.auto_off + '\n' + turnOnMessage;
+                message += '\n';
+            }
+        }
+        const exitThisDialogHint = verbose && !provider.options.position ? ( localizeWithPath(_moduleId, 6, '\n\nExit this dialog (Escape).')) : '';
+        let content = provider.provideContent();
+        if (provider.options.type === AccessibleViewType.Help) {
+            const resolvedContent = resolveContentAndKeybindingItems(this._keybindingService, content + readMoreLink + disableHelpHint + exitThisDialogHint);
+            if (resolvedContent) {
+                content = resolvedContent.content.value;
+                if (resolvedContent.configureKeybindingItems) {
+                    provider.options.configureKeybindingItems = resolvedContent.configureKeybindingItems;
+                }
+            }
+        }
+        const newContent = message + content;
+        this.calculateCodeBlocks(newContent);
+        this._currentContent = newContent;
+        this._updateContextKeys(provider, true);
+        const widgetIsFocused = this._editorWidget.hasTextFocus() || this._editorWidget.hasWidgetFocus();
+        this._getTextModel(( (URI.from(
+            { path: `accessible-view-${provider.id}`, scheme: 'accessible-view', fragment: this._currentContent }
+        )))).then((model) => {
+            if (!model) {
+                return;
+            }
+            this._editorWidget.setModel(model);
+            const domNode = this._editorWidget.getDomNode();
+            if (!domNode) {
+                return;
+            }
+            model.setLanguage(provider.options.language ?? 'markdown');
+            container.appendChild(this._container);
+            let actionsHint = '';
+            const hasActions = this._accessibleViewSupportsNavigation.get() || this._accessibleViewVerbosityEnabled.get() || this._accessibleViewGoToSymbolSupported.get() || provider.actions?.length;
+            if (verbose && !showAccessibleViewHelp && hasActions) {
+                actionsHint = provider.options.position ? ( localizeWithPath(
+                    _moduleId,
+                    7,
+                    'Explore actions such as disabling this hint (Shift+Tab), use Escape to exit this dialog.'
+                )) : ( localizeWithPath(_moduleId, 8, 'Explore actions such as disabling this hint (Shift+Tab).'));
+            }
+            let ariaLabel = provider.options.type === AccessibleViewType.Help ? ( localizeWithPath(_moduleId, 9, "Accessibility Help")) : ( localizeWithPath(_moduleId, 10, "Accessible View"));
+            this._title.textContent = ariaLabel;
+            if (actionsHint && provider.options.type === AccessibleViewType.View) {
+                ariaLabel = ( localizeWithPath(_moduleId, 11, "Accessible View, {0}", actionsHint));
+            }
+            else if (actionsHint) {
+                ariaLabel = ( localizeWithPath(_moduleId, 12, "Accessibility Help, {0}", actionsHint));
+            }
+            if (isWindows && widgetIsFocused) {
+                ariaLabel = '';
+            }
+            this._editorWidget.updateOptions({ ariaLabel });
+            this._editorWidget.focus();
+            if (this._currentProvider?.options.position) {
+                const position = this._editorWidget.getPosition();
+                const isDefaultPosition = position?.lineNumber === 1 && position.column === 1;
+                if (this._currentProvider.options.position === 'bottom' || this._currentProvider.options.position === 'initial-bottom' && isDefaultPosition) {
+                    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(this._currentProvider.actions, provider.options.type);
+        const hide = (e) => {
+            if (!this._inQuickPick) {
+                provider.onClose();
+            }
+            e?.stopPropagation();
+            this._contextViewService.hideContextView();
+            this._updateContextKeys(provider, false);
+            this._lastProvider = undefined;
+            this._currentContent = undefined;
+        };
+        const disposableStore = ( (new DisposableStore()));
+        disposableStore.add(this._editorWidget.onKeyDown((e) => {
+            if (e.keyCode === KeyCode.Enter) {
+                this._commandService.executeCommand('editor.action.openLink');
+            }
+            else if (e.keyCode === KeyCode.Escape || shouldHide(e.browserEvent, this._keybindingService, this._configurationService)) {
+                hide(e);
+            }
+            else if (e.keyCode === KeyCode.KeyH && provider.options.readMoreUrl) {
+                const url = provider.options.readMoreUrl;
+                alert(AccessibilityHelpNLS.openingDocs);
+                this._openerService.open(( (URI.parse(url))));
+                e.preventDefault();
+                e.stopPropagation();
+            }
+            if (provider instanceof AdvancedContentProvider) {
+                provider.onKeyDown?.(e);
+            }
+        }));
+        disposableStore.add(addDisposableListener(this._toolbar.getElement(), EventType.KEY_DOWN, (e) => {
+            const keyboardEvent = ( (new StandardKeyboardEvent(e)));
+            if (keyboardEvent.equals(KeyCode.Escape)) {
+                hide(e);
+            }
+        }));
+        disposableStore.add(this._editorWidget.onDidBlurEditorWidget(() => {
+            if (!isActiveElement(this._toolbar.getElement())) {
+                hide();
+            }
+        }));
+        disposableStore.add(this._editorWidget.onDidContentSizeChange(() => this._layout()));
+        disposableStore.add(this._layoutService.onDidLayoutActiveContainer(() => this._layout()));
+        return disposableStore;
+    }
+    _updateToolbar(providedActions, type) {
+        this._toolbar.setAriaLabel(type === AccessibleViewType.Help ? ( localizeWithPath(_moduleId, 13, 'Accessibility Help')) : ( localizeWithPath(_moduleId, 14, "Accessible View")));
+        const menuActions = [];
+        const toolbarMenu = this._register(this._menuService.createMenu(MenuId.AccessibleView, this._contextKeyService));
+        createAndFillInActionBarActions(toolbarMenu, {}, menuActions);
+        if (providedActions) {
+            for (const providedAction of providedActions) {
+                providedAction.class = providedAction.class || ThemeIcon.asClassName(Codicon.primitiveSquare);
+                providedAction.checked = undefined;
+            }
+            this._toolbar.setActions([...providedActions, ...menuActions]);
+        }
+        else {
+            this._toolbar.setActions(menuActions);
+        }
+    }
+    _layout() {
+        const dimension = this._layoutService.activeContainerDimension;
+        const maxHeight = dimension.height && dimension.height * .4;
+        const height = Math.min(maxHeight, this._editorWidget.getContentHeight());
+        const width = Math.min(dimension.width * 0.62 , DIMENSIONS.MAX_WIDTH);
+        this._editorWidget.layout({ width, height });
+    }
+    async _getTextModel(resource) {
+        const existing = this._modelService.getModel(resource);
+        if (existing && !existing.isDisposed()) {
+            return existing;
+        }
+        return this._modelService.createModel(resource.fragment, null, resource, false);
+    }
+    _goToSymbolsSupported() {
+        if (!this._currentProvider) {
+            return false;
+        }
+        return this._currentProvider.options.type === AccessibleViewType.Help || this._currentProvider.options.language === 'markdown' || this._currentProvider.options.language === undefined || (this._currentProvider instanceof AdvancedContentProvider && !!this._currentProvider.getSymbols?.());
+    }
+    _updateLastProvider() {
+        const provider = this._currentProvider;
+        if (!provider) {
+            return;
+        }
+        const lastProvider = provider instanceof AdvancedContentProvider ? ( (new AdvancedContentProvider(
+            provider.id,
+            provider.options,
+            provider.provideContent.bind(provider),
+            provider.onClose.bind(provider),
+            provider.verbositySettingKey,
+            provider.onOpen?.bind(provider),
+            provider.actions,
+            provider.next?.bind(provider),
+            provider.previous?.bind(provider),
+            provider.onDidChangeContent?.bind(provider),
+            provider.onKeyDown?.bind(provider),
+            provider.getSymbols?.bind(provider)
+        ))) : ( (new ExtensionContentProvider(
+            provider.id,
+            provider.options,
+            provider.provideContent.bind(provider),
+            provider.onClose.bind(provider),
+            provider.onOpen?.bind(provider),
+            provider.next?.bind(provider),
+            provider.previous?.bind(provider),
+            provider.actions,
+            provider.onDidChangeContent?.bind(provider)
+        )));
+        return lastProvider;
+    }
+    showAccessibleViewHelp() {
+        const lastProvider = this._updateLastProvider();
+        if (!lastProvider) {
+            return;
+        }
+        const accessibleViewHelpProvider = {
+            id: lastProvider.id,
+            provideContent: () => lastProvider.options.customHelp ? lastProvider?.options.customHelp() : this._getAccessibleViewHelpDialogContent(this._goToSymbolsSupported()),
+            onClose: () => {
+                this._contextViewService.hideContextView();
+                queueMicrotask(() => this.show(lastProvider));
+            },
+            options: { type: AccessibleViewType.Help },
+            verbositySettingKey: lastProvider instanceof AdvancedContentProvider ? lastProvider.verbositySettingKey : undefined
+        };
+        this._contextViewService.hideContextView();
+        queueMicrotask(() => this.show(accessibleViewHelpProvider, undefined, true));
+    }
+    _getAccessibleViewHelpDialogContent(providerHasSymbols) {
+        const navigationHint = this._getNavigationHint();
+        const goToSymbolHint = this._getGoToSymbolHint(providerHasSymbols);
+        const toolbarHint = ( localizeWithPath(_moduleId, 15, "Navigate to the toolbar (Shift+Tab)."));
+        const chatHints = this._getChatHints();
+        let hint = ( localizeWithPath(_moduleId, 16, "In the accessible view, you can:\n"));
+        if (navigationHint) {
+            hint += ' - ' + navigationHint + '\n';
+        }
+        if (goToSymbolHint) {
+            hint += ' - ' + goToSymbolHint + '\n';
+        }
+        if (toolbarHint) {
+            hint += ' - ' + toolbarHint + '\n';
+        }
+        if (chatHints) {
+            hint += chatHints;
+        }
+        return hint;
+    }
+    _getChatHints() {
+        if (this._currentProvider?.id !== AccessibleViewProviderId.Chat) {
+            return;
+        }
+        return [( localizeWithPath(
+            _moduleId,
+            17,
+            " - Insert the code block at the cursor<keybinding:workbench.action.chat.insertCodeBlock>."
+        )),
+            ( localizeWithPath(
+                _moduleId,
+                18,
+                " - Insert the code block into a new file<keybinding:workbench.action.chat.insertIntoNewFile>."
+            )),
+            ( localizeWithPath(
+                _moduleId,
+                19,
+                " - Run the code block in the terminal<keybinding:'workbench.action.chat.runInTerminal>.\n"
+            ))].join('\n');
+    }
+    _getNavigationHint() {
+        return ( localizeWithPath(
+            _moduleId,
+            20,
+            "Show the next item<keybinding:{0}> or previous item<keybinding:{1}>.",
+            AccessibilityCommandId.ShowNext,
+            AccessibilityCommandId.ShowPrevious
+        ));
+    }
+    _getDisableVerbosityHint() {
+        return ( localizeWithPath(
+            _moduleId,
+            21,
+            "\n\nDisable accessibility verbosity for this feature<keybinding:{0}>.",
+            AccessibilityCommandId.DisableVerbosityHint
+        ));
+    }
+    _getGoToSymbolHint(providerHasSymbols) {
+        if (!providerHasSymbols) {
+            return;
+        }
+        return ( localizeWithPath(
+            _moduleId,
+            22,
+            'Go to a symbol<keybinding:{0}>.',
+            AccessibilityCommandId.GoToSymbol
+        ));
+    }
+};
+AccessibleView = ( (__decorate([
+    ( (__param(0, IOpenerService))),
+    ( (__param(1, IInstantiationService))),
+    ( (__param(2, IConfigurationService))),
+    ( (__param(3, IModelService))),
+    ( (__param(4, IContextViewService))),
+    ( (__param(5, IContextKeyService))),
+    ( (__param(6, IAccessibilityService))),
+    ( (__param(7, IKeybindingService))),
+    ( (__param(8, ILayoutService))),
+    ( (__param(9, IMenuService))),
+    ( (__param(10, ICommandService))),
+    ( (__param(11, IChatCodeBlockContextProviderService))),
+    ( (__param(12, IStorageService))),
+    ( (__param(13, IQuickInputService)))
+], AccessibleView)));
+let AccessibleViewService = class AccessibleViewService extends Disposable {
+    constructor(_instantiationService, _configurationService, _keybindingService) {
+        super();
+        this._instantiationService = _instantiationService;
+        this._configurationService = _configurationService;
+        this._keybindingService = _keybindingService;
+    }
+    show(provider, position) {
+        if (!this._accessibleView) {
+            this._accessibleView = this._register(this._instantiationService.createInstance(AccessibleView));
+        }
+        this._accessibleView.show(provider, undefined, undefined, position);
+    }
+    configureKeybindings() {
+        this._accessibleView?.configureKeybindings();
+    }
+    openHelpLink() {
+        this._accessibleView?.openHelpLink();
+    }
+    showLastProvider(id) {
+        this._accessibleView?.showLastProvider(id);
+    }
+    next() {
+        this._accessibleView?.next();
+    }
+    previous() {
+        this._accessibleView?.previous();
+    }
+    goToSymbol() {
+        this._accessibleView?.goToSymbol();
+    }
+    getOpenAriaHint(verbositySettingKey) {
+        if (!this._configurationService.getValue(verbositySettingKey)) {
+            return null;
+        }
+        const keybinding = this._keybindingService.lookupKeybinding(AccessibilityCommandId.OpenAccessibleView)?.getAriaLabel();
+        let hint = null;
+        if (keybinding) {
+            hint = ( localizeWithPath(_moduleId, 23, "Inspect this in the accessible view with {0}", keybinding));
+        }
+        else {
+            hint = ( localizeWithPath(
+                _moduleId,
+                24,
+                "Inspect this in the accessible view via the command Open Accessible View which is currently not triggerable via keybinding."
+            ));
+        }
+        return hint;
+    }
+    disableHint() {
+        this._accessibleView?.disableHint();
+    }
+    showAccessibleViewHelp() {
+        this._accessibleView?.showAccessibleViewHelp();
+    }
+    getPosition(id) {
+        return this._accessibleView?.getPosition(id) ?? 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);
+        }
+    }
+    getCodeBlockContext() {
+        return this._accessibleView?.getCodeBlockContext();
+    }
+    navigateToCodeBlock(type) {
+        this._accessibleView?.navigateToCodeBlock(type);
+    }
+};
+AccessibleViewService = ( (__decorate([
+    ( (__param(0, IInstantiationService))),
+    ( (__param(1, IConfigurationService))),
+    ( (__param(2, IKeybindingService)))
+], AccessibleViewService)));
+let AccessibleViewSymbolQuickPick = class AccessibleViewSymbolQuickPick {
+    constructor(_accessibleView, _quickInputService) {
+        this._accessibleView = _accessibleView;
+        this._quickInputService = _quickInputService;
+    }
+    show(provider) {
+        const quickPick = this._quickInputService.createQuickPick();
+        quickPick.placeholder = ( localizeWithPath(_moduleId, 25, "Type to search symbols"));
+        quickPick.title = ( localizeWithPath(_moduleId, 26, "Go to Symbol Accessible View"));
+        const symbols = this._accessibleView.getSymbols();
+        if (!symbols) {
+            return;
+        }
+        for (const symbol of symbols) {
+        }
+        quickPick.canSelectMany = false;
+        quickPick.items = symbols;
+        quickPick.show();
+        quickPick.onDidAccept(() => {
+            this._accessibleView.showSymbol(provider, quickPick.selectedItems[0]);
+            quickPick.hide();
+        });
+        quickPick.onDidHide(() => {
+            if (quickPick.selectedItems.length === 0) {
+                this._accessibleView.show(provider);
+            }
+        });
+    }
+};
+AccessibleViewSymbolQuickPick = ( (__decorate([
+    ( (__param(1, IQuickInputService)))
+], AccessibleViewSymbolQuickPick)));
+function shouldHide(event, keybindingService, configurationService) {
+    if (!configurationService.getValue(AccessibilityWorkbenchSettingId.AccessibleViewCloseOnKeyPress)) {
+        return false;
+    }
+    const standardKeyboardEvent = ( (new StandardKeyboardEvent(event)));
+    const resolveResult = keybindingService.softDispatch(standardKeyboardEvent, standardKeyboardEvent.target);
+    const isValidChord = resolveResult.kind === ResultKind.MoreChordsNeeded;
+    if (keybindingService.inChordMode || isValidChord) {
+        return false;
+    }
+    return shouldHandleKey(event) && !event.ctrlKey && !event.altKey && !event.metaKey && !event.shiftKey;
+}
+function shouldHandleKey(event) {
+    return !!event.code.match(/^(Key[A-Z]|Digit[0-9]|Equal|Comma|Period|Slash|Quote|Backquote|Backslash|Minus|Semicolon|Space|Enter)$/);
+}
+
+export { AccessibleView, AccessibleViewService };