@codingame/monaco-vscode-api 4.0.0 → 4.1.0

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

@@ -0,0 +1,389 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { DisposableStore, Disposable, MutableDisposable } from '../../../../../base/common/lifecycle.js';
+import { localize2WithPath } from '../../../../../nls.js';
+import { CONTEXT_ACCESSIBILITY_MODE_ENABLED } from '../../../../../platform/accessibility/common/accessibility.js';
+import { registerAction2, Action2 } from '../../../../../platform/actions/common/actions.js';
+import { ContextKeyExpr, IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { accessibleViewCurrentProviderId, accessibleViewIsShown } from '../../../accessibility/browser/accessibilityConfiguration.js';
+import { IAccessibleViewService } from '../../../accessibility/browser/accessibleView.js';
+import { AccessibleViewAction, AccessibilityHelpAction } from '../../../accessibility/browser/accessibleViewActions.js';
+import { ITerminalService } from '../../../terminal/browser/terminal.js';
+import { registerTerminalAction } from '../../../terminal/browser/terminalActions.js';
+import { registerTerminalContribution } from '../../../terminal/browser/terminalExtensions.js';
+import { TerminalContextKeys } from '../../../terminal/common/terminalContextKey.js';
+import { BufferContentTracker } from './bufferContentTracker.js';
+import { TerminalAccessibilityHelpProvider } from './terminalAccessibilityHelp.js';
+import { TextAreaSyncAddon } from './textAreaSyncAddon.js';
+import { Position } from '../../../../../editor/common/core/position.js';
+import { TerminalAccessibleBufferProvider } from './terminalAccessibleBufferProvider.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';
+import { Event } from '../../../../../base/common/event.js';
+var TextAreaSyncContribution_1, TerminalAccessibleViewContribution_1;
+let TextAreaSyncContribution = class TextAreaSyncContribution extends DisposableStore {
+    static { TextAreaSyncContribution_1 = this; }
+    static { this.ID = 'terminal.textAreaSync'; }
+    static get(instance) {
+        return instance.getContribution(TextAreaSyncContribution_1.ID);
+    }
+    constructor(_instance, processManager, widgetManager, _instantiationService) {
+        super();
+        this._instance = _instance;
+        this._instantiationService = _instantiationService;
+    }
+    layout(xterm) {
+        if (this._addon) {
+            return;
+        }
+        this._addon = this.add(this._instantiationService.createInstance(TextAreaSyncAddon, this._instance.capabilities));
+        xterm.raw.loadAddon(this._addon);
+        this._addon.activate(xterm.raw);
+    }
+};
+TextAreaSyncContribution = TextAreaSyncContribution_1 = ( __decorate([
+    ( __param(3, IInstantiationService))
+], TextAreaSyncContribution));
+registerTerminalContribution(TextAreaSyncContribution.ID, TextAreaSyncContribution);
+let TerminalAccessibleViewContribution = class TerminalAccessibleViewContribution extends Disposable {
+    static { TerminalAccessibleViewContribution_1 = this; }
+    static { this.ID = 'terminal.accessibleBufferProvider'; }
+    static get(instance) {
+        return instance.getContribution(TerminalAccessibleViewContribution_1.ID);
+    }
+    constructor(_instance, processManager, widgetManager, _accessibleViewService, _instantiationService, _terminalService, _configurationService, _contextKeyService) {
+        super();
+        this._instance = _instance;
+        this._accessibleViewService = _accessibleViewService;
+        this._instantiationService = _instantiationService;
+        this._terminalService = _terminalService;
+        this._configurationService = _configurationService;
+        this._contextKeyService = _contextKeyService;
+        this._onDidRunCommand = ( new MutableDisposable());
+        this._register(AccessibleViewAction.addImplementation(90, 'terminal', () => {
+            if (this._terminalService.activeInstance !== this._instance) {
+                return false;
+            }
+            this.show();
+            return true;
+        }, TerminalContextKeys.focus));
+        this._register(_instance.onDidExecuteText(() => {
+            const focusAfterRun = _configurationService.getValue("terminal.integrated.focusAfterRun" );
+            if (focusAfterRun === 'terminal') {
+                _instance.focus(true);
+            }
+            else if (focusAfterRun === 'accessible-buffer') {
+                this.show();
+            }
+        }));
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration("terminal.integrated.accessibleViewFocusOnCommandExecution" )) {
+                this._updateCommandExecutedListener();
+            }
+        }));
+        this._register(this._instance.capabilities.onDidAddCapability(e => {
+            if (e.capability.type === 2 ) {
+                this._updateCommandExecutedListener();
+            }
+        }));
+    }
+    xtermReady(xterm) {
+        const addon = this._instantiationService.createInstance(TextAreaSyncAddon, this._instance.capabilities);
+        xterm.raw.loadAddon(addon);
+        addon.activate(xterm.raw);
+        this._xterm = xterm;
+        this._register(this._xterm.raw.onWriteParsed(async () => {
+            if (this._terminalService.activeInstance !== this._instance) {
+                return;
+            }
+            if (this._isTerminalAccessibleViewOpen() && this._xterm.raw.buffer.active.baseY === 0) {
+                this.show();
+            }
+        }));
+        const onRequestUpdateEditor = Event.latch(this._xterm.raw.onScroll);
+        this._register(onRequestUpdateEditor(() => {
+            if (this._terminalService.activeInstance !== this._instance) {
+                return;
+            }
+            if (this._isTerminalAccessibleViewOpen()) {
+                this.show();
+            }
+        }));
+    }
+    _updateCommandExecutedListener() {
+        if (!( this._instance.capabilities.has(2 ))) {
+            return;
+        }
+        if (!this._configurationService.getValue("terminal.integrated.accessibleViewFocusOnCommandExecution" )) {
+            this._onDidRunCommand.clear();
+            return;
+        }
+        else if (this._onDidRunCommand.value) {
+            return;
+        }
+        const capability = this._instance.capabilities.get(2 );
+        this._onDidRunCommand.value = this._register(capability.onCommandExecuted(() => {
+            if (this._instance.hasFocus) {
+                this.show();
+            }
+        }));
+    }
+    _isTerminalAccessibleViewOpen() {
+        return accessibleViewCurrentProviderId.getValue(this._contextKeyService) === "terminal" ;
+    }
+    show() {
+        if (!this._xterm) {
+            return;
+        }
+        if (!this._bufferTracker) {
+            this._bufferTracker = this._register(this._instantiationService.createInstance(BufferContentTracker, this._xterm));
+        }
+        if (!this._bufferProvider) {
+            this._bufferProvider = this._register(this._instantiationService.createInstance(TerminalAccessibleBufferProvider, this._instance, this._bufferTracker, () => {
+                return this._register(this._instantiationService.createInstance(TerminalAccessibilityHelpProvider, this._instance, this._xterm)).provideContent();
+            }));
+        }
+        const position = this._configurationService.getValue("terminal.integrated.accessibleViewPreserveCursorPosition" ) ? this._accessibleViewService.getPosition("terminal" ) : undefined;
+        this._accessibleViewService.show(this._bufferProvider, position);
+    }
+    navigateToCommand(type) {
+        const currentLine = this._accessibleViewService.getPosition("terminal" )?.lineNumber;
+        const commands = this._getCommandsWithEditorLine();
+        if (!commands?.length || !currentLine) {
+            return;
+        }
+        const filteredCommands = type === "previous"  ? commands.filter(c => c.lineNumber < currentLine).sort((a, b) => b.lineNumber - a.lineNumber) : commands.filter(c => c.lineNumber > currentLine).sort((a, b) => a.lineNumber - b.lineNumber);
+        if (!filteredCommands.length) {
+            return;
+        }
+        this._accessibleViewService.setPosition(( new Position(filteredCommands[0].lineNumber, 1)), true);
+    }
+    _getCommandsWithEditorLine() {
+        const capability = this._instance.capabilities.get(2 );
+        const commands = capability?.commands;
+        const currentCommand = capability?.currentCommand;
+        if (!commands?.length) {
+            return;
+        }
+        const result = [];
+        for (const command of commands) {
+            const lineNumber = this._getEditorLineForCommand(command);
+            if (!lineNumber) {
+                continue;
+            }
+            result.push({ command, lineNumber });
+        }
+        if (currentCommand) {
+            const lineNumber = this._getEditorLineForCommand(currentCommand);
+            if (!!lineNumber) {
+                result.push({ command: currentCommand, lineNumber });
+            }
+        }
+        return result;
+    }
+    _getEditorLineForCommand(command) {
+        if (!this._bufferTracker) {
+            return;
+        }
+        let line;
+        if ('marker' in command) {
+            line = command.marker?.line;
+        }
+        else if ('commandStartMarker' in command) {
+            line = command.commandStartMarker?.line;
+        }
+        if (line === undefined || line < 0) {
+            return;
+        }
+        line = this._bufferTracker.bufferToEditorLineMapping.get(line);
+        if (line === undefined) {
+            return;
+        }
+        return line + 1;
+    }
+};
+TerminalAccessibleViewContribution = TerminalAccessibleViewContribution_1 = ( __decorate([
+    ( __param(3, IAccessibleViewService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, ITerminalService)),
+    ( __param(6, IConfigurationService)),
+    ( __param(7, IContextKeyService))
+], TerminalAccessibleViewContribution));
+registerTerminalContribution(TerminalAccessibleViewContribution.ID, TerminalAccessibleViewContribution);
+class TerminalAccessibilityHelpContribution extends Disposable {
+    constructor() {
+        super();
+        this._register(AccessibilityHelpAction.addImplementation(105, 'terminal', async (accessor) => {
+            const instantiationService = accessor.get(IInstantiationService);
+            const terminalService = accessor.get(ITerminalService);
+            const accessibleViewService = accessor.get(IAccessibleViewService);
+            const instance = await terminalService.getActiveOrCreateInstance();
+            await terminalService.revealActiveTerminal();
+            const terminal = instance?.xterm;
+            if (!terminal) {
+                return;
+            }
+            accessibleViewService.show(instantiationService.createInstance(TerminalAccessibilityHelpProvider, instance, terminal));
+        }, ( ContextKeyExpr.or(TerminalContextKeys.focus, ( ContextKeyExpr.and(accessibleViewIsShown, ( ContextKeyExpr.equals(
+            accessibleViewCurrentProviderId.key,
+            "terminal"
+        ))))))));
+    }
+}
+registerTerminalContribution(TerminalAccessibilityHelpContribution.ID, TerminalAccessibilityHelpContribution);
+class FocusAccessibleBufferAction extends Action2 {
+    constructor() {
+        super({
+            id: "workbench.action.terminal.focusAccessibleBuffer" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/terminalContrib/accessibility/browser/terminal.accessibility.contribution',
+                'workbench.action.terminal.focusAccessibleBuffer',
+                "Focus Accessible Terminal View"
+            )),
+            precondition: ( ContextKeyExpr.or(
+                TerminalContextKeys.processSupported,
+                TerminalContextKeys.terminalHasBeenCreated
+            )),
+            keybinding: [
+                {
+                    primary: 512  | 60 ,
+                    secondary: [2048  | 16 ],
+                    linux: {
+                        primary: 512  | 60  | 1024 ,
+                        secondary: [2048  | 16 ]
+                    },
+                    weight: 200 ,
+                    when: ( ContextKeyExpr.and(CONTEXT_ACCESSIBILITY_MODE_ENABLED, TerminalContextKeys.focus))
+                }
+            ]
+        });
+    }
+    async run(accessor, ...args) {
+        const terminalService = accessor.get(ITerminalService);
+        const terminal = await terminalService.getActiveOrCreateInstance();
+        if (!terminal?.xterm) {
+            return;
+        }
+        TerminalAccessibleViewContribution.get(terminal)?.show();
+    }
+}
+registerAction2(FocusAccessibleBufferAction);
+registerTerminalAction({
+    id: "workbench.action.terminal.accessibleBufferGoToNextCommand" ,
+    title: ( localize2WithPath(
+        'vs/workbench/contrib/terminalContrib/accessibility/browser/terminal.accessibility.contribution',
+        'workbench.action.terminal.accessibleBufferGoToNextCommand',
+        "Accessible Buffer Go to Next Command"
+    )),
+    precondition: ( ContextKeyExpr.or(
+        TerminalContextKeys.processSupported,
+        TerminalContextKeys.terminalHasBeenCreated,
+        ( ContextKeyExpr.and(accessibleViewIsShown, ( ContextKeyExpr.equals(
+            accessibleViewCurrentProviderId.key,
+            "terminal"
+        ))))
+    )),
+    keybinding: [
+        {
+            primary: 512  | 18 ,
+            when: ( ContextKeyExpr.and(( ContextKeyExpr.and(accessibleViewIsShown, ( ContextKeyExpr.equals(
+                accessibleViewCurrentProviderId.key,
+                "terminal"
+            )))))),
+            weight: 200  + 2
+        }
+    ],
+    run: async (c) => {
+        const instance = await c.service.activeInstance;
+        if (!instance) {
+            return;
+        }
+        await TerminalAccessibleViewContribution.get(instance)?.navigateToCommand("next" );
+    }
+});
+registerTerminalAction({
+    id: "workbench.action.terminal.accessibleBufferGoToPreviousCommand" ,
+    title: ( localize2WithPath(
+        'vs/workbench/contrib/terminalContrib/accessibility/browser/terminal.accessibility.contribution',
+        'workbench.action.terminal.accessibleBufferGoToPreviousCommand',
+        "Accessible Buffer Go to Previous Command"
+    )),
+    precondition: ( ContextKeyExpr.and(( ContextKeyExpr.or(
+        TerminalContextKeys.processSupported,
+        TerminalContextKeys.terminalHasBeenCreated
+    )), ( ContextKeyExpr.and(accessibleViewIsShown, ( ContextKeyExpr.equals(
+        accessibleViewCurrentProviderId.key,
+        "terminal"
+    )))))),
+    keybinding: [
+        {
+            primary: 512  | 16 ,
+            when: ( ContextKeyExpr.and(( ContextKeyExpr.and(accessibleViewIsShown, ( ContextKeyExpr.equals(
+                accessibleViewCurrentProviderId.key,
+                "terminal"
+            )))))),
+            weight: 200  + 2
+        }
+    ],
+    run: async (c) => {
+        const instance = await c.service.activeInstance;
+        if (!instance) {
+            return;
+        }
+        await TerminalAccessibleViewContribution.get(instance)?.navigateToCommand("previous" );
+    }
+});
+registerTerminalAction({
+    id: "workbench.action.terminal.scrollToBottomAccessibleView" ,
+    title: ( localize2WithPath(
+        'vs/workbench/contrib/terminalContrib/accessibility/browser/terminal.accessibility.contribution',
+        'workbench.action.terminal.scrollToBottomAccessibleView',
+        'Scroll to Accessible View Bottom'
+    )),
+    precondition: ( ContextKeyExpr.and(( ContextKeyExpr.or(
+        TerminalContextKeys.processSupported,
+        TerminalContextKeys.terminalHasBeenCreated
+    )), ( ContextKeyExpr.and(accessibleViewIsShown, ( ContextKeyExpr.equals(
+        accessibleViewCurrentProviderId.key,
+        "terminal"
+    )))))),
+    keybinding: {
+        primary: 2048  | 13 ,
+        linux: { primary: 1024  | 13  },
+        when: ( accessibleViewCurrentProviderId.isEqualTo("terminal" )),
+        weight: 200
+    },
+    run: (c, accessor) => {
+        const accessibleViewService = accessor.get(IAccessibleViewService);
+        const lastPosition = accessibleViewService.getLastPosition();
+        if (!lastPosition) {
+            return;
+        }
+        accessibleViewService.setPosition(lastPosition, true);
+    }
+});
+registerTerminalAction({
+    id: "workbench.action.terminal.scrollToTopAccessibleView" ,
+    title: ( localize2WithPath(
+        'vs/workbench/contrib/terminalContrib/accessibility/browser/terminal.accessibility.contribution',
+        'workbench.action.terminal.scrollToTopAccessibleView',
+        'Scroll to Accessible View Top'
+    )),
+    precondition: ( ContextKeyExpr.and(( ContextKeyExpr.or(
+        TerminalContextKeys.processSupported,
+        TerminalContextKeys.terminalHasBeenCreated
+    )), ( ContextKeyExpr.and(accessibleViewIsShown, ( ContextKeyExpr.equals(
+        accessibleViewCurrentProviderId.key,
+        "terminal"
+    )))))),
+    keybinding: {
+        primary: 2048  | 14 ,
+        linux: { primary: 1024  | 14  },
+        when: ( accessibleViewCurrentProviderId.isEqualTo("terminal" )),
+        weight: 200
+    },
+    run: (c, accessor) => {
+        const accessibleViewService = accessor.get(IAccessibleViewService);
+        accessibleViewService.setPosition({ lineNumber: 1, column: 1 }, true);
+    }
+});
+export { TerminalAccessibilityHelpContribution, TerminalAccessibleViewContribution };

