@codingame/monaco-vscode-api 2.2.2 → 3.0.0

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

@@ -18,7 +18,7 @@ import { ThemeIcon } from '../../../../base/common/themables.js';
 import { Codicon } from '../../../../base/common/codicons.js';
 import { InlineCompletionsController } from '../../../../editor/contrib/inlineCompletions/browser/inlineCompletionsController.js';
 import '../../../../editor/contrib/inlineCompletions/browser/inlineCompletionContextKeys.js';
-import { IAudioCueService, AudioCue } from '../../../../platform/audioCues/browser/audioCueService.js';
+import { IAccessibilitySignalService, AccessibilitySignal } from '../../../../platform/accessibilitySignal/browser/accessibilitySignalService.js';
 function descriptionForCommand(commandId, msg, noKbMsg, keybindingService) {
     const kb = keybindingService.lookupKeybinding(commandId);
     if (kb) {
@@ -83,7 +83,7 @@ class NotificationAccessibleViewContribution extends Disposable {
             const accessibleViewService = accessor.get(IAccessibleViewService);
             const listService = accessor.get(IListService);
             const commandService = accessor.get(ICommandService);
-            const audioCueService = accessor.get(IAudioCueService);
+            const accessibilitySignalService = accessor.get(IAccessibilitySignalService);
             function renderAccessibleView() {
                 const notification = getNotificationFromContext(listService);
                 if (!notification) {
@@ -154,7 +154,7 @@ class NotificationAccessibleViewContribution extends Disposable {
                     },
                     verbositySettingKey: "accessibility.verbosity.notification" ,
                     options: { type: "view"  },
-                    actions: getActionsFromNotification(notification, audioCueService)
+                    actions: getActionsFromNotification(notification, accessibilitySignalService)
                 });
                 return true;
             }
@@ -162,7 +162,7 @@ class NotificationAccessibleViewContribution extends Disposable {
         }, NotificationFocusedContext));
     }
 }
-function getActionsFromNotification(notification, audioCueService) {
+function getActionsFromNotification(notification, accessibilitySignalService) {
     let actions = undefined;
     if (notification.actions) {
         actions = [];
@@ -199,7 +199,7 @@ function getActionsFromNotification(notification, audioCueService) {
             "Clear Notification"
         )), run: () => {
                 notification.close();
-                audioCueService.playAudioCue(AudioCue.clear);
+                accessibilitySignalService.playSignal(AccessibilitySignal.clear);
             }, enabled: true, class: ThemeIcon.asClassName(Codicon.clearAll)
         });
     }
