@codingame/monaco-vscode-accessibility-service-override 1.82.4 → 1.82.5-next.0

package/accessibility.d.ts

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

package/accessibility.js

@@ -0,0 +1,12 @@
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { IAccessibleViewService, AccessibleViewService } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibleView';
+import './vscode/src/vs/workbench/contrib/accessibility/browser/accessibility.contribution.js';
+import './vscode/src/vs/workbench/contrib/codeEditor/browser/accessibility/accessibility.js';
+
+function getServiceOverride() {
+    return {
+        [( IAccessibleViewService.toString())]: new SyncDescriptor(AccessibleViewService, [], true)
+    };
+}
+
+export { getServiceOverride as default };

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

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

package/external/tslib/tslib.es6.js

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

package/index.d.ts

@@ -1 +1 @@
-export { default } from 'vscode/service-override/accessibility'
+export { default } from './accessibility.js';

package/index.js

@@ -1 +1 @@
-export { default } from 'vscode/service-override/accessibility'
+export { default } from './accessibility.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-accessibility-service-override",
-  "version": "1.82.4",
+  "version": "1.82.5-next.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,7 +18,7 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@1.82.4",
+    "vscode": "npm:@codingame/monaco-vscode-api@1.82.5-next.0",
     "monaco-editor": "0.43.0"
   }
 }

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

@@ -0,0 +1,14 @@
+import { registerAccessibilityConfiguration } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { UnfocusedViewDimmingContribution } from './unfocusedViewDimmingContribution.js';
+import { EditorAccessibilityHelpContribution, HoverAccessibleViewContribution, NotificationAccessibleViewContribution, InlineCompletionsAccessibleViewContribution } from './accessibilityContributions.js';
+
+registerAccessibilityConfiguration();
+const workbenchRegistry = ( Registry.as(Extensions.Workbench));
+workbenchRegistry.registerWorkbenchContribution(EditorAccessibilityHelpContribution, 4 );
+workbenchRegistry.registerWorkbenchContribution(UnfocusedViewDimmingContribution, 3 );
+const workbenchContributionsRegistry = ( Registry.as(Extensions.Workbench));
+workbenchContributionsRegistry.registerWorkbenchContribution(HoverAccessibleViewContribution, 4 );
+workbenchContributionsRegistry.registerWorkbenchContribution(NotificationAccessibleViewContribution, 4 );
+workbenchContributionsRegistry.registerWorkbenchContribution(InlineCompletionsAccessibleViewContribution, 4 );

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

@@ -0,0 +1,314 @@
+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 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
+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 'vscode/vscode/vs/workbench/contrib/files/browser/fileConstants';
+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 'vscode/vscode/vs/workbench/browser/parts/notifications/notificationsCommands';
+import { IListService, WorkbenchList } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { NotificationFocusedContext } from 'vscode/vscode/vs/workbench/common/contextkeys';
+import { IAccessibleViewService } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibleView';
+import { IHoverService } from 'vscode/vscode/vs/workbench/services/hover/browser/hover';
+import { alert } from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
+import { AccessibilityHelpAction, AccessibleViewAction } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibleViewActions';
+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';
+
+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(AccessibilityHelpProvider, codeEditor));
+        }, EditorContextKeys.focus));
+    }
+}
+let AccessibilityHelpProvider = class AccessibilityHelpProvider {
+    onClose() {
+        this._editor.focus();
+    }
+    constructor(_editor, _keybindingService) {
+        this._editor = _editor;
+        this._keybindingService = _keybindingService;
+        this.options = { type: "help" , readMoreUrl: 'https://go.microsoft.com/fwlink/?linkid=851010' };
+        this.verbositySettingKey = "accessibility.verbosity.editor" ;
+    }
+    _descriptionForCommand(commandId, msg, noKbMsg) {
+        const kb = this._keybindingService.lookupKeybinding(commandId);
+        if (kb) {
+            return strings.format(msg, kb.getAriaLabel());
+        }
+        return strings.format(noKbMsg, commandId);
+    }
+    provideContent() {
+        const options = this._editor.getOptions();
+        const content = [];
+        if (options.get(60 )) {
+            if (options.get(89 )) {
+                content.push(AccessibilityHelpNLS.readonlyDiffEditor);
+            }
+            else {
+                content.push(AccessibilityHelpNLS.editableDiffEditor);
+            }
+        }
+        else {
+            if (options.get(89 )) {
+                content.push(AccessibilityHelpNLS.readonlyEditor);
+            }
+            else {
+                content.push(AccessibilityHelpNLS.editableEditor);
+            }
+        }
+        if (options.get(113 )) {
+            content.push(this._descriptionForCommand('editor.action.focusStickyScroll', AccessibilityHelpNLS.stickScrollKb, AccessibilityHelpNLS.stickScrollNoKb));
+        }
+        if (options.get(141 )) {
+            content.push(this._descriptionForCommand(ToggleTabFocusModeAction.ID, AccessibilityHelpNLS.tabFocusModeOnMsg, AccessibilityHelpNLS.tabFocusModeOnMsgNoKb));
+        }
+        else {
+            content.push(this._descriptionForCommand(ToggleTabFocusModeAction.ID, AccessibilityHelpNLS.tabFocusModeOffMsg, AccessibilityHelpNLS.tabFocusModeOffMsgNoKb));
+        }
+        return content.join('\n\n');
+    }
+};
+AccessibilityHelpProvider = ( __decorate([
+    ( __param(1, IKeybindingService))
+], AccessibilityHelpProvider));
+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 };

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

