@codingame/monaco-vscode-api 4.5.1 → 5.0.0

package/vscode/src/vs/platform/accessibilitySignal/browser/accessibilitySignalService.js

@@ -1,62 +1,61 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { CachedFunction } from '../../../base/common/cache.js';
+import { getStructuralKey } from '../../../base/common/equals.js';
 import { Disposable, toDisposable } from '../../../base/common/lifecycle.js';
 import { FileAccess } from '../../../base/common/network.js';
-import { IAccessibilityService } from '../../accessibility/common/accessibility.service.js';
-import { IConfigurationService } from '../../configuration/common/configuration.service.js';
-import { Event } from '../../../base/common/event.js';
-import { localizeWithPath } from '../../../nls.js';
 import { derived } from '../../../base/common/observableInternal/derived.js';
 import '../../../base/common/observableInternal/autorun.js';
-import { observableFromEvent } from '../../../base/common/observableInternal/utils.js';
+import { observableFromEvent, ValueWithChangeEventFromObservable } from '../../../base/common/observableInternal/utils.js';
 import '../../../base/common/cancellation.js';
+import { localizeWithPath } from '../../../nls.js';
+import { IAccessibilityService } from '../../accessibility/common/accessibility.service.js';
+import { IConfigurationService } from '../../configuration/common/configuration.service.js';
 import { ITelemetryService } from '../../telemetry/common/telemetry.service.js';
