@codingame/monaco-vscode-api 23.3.0 → 24.1.0

package/vscode/src/vs/editor/standalone/browser/iPadShowKeyboard/iPadShowKeyboard.js

@@ -1,5 +1,5 @@
 
-import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { registerCss } from '../../../../../../../css.js';
 import * as iPadShowKeyboard from './iPadShowKeyboard.css';
 import { createElement, addDisposableListener } from '../../../../base/browser/dom.js';
 import { Disposable } from '../../../../base/common/lifecycle.js';

package/vscode/src/vs/editor/standalone/browser/quickInput/standaloneQuickInputService.js

@@ -1,5 +1,5 @@
 
-import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { registerCss } from '../../../../../../../css.js';
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import * as standaloneQuickInput from './standaloneQuickInput.css';
 import { Event } from '../../../../base/common/event.js';

package/vscode/src/vs/editor/standalone/browser/services/standaloneWebWorkerService.d.ts

@@ -0,0 +1,7 @@
+import { WebWorkerDescriptor } from "../../../../platform/webWorker/browser/webWorkerDescriptor.js";
+import { WebWorkerService } from "../../../../platform/webWorker/browser/webWorkerServiceImpl.js";
+export declare class StandaloneWebWorkerService extends WebWorkerService {
+    protected _createWorker(descriptor: WebWorkerDescriptor): Promise<Worker>;
+    getWorkerUrl(descriptor: WebWorkerDescriptor): string;
+    getWorkerOptions(descriptor: WebWorkerDescriptor): WorkerOptions | undefined;
+}

package/vscode/src/vs/editor/standalone/browser/services/standaloneWebWorkerService.js

@@ -0,0 +1,44 @@
+
+import { getMonacoEnvironment } from '../../../../base/browser/browser.js';
+import { WebWorkerService } from '../../../../platform/webWorker/browser/webWorkerServiceImpl.js';
+
+class StandaloneWebWorkerService extends WebWorkerService {
+    _createWorker(descriptor) {
+        const monacoEnvironment = getMonacoEnvironment();
+        if (monacoEnvironment) {
+            if (typeof monacoEnvironment.getWorker === 'function') {
+                const worker = monacoEnvironment.getWorker('workerMain.js', descriptor.label);
+                if (worker !== undefined) {
+                    return Promise.resolve(worker);
+                }
+            }
+        }
+        return super._createWorker(descriptor);
+    }
+    getWorkerUrl(descriptor) {
+        const monacoEnvironment = getMonacoEnvironment();
+        if (monacoEnvironment) {
+            if (typeof monacoEnvironment.getWorkerUrl === 'function') {
+                const workerUrl = monacoEnvironment.getWorkerUrl('workerMain.js', descriptor.label);
+                if (workerUrl !== undefined) {
+                    const absoluteUrl = ( ( new URL(workerUrl, document.baseURI)).toString());
+                    return absoluteUrl;
+                }
+            }
+        }
+        if (!descriptor.esmModuleLocationBundler) {
+            throw ( new Error(
+                `You must define a function MonacoEnvironment.getWorkerUrl or MonacoEnvironment.getWorker for the worker label: ${descriptor.label}`
+            ));
+        }
+        const url = typeof descriptor.esmModuleLocationBundler === 'function' ? descriptor.esmModuleLocationBundler() : descriptor.esmModuleLocationBundler;
+        const urlStr = ( url.toString());
+        return urlStr;
+    }
+    getWorkerOptions(descriptor) {
+        const monacoEnvironment = getMonacoEnvironment();
+        return monacoEnvironment?.getWorkerOptions?.('workerMain.js', descriptor.label);
+    }
+}
+
+export { StandaloneWebWorkerService };

package/vscode/src/vs/editor/standalone/browser/standaloneServices.js

@@ -16,7 +16,7 @@ import { OS, isLinux, isMacintosh } from '../../../base/common/platform.js';
 import { format } from '../../../base/common/strings.js';
 import '../../../base/common/errors.js';
 import { ResourceMap } from '../../../base/common/map.js';
-import { ILanguageFeaturesService } from '../../common/services/languageFeatures.service.js';
+import { IInstantiationService, createDecorator } from '../../../platform/instantiation/common/instantiation.js';
 import { registerSingleton, InstantiationType, getSingletonServiceDescriptors } from '../../../platform/instantiation/common/extensions.js';
 import '../../../platform/hover/browser/hoverService.js';
 import '../../browser/services/inlineCompletionsService.js';