@@ -0,0 +1,65 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { clamp } from 'monaco-editor/esm/vs/base/common/numbers.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+
+let UnfocusedViewDimmingContribution = class UnfocusedViewDimmingContribution extends Disposable {
+    constructor(configurationService) {
+        super();
+        this._register(toDisposable(() => this._removeStyleElement()));
+        this._register(Event.runAndSubscribe(configurationService.onDidChangeConfiguration, e => {
+            if (e && !e.affectsConfiguration("accessibility.dimUnfocused.enabled" ) && !e.affectsConfiguration("accessibility.dimUnfocused.opacity" )) {
+                return;
+            }
+            let cssTextContent = '';
+            const enabled = ensureBoolean(configurationService.getValue("accessibility.dimUnfocused.enabled" ), false);
+            if (enabled) {
+                const opacity = clamp(ensureNumber(configurationService.getValue("accessibility.dimUnfocused.opacity" ), 0.75 ), 0.2 , 1 );
+                if (opacity !== 1) {
+                    const rules = ( new Set());
+                    const filterRule = `filter: opacity(${opacity});`;
+                    rules.add(`.monaco-workbench .pane-body.integrated-terminal:not(:focus-within) .tabs-container { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .pane-body.integrated-terminal .terminal-wrapper:not(:focus-within) { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .monaco-editor { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .tabs-breadcrumbs { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .terminal-wrapper { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .settings-editor { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .keybindings-editor { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .monaco-editor-pane-placeholder { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .gettingStartedContainer { ${filterRule} }`);
+                    cssTextContent = [...rules].join('\n');
+                }
+            }
+            if (cssTextContent.length === 0) {
+                this._removeStyleElement();
+            }
+            else {
+                this._getStyleElement().textContent = cssTextContent;
+            }
+        }));
+    }
+    _getStyleElement() {
+        if (!this._styleElement) {
+            this._styleElement = document.createElement('style');
+            this._styleElement.className = 'accessibilityUnfocusedViewOpacity';
+            document.head.appendChild(this._styleElement);
+        }
+        return this._styleElement;
+    }
+    _removeStyleElement() {
+        this._styleElement?.remove();
+        this._styleElement = undefined;
+    }
+};
+UnfocusedViewDimmingContribution = ( __decorate([
+    ( __param(0, IConfigurationService))
+], UnfocusedViewDimmingContribution));
+function ensureBoolean(value, defaultValue) {
+    return typeof value === 'boolean' ? value : defaultValue;
+}
+function ensureNumber(value, defaultValue) {
+    return typeof value === 'number' ? value : defaultValue;
+}
+
+export { UnfocusedViewDimmingContribution };

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

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

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

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