+const _moduleId = "vs/platform/accessibilitySignal/browser/accessibilitySignalService";
+const AcknowledgeDocCommentsToken = Symbol('AcknowledgeDocCommentsToken');
 let AccessibilitySignalService = class AccessibilitySignalService extends Disposable {
     constructor(configurationService, accessibilityService, telemetryService) {
         super();
         this.configurationService = configurationService;
         this.accessibilityService = accessibilityService;
         this.telemetryService = telemetryService;
-        this.sounds = ( new Map());
+        this.sounds = ( (new Map()));
         this.screenReaderAttached = observableFromEvent(this.accessibilityService.onDidChangeScreenReaderOptimized, () =>  this.accessibilityService.isScreenReaderOptimized());
-        this.sentTelemetry = ( new Set());
-        this.playingSounds = ( new Set());
-        this.obsoleteAccessibilitySignalsEnabled = observableFromEvent(Event.filter(this.configurationService.onDidChangeConfiguration, (e) => e.affectsConfiguration('accessibilitySignals.enabled')), () =>  this.configurationService.getValue('accessibilitySignals.enabled'));
-        this.isSoundEnabledCache = ( new Cache((event) => {
-            const settingObservable = observableFromEvent(Event.filter(this.configurationService.onDidChangeConfiguration, (e) => e.affectsConfiguration(event.signal.legacySoundSettingsKey) || e.affectsConfiguration(event.signal.settingsKey)), () => this.configurationService.getValue(event.signal.settingsKey + '.sound'));
+        this.sentTelemetry = ( (new Set()));
+        this.playingSounds = ( (new Set()));
+        this._signalConfigValue = ( (new CachedFunction(
+            (signal) => observableConfigValue(signal.settingsKey, this.configurationService)
+        )));
+        this._signalEnabledState = ( (new CachedFunction({ getCacheKey: getStructuralKey }, (arg) => {
             return derived(reader => {
-                const setting = settingObservable.read(reader);
-                if (setting === 'on' ||
-                    (setting === 'auto' && this.screenReaderAttached.read(reader))) {
-                    return true;
+                const setting = this._signalConfigValue.get(arg.signal).read(reader);
+                if (arg.modality === 'sound' || arg.modality === undefined) {
+                    if (checkEnabledState(setting.sound, () => this.screenReaderAttached.read(reader), arg.userGesture)) {
+                        return true;
+                    }
                 }
-                else if (setting === 'always' || setting === 'userGesture' && event.userGesture) {
-                    return true;
-                }
-                const obsoleteSetting = this.obsoleteAccessibilitySignalsEnabled.read(reader);
-                if (obsoleteSetting === 'on' ||
-                    (obsoleteSetting === 'auto' && this.screenReaderAttached.read(reader))) {
-                    return true;
+                if (arg.modality === 'announcement' || arg.modality === undefined) {
+                    if (checkEnabledState(setting.announcement, () => this.screenReaderAttached.read(reader), arg.userGesture)) {
+                        return true;
+                    }
                 }
                 return false;
-            });
-        }, JSON.stringify));
-        this.isAnnouncementEnabledCache = ( new Cache((event) => {
-            const settingObservable = observableFromEvent(Event.filter(this.configurationService.onDidChangeConfiguration, (e) => e.affectsConfiguration(event.signal.legacyAnnouncementSettingsKey) || e.affectsConfiguration(event.signal.settingsKey)), () => event.signal.announcementMessage ? this.configurationService.getValue(event.signal.settingsKey + '.announcement') : false);
-            return derived(reader => {
-                const setting = settingObservable.read(reader);
-                if (!this.screenReaderAttached.read(reader)) {
-                    return false;
-                }
-                return setting === 'auto' || setting === 'always' || setting === 'userGesture' && event.userGesture;
-            });
-        }, JSON.stringify));
+            }).recomputeInitiallyAndOnChange(this._store);
+        })));
+    }
+    getEnabledState(signal, userGesture, modality) {
+        return (
+             (new ValueWithChangeEventFromObservable(this._signalEnabledState.get({ signal, userGesture, modality })))
+        );
     }
     async playSignal(signal, options = {}) {
+        const shouldPlayAnnouncement = options.modality === 'announcement' || options.modality === undefined;
         const announcementMessage = signal.announcementMessage;
-        if (this.isAnnouncementEnabled(signal, options.userGesture) && announcementMessage) {
+        if (shouldPlayAnnouncement && this.isAnnouncementEnabled(signal, options.userGesture) && announcementMessage) {
             this.accessibilityService.status(announcementMessage);
         }
-        if (this.isSoundEnabled(signal, options.userGesture)) {
+        const shouldPlaySound = options.modality === 'sound' || options.modality === undefined;
+        if (shouldPlaySound && this.isSoundEnabled(signal, options.userGesture)) {
             this.sendSignalTelemetry(signal, options.source);
             await this.playSound(signal.sound.getSound(), options.allowManyInParallel);
         }
@@ -65,18 +64,20 @@ let AccessibilitySignalService = class AccessibilitySignalService extends Dispos
         for (const signal of signals) {
             this.sendSignalTelemetry('signal' in signal ? signal.signal : signal, 'source' in signal ? signal.source : undefined);
         }
-        const signalArray = ( signals.map(s => 'signal' in s ? s.signal : s));
-        const announcements = ( signalArray.filter(signal => this.isAnnouncementEnabled(signal)).map(s => s.announcementMessage));
+        const signalArray = ( (signals.map(s => 'signal' in s ? s.signal : s)));
+        const announcements = ( (signalArray.filter(signal => this.isAnnouncementEnabled(signal)).map(s => s.announcementMessage)));
         if (announcements.length) {
             this.accessibilityService.status(announcements.join(', '));
         }
-        const sounds = ( new Set(( signalArray.filter(signal => this.isSoundEnabled(signal)).map(signal => signal.sound.getSound()))));
-        await Promise.all(( Array.from(sounds).map(sound => this.playSound(sound, true))));
+        const sounds = ( (new Set(
+             (signalArray.filter(signal => this.isSoundEnabled(signal)).map(signal => signal.sound.getSound()))
+        )));
+        await Promise.all(( (Array.from(sounds).map(sound => this.playSound(sound, true)))));
     }
     sendSignalTelemetry(signal, source) {
         const isScreenReaderOptimized = this.accessibilityService.isScreenReaderOptimized();
         const key = signal.name + (source ? `::${source}` : '') + (isScreenReaderOptimized ? '{screenReaderOptimized}' : '');
-        if (( this.sentTelemetry.has(key)) || this.getVolumeInPercent() === 0) {
+        if (( (this.sentTelemetry.has(key))) || this.getVolumeInPercent() === 0) {
             return;
         }
         this.sentTelemetry.add(key);
@@ -94,11 +95,11 @@ let AccessibilitySignalService = class AccessibilitySignalService extends Dispos
         return Math.max(Math.min(volume, 100), 0);
     }
     async playSound(sound, allowManyInParallel = false) {
-        if (!allowManyInParallel && ( this.playingSounds.has(sound))) {
+        if (!allowManyInParallel && ( (this.playingSounds.has(sound)))) {
             return;
         }
         this.playingSounds.add(sound);
-        const url = ( ( FileAccess.asBrowserUri(`vs/platform/accessibilitySignal/browser/media/${sound.fileName}`)).toString(true));
+        const url = ( (( (FileAccess.asBrowserUri(`vs/platform/accessibilitySignal/browser/media/${sound.fileName}`))).toString(true)));
         try {
             const sound = this.sounds.get(url);
             if (sound) {
@@ -140,57 +141,43 @@ let AccessibilitySignalService = class AccessibilitySignalService extends Dispos
         if (!signal.announcementMessage) {
             return false;
         }
-        return this.isAnnouncementEnabledCache.get({ signal, userGesture }).get() ?? false;
+        return this._signalEnabledState.get({ signal, userGesture: !!userGesture, modality: 'announcement' }).get();
     }
     isSoundEnabled(signal, userGesture) {
-        return this.isSoundEnabledCache.get({ signal, userGesture }).get() ?? false;
+        return this._signalEnabledState.get({ signal, userGesture: !!userGesture, modality: 'sound' }).get();
     }
     onSoundEnabledChanged(signal) {
-        return Event.fromObservableLight(this.isSoundEnabledCache.get({ signal }));
-    }
-    onAnnouncementEnabledChanged(signal) {
-        return Event.fromObservableLight(this.isAnnouncementEnabledCache.get({ signal }));
+        return this.getEnabledState(signal, false).onDidChange;
     }
 };
-AccessibilitySignalService = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, IAccessibilityService)),
-    ( __param(2, ITelemetryService))
-], AccessibilitySignalService));
-function playAudio(url, volume) {
-    return ( new Promise((resolve, reject) => {
-        const audio = ( new Audio(url));
-        audio.volume = volume;
-        audio.addEventListener('ended', () => {
-            resolve(audio);
-        });
-        audio.addEventListener('error', (e) => {
-            reject(e.error);
-        });
-        audio.play().catch(e => {
-            reject(e);
-        });
-    }));
+AccessibilitySignalService = ( (__decorate([
+    ( (__param(0, IConfigurationService))),
+    ( (__param(1, IAccessibilityService))),
+    ( (__param(2, ITelemetryService)))
+], AccessibilitySignalService)));
+function checkEnabledState(state, getScreenReaderAttached, isTriggeredByUserGesture) {
+    return state === 'on' || state === 'always' || (state === 'auto' && getScreenReaderAttached()) || state === 'userGesture' && isTriggeredByUserGesture;
 }
-class Cache {
-    constructor(getValue, getKey) {
-        this.getValue = getValue;
-        this.getKey = getKey;
-        this.map = ( new Map());
-    }
-    get(arg) {
-        if (( this.map.has(arg))) {
-            return this.map.get(arg);
-        }
-        const value = this.getValue(arg);
-        const key = this.getKey(arg);
-        this.map.set(key, value);
-        return value;
-    }
+function playAudio(url, volume) {
+    return (
+         (new Promise((resolve, reject) => {
+            const audio = ( (new Audio(url)));
+            audio.volume = volume;
+            audio.addEventListener('ended', () => {
+                resolve(audio);
+            });
+            audio.addEventListener('error', (e) => {
+                reject(e.error);
+            });
+            audio.play().catch(e => {
+                reject(e);
+            });
+        }))
+    );
 }
 class Sound {
     static register(options) {
-        const sound = ( new Sound(options.fileName));
+        const sound = ( (new Sound(options.fileName)));
         return sound;
     }
     static { this.error = Sound.register({ fileName: 'error.mp3' }); }
@@ -205,7 +192,6 @@ class Sound {
     static { this.diffLineDeleted = Sound.register({ fileName: 'diffLineDeleted.mp3' }); }
     static { this.diffLineModified = Sound.register({ fileName: 'diffLineModified.mp3' }); }
     static { this.chatRequestSent = Sound.register({ fileName: 'chatRequestSent.mp3' }); }
-    static { this.chatResponsePending = Sound.register({ fileName: 'chatResponsePending.mp3' }); }
     static { this.chatResponseReceived1 = Sound.register({ fileName: 'chatResponseReceived1.mp3' }); }
     static { this.chatResponseReceived2 = Sound.register({ fileName: 'chatResponseReceived2.mp3' }); }
     static { this.chatResponseReceived3 = Sound.register({ fileName: 'chatResponseReceived3.mp3' }); }
@@ -215,6 +201,7 @@ class Sound {
     static { this.format = Sound.register({ fileName: 'format.mp3' }); }
     static { this.voiceRecordingStarted = Sound.register({ fileName: 'voiceRecordingStarted.mp3' }); }
     static { this.voiceRecordingStopped = Sound.register({ fileName: 'voiceRecordingStopped.mp3' }); }
+    static { this.progress = Sound.register({ fileName: 'progress.mp3' }); }
     constructor(fileName) {
         this.fileName = fileName;
     }
@@ -234,295 +221,183 @@ class SoundSource {
     }
 }
 class AccessibilitySignal {
-    static { this._signals = ( new Set()); }
+    constructor(sound, name, legacySoundSettingsKey, settingsKey, legacyAnnouncementSettingsKey, announcementMessage) {
+        this.sound = sound;
+        this.name = name;
+        this.legacySoundSettingsKey = legacySoundSettingsKey;
+        this.settingsKey = settingsKey;
+        this.legacyAnnouncementSettingsKey = legacyAnnouncementSettingsKey;
+        this.announcementMessage = announcementMessage;
+    }
+    static { this._signals = ( (new Set())); }
     static register(options) {
-        const soundSource = ( new SoundSource(
+        const soundSource = ( (new SoundSource(
             'randomOneOf' in options.sound ? options.sound.randomOneOf : [options.sound]
-        ));
-        const signal = ( new AccessibilitySignal(
+        )));
+        const signal = ( (new AccessibilitySignal(
             soundSource,
             options.name,
             options.legacySoundSettingsKey,
             options.settingsKey,
             options.legacyAnnouncementSettingsKey,
             options.announcementMessage
-        ));
+        )));
         AccessibilitySignal._signals.add(signal);
         return signal;
     }
     static get allAccessibilitySignals() {
         return [...this._signals];
     }
-    static { this.error = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.lineHasError.name',
-            'Error on Line'
-        )),
+    static { this.errorAtPosition = AccessibilitySignal.register({
+        name: ( localizeWithPath(_moduleId, 0, 'Error at Position')),
+        sound: Sound.error,
+        announcementMessage: ( localizeWithPath(_moduleId, 1, 'Error')),
+        settingsKey: 'accessibility.signals.positionHasError',
+    }); }
+    static { this.warningAtPosition = AccessibilitySignal.register({
+        name: ( localizeWithPath(_moduleId, 2, 'Warning at Position')),
+        sound: Sound.warning,
+        announcementMessage: ( localizeWithPath(_moduleId, 3, 'Warning')),
+        settingsKey: 'accessibility.signals.positionHasWarning',
+    }); }
+    static { this.errorOnLine = AccessibilitySignal.register({
+        name: ( localizeWithPath(_moduleId, 4, 'Error on Line')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.lineHasError',
         legacyAnnouncementSettingsKey: "accessibility.alert.error" ,
-        announcementMessage: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibility.signals.lineHasError',
-            'Error'
-        )),
-        settingsKey: 'accessibility.signals.lineHasError'
+        announcementMessage: ( localizeWithPath(_moduleId, 5, 'Error on Line')),
+        settingsKey: 'accessibility.signals.lineHasError',
     }); }
-    static { this.warning = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.lineHasWarning.name',
-            'Warning on Line'
-        )),
+    static { this.warningOnLine = AccessibilitySignal.register({
+        name: ( localizeWithPath(_moduleId, 6, 'Warning on Line')),
         sound: Sound.warning,
         legacySoundSettingsKey: 'audioCues.lineHasWarning',
         legacyAnnouncementSettingsKey: "accessibility.alert.warning" ,
-        announcementMessage: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibility.signals.lineHasWarning',
-            'Warning'
-        )),
-        settingsKey: 'accessibility.signals.lineHasWarning'
+        announcementMessage: ( localizeWithPath(_moduleId, 7, 'Warning on Line')),
+        settingsKey: 'accessibility.signals.lineHasWarning',
     }); }
     static { this.foldedArea = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.lineHasFoldedArea.name',
-            'Folded Area on Line'
-        )),
+        name: ( localizeWithPath(_moduleId, 8, 'Folded Area on Line')),
         sound: Sound.foldedArea,
         legacySoundSettingsKey: 'audioCues.lineHasFoldedArea',
         legacyAnnouncementSettingsKey: "accessibility.alert.foldedArea" ,