@@ -235,8 +235,8 @@ class InlineCompletionsAccessibleViewContribution extends Disposable {
                 if (!model || !state) {
                     return false;
                 }
-                const lineText = model.textModel.getLineContent(state.ghostText.lineNumber);
-                const ghostText = state.ghostText.renderForScreenReader(lineText);
+                const lineText = model.textModel.getLineContent(state.primaryGhostText.lineNumber);
+                const ghostText = state.primaryGhostText.renderForScreenReader(lineText);
                 if (!ghostText) {
                     return false;
                 }

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

@@ -48,7 +48,7 @@ let EditorAccessibilityHelpProvider = class EditorAccessibilityHelpProvider {
         const options = this._editor.getOptions();
         const content = [];
         if (options.get(61 )) {
-            if (options.get(90 )) {
+            if (options.get(91 )) {
                 content.push(AccessibilityHelpNLS.readonlyDiffEditor);
             }
             else {
@@ -56,14 +56,14 @@ let EditorAccessibilityHelpProvider = class EditorAccessibilityHelpProvider {
             }
         }
         else {
-            if (options.get(90 )) {
+            if (options.get(91 )) {
                 content.push(AccessibilityHelpNLS.readonlyEditor);
             }
             else {
                 content.push(AccessibilityHelpNLS.editableEditor);
             }
         }
-        content.push(AccessibilityHelpNLS.listAudioCues);
+        content.push(AccessibilityHelpNLS.listSignalSounds);
         content.push(AccessibilityHelpNLS.listAlerts);
         const chatCommandInfo = getChatCommandInfo(this._keybindingService, this._contextKeyService);
         if (chatCommandInfo) {
@@ -73,10 +73,10 @@ let EditorAccessibilityHelpProvider = class EditorAccessibilityHelpProvider {
         if (commentCommandInfo) {
             content.push(commentCommandInfo);
         }
-        if (options.get(114 ).enabled) {
+        if (options.get(115 ).enabled) {
             content.push(descriptionForCommand('editor.action.focusStickyScroll', AccessibilityHelpNLS.stickScrollKb, AccessibilityHelpNLS.stickScrollNoKb, this._keybindingService));
         }
-        if (options.get(142 )) {
+        if (options.get(143 )) {
             content.push(descriptionForCommand(ToggleTabFocusModeAction.ID, AccessibilityHelpNLS.tabFocusModeOnMsg, AccessibilityHelpNLS.tabFocusModeOnMsgNoKb, this._keybindingService));
         }
         else {

package/vscode/src/vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution.js

@@ -0,0 +1,306 @@
+import { ShowSignalSoundHelp, ShowAccessibilityAnnouncementHelp } from './commands.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { registerAction2 } from '../../../../platform/actions/common/actions.js';
+import { Extensions as Extensions$1 } from '../../../../platform/configuration/common/configurationRegistry.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { Extensions } from '../../../common/contributions.js';
+import { AccessibilitySignalLineDebuggerContribution } from './accessibilitySignalDebuggerContribution.js';
+import { SignalLineFeatureContribution } from './accessibilitySignalLineFeatureContribution.js';
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(SignalLineFeatureContribution, 3 );
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(AccessibilitySignalLineDebuggerContribution, 3 );
+const soundFeatureBase = {
+    'type': 'string',
+    'enum': ['auto', 'on', 'off'],
+    'default': 'auto',
+    'enumDescriptions': [
+        ( localizeWithPath(
+            'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+            'audioCues.enabled.auto',
+            "Enable sound when a screen reader is attached."
+        )),
+        ( localizeWithPath(
+            'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+            'audioCues.enabled.on',
+            "Enable sound."
+        )),
+        ( localizeWithPath(
+            'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+            'audioCues.enabled.off',
+            "Disable sound."
+        ))
+    ],
+    tags: ['accessibility'],
+};
+const markdownDeprecationMessage = ( localizeWithPath(
+    'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+    'audioCues.enabled.deprecated',
+    "This setting is deprecated. Use `signals` settings instead."
+));
+const soundDeprecatedFeatureBase = {
+    ...soundFeatureBase,
+    markdownDeprecationMessage
+};
+( Registry.as(Extensions$1.Configuration)).registerConfiguration({
+    'properties': {
+        'audioCues.enabled': {
+            markdownDeprecationMessage: 'Deprecated. Use the specific setting for each audio cue instead (`audioCues.*`).',
+            tags: ['accessibility']
+        },
+        'audioCues.volume': {
+            markdownDeprecationMessage: 'Deprecated. Use `accessibility.signals.sounds.volume` instead.',
+            tags: ['accessibility']
+        },
+        'audioCues.debouncePositionChanges': {
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                'audioCues.debouncePositionChanges',
+                "Whether or not position changes should be debounced"
+            )),
+            'type': 'boolean',
+            'default': false,
+            tags: ['accessibility'],
+            'markdownDeprecationMessage': ( localizeWithPath(
+                'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                'audioCues.debouncePositionChangesDeprecated',
+                'This setting is deprecated, instead use the `signals.debouncePositionChanges` setting.'
+            ))
+        },
+        'audioCues.lineHasBreakpoint': {
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                'audioCues.lineHasBreakpoint',
+                "Plays a sound when the active line has a breakpoint."
+            )),
+            ...soundDeprecatedFeatureBase
+        },
+        'audioCues.lineHasInlineSuggestion': {
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                'audioCues.lineHasInlineSuggestion',
+                "Plays a sound when the active line has an inline suggestion."
+            )),
+            ...soundDeprecatedFeatureBase
+        },
+        'audioCues.lineHasError': {
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                'audioCues.lineHasError',
+                "Plays a sound when the active line has an error."
+            )),
+            ...soundDeprecatedFeatureBase,
+        },
+        'audioCues.lineHasFoldedArea': {
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                'audioCues.lineHasFoldedArea',
+                "Plays a sound when the active line has a folded area that can be unfolded."
+            )),
+            ...soundDeprecatedFeatureBase,
+        },
+        'audioCues.lineHasWarning': {
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                'audioCues.lineHasWarning',
+                "Plays a sound when the active line has a warning."
+            )),
+            ...soundDeprecatedFeatureBase,
+            default: 'off',
+        },
+        'audioCues.onDebugBreak': {
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                'audioCues.onDebugBreak',
+                "Plays a sound when the debugger stopped on a breakpoint."
+            )),
+            ...soundDeprecatedFeatureBase,
+        },
+        'audioCues.noInlayHints': {
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                'audioCues.noInlayHints',
+                "Plays a sound when trying to read a line with inlay hints that has no inlay hints."
+            )),
+            ...soundDeprecatedFeatureBase,
+        },
+        'audioCues.taskCompleted': {
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                'audioCues.taskCompleted',
+                "Plays a sound when a task is completed."
+            )),
+            ...soundDeprecatedFeatureBase,
+        },
+        'audioCues.taskFailed': {
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                'audioCues.taskFailed',
+                "Plays a sound when a task fails (non-zero exit code)."
+            )),
+            ...soundDeprecatedFeatureBase,
+        },
+        'audioCues.terminalCommandFailed': {
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                'audioCues.terminalCommandFailed',
+                "Plays a sound when a terminal command fails (non-zero exit code)."
+            )),
+            ...soundDeprecatedFeatureBase,
+        },
+        'audioCues.terminalQuickFix': {
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                'audioCues.terminalQuickFix',
+                "Plays a sound when terminal Quick Fixes are available."
+            )),
+            ...soundDeprecatedFeatureBase,
+        },
+        'audioCues.terminalBell': {
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                'audioCues.terminalBell',
+                "Plays a sound when the terminal bell is ringing."
+            )),
+            ...soundDeprecatedFeatureBase,
+            default: 'on'
+        },
+        'audioCues.diffLineInserted': {
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                'audioCues.diffLineInserted',
+                "Plays a sound when the focus moves to an inserted line in Accessible Diff Viewer mode or to the next/previous change."
+            )),
+            ...soundDeprecatedFeatureBase,
+        },
+        'audioCues.diffLineDeleted': {
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                'audioCues.diffLineDeleted',
+                "Plays a sound when the focus moves to a deleted line in Accessible Diff Viewer mode or to the next/previous change."
+            )),
+            ...soundDeprecatedFeatureBase,
+        },
+        'audioCues.diffLineModified': {
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                'audioCues.diffLineModified',
+                "Plays a sound when the focus moves to a modified line in Accessible Diff Viewer mode or to the next/previous change."
+            )),
+            ...soundDeprecatedFeatureBase,
+        },
+        'audioCues.notebookCellCompleted': {
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                'audioCues.notebookCellCompleted',
+                "Plays a sound when a notebook cell execution is successfully completed."
+            )),
+            ...soundDeprecatedFeatureBase,
+        },
+        'audioCues.notebookCellFailed': {
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                'audioCues.notebookCellFailed',
+                "Plays a sound when a notebook cell execution fails."
+            )),
+            ...soundDeprecatedFeatureBase,
+        },
+        'audioCues.chatRequestSent': {
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                'audioCues.chatRequestSent',
+                "Plays a sound when a chat request is made."
+            )),
+            ...soundDeprecatedFeatureBase,
+            default: 'off'
+        },
+        'audioCues.chatResponsePending': {
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                'audioCues.chatResponsePending',
+                "Plays a sound on loop while the response is pending."
+            )),
+            ...soundDeprecatedFeatureBase,
+            default: 'auto'
+        },
+        'audioCues.chatResponseReceived': {
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                'audioCues.chatResponseReceived',
+                "Plays a sound on loop while the response has been received."
+            )),
+            ...soundDeprecatedFeatureBase,
+            default: 'off'
+        },
+        'audioCues.clear': {
+            'description': ( localizeWithPath(
+                'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                'audioCues.clear',
+                "Plays a sound when a feature is cleared (for example, the terminal, Debug Console, or Output channel). When this is disabled, an ARIA alert will announce 'Cleared'."
+            )),
+            ...soundDeprecatedFeatureBase,
+            default: 'off'
+        },
+        'audioCues.save': {
+            'markdownDescription': ( localizeWithPath(
+                'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                'audioCues.save',
+                "Plays a sound when a file is saved. Also see {0}",
+                '`#accessibility.alert.save#`'
+            )),
+            'type': 'string',
+            'enum': ['userGesture', 'always', 'never'],
+            'default': 'never',
+            'enumDescriptions': [
+                ( localizeWithPath(
+                    'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                    'audioCues.save.userGesture',
+                    "Plays the audio cue when a user explicitly saves a file."
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                    'audioCues.save.always',
+                    "Plays the audio cue whenever a file is saved, including auto save."
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                    'audioCues.save.never',
+                    "Never plays the audio cue."
+                ))
+            ],
+            tags: ['accessibility'],
+            markdownDeprecationMessage
+        },
+        'audioCues.format': {
+            'markdownDescription': ( localizeWithPath(
+                'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                'audioCues.format',
+                "Plays a sound when a file or notebook is formatted. Also see {0}",
+                '`#accessibility.alert.format#`'
+            )),
+            'type': 'string',
+            'enum': ['userGesture', 'always', 'never'],
+            'default': 'never',
+            'enumDescriptions': [
+                ( localizeWithPath(
+                    'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                    'audioCues.format.userGesture',
+                    "Plays the audio cue when a user explicitly formats a file."
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                    'audioCues.format.always',
+                    "Plays the audio cue whenever a file is formatted, including if it is set to format on save, type, or, paste, or run of a cell."
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignal.contribution',
+                    'audioCues.format.never',
+                    "Never plays the audio cue."
+                ))
+            ],
+            tags: ['accessibility'],
+            markdownDeprecationMessage
+        },
+    },
+});
+registerAction2(ShowSignalSoundHelp);
+registerAction2(ShowAccessibilityAnnouncementHelp);
+export { soundFeatureBase };