package/vscode/src/vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibilityHelp.js

@@ -0,0 +1,190 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+import { format } from '../../../../../base/common/strings.js';
+import { localizeWithPath } from '../../../../../nls.js';
+import { IAccessibilityService } from '../../../../../platform/accessibility/common/accessibility.js';
+import { ICommandService } from '../../../../../platform/commands/common/commands.js';
+import { ContextKeyExpr, IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { IKeybindingService } from '../../../../../platform/keybinding/common/keybinding.js';
+import { accessibleViewIsShown, accessibleViewCurrentProviderId } from '../../../accessibility/browser/accessibilityConfiguration.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';
+let TerminalAccessibilityHelpProvider = class TerminalAccessibilityHelpProvider extends Disposable {
+    onClose() {
+        const expr = ( ContextKeyExpr.and(accessibleViewIsShown, ( ContextKeyExpr.equals(
+            accessibleViewCurrentProviderId.key,
+            "terminal-help"
+        ))));
+        if (expr?.evaluate(this._contextKeyService.getContext(null))) {
+            this._commandService.executeCommand("workbench.action.terminal.focusAccessibleBuffer" );
+        }
+        else {
+            this._instance.focus();
+        }
+        this.dispose();
+    }
+    constructor(_instance, _xterm, _instantiationService, _keybindingService, _contextKeyService, _commandService, _accessibilityService, _configurationService) {
+        super();
+        this._instance = _instance;
+        this._keybindingService = _keybindingService;
+        this._contextKeyService = _contextKeyService;
+        this._commandService = _commandService;
+        this._accessibilityService = _accessibilityService;
+        this._configurationService = _configurationService;
+        this.id = "terminal-help" ;
+        this._hasShellIntegration = false;
+        this.options = {
+            type: "help" ,
+            readMoreUrl: 'https://code.visualstudio.com/docs/editor/accessibility#_terminal-accessibility'
+        };
+        this.verbositySettingKey = "accessibility.verbosity.terminal" ;
+        this._hasShellIntegration = _xterm.shellIntegration.status === 2 ;
+    }
+    _descriptionForCommand(commandId, msg, noKbMsg) {
+        if (commandId === "workbench.action.terminal.runRecentCommand" ) {
+            const kb = this._keybindingService.lookupKeybindings(commandId);
+            const isScreenReaderOptimized = this._accessibilityService.isScreenReaderOptimized();
+            if (isScreenReaderOptimized && kb[1]) {
+                format(msg, kb[1].getAriaLabel());
+            }
+            else if (kb[0]) {
+                format(msg, kb[0].getAriaLabel());
+            }
+            else {
+                return format(noKbMsg, commandId);
+            }
+        }
+        const kb = this._keybindingService.lookupKeybinding(commandId, this._contextKeyService)?.getAriaLabel();
+        return !kb ? format(noKbMsg, commandId) : format(msg, kb);
+    }
+    provideContent() {
+        const content = [];
+        content.push(this._descriptionForCommand("workbench.action.terminal.focusAccessibleBuffer" , ( localizeWithPath(
+            'vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibilityHelp',
+            'focusAccessibleTerminalView',
+            'The Focus Accessible Terminal View ({0}) command enables screen readers to read terminal contents.'
+        )), ( localizeWithPath(
+            'vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibilityHelp',
+            'focusAccessibleTerminalViewNoKb',
+            'The Focus Terminal Accessible View command enables screen readers to read terminal contents and is currently not triggerable by a keybinding.'
+        ))));
+        content.push(( localizeWithPath(
+            'vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibilityHelp',
+            'preserveCursor',
+            'Customize the behavior of the cursor when toggling between the terminal and accessible view with `terminal.integrated.accessibleViewPreserveCursorPosition.`'
+        )));
+        if (!this._configurationService.getValue("terminal.integrated.accessibleViewFocusOnCommandExecution" )) {
+            content.push(( localizeWithPath(
+                'vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibilityHelp',
+                'focusViewOnExecution',
+                'Enable `terminal.integrated.accessibleViewFocusOnCommandExecution` to automatically focus the terminal accessible view when a command is executed in the terminal.'
+            )));
+        }
+        if (this._instance.shellType === "cmd" ) {
+            content.push(( localizeWithPath(
+                'vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibilityHelp',
+                'commandPromptMigration',
+                "Consider using powershell instead of command prompt for an improved experience"
+            )));
+        }
+        if (this._hasShellIntegration) {
+            const shellIntegrationCommandList = [];
+            shellIntegrationCommandList.push(( localizeWithPath(
+                'vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibilityHelp',
+                'shellIntegration',
+                "The terminal has a feature called shell integration that offers an enhanced experience and provides useful commands for screen readers such as:"
+            )));
+            shellIntegrationCommandList.push('- ' + this._descriptionForCommand("workbench.action.terminal.accessibleBufferGoToNextCommand" , ( localizeWithPath(
+                'vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibilityHelp',
+                'goToNextCommand',
+                'Go to Next Command ({0}) in the accessible view'
+            )), ( localizeWithPath(
+                'vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibilityHelp',
+                'goToNextCommandNoKb',
+                'Go to Next Command in the accessible view is currently not triggerable by a keybinding.'
+            ))));
+            shellIntegrationCommandList.push('- ' + this._descriptionForCommand("workbench.action.terminal.accessibleBufferGoToPreviousCommand" , ( localizeWithPath(
+                'vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibilityHelp',
+                'goToPreviousCommand',
+                'Go to Previous Command ({0}) in the accessible view'
+            )), ( localizeWithPath(
+                'vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibilityHelp',
+                'goToPreviousCommandNoKb',
+                'Go to Previous Command in the accessible view is currently not triggerable by a keybinding.'
+            ))));
+            shellIntegrationCommandList.push('- ' + this._descriptionForCommand("editor.action.accessibleViewGoToSymbol" , ( localizeWithPath(
+                'vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibilityHelp',
+                'goToSymbol',
+                'Go to Symbol ({0})'
+            )), ( localizeWithPath(
+                'vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibilityHelp',
+                'goToSymbolNoKb',
+                'Go to symbol is currently not triggerable by a keybinding.'
+            ))));
+            shellIntegrationCommandList.push('- ' + this._descriptionForCommand("workbench.action.terminal.runRecentCommand" , ( localizeWithPath(
+                'vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibilityHelp',
+                'runRecentCommand',
+                'Run Recent Command ({0})'
+            )), ( localizeWithPath(
+                'vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibilityHelp',
+                'runRecentCommandNoKb',
+                'Run Recent Command is currently not triggerable by a keybinding.'
+            ))));
+            shellIntegrationCommandList.push('- ' + this._descriptionForCommand("workbench.action.terminal.goToRecentDirectory" , ( localizeWithPath(
+                'vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibilityHelp',
+                'goToRecentDirectory',
+                'Go to Recent Directory ({0})'
+            )), ( localizeWithPath(
+                'vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibilityHelp',
+                'goToRecentDirectoryNoKb',
+                'Go to Recent Directory is currently not triggerable by a keybinding.'
+            ))));
+            content.push(shellIntegrationCommandList.join('\n'));
+        }
+        else {
+            content.push(this._descriptionForCommand("workbench.action.terminal.runRecentCommand" , ( localizeWithPath(
+                'vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibilityHelp',
+                'goToRecentDirectoryNoShellIntegration',
+                'The Go to Recent Directory command ({0}) enables screen readers to easily navigate to a directory that has been used in the terminal.'
+            )), ( localizeWithPath(
+                'vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibilityHelp',
+                'goToRecentDirectoryNoKbNoShellIntegration',
+                'The Go to Recent Directory command enables screen readers to easily navigate to a directory that has been used in the terminal and is currently not triggerable by a keybinding.'
+            ))));
+        }
+        content.push(this._descriptionForCommand("workbench.action.terminal.openDetectedLink" , ( localizeWithPath(
+            'vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibilityHelp',
+            'openDetectedLink',
+            'The Open Detected Link ({0}) command enables screen readers to easily open links found in the terminal.'
+        )), ( localizeWithPath(
+            'vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibilityHelp',
+            'openDetectedLinkNoKb',
+            'The Open Detected Link command enables screen readers to easily open links found in the terminal and is currently not triggerable by a keybinding.'
+        ))));
+        content.push(this._descriptionForCommand("workbench.action.terminal.newWithProfile" , ( localizeWithPath(
+            'vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibilityHelp',
+            'newWithProfile',
+            'The Create New Terminal (With Profile) ({0}) command allows for easy terminal creation using a specific profile.'
+        )), ( localizeWithPath(
+            'vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibilityHelp',
+            'newWithProfileNoKb',
+            'The Create New Terminal (With Profile) command allows for easy terminal creation using a specific profile and is currently not triggerable by a keybinding.'
+        ))));
+        content.push(( localizeWithPath(
+            'vs/workbench/contrib/terminalContrib/accessibility/browser/terminalAccessibilityHelp',
+            'focusAfterRun',
+            'Configure what gets focused after running selected text in the terminal with `{0}`.',
+            "terminal.integrated.focusAfterRun"
+        )));
+        return content.join('\n\n');
+    }
+};
+TerminalAccessibilityHelpProvider = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IKeybindingService)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, ICommandService)),
+    ( __param(6, IAccessibilityService)),
+    ( __param(7, IConfigurationService))
+], TerminalAccessibilityHelpProvider));
+export { TerminalAccessibilityHelpProvider };