-        announcementMessage: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibility.signals.lineHasFoldedArea',
-            'Folded'
-        )),
-        settingsKey: 'accessibility.signals.lineHasFoldedArea'
+        announcementMessage: ( localizeWithPath(_moduleId, 9, 'Folded')),
+        settingsKey: 'accessibility.signals.lineHasFoldedArea',
     }); }
     static { this.break = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.lineHasBreakpoint.name',
-            'Breakpoint on Line'
-        )),
+        name: ( localizeWithPath(_moduleId, 10, 'Breakpoint on Line')),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.lineHasBreakpoint',
         legacyAnnouncementSettingsKey: "accessibility.alert.breakpoint" ,
-        announcementMessage: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibility.signals.lineHasBreakpoint',
-            'Breakpoint'
-        )),
-        settingsKey: 'accessibility.signals.lineHasBreakpoint'
+        announcementMessage: ( localizeWithPath(_moduleId, 11, 'Breakpoint')),
+        settingsKey: 'accessibility.signals.lineHasBreakpoint',
     }); }
     static { this.inlineSuggestion = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.lineHasInlineSuggestion.name',
-            'Inline Suggestion on Line'
-        )),
+        name: ( localizeWithPath(_moduleId, 12, 'Inline Suggestion on Line')),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.lineHasInlineSuggestion',
-        settingsKey: 'accessibility.signals.lineHasInlineSuggestion'
+        settingsKey: 'accessibility.signals.lineHasInlineSuggestion',
     }); }
     static { this.terminalQuickFix = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.terminalQuickFix.name',
-            'Terminal Quick Fix'
-        )),
+        name: ( localizeWithPath(_moduleId, 13, 'Terminal Quick Fix')),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.terminalQuickFix',
         legacyAnnouncementSettingsKey: "accessibility.alert.terminalQuickFix" ,