package/vscode/src/vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignalDebuggerContribution.js

@@ -0,0 +1,46 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
+import { AccessibilitySignal, IAccessibilitySignalService } from '../../../../platform/accessibilitySignal/browser/accessibilitySignalService.js';
+import { IDebugService } from '../../debug/common/debug.js';
+import { observableFromEvent } from '../../../../base/common/observableInternal/utils.js';
+import { autorunWithStore } from '../../../../base/common/observableInternal/autorun.js';
+let AccessibilitySignalLineDebuggerContribution = class AccessibilitySignalLineDebuggerContribution extends Disposable {
+    constructor(debugService, accessibilitySignalService) {
+        super();
+        this.accessibilitySignalService = accessibilitySignalService;
+        const isEnabled = observableFromEvent(accessibilitySignalService.onSoundEnabledChanged(AccessibilitySignal.onDebugBreak), () => accessibilitySignalService.isSoundEnabled(AccessibilitySignal.onDebugBreak));
+        this._register(autorunWithStore((reader, store) => {
+            if (!isEnabled.read(reader)) {
+                return;
+            }
+            const sessionDisposables = ( new Map());
+            store.add(toDisposable(() => {
+                sessionDisposables.forEach(d => d.dispose());
+                sessionDisposables.clear();
+            }));
+            store.add(debugService.onDidNewSession((session) => sessionDisposables.set(session, this.handleSession(session))));
+            store.add(debugService.onDidEndSession(({ session }) => {
+                sessionDisposables.get(session)?.dispose();
+                sessionDisposables.delete(session);
+            }));
+            debugService
+                .getModel()
+                .getSessions()
+                .forEach((session) => sessionDisposables.set(session, this.handleSession(session)));
+        }));
+    }
+    handleSession(session) {
+        return session.onDidChangeState(e => {
+            const stoppedDetails = session.getStoppedDetails();
+            const BREAKPOINT_STOP_REASON = 'breakpoint';
+            if (stoppedDetails && stoppedDetails.reason === BREAKPOINT_STOP_REASON) {
+                this.accessibilitySignalService.playSignal(AccessibilitySignal.onDebugBreak);
+            }
+        });
+    }
+};
+AccessibilitySignalLineDebuggerContribution = ( __decorate([
+    ( __param(0, IDebugService)),
+    ( __param(1, IAccessibilitySignalService))
+], AccessibilitySignalLineDebuggerContribution));
+export { AccessibilitySignalLineDebuggerContribution };