@@ -41,7 +41,6 @@ import { IConfigurationService } from '../../../platform/configuration/common/co
 import { Configuration as Configuration$1, ConfigurationModel, ConfigurationChangeEvent } from '../../../platform/configuration/common/configurationModels.js';
 import { IContextKeyService } from '../../../platform/contextkey/common/contextkey.service.js';
 import { IDialogService } from '../../../platform/dialogs/common/dialogs.service.js';
-import { IInstantiationService, createDecorator } from '../../../platform/instantiation/common/instantiation.js';
 import { AbstractKeybindingService } from '../../../platform/keybinding/common/abstractKeybindingService.js';
 import { IKeybindingService } from '../../../platform/keybinding/common/keybinding.service.js';
 import { KeybindingResolver } from '../../../platform/keybinding/common/keybindingResolver.js';
@@ -68,8 +67,6 @@ import { ContextViewService } from '../../../platform/contextview/browser/contex
 import { LanguageService } from '../../common/services/languageService.js';
 import { ContextMenuService } from '../../../platform/contextview/browser/contextMenuService.js';
 import { OpenerService } from '../../browser/services/openerService.js';
-import { IEditorWorkerService } from '../../common/services/editorWorker.service.js';
-import { EditorWorkerService } from '../../browser/services/editorWorkerService.js';
 import { ILanguageService } from '../../common/languages/language.service.js';
 import { MarkerDecorationsService } from '../../common/services/markerDecorationsService.js';
 import { IMarkerDecorationsService } from '../../common/services/markerDecorations.service.js';
@@ -97,7 +94,6 @@ import { InMemoryStorageService } from '../../../platform/storage/common/storage
 import { IStorageService } from '../../../platform/storage/common/storage.service.js';
 import { DefaultConfiguration as DefaultConfiguration$1 } from '../../../platform/configuration/common/configurations.js';
 import { IAccessibilitySignalService } from '../../../platform/accessibilitySignal/browser/accessibilitySignalService.service.js';
-import { ILanguageConfigurationService } from '../../common/languages/languageConfigurationRegistry.service.js';
 import { LogService } from '../../../platform/log/common/logService.js';
 import { IEnvironmentService } from '../../../platform/environment/common/environment.service.js';
 import { mainWindow } from '../../../base/browser/window.js';
@@ -105,6 +101,9 @@ import { ITreeSitterLibraryService } from '../../common/services/treeSitter/tree
 import { StandaloneTreeSitterLibraryService } from './standaloneTreeSitterLibraryService.js';
 import { NullDataChannelService } from '../../../platform/dataChannel/common/dataChannel.js';
 import { IDataChannelService } from '../../../platform/dataChannel/common/dataChannel.service.js';