-        announcementMessage: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibility.signals.terminalQuickFix',
-            'Quick Fix'
-        )),
-        settingsKey: 'accessibility.signals.terminalQuickFix'
+        announcementMessage: ( localizeWithPath(_moduleId, 14, 'Quick Fix')),
+        settingsKey: 'accessibility.signals.terminalQuickFix',
     }); }
     static { this.onDebugBreak = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.onDebugBreak.name',
-            'Debugger Stopped on Breakpoint'
-        )),
+        name: ( localizeWithPath(_moduleId, 15, 'Debugger Stopped on Breakpoint')),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.onDebugBreak',
         legacyAnnouncementSettingsKey: "accessibility.alert.onDebugBreak" ,
-        announcementMessage: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibility.signals.onDebugBreak',
-            'Breakpoint'
-        )),
-        settingsKey: 'accessibility.signals.onDebugBreak'
+        announcementMessage: ( localizeWithPath(_moduleId, 16, 'Breakpoint')),
+        settingsKey: 'accessibility.signals.onDebugBreak',
     }); }
     static { this.noInlayHints = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.noInlayHints',
-            'No Inlay Hints on Line'
-        )),
+        name: ( localizeWithPath(_moduleId, 17, 'No Inlay Hints on Line')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.noInlayHints',
         legacyAnnouncementSettingsKey: "accessibility.alert.noInlayHints" ,
-        announcementMessage: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibility.signals.noInlayHints',
-            'No Inlay Hints'
-        )),
-        settingsKey: 'accessibility.signals.noInlayHints'
+        announcementMessage: ( localizeWithPath(_moduleId, 18, 'No Inlay Hints')),
+        settingsKey: 'accessibility.signals.noInlayHints',
     }); }
     static { this.taskCompleted = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.taskCompleted',
-            'Task Completed'
-        )),
+        name: ( localizeWithPath(_moduleId, 19, 'Task Completed')),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.taskCompleted',
         legacyAnnouncementSettingsKey: "accessibility.alert.taskCompleted" ,
