@codingame/monaco-vscode-api 4.5.1 → 4.5.2

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

@@ -10,18 +10,19 @@ import '../../../base/common/observableInternal/autorun.js';
 import { observableFromEvent } from '../../../base/common/observableInternal/utils.js';
 import '../../../base/common/cancellation.js';
 import { ITelemetryService } from '../../telemetry/common/telemetry.service.js';
+const _moduleId = "vs/platform/accessibilitySignal/browser/accessibilitySignalService";
 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.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) => {
+        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'));
             return derived(reader => {
                 const setting = settingObservable.read(reader);
@@ -39,8 +40,8 @@ let AccessibilitySignalService = class AccessibilitySignalService extends Dispos
                 }
                 return false;
             });
-        }, JSON.stringify));
-        this.isAnnouncementEnabledCache = ( new Cache((event) => {
+        }, 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);
@@ -49,7 +50,7 @@ let AccessibilitySignalService = class AccessibilitySignalService extends Dispos
                 }
                 return setting === 'auto' || setting === 'always' || setting === 'userGesture' && event.userGesture;
             });
-        }, JSON.stringify));
+        }, JSON.stringify)));
     }
     async playSignal(signal, options = {}) {
         const announcementMessage = signal.announcementMessage;
@@ -65,18 +66,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 +97,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) {
@@ -152,34 +155,36 @@ let AccessibilitySignalService = class AccessibilitySignalService extends Dispos
         return Event.fromObservableLight(this.isAnnouncementEnabledCache.get({ signal }));
     }
 };
-AccessibilitySignalService = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, IAccessibilityService)),
-    ( __param(2, ITelemetryService))
-], AccessibilitySignalService));
+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);
-        });
-    }));
+    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 Cache {
     constructor(getValue, getKey) {
         this.getValue = getValue;
         this.getKey = getKey;
-        this.map = ( new Map());
+        this.map = ( (new Map()));
     }
     get(arg) {
-        if (( this.map.has(arg))) {
+        if (( (this.map.has(arg)))) {
             return this.map.get(arg);
         }
         const value = this.getValue(arg);
@@ -190,7 +195,7 @@ class Cache {
 }
 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' }); }
@@ -234,19 +239,19 @@ class SoundSource {
     }
 }
 class AccessibilitySignal {
-    static { this._signals = ( new Set()); }
+    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;
     }
@@ -254,275 +259,143 @@ class AccessibilitySignal {
         return [...this._signals];
     }
     static { this.error = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.lineHasError.name',
-            'Error on Line'
-        )),
+        name: ( localizeWithPath(_moduleId, 0, 'Error on Line')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.lineHasError',
         legacyAnnouncementSettingsKey: "accessibility.alert.error" ,
-        announcementMessage: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibility.signals.lineHasError',
-            'Error'
-        )),
+        announcementMessage: ( localizeWithPath(_moduleId, 1, 'Error')),
         settingsKey: 'accessibility.signals.lineHasError'
     }); }
     static { this.warning = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.lineHasWarning.name',
-            'Warning on Line'
-        )),
+        name: ( localizeWithPath(_moduleId, 2, 'Warning on Line')),
         sound: Sound.warning,
         legacySoundSettingsKey: 'audioCues.lineHasWarning',
         legacyAnnouncementSettingsKey: "accessibility.alert.warning" ,
-        announcementMessage: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibility.signals.lineHasWarning',
-            'Warning'
-        )),
+        announcementMessage: ( localizeWithPath(_moduleId, 3, 'Warning')),
         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, 4, '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'