package/vscode/src/vs/workbench/contrib/accessibilitySignals/browser/accessibilitySignalLineFeatureContribution.js

@@ -0,0 +1,177 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { CachedFunction } from '../../../../base/common/cache.js';
+import { Event } from '../../../../base/common/event.js';
+import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { isDiffEditor, isCodeEditor } from '../../../../editor/browser/editorBrowser.js';
+import { FoldingController } from '../../../../editor/contrib/folding/browser/folding.js';
+import { AccessibilitySignal, IAccessibilitySignalService } from '../../../../platform/accessibilitySignal/browser/accessibilitySignalService.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { MarkerSeverity, IMarkerService } from '../../../../platform/markers/common/markers.js';
+import { IDebugService } from '../../debug/common/debug.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { observableFromEvent, debouncedObservable, wasEventTriggeredRecently, constObservable, observableFromPromise } from '../../../../base/common/observableInternal/utils.js';
+import { derived, derivedOpts } from '../../../../base/common/observableInternal/derived.js';
+import { autorun, autorunDelta } from '../../../../base/common/observableInternal/autorun.js';
+let SignalLineFeatureContribution = class SignalLineFeatureContribution extends Disposable {
+    constructor(editorService, instantiationService, accessibilitySignalService, _configurationService) {
+        super();
+        this.editorService = editorService;
+        this.instantiationService = instantiationService;
+        this.accessibilitySignalService = accessibilitySignalService;
+        this._configurationService = _configurationService;
+        this.store = this._register(( new DisposableStore()));
+        this.features = [
+            this.instantiationService.createInstance(MarkerLineFeature, AccessibilitySignal.error, MarkerSeverity.Error),
+            this.instantiationService.createInstance(MarkerLineFeature, AccessibilitySignal.warning, MarkerSeverity.Warning),
+            this.instantiationService.createInstance(FoldedAreaLineFeature),
+            this.instantiationService.createInstance(BreakpointLineFeature),
+        ];
+        this.isSoundEnabledCache = ( new CachedFunction(
+            (cue) => observableFromEvent(this.accessibilitySignalService.onSoundEnabledChanged(cue), () => this.accessibilitySignalService.isSoundEnabled(cue))
+        ));
+        this.isAnnouncmentEnabledCahce = ( new CachedFunction(
+            (cue) => observableFromEvent(this.accessibilitySignalService.onAnnouncementEnabledChanged(cue), () => this.accessibilitySignalService.isAnnouncementEnabled(cue))
+        ));
+        const someAccessibilitySignalIsEnabled = derived((reader) => (  this.features.some(
+            (feature) => this.isSoundEnabledCache.get(feature.signal).read(reader) || this.isAnnouncmentEnabledCahce.get(feature.signal).read(reader)
+        )));
+        const activeEditorObservable = observableFromEvent(this.editorService.onDidActiveEditorChange, (_) => {
+            const activeTextEditorControl = this.editorService.activeTextEditorControl;
+            const editor = isDiffEditor(activeTextEditorControl)
+                ? activeTextEditorControl.getOriginalEditor()
+                : isCodeEditor(activeTextEditorControl)
+                    ? activeTextEditorControl
+                    : undefined;
+            return editor && editor.hasModel() ? { editor, model: editor.getModel() } : undefined;
+        });
+        this._register(autorun(reader => {
+            this.store.clear();
+            if (!someAccessibilitySignalIsEnabled.read(reader)) {
+                return;
+            }
+            const activeEditor = activeEditorObservable.read(reader);
+            if (activeEditor) {
+                this.registerAccessibilitySignalsForEditor(activeEditor.editor, activeEditor.model, this.store);
+            }
+        }));
+    }
+    registerAccessibilitySignalsForEditor(editor, editorModel, store) {
+        const curPosition = observableFromEvent(editor.onDidChangeCursorPosition, (args) => {
+            if (args &&
+                args.reason !== 3  &&
+                args.reason !== 0 ) {
+                return undefined;
+            }
+            return editor.getPosition();
+        });
+        const debouncedPosition = debouncedObservable(curPosition, this._configurationService.getValue('accessibility.signals.debouncePositionChanges') ? 300 : 0, store);
+        const isTyping = wasEventTriggeredRecently(editorModel.onDidChangeContent.bind(editorModel), 1000, store);
+        const featureStates = ( this.features.map((feature) => {
+            const lineFeatureState = feature.getObservableState(editor, editorModel);
+            const isFeaturePresent = derivedOpts({ debugName: `isPresentInLine:${feature.signal.name}` }, (reader) => {
+                if (!this.isSoundEnabledCache.get(feature.signal).read(reader) && !this.isAnnouncmentEnabledCahce.get(feature.signal).read(reader)) {
+                    return false;
+                }
+                const position = debouncedPosition.read(reader);
+                if (!position) {
+                    return false;
+                }
+                return lineFeatureState.read(reader).isPresent(position);
+            });
+            return derivedOpts({ debugName: `typingDebouncedFeatureState:\n${feature.signal.name}` }, (reader) => feature.debounceWhileTyping && isTyping.read(reader)
+                ? (debouncedPosition.read(reader), isFeaturePresent.get())
+                : isFeaturePresent.read(reader));
+        }));
+        const state = derived((reader) =>  ({
+            lineNumber: debouncedPosition.read(reader),
+            featureStates: ( new Map(( this.features.map((feature, idx) => [
+                feature,
+                featureStates[idx].read(reader),
+            ])))),
+        }));
+        store.add(autorunDelta(state, ({ lastValue, newValue }) => {
+            const newFeatures = this.features.filter(feature => newValue?.featureStates.get(feature) &&
+                (!lastValue?.featureStates?.get(feature) || newValue.lineNumber !== lastValue.lineNumber));
+            this.accessibilitySignalService.playAccessibilitySignals(( newFeatures.map(f => f.signal)));
+        }));
+    }
+};
+SignalLineFeatureContribution = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IAccessibilitySignalService)),
+    ( __param(3, IConfigurationService))
+], SignalLineFeatureContribution));
+let MarkerLineFeature = class MarkerLineFeature {
+    constructor(signal, severity, markerService) {
+        this.signal = signal;
+        this.severity = severity;
+        this.markerService = markerService;
+        this.debounceWhileTyping = true;
+        this._previousLine = 0;
+    }
+    getObservableState(editor, model) {
+        return observableFromEvent(Event.filter(this.markerService.onMarkerChanged, (changedUris) => ( changedUris.some((u) => ( u.toString()) === ( model.uri.toString())))), () =>  ({
+            isPresent: (position) => {
+                const lineChanged = position.lineNumber !== this._previousLine;
+                this._previousLine = position.lineNumber;
+                const hasMarker = ( this.markerService
+                    .read({ resource: model.uri })
+                    .some((m) => {
+                    const onLine = m.severity === this.severity && m.startLineNumber <= position.lineNumber && position.lineNumber <= m.endLineNumber;
+                    return lineChanged ? onLine : onLine && (position.lineNumber <= m.endLineNumber && m.startColumn <= position.column && m.endColumn >= position.column);
+                }));
+                return hasMarker;
+            },
+        }));
+    }
+};
+MarkerLineFeature = ( __decorate([
+    ( __param(2, IMarkerService))
+], MarkerLineFeature));
+class FoldedAreaLineFeature {
+    constructor() {
+        this.signal = AccessibilitySignal.foldedArea;
+    }
+    getObservableState(editor, model) {
+        const foldingController = FoldingController.get(editor);
+        if (!foldingController) {
+            return constObservable({
+                isPresent: () => false,
+            });
+        }
+        const foldingModel = observableFromPromise(foldingController.getFoldingModel() ?? Promise.resolve(undefined));
+        return ( foldingModel.map((v) => ({
+            isPresent: (position) => {
+                const regionAtLine = v.value?.getRegionAtLine(position.lineNumber);
+                const hasFolding = !regionAtLine
+                    ? false
+                    : regionAtLine.isCollapsed &&
+                        regionAtLine.startLineNumber === position.lineNumber;
+                return hasFolding;
+            },
+        })));
+    }
+}
+let BreakpointLineFeature = class BreakpointLineFeature {
+    constructor(debugService) {
+        this.debugService = debugService;
+        this.signal = AccessibilitySignal.break;
+    }
+    getObservableState(editor, model) {
+        return observableFromEvent(this.debugService.getModel().onDidChangeBreakpoints, () =>  ({
+            isPresent: (position) => {
+                const breakpoints = this.debugService
+                    .getModel()
+                    .getBreakpoints({ uri: model.uri, lineNumber: position.lineNumber });
+                const hasBreakpoints = breakpoints.length > 0;
+                return hasBreakpoints;
+            },
+        }));
+    }
+};
+BreakpointLineFeature = ( __decorate([
+    ( __param(0, IDebugService))
+], BreakpointLineFeature));
+export { SignalLineFeatureContribution };