-        announcementMessage: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibility.signals.taskCompleted',
-            'Task Completed'
-        )),
-        settingsKey: 'accessibility.signals.taskCompleted'
+        announcementMessage: ( localizeWithPath(_moduleId, 20, 'Task Completed')),
+        settingsKey: 'accessibility.signals.taskCompleted',
     }); }
     static { this.taskFailed = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.taskFailed',
-            'Task Failed'
-        )),
+        name: ( localizeWithPath(_moduleId, 21, 'Task Failed')),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.taskFailed',
         legacyAnnouncementSettingsKey: "accessibility.alert.taskFailed" ,
-        announcementMessage: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibility.signals.taskFailed',
-            'Task Failed'
-        )),
-        settingsKey: 'accessibility.signals.taskFailed'
+        announcementMessage: ( localizeWithPath(_moduleId, 22, 'Task Failed')),
+        settingsKey: 'accessibility.signals.taskFailed',
     }); }
     static { this.terminalCommandFailed = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.terminalCommandFailed',
-            'Terminal Command Failed'
-        )),
+        name: ( localizeWithPath(_moduleId, 23, 'Terminal Command Failed')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.terminalCommandFailed',
         legacyAnnouncementSettingsKey: "accessibility.alert.terminalCommandFailed" ,
-        announcementMessage: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibility.signals.terminalCommandFailed',
-            'Command Failed'
-        )),
-        settingsKey: 'accessibility.signals.terminalCommandFailed'
+        announcementMessage: ( localizeWithPath(_moduleId, 24, 'Command Failed')),
+        settingsKey: 'accessibility.signals.terminalCommandFailed',
     }); }
     static { this.terminalBell = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.terminalBell',
-            'Terminal Bell'
-        )),
+        name: ( localizeWithPath(_moduleId, 25, 'Terminal Bell')),
         sound: Sound.terminalBell,
         legacySoundSettingsKey: 'audioCues.terminalBell',
         legacyAnnouncementSettingsKey: "accessibility.alert.terminalBell" ,