+import { IWebWorkerService } from '../../../platform/webWorker/browser/webWorkerService.service.js';
+import { StandaloneWebWorkerService } from './services/standaloneWebWorkerService.js';
+import { IDefaultAccountService } from '../../../platform/defaultAccount/common/defaultAccount.service.js';
 
 class SimpleModel {
     constructor(model) {
@@ -879,22 +878,6 @@ StandaloneContextMenuService = ( __decorate([
     ( __param(4, IMenuService)),
     ( __param(5, IContextKeyService))
 ], StandaloneContextMenuService));
-const standaloneEditorWorkerDescriptor = {
-    esmModuleLocation: undefined,
-    label: 'editorWorkerService'
-};
-let StandaloneEditorWorkerService = class StandaloneEditorWorkerService extends EditorWorkerService {
-    constructor(modelService, configurationService, logService, languageConfigurationService, languageFeaturesService) {
-        super(standaloneEditorWorkerDescriptor, modelService, configurationService, logService, languageConfigurationService, languageFeaturesService);
-    }
-};
-StandaloneEditorWorkerService = ( __decorate([
-    ( __param(0, IModelService)),
-    ( __param(1, ITextResourceConfigurationService)),
-    ( __param(2, ILogService)),
-    ( __param(3, ILanguageConfigurationService)),
-    ( __param(4, ILanguageFeaturesService))
-], StandaloneEditorWorkerService));
 class StandaloneAccessbilitySignalService {
     async playSignal(cue, options) {
     }
@@ -921,6 +904,17 @@ class StandaloneAccessbilitySignalService {
         return toDisposable(() => { });
     }
 }
+class StandaloneDefaultAccountService {
+    constructor() {
+        this.onDidChangeDefaultAccount = Event.None;
+    }
+    async getDefaultAccount() {
+        return null;
+    }
+    setDefaultAccount(account) {
+    }
+}
+registerSingleton(IWebWorkerService, StandaloneWebWorkerService, InstantiationType.Eager);
 registerSingleton(ILogService, StandaloneLogService, InstantiationType.Eager);
 registerSingleton(IConfigurationService, StandaloneConfigurationService, InstantiationType.Eager);
 registerSingleton(ITextResourceConfigurationService, StandaloneResourceConfigurationService, InstantiationType.Eager);
@@ -940,7 +934,6 @@ registerSingleton(IContextKeyService, ContextKeyService, InstantiationType.Eager
 registerSingleton(IProgressService, StandaloneProgressService, InstantiationType.Eager);
 registerSingleton(IEditorProgressService, StandaloneEditorProgressService, InstantiationType.Eager);
 registerSingleton(IStorageService, InMemoryStorageService, InstantiationType.Eager);
-registerSingleton(IEditorWorkerService, StandaloneEditorWorkerService, InstantiationType.Eager);
 registerSingleton(IBulkEditService, StandaloneBulkEditService, InstantiationType.Eager);
 registerSingleton(IWorkspaceTrustManagementService, StandaloneWorkspaceTrustManagementService, InstantiationType.Eager);
 registerSingleton(ITextModelService, StandaloneTextModelService, InstantiationType.Eager);
@@ -958,6 +951,7 @@ registerSingleton(IAccessibilitySignalService, StandaloneAccessbilitySignalServi
 registerSingleton(ITreeSitterLibraryService, StandaloneTreeSitterLibraryService, InstantiationType.Eager);
 registerSingleton(ILoggerService, NullLoggerService, InstantiationType.Eager);
 registerSingleton(IDataChannelService, NullDataChannelService, InstantiationType.Eager);
+registerSingleton(IDefaultAccountService, StandaloneDefaultAccountService, InstantiationType.Eager);
 var StandaloneServices;
 (function (StandaloneServices) {
     const serviceCollection = ( new ServiceCollection());

package/vscode/src/vs/platform/accessibility/browser/accessibleView.d.ts

@@ -1,5 +1,5 @@
 import { IKeyboardEvent } from "../../keybinding/common/keybinding.js";
-import { IPickerQuickAccessItem } from "@codingame/monaco-vscode-3b5a5cd1-d4ff-500a-b609-57e0cd4afa0a-common/vscode/vs/platform/quickinput/browser/pickerQuickAccess";
+import { IPickerQuickAccessItem } from "../../quickinput/browser/pickerQuickAccess.js";
 import { Event } from "../../../base/common/event.js";
 import { IAction } from "../../../base/common/actions.js";
 import { IQuickPickItem } from "../../quickinput/common/quickInput.js";
@@ -11,6 +11,7 @@ export declare enum AccessibleViewProviderId {
     DiffEditor = "diffEditor",
     MergeEditor = "mergeEditor",
     PanelChat = "panelChat",
+    ChatTerminalOutput = "chatTerminalOutput",
     InlineChat = "inlineChat",
     AgentChat = "agentChat",
     QuickChat = "quickChat",
@@ -119,7 +120,7 @@ export declare class AccessibleContentProvider extends Disposable implements IAc
     onDidRequestClearLastProvider?: Event<AccessibleViewProviderId> | undefined;
     constructor(id: AccessibleViewProviderId, options: IAccessibleViewOptions, provideContent: () => string, onClose: () => void, verbositySettingKey: string, onOpen?: (() => void) | undefined, actions?: IAction[] | undefined, provideNextContent?: (() => string | undefined) | undefined, providePreviousContent?: (() => string | undefined) | undefined, onDidChangeContent?: Event<void> | undefined, onKeyDown?: ((e: IKeyboardEvent) => void) | undefined, getSymbols?: (() => IAccessibleViewSymbol[]) | undefined, onDidRequestClearLastProvider?: Event<AccessibleViewProviderId> | undefined);
 }
-export declare function isIAccessibleViewContentProvider(obj: any): obj is IAccessibleViewContentProvider;
+export declare function isIAccessibleViewContentProvider(obj: unknown): obj is IAccessibleViewContentProvider;
 export declare class ExtensionContentProvider extends Disposable implements IBasicContentProvider {
     readonly id: string;
     options: IAccessibleViewOptions;

package/vscode/src/vs/platform/accessibility/browser/accessibleView.js

@@ -9,6 +9,7 @@ var AccessibleViewProviderId;
     AccessibleViewProviderId["DiffEditor"] = "diffEditor";
     AccessibleViewProviderId["MergeEditor"] = "mergeEditor";
     AccessibleViewProviderId["PanelChat"] = "panelChat";
+    AccessibleViewProviderId["ChatTerminalOutput"] = "chatTerminalOutput";
     AccessibleViewProviderId["InlineChat"] = "inlineChat";
     AccessibleViewProviderId["AgentChat"] = "agentChat";
     AccessibleViewProviderId["QuickChat"] = "quickChat";
@@ -57,7 +58,15 @@ class AccessibleContentProvider extends Disposable {
     }
 }
 function isIAccessibleViewContentProvider(obj) {
-    return obj && obj.id && obj.options && obj.provideContent && obj.onClose && obj.verbositySettingKey;
+    if (!obj || typeof obj !== 'object') {
+        return false;
+    }
+    const candidate = obj;
+    return !!candidate.id
+        && !!candidate.options
+        && typeof candidate.provideContent === 'function'
+        && typeof candidate.onClose === 'function'
+        && typeof candidate.verbositySettingKey === 'string';
 }
 class ExtensionContentProvider extends Disposable {
     constructor(id, options, provideContent, onClose, onOpen, provideNextContent, providePreviousContent, actions, onDidChangeContent) {

package/vscode/src/vs/platform/accessibility/common/accessibility.d.ts

@@ -12,5 +12,5 @@ export interface IAccessibilityInformation {
     label: string;
     role?: string;
 }
-export declare function isAccessibilityInformation(obj: any): obj is IAccessibilityInformation;
+export declare function isAccessibilityInformation(obj: unknown): obj is IAccessibilityInformation;
 export declare const ACCESSIBLE_VIEW_SHOWN_STORAGE_PREFIX = "ACCESSIBLE_VIEW_SHOWN_";

package/vscode/src/vs/platform/accessibility/common/accessibility.js

@@ -9,9 +9,12 @@ var AccessibilitySupport;
 })(AccessibilitySupport || (AccessibilitySupport = {}));
 const CONTEXT_ACCESSIBILITY_MODE_ENABLED = ( new RawContextKey('accessibilityModeEnabled', false));
 function isAccessibilityInformation(obj) {
-    return obj && typeof obj === 'object'
-        && typeof obj.label === 'string'
-        && (typeof obj.role === 'undefined' || typeof obj.role === 'string');
+    if (!obj || typeof obj !== 'object') {
+        return false;
+    }
+    const candidate = obj;
+    return typeof candidate.label === 'string'
+        && (typeof candidate.role === 'undefined' || typeof candidate.role === 'string');
 }
 const ACCESSIBLE_VIEW_SHOWN_STORAGE_PREFIX = 'ACCESSIBLE_VIEW_SHOWN_';
 

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

@@ -282,176 +282,176 @@ class AccessibilitySignal {
         return [...this._signals];
     }
     static { this.errorAtPosition = AccessibilitySignal.register({
-        name: ( localize(1659, 'Error at Position')),
+        name: ( localize(1671, 'Error at Position')),
         sound: Sound.error,
-        announcementMessage: ( localize(1660, 'Error')),
+        announcementMessage: ( localize(1672, 'Error')),
         settingsKey: 'accessibility.signals.positionHasError',
         delaySettingsKey: 'accessibility.signalOptions.delays.errorAtPosition'
     }); }
     static { this.warningAtPosition = AccessibilitySignal.register({
-        name: ( localize(1661, 'Warning at Position')),
+        name: ( localize(1673, 'Warning at Position')),
         sound: Sound.warning,
-        announcementMessage: ( localize(1662, 'Warning')),
+        announcementMessage: ( localize(1674, 'Warning')),
         settingsKey: 'accessibility.signals.positionHasWarning',
         delaySettingsKey: 'accessibility.signalOptions.delays.warningAtPosition'
     }); }
     static { this.errorOnLine = AccessibilitySignal.register({
-        name: ( localize(1663, 'Error on Line')),
+        name: ( localize(1675, 'Error on Line')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.lineHasError',
         legacyAnnouncementSettingsKey: 'accessibility.alert.error',
-        announcementMessage: ( localize(1664, 'Error on Line')),
+        announcementMessage: ( localize(1676, 'Error on Line')),
         settingsKey: 'accessibility.signals.lineHasError',
     }); }
     static { this.warningOnLine = AccessibilitySignal.register({
-        name: ( localize(1665, 'Warning on Line')),
+        name: ( localize(1677, 'Warning on Line')),
         sound: Sound.warning,
         legacySoundSettingsKey: 'audioCues.lineHasWarning',
         legacyAnnouncementSettingsKey: 'accessibility.alert.warning',
-        announcementMessage: ( localize(1666, 'Warning on Line')),
+        announcementMessage: ( localize(1678, 'Warning on Line')),
         settingsKey: 'accessibility.signals.lineHasWarning',
     }); }
     static { this.foldedArea = AccessibilitySignal.register({
-        name: ( localize(1667, 'Folded Area on Line')),
+        name: ( localize(1679, 'Folded Area on Line')),
         sound: Sound.foldedArea,
         legacySoundSettingsKey: 'audioCues.lineHasFoldedArea',
         legacyAnnouncementSettingsKey: 'accessibility.alert.foldedArea',
-        announcementMessage: ( localize(1668, 'Folded')),
+        announcementMessage: ( localize(1680, 'Folded')),
         settingsKey: 'accessibility.signals.lineHasFoldedArea',
     }); }
     static { this.break = AccessibilitySignal.register({
-        name: ( localize(1669, 'Breakpoint on Line')),
+        name: ( localize(1681, 'Breakpoint on Line')),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.lineHasBreakpoint',
         legacyAnnouncementSettingsKey: 'accessibility.alert.breakpoint',
-        announcementMessage: ( localize(1670, 'Breakpoint')),
+        announcementMessage: ( localize(1682, 'Breakpoint')),
         settingsKey: 'accessibility.signals.lineHasBreakpoint',
     }); }
     static { this.inlineSuggestion = AccessibilitySignal.register({
-        name: ( localize(1671, 'Inline Suggestion on Line')),
+        name: ( localize(1683, 'Inline Suggestion on Line')),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.lineHasInlineSuggestion',
         settingsKey: 'accessibility.signals.lineHasInlineSuggestion',
     }); }
     static { this.nextEditSuggestion = AccessibilitySignal.register({
-        name: ( localize(1672, 'Next Edit Suggestion on Line')),
+        name: ( localize(1684, 'Next Edit Suggestion on Line')),
         sound: Sound.nextEditSuggestion,
         legacySoundSettingsKey: 'audioCues.nextEditSuggestion',
         settingsKey: 'accessibility.signals.nextEditSuggestion',
-        announcementMessage: ( localize(1673, 'Next Edit Suggestion')),
+        announcementMessage: ( localize(1685, 'Next Edit Suggestion')),
     }); }
     static { this.terminalQuickFix = AccessibilitySignal.register({
-        name: ( localize(1674, 'Terminal Quick Fix')),
+        name: ( localize(1686, 'Terminal Quick Fix')),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.terminalQuickFix',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalQuickFix',
-        announcementMessage: ( localize(1675, 'Quick Fix')),
+        announcementMessage: ( localize(1687, 'Quick Fix')),
         settingsKey: 'accessibility.signals.terminalQuickFix',
     }); }
     static { this.onDebugBreak = AccessibilitySignal.register({
-        name: ( localize(1676, 'Debugger Stopped on Breakpoint')),
+        name: ( localize(1688, 'Debugger Stopped on Breakpoint')),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.onDebugBreak',
         legacyAnnouncementSettingsKey: 'accessibility.alert.onDebugBreak',
-        announcementMessage: ( localize(1677, 'Breakpoint')),
+        announcementMessage: ( localize(1689, 'Breakpoint')),
         settingsKey: 'accessibility.signals.onDebugBreak',
     }); }
     static { this.noInlayHints = AccessibilitySignal.register({
-        name: ( localize(1678, 'No Inlay Hints on Line')),
+        name: ( localize(1690, 'No Inlay Hints on Line')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.noInlayHints',
         legacyAnnouncementSettingsKey: 'accessibility.alert.noInlayHints',
-        announcementMessage: ( localize(1679, 'No Inlay Hints')),
+        announcementMessage: ( localize(1691, 'No Inlay Hints')),
         settingsKey: 'accessibility.signals.noInlayHints',
     }); }
     static { this.taskCompleted = AccessibilitySignal.register({
-        name: ( localize(1680, 'Task Completed')),
+        name: ( localize(1692, 'Task Completed')),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.taskCompleted',
         legacyAnnouncementSettingsKey: 'accessibility.alert.taskCompleted',
-        announcementMessage: ( localize(1681, 'Task Completed')),
+        announcementMessage: ( localize(1693, 'Task Completed')),
         settingsKey: 'accessibility.signals.taskCompleted',
     }); }
     static { this.taskFailed = AccessibilitySignal.register({
-        name: ( localize(1682, 'Task Failed')),
+        name: ( localize(1694, 'Task Failed')),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.taskFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.taskFailed',
-        announcementMessage: ( localize(1683, 'Task Failed')),
+        announcementMessage: ( localize(1695, 'Task Failed')),
         settingsKey: 'accessibility.signals.taskFailed',
     }); }
     static { this.terminalCommandFailed = AccessibilitySignal.register({
-        name: ( localize(1684, 'Terminal Command Failed')),
+        name: ( localize(1696, 'Terminal Command Failed')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.terminalCommandFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalCommandFailed',
-        announcementMessage: ( localize(1685, 'Command Failed')),
+        announcementMessage: ( localize(1697, 'Command Failed')),
         settingsKey: 'accessibility.signals.terminalCommandFailed',
     }); }
     static { this.terminalCommandSucceeded = AccessibilitySignal.register({
-        name: ( localize(1686, 'Terminal Command Succeeded')),
+        name: ( localize(1698, 'Terminal Command Succeeded')),
         sound: Sound.terminalCommandSucceeded,
-        announcementMessage: ( localize(1687, 'Command Succeeded')),
+        announcementMessage: ( localize(1699, 'Command Succeeded')),
         settingsKey: 'accessibility.signals.terminalCommandSucceeded',
     }); }
     static { this.terminalBell = AccessibilitySignal.register({
-        name: ( localize(1688, 'Terminal Bell')),
+        name: ( localize(1700, 'Terminal Bell')),
         sound: Sound.terminalBell,
         legacySoundSettingsKey: 'audioCues.terminalBell',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalBell',
-        announcementMessage: ( localize(1689, 'Terminal Bell')),
+        announcementMessage: ( localize(1701, 'Terminal Bell')),
         settingsKey: 'accessibility.signals.terminalBell',
     }); }
     static { this.notebookCellCompleted = AccessibilitySignal.register({
-        name: ( localize(1690, 'Notebook Cell Completed')),
+        name: ( localize(1702, 'Notebook Cell Completed')),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.notebookCellCompleted',
         legacyAnnouncementSettingsKey: 'accessibility.alert.notebookCellCompleted',
-        announcementMessage: ( localize(1691, 'Notebook Cell Completed')),
+        announcementMessage: ( localize(1703, 'Notebook Cell Completed')),
         settingsKey: 'accessibility.signals.notebookCellCompleted',
     }); }
     static { this.notebookCellFailed = AccessibilitySignal.register({
-        name: ( localize(1692, 'Notebook Cell Failed')),
+        name: ( localize(1704, 'Notebook Cell Failed')),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.notebookCellFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.notebookCellFailed',
-        announcementMessage: ( localize(1693, 'Notebook Cell Failed')),
+        announcementMessage: ( localize(1705, 'Notebook Cell Failed')),
         settingsKey: 'accessibility.signals.notebookCellFailed',
     }); }
     static { this.diffLineInserted = AccessibilitySignal.register({
-        name: ( localize(1694, 'Diff Line Inserted')),
+        name: ( localize(1706, 'Diff Line Inserted')),
         sound: Sound.diffLineInserted,
         legacySoundSettingsKey: 'audioCues.diffLineInserted',
         settingsKey: 'accessibility.signals.diffLineInserted',
     }); }
     static { this.diffLineDeleted = AccessibilitySignal.register({
-        name: ( localize(1695, 'Diff Line Deleted')),
+        name: ( localize(1707, 'Diff Line Deleted')),
         sound: Sound.diffLineDeleted,
         legacySoundSettingsKey: 'audioCues.diffLineDeleted',
         settingsKey: 'accessibility.signals.diffLineDeleted',
     }); }
     static { this.diffLineModified = AccessibilitySignal.register({
-        name: ( localize(1696, 'Diff Line Modified')),
+        name: ( localize(1708, 'Diff Line Modified')),
         sound: Sound.diffLineModified,
         legacySoundSettingsKey: 'audioCues.diffLineModified',
         settingsKey: 'accessibility.signals.diffLineModified',
     }); }
     static { this.chatEditModifiedFile = AccessibilitySignal.register({
-        name: ( localize(1697, 'Chat Edit Modified File')),
+        name: ( localize(1709, 'Chat Edit Modified File')),
         sound: Sound.chatEditModifiedFile,
-        announcementMessage: ( localize(1698, 'File Modified from Chat Edits')),
+        announcementMessage: ( localize(1710, 'File Modified from Chat Edits')),
         settingsKey: 'accessibility.signals.chatEditModifiedFile',
     }); }
     static { this.chatRequestSent = AccessibilitySignal.register({
-        name: ( localize(1699, 'Chat Request Sent')),
+        name: ( localize(1711, 'Chat Request Sent')),
         sound: Sound.requestSent,
         legacySoundSettingsKey: 'audioCues.chatRequestSent',
         legacyAnnouncementSettingsKey: 'accessibility.alert.chatRequestSent',
-        announcementMessage: ( localize(1700, 'Chat Request Sent')),
+        announcementMessage: ( localize(1712, 'Chat Request Sent')),
         settingsKey: 'accessibility.signals.chatRequestSent',
     }); }
     static { this.chatResponseReceived = AccessibilitySignal.register({
-        name: ( localize(1701, 'Chat Response Received')),
+        name: ( localize(1713, 'Chat Response Received')),
         legacySoundSettingsKey: 'audioCues.chatResponseReceived',
         sound: {
             randomOneOf: [
@@ -464,79 +464,79 @@ class AccessibilitySignal {
         settingsKey: 'accessibility.signals.chatResponseReceived'
     }); }
     static { this.codeActionTriggered = AccessibilitySignal.register({
-        name: ( localize(1702, 'Code Action Request Triggered')),
+        name: ( localize(1714, 'Code Action Request Triggered')),
         sound: Sound.codeActionTriggered,
         legacySoundSettingsKey: 'audioCues.codeActionRequestTriggered',
         legacyAnnouncementSettingsKey: 'accessibility.alert.codeActionRequestTriggered',
-        announcementMessage: ( localize(1703, 'Code Action Request Triggered')),
+        announcementMessage: ( localize(1715, 'Code Action Request Triggered')),
         settingsKey: 'accessibility.signals.codeActionTriggered',
     }); }
     static { this.codeActionApplied = AccessibilitySignal.register({
-        name: ( localize(1704, 'Code Action Applied')),
+        name: ( localize(1716, 'Code Action Applied')),
         legacySoundSettingsKey: 'audioCues.codeActionApplied',
         sound: Sound.codeActionApplied,
         settingsKey: 'accessibility.signals.codeActionApplied'
     }); }
     static { this.progress = AccessibilitySignal.register({
-        name: ( localize(1705, 'Progress')),
+        name: ( localize(1717, 'Progress')),
         sound: Sound.progress,
         legacySoundSettingsKey: 'audioCues.chatResponsePending',
         legacyAnnouncementSettingsKey: 'accessibility.alert.progress',
-        announcementMessage: ( localize(1706, 'Progress')),
+        announcementMessage: ( localize(1718, 'Progress')),
         settingsKey: 'accessibility.signals.progress'
     }); }
     static { this.clear = AccessibilitySignal.register({
-        name: ( localize(1707, 'Clear')),
+        name: ( localize(1719, 'Clear')),
         sound: Sound.clear,
         legacySoundSettingsKey: 'audioCues.clear',
         legacyAnnouncementSettingsKey: 'accessibility.alert.clear',
-        announcementMessage: ( localize(1708, 'Clear')),
+        announcementMessage: ( localize(1720, 'Clear')),
         settingsKey: 'accessibility.signals.clear'
     }); }
     static { this.save = AccessibilitySignal.register({
-        name: ( localize(1709, 'Save')),
+        name: ( localize(1721, 'Save')),
         sound: Sound.save,
         legacySoundSettingsKey: 'audioCues.save',
         legacyAnnouncementSettingsKey: 'accessibility.alert.save',
-        announcementMessage: ( localize(1710, 'Save')),
+        announcementMessage: ( localize(1722, 'Save')),
         settingsKey: 'accessibility.signals.save'
     }); }
     static { this.format = AccessibilitySignal.register({
-        name: ( localize(1711, 'Format')),
+        name: ( localize(1723, 'Format')),
         sound: Sound.format,
         legacySoundSettingsKey: 'audioCues.format',
         legacyAnnouncementSettingsKey: 'accessibility.alert.format',
-        announcementMessage: ( localize(1712, 'Format')),
+        announcementMessage: ( localize(1724, 'Format')),
         settingsKey: 'accessibility.signals.format'
     }); }
     static { this.voiceRecordingStarted = AccessibilitySignal.register({
-        name: ( localize(1713, 'Voice Recording Started')),
+        name: ( localize(1725, 'Voice Recording Started')),
         sound: Sound.voiceRecordingStarted,
         legacySoundSettingsKey: 'audioCues.voiceRecordingStarted',
         settingsKey: 'accessibility.signals.voiceRecordingStarted'
     }); }
     static { this.voiceRecordingStopped = AccessibilitySignal.register({
-        name: ( localize(1714, 'Voice Recording Stopped')),
+        name: ( localize(1726, 'Voice Recording Stopped')),
         sound: Sound.voiceRecordingStopped,
         legacySoundSettingsKey: 'audioCues.voiceRecordingStopped',
         settingsKey: 'accessibility.signals.voiceRecordingStopped'
     }); }
     static { this.editsKept = AccessibilitySignal.register({
-        name: ( localize(1715, 'Edits Kept')),
+        name: ( localize(1727, 'Edits Kept')),
         sound: Sound.editsKept,
-        announcementMessage: ( localize(1716, 'Edits Kept')),
+        announcementMessage: ( localize(1728, 'Edits Kept')),
         settingsKey: 'accessibility.signals.editsKept',
     }); }
     static { this.editsUndone = AccessibilitySignal.register({
-        name: ( localize(1717, 'Undo Edits')),
+        name: ( localize(1729, 'Undo Edits')),
         sound: Sound.editsUndone,
-        announcementMessage: ( localize(1718, 'Edits Undone')),
+        announcementMessage: ( localize(1730, 'Edits Undone')),
         settingsKey: 'accessibility.signals.editsUndone',
     }); }
     static { this.chatUserActionRequired = AccessibilitySignal.register({
-        name: ( localize(1719, 'Chat User Action Required')),
+        name: ( localize(1731, 'Chat User Action Required')),
         sound: Sound.chatUserActionRequired,
-        announcementMessage: ( localize(1720, 'Chat User Action Required')),
+        announcementMessage: ( localize(1732, 'Chat User Action Required')),
         settingsKey: 'accessibility.signals.chatUserActionRequired',
         managesOwnEnablement: true
     }); }

package/vscode/src/vs/platform/accessibilitySignal/browser/progressAccessibilitySignalScheduler.d.ts

@@ -0,0 +1,12 @@
+import { Disposable } from "../../../base/common/lifecycle.js";
+import { IAccessibilitySignalService } from "./accessibilitySignalService.service.js";
+/**
+ * Schedules a signal to play while progress is happening.
+ */
+export declare class AccessibilityProgressSignalScheduler extends Disposable {
+    private readonly _accessibilitySignalService;
+    private _scheduler;
+    private _signalLoop;
+    constructor(msDelayTime: number, msLoopTime: number | undefined, _accessibilitySignalService: IAccessibilitySignalService);
+    dispose(): void;
+}

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

@@ -0,0 +1,28 @@
+
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { RunOnceScheduler } from '../../../base/common/async.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { AccessibilitySignal } from './accessibilitySignalService.js';
+import { IAccessibilitySignalService } from './accessibilitySignalService.service.js';
+
+const PROGRESS_SIGNAL_LOOP_DELAY = 5000;
+let AccessibilityProgressSignalScheduler = class AccessibilityProgressSignalScheduler extends Disposable {
+    constructor(msDelayTime, msLoopTime, _accessibilitySignalService) {
+        super();
+        this._accessibilitySignalService = _accessibilitySignalService;
+        this._scheduler = this._register(( new RunOnceScheduler(() => {
+            this._signalLoop = this._accessibilitySignalService.playSignalLoop(AccessibilitySignal.progress, msLoopTime ?? PROGRESS_SIGNAL_LOOP_DELAY);
+        }, msDelayTime)));
+        this._scheduler.schedule();
+    }
+    dispose() {
+        super.dispose();
+        this._signalLoop?.dispose();
+        this._scheduler.dispose();
+    }
+};
+AccessibilityProgressSignalScheduler = ( __decorate([
+    ( __param(2, IAccessibilitySignalService))
+], AccessibilityProgressSignalScheduler));
+
+export { AccessibilityProgressSignalScheduler };

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

@@ -2,12 +2,12 @@
 import { localize2 } from '../../../nls.js';
 
 const Categories = ( Object.freeze({
-    View: ( localize2(1721, 'View')),
-    Help: ( localize2(1722, 'Help')),
-    Test: ( localize2(1723, 'Test')),
-    File: ( localize2(1724, 'File')),
-    Preferences: ( localize2(1725, 'Preferences')),
-    Developer: ( localize2(1726, "Developer")),
+    View: ( localize2(1733, 'View')),
+    Help: ( localize2(1734, 'Help')),
+    Test: ( localize2(1735, 'Test')),
+    File: ( localize2(1736, 'File')),
+    Preferences: ( localize2(1737, 'Preferences')),
+    Developer: ( localize2(1738, "Developer")),
 }));
 
 export { Categories };