-        )),
+        announcementMessage: ( localizeWithPath(_moduleId, 5, '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, 6, 'Breakpoint on Line')),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.lineHasBreakpoint',
         legacyAnnouncementSettingsKey: "accessibility.alert.breakpoint" ,
-        announcementMessage: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibility.signals.lineHasBreakpoint',
-            'Breakpoint'
-        )),
+        announcementMessage: ( localizeWithPath(_moduleId, 7, '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, 8, 'Inline Suggestion on Line')),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.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, 9, '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'
-        )),
+        announcementMessage: ( localizeWithPath(_moduleId, 10, '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, 11, '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'
-        )),
+        announcementMessage: ( localizeWithPath(_moduleId, 12, '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, 13, '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'
-        )),
+        announcementMessage: ( localizeWithPath(_moduleId, 14, '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, 15, 'Task Completed')),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.taskCompleted',
         legacyAnnouncementSettingsKey: "accessibility.alert.taskCompleted" ,
-        announcementMessage: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibility.signals.taskCompleted',
-            'Task Completed'
-        )),
+        announcementMessage: ( localizeWithPath(_moduleId, 16, '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, 17, 'Task Failed')),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.taskFailed',
         legacyAnnouncementSettingsKey: "accessibility.alert.taskFailed" ,
-        announcementMessage: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibility.signals.taskFailed',
-            'Task Failed'
-        )),
+        announcementMessage: ( localizeWithPath(_moduleId, 18, '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, 19, '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'
-        )),
+        announcementMessage: ( localizeWithPath(_moduleId, 20, '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, 21, 'Terminal Bell')),
         sound: Sound.terminalBell,
         legacySoundSettingsKey: 'audioCues.terminalBell',
         legacyAnnouncementSettingsKey: "accessibility.alert.terminalBell" ,
-        announcementMessage: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibility.signals.terminalBell',
-            'Terminal Bell'
-        )),
+        announcementMessage: ( localizeWithPath(_moduleId, 22, '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, 23, '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'
-        )),
+        announcementMessage: ( localizeWithPath(_moduleId, 24, '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, 25, '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'
-        )),
+        announcementMessage: ( localizeWithPath(_moduleId, 26, '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, 27, 'Diff Line Inserted')),
         sound: Sound.diffLineInserted,
         legacySoundSettingsKey: 'audioCues.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, 28, 'Diff Line Deleted')),
         sound: Sound.diffLineDeleted,
         legacySoundSettingsKey: 'audioCues.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, 29, 'Diff Line Modified')),
         sound: Sound.diffLineModified,
         legacySoundSettingsKey: 'audioCues.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, 30, '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'
-        )),
+        announcementMessage: ( localizeWithPath(_moduleId, 31, '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, 32, 'Chat Response Received')),
         legacySoundSettingsKey: 'audioCues.chatResponseReceived',
         sound: {
             randomOneOf: [
@@ -535,85 +408,45 @@ class AccessibilitySignal {
         settingsKey: 'accessibility.signals.chatResponseReceived'
     }); }
     static { this.chatResponsePending = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.chatResponsePending',
-            'Chat Response Pending'
-        )),
+        name: ( localizeWithPath(_moduleId, 33, 'Chat Response Pending')),
         sound: Sound.chatResponsePending,
         legacySoundSettingsKey: 'audioCues.chatResponsePending',
         legacyAnnouncementSettingsKey: "accessibility.alert.chatResponsePending" ,
-        announcementMessage: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibility.signals.chatResponsePending',
-            'Chat Response Pending'
-        )),
+        announcementMessage: ( localizeWithPath(_moduleId, 34, 'Chat Response Pending')),
         settingsKey: 'accessibility.signals.chatResponsePending'
     }); }
     static { this.clear = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.clear',
-            'Clear'
-        )),
+        name: ( localizeWithPath(_moduleId, 35, '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, 36, 'Clear')),
         settingsKey: 'accessibility.signals.clear'
     }); }
     static { this.save = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.save',
-            'Save'
-        )),
+        name: ( localizeWithPath(_moduleId, 37, '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, 38, 'Save')),
         settingsKey: 'accessibility.signals.save'
     }); }
     static { this.format = AccessibilitySignal.register({
-        name: ( localizeWithPath(
-            'vs/platform/accessibilitySignal/browser/accessibilitySignalService',
-            'accessibilitySignals.format',
-            'Format'
-        )),
+        name: ( localizeWithPath(_moduleId, 39, '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, 40, '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, 41, '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, 42, 'Voice Recording Stopped')),
         sound: Sound.voiceRecordingStopped,
         legacySoundSettingsKey: 'audioCues.voiceRecordingStopped',
         settingsKey: 'accessibility.signals.voiceRecordingStopped'

package/vscode/src/vs/platform/action/common/actionCommonCategories.js

@@ -1,18 +1,11 @@
 import { localize2WithPath } from '../../../nls.js';
-const Categories = ( Object.freeze({
-    View: ( localize2WithPath('vs/platform/action/common/actionCommonCategories', 'view', 'View')),
-    Help: ( localize2WithPath('vs/platform/action/common/actionCommonCategories', 'help', 'Help')),
-    Test: ( localize2WithPath('vs/platform/action/common/actionCommonCategories', 'test', 'Test')),
-    File: ( localize2WithPath('vs/platform/action/common/actionCommonCategories', 'file', 'File')),
-    Preferences: ( localize2WithPath(
-     'vs/platform/action/common/actionCommonCategories',
-     'preferences',
-     'Preferences'
-    )),
-    Developer: ( localize2WithPath(
-     'vs/platform/action/common/actionCommonCategories',
-     { key: 'developer', comment: ['A developer on Code itself or someone diagnosing issues in Code'] },
-     "Developer"
-    )),
-}));
+const _moduleId = "vs/platform/action/common/actionCommonCategories";
+const Categories = ( (Object.freeze({
+    View: ( localize2WithPath(_moduleId, 0, 'View')),
+    Help: ( localize2WithPath(_moduleId, 1, 'Help')),
+    Test: ( localize2WithPath(_moduleId, 2, 'Test')),
+    File: ( localize2WithPath(_moduleId, 3, 'File')),
+    Preferences: ( localize2WithPath(_moduleId, 4, 'Preferences')),
+    Developer: ( localize2WithPath(_moduleId, 5, "Developer")),
+})));
 export { Categories };