-        announcementMessage: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibility.signals.terminalBell',
-            'Terminal Bell'
-        )),
-        settingsKey: 'accessibility.signals.terminalBell'
+        announcementMessage: ( localizeWithPath(_moduleId, 26, 'Terminal Bell')),
+        settingsKey: 'accessibility.signals.terminalBell',
     }); }
     static { this.notebookCellCompleted = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.notebookCellCompleted',
-            'Notebook Cell Completed'
-        )),
+        name: ( localizeWithPath(_moduleId, 27, 'Notebook Cell Completed')),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.notebookCellCompleted',
         legacyAnnouncementSettingsKey: "accessibility.alert.notebookCellCompleted" ,
-        announcementMessage: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibility.signals.notebookCellCompleted',
-            'Notebook Cell Completed'
-        )),
-        settingsKey: 'accessibility.signals.notebookCellCompleted'
+        announcementMessage: ( localizeWithPath(_moduleId, 28, 'Notebook Cell Completed')),
+        settingsKey: 'accessibility.signals.notebookCellCompleted',
     }); }
     static { this.notebookCellFailed = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.notebookCellFailed',
-            'Notebook Cell Failed'
-        )),
+        name: ( localizeWithPath(_moduleId, 29, 'Notebook Cell Failed')),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.notebookCellFailed',
         legacyAnnouncementSettingsKey: "accessibility.alert.notebookCellFailed" ,
-        announcementMessage: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibility.signals.notebookCellFailed',
-            'Notebook Cell Failed'
-        )),
-        settingsKey: 'accessibility.signals.notebookCellFailed'
+        announcementMessage: ( localizeWithPath(_moduleId, 30, 'Notebook Cell Failed')),
+        settingsKey: 'accessibility.signals.notebookCellFailed',
     }); }
     static { this.diffLineInserted = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.diffLineInserted',
-            'Diff Line Inserted'
-        )),
+        name: ( localizeWithPath(_moduleId, 31, 'Diff Line Inserted')),
         sound: Sound.diffLineInserted,
         legacySoundSettingsKey: 'audioCues.diffLineInserted',
-        settingsKey: 'accessibility.signals.diffLineInserted'
+        settingsKey: 'accessibility.signals.diffLineInserted',
     }); }
     static { this.diffLineDeleted = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.diffLineDeleted',
-            'Diff Line Deleted'
-        )),
+        name: ( localizeWithPath(_moduleId, 32, 'Diff Line Deleted')),
         sound: Sound.diffLineDeleted,
         legacySoundSettingsKey: 'audioCues.diffLineDeleted',
-        settingsKey: 'accessibility.signals.diffLineDeleted'
+        settingsKey: 'accessibility.signals.diffLineDeleted',
     }); }
     static { this.diffLineModified = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.diffLineModified',
-            'Diff Line Modified'
-        )),
+        name: ( localizeWithPath(_moduleId, 33, 'Diff Line Modified')),
         sound: Sound.diffLineModified,
         legacySoundSettingsKey: 'audioCues.diffLineModified',
-        settingsKey: 'accessibility.signals.diffLineModified'
+        settingsKey: 'accessibility.signals.diffLineModified',
     }); }
     static { this.chatRequestSent = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.chatRequestSent',
-            'Chat Request Sent'
-        )),
+        name: ( localizeWithPath(_moduleId, 34, 'Chat Request Sent')),
         sound: Sound.chatRequestSent,
         legacySoundSettingsKey: 'audioCues.chatRequestSent',
         legacyAnnouncementSettingsKey: "accessibility.alert.chatRequestSent" ,
-        announcementMessage: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibility.signals.chatRequestSent',
-            'Chat Request Sent'
-        )),
-        settingsKey: 'accessibility.signals.chatRequestSent'
+        announcementMessage: ( localizeWithPath(_moduleId, 35, 'Chat Request Sent')),
+        settingsKey: 'accessibility.signals.chatRequestSent',
     }); }
     static { this.chatResponseReceived = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.chatResponseReceived',
-            'Chat Response Received'
-        )),
+        name: ( localizeWithPath(_moduleId, 36, 'Chat Response Received')),
         legacySoundSettingsKey: 'audioCues.chatResponseReceived',
         sound: {
             randomOneOf: [
@@ -534,97 +409,56 @@ class AccessibilitySignal {
         },
         settingsKey: 'accessibility.signals.chatResponseReceived'
     }); }
-    static { this.chatResponsePending = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.chatResponsePending',
-            'Chat Response Pending'
-        )),
-        sound: Sound.chatResponsePending,
+    static { this.progress = AccessibilitySignal.register({
+        name: ( localizeWithPath(_moduleId, 37, 'Progress')),
+        sound: Sound.progress,
         legacySoundSettingsKey: 'audioCues.chatResponsePending',
-        legacyAnnouncementSettingsKey: "accessibility.alert.chatResponsePending" ,
-        announcementMessage: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibility.signals.chatResponsePending',
-            'Chat Response Pending'
-        )),
-        settingsKey: 'accessibility.signals.chatResponsePending'
+        legacyAnnouncementSettingsKey: "accessibility.alert.chatResponseProgress" ,
+        announcementMessage: ( localizeWithPath(_moduleId, 38, 'Progress')),
+        settingsKey: 'accessibility.signals.progress'
     }); }
     static { this.clear = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.clear',
-            'Clear'
-        )),
+        name: ( localizeWithPath(_moduleId, 39, 'Clear')),
         sound: Sound.clear,
         legacySoundSettingsKey: 'audioCues.clear',
         legacyAnnouncementSettingsKey: "accessibility.alert.clear" ,
-        announcementMessage: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibility.signals.clear',
-            'Clear'
-        )),
+        announcementMessage: ( localizeWithPath(_moduleId, 40, 'Clear')),
         settingsKey: 'accessibility.signals.clear'
     }); }
     static { this.save = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.save',
-            'Save'
-        )),
+        name: ( localizeWithPath(_moduleId, 41, 'Save')),
         sound: Sound.save,
         legacySoundSettingsKey: 'audioCues.save',
         legacyAnnouncementSettingsKey: "accessibility.alert.save" ,
-        announcementMessage: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibility.signals.save',
-            'Save'
-        )),
+        announcementMessage: ( localizeWithPath(_moduleId, 42, 'Save')),
         settingsKey: 'accessibility.signals.save'
     }); }
     static { this.format = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.format',
-            'Format'
-        )),
+        name: ( localizeWithPath(_moduleId, 43, 'Format')),
         sound: Sound.format,
         legacySoundSettingsKey: 'audioCues.format',
         legacyAnnouncementSettingsKey: "accessibility.alert.format" ,
-        announcementMessage: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibility.signals.format',
-            'Format'
-        )),
+        announcementMessage: ( localizeWithPath(_moduleId, 44, 'Format')),
         settingsKey: 'accessibility.signals.format'
     }); }
     static { this.voiceRecordingStarted = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.voiceRecordingStarted',
-            'Voice Recording Started'
-        )),
+        name: ( localizeWithPath(_moduleId, 45, 'Voice Recording Started')),
         sound: Sound.voiceRecordingStarted,
         legacySoundSettingsKey: 'audioCues.voiceRecordingStarted',
         settingsKey: 'accessibility.signals.voiceRecordingStarted'
     }); }
     static { this.voiceRecordingStopped = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.voiceRecordingStopped',
-            'Voice Recording Stopped'
-        )),
+        name: ( localizeWithPath(_moduleId, 46, 'Voice Recording Stopped')),
         sound: Sound.voiceRecordingStopped,
         legacySoundSettingsKey: 'audioCues.voiceRecordingStopped',
         settingsKey: 'accessibility.signals.voiceRecordingStopped'
     }); }
-    constructor(sound, name, legacySoundSettingsKey, settingsKey, legacyAnnouncementSettingsKey, announcementMessage) {
-        this.sound = sound;
-        this.name = name;
-        this.legacySoundSettingsKey = legacySoundSettingsKey;
-        this.settingsKey = settingsKey;
-        this.legacyAnnouncementSettingsKey = legacyAnnouncementSettingsKey;
-        this.announcementMessage = announcementMessage;
-    }
 }
-export { AccessibilitySignal, AccessibilitySignalService, Sound, SoundSource };
+function observableConfigValue(key, configurationService) {
+    return observableFromEvent((handleChange) => configurationService.onDidChangeConfiguration(e => {
+        if (e.affectsConfiguration(key)) {
+            handleChange(e);
+        }
+    }), () => configurationService.getValue(key));
+}
+export { AccessibilitySignal, AccessibilitySignalService, AcknowledgeDocCommentsToken, Sound, SoundSource, observableConfigValue };