@codingame/monaco-vscode-api 1.78.4 → 1.78.5

package/dist/{theme2.js → vscode/vs/workbench/common/theme.js}

@@ -1,173 +1,6 @@
-import { __decorate, __param, IFileService } from './polyfill.js';
-import { RawContextKey, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
-import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
-import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { isEqual, basename, dirname, extname } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
 import { registerColor, editorBackground, transparent, contrastBorder, treeIndentGuidesStroke, focusBorder, editorWidgetForeground, editorWidgetBackground, editorForeground, inputBorder, listActiveSelectionBackground, darken, listActiveSelectionForeground, editorInfoForeground, activeContrastBorder, errorForeground, editorWarningForeground, toolbarHoverBackground, widgetBorder, textLinkForeground, lighten, editorErrorForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
 import { Color } from 'monaco-editor/esm/vs/base/common/color.js';
-const IsFullscreenContext = ( new RawContextKey('isFullscreen', false, ( localize('isFullscreen', "Whether the window is in fullscreen mode"))));
-const ActiveEditorDirtyContext = ( new RawContextKey('activeEditorIsDirty', false, ( localize('activeEditorIsDirty', "Whether the active editor has unsaved changes"))));
-const ActiveEditorPinnedContext = ( new RawContextKey('activeEditorIsNotPreview', false, ( localize(
-    'activeEditorIsNotPreview',
-    "Whether the active editor is not in preview mode"
-))));
-const ActiveEditorLastInGroupContext = ( new RawContextKey('activeEditorIsLastInGroup', false, ( localize(
-    'activeEditorIsLastInGroup',
-    "Whether the active editor is the last one in its group"
-))));
-const ActiveEditorStickyContext = ( new RawContextKey('activeEditorIsPinned', false, ( localize('activeEditorIsPinned', "Whether the active editor is pinned"))));
-const ActiveEditorCanSplitInGroupContext = ( new RawContextKey('activeEditorCanSplitInGroup', true));
-const ActiveEditorAvailableEditorIdsContext = ( new RawContextKey('activeEditorAvailableEditorIds', '', ( localize(
-    'activeEditorAvailableEditorIds',
-    "The available editor identifiers that are usable for the active editor"
-))));
-const TextCompareEditorVisibleContext = ( new RawContextKey('textCompareEditorVisible', false, ( localize('textCompareEditorVisible', "Whether a text compare editor is visible"))));
-const TextCompareEditorActiveContext = ( new RawContextKey('textCompareEditorActive', false, ( localize('textCompareEditorActive', "Whether a text compare editor is active"))));
-const SideBySideEditorActiveContext = ( new RawContextKey('sideBySideEditorActive', false, ( localize('sideBySideEditorActive', "Whether a side by side editor is active"))));
-const EditorGroupEditorsCountContext = ( new RawContextKey('groupEditorsCount', 0, ( localize('groupEditorsCount', "The number of opened editor groups"))));
-const ActiveEditorGroupEmptyContext = ( new RawContextKey('activeEditorGroupEmpty', false, ( localize('activeEditorGroupEmpty', "Whether the active editor group is empty"))));
-const ActiveEditorGroupLockedContext = ( new RawContextKey('activeEditorGroupLocked', false, ( localize('activeEditorGroupLocked', "Whether the active editor group is locked"))));
-const MultipleEditorGroupsContext = ( new RawContextKey('multipleEditorGroups', false, ( localize('multipleEditorGroups', "Whether there are multiple editor groups opened"))));
-const InEditorZenModeContext = ( new RawContextKey('inZenMode', false, ( localize('inZenMode', "Whether Zen mode is enabled"))));
-const IsCenteredLayoutContext = ( new RawContextKey('isCenteredLayout', false, ( localize('isCenteredLayout', "Whether centered layout is enabled"))));
-const EditorAreaVisibleContext = ( new RawContextKey('editorAreaVisible', true, ( localize('editorAreaVisible', "Whether the editor area is visible"))));
-const EditorTabsVisibleContext = ( new RawContextKey('editorTabsVisible', true, ( localize('editorTabsVisible', "Whether editor tabs are visible"))));
-const SideBarVisibleContext = ( new RawContextKey('sideBarVisible', false, ( localize('sideBarVisible', "Whether the sidebar is visible"))));
-const NotificationFocusedContext = ( new RawContextKey('notificationFocus', true, ( localize('notificationFocus', "Whether a notification has keyboard focus"))));
-const NotificationsCenterVisibleContext = ( new RawContextKey('notificationCenterVisible', false, ( localize('notificationCenterVisible', "Whether the notifications center is visible"))));
-const NotificationsToastsVisibleContext = ( new RawContextKey('notificationToastsVisible', false, ( localize('notificationToastsVisible', "Whether a notification toast is visible"))));
-const AuxiliaryBarVisibleContext = ( new RawContextKey('auxiliaryBarVisible', false, ( localize('auxiliaryBarVisible', "Whether the auxiliary bar is visible"))));
-const PanelFocusContext = ( new RawContextKey('panelFocus', false, ( localize('panelFocus', "Whether the panel has keyboard focus"))));
-const PanelPositionContext = ( new RawContextKey('panelPosition', 'bottom', ( localize('panelPosition', "The position of the panel, always 'bottom'"))));
-const PanelAlignmentContext = ( new RawContextKey('panelAlignment', 'center', ( localize(
-    'panelAlignment',
-    "The alignment of the panel, either 'center', 'left', 'right' or 'justify'"
-))));
-const PanelVisibleContext = ( new RawContextKey('panelVisible', false, ( localize('panelVisible', "Whether the panel is visible"))));
-const PanelMaximizedContext = ( new RawContextKey('panelMaximized', false, ( localize('panelMaximized', "Whether the panel is maximized"))));
-const FocusedViewContext = ( new RawContextKey('focusedView', '', ( localize('focusedView', "The identifier of the view that has keyboard focus"))));
-let ResourceContextKey = class ResourceContextKey {
-    constructor(_contextKeyService, _fileService, _languageService, _modelService) {
-        this._contextKeyService = _contextKeyService;
-        this._fileService = _fileService;
-        this._languageService = _languageService;
-        this._modelService = _modelService;
-        this._disposables = ( new DisposableStore());
-        this._schemeKey = ResourceContextKey.Scheme.bindTo(this._contextKeyService);
-        this._filenameKey = ResourceContextKey.Filename.bindTo(this._contextKeyService);
-        this._dirnameKey = ResourceContextKey.Dirname.bindTo(this._contextKeyService);
-        this._pathKey = ResourceContextKey.Path.bindTo(this._contextKeyService);
-        this._langIdKey = ResourceContextKey.LangId.bindTo(this._contextKeyService);
-        this._resourceKey = ResourceContextKey.Resource.bindTo(this._contextKeyService);
-        this._extensionKey = ResourceContextKey.Extension.bindTo(this._contextKeyService);
-        this._hasResource = ResourceContextKey.HasResource.bindTo(this._contextKeyService);
-        this._isFileSystemResource = ResourceContextKey.IsFileSystemResource.bindTo(this._contextKeyService);
-        this._disposables.add(_fileService.onDidChangeFileSystemProviderRegistrations(() => {
-            const resource = this.get();
-            this._isFileSystemResource.set(Boolean(resource && _fileService.hasProvider(resource)));
-        }));
-        this._disposables.add(_modelService.onModelAdded(model => {
-            if (isEqual(model.uri, this.get())) {
-                this._setLangId();
-            }
-        }));
-        this._disposables.add(_modelService.onModelLanguageChanged(e => {
-            if (isEqual(e.model.uri, this.get())) {
-                this._setLangId();
-            }
-        }));
-    }
-    dispose() {
-        this._disposables.dispose();
-    }
-    _setLangId() {
-        const value = this.get();
-        if (!value) {
-            this._langIdKey.set(null);
-            return;
-        }
-        const langId = this._modelService.getModel(value)?.getLanguageId() ?? this._languageService.guessLanguageIdByFilepathOrFirstLine(value);
-        this._langIdKey.set(langId);
-    }
-    set(value) {
-        value = value ?? undefined;
-        if (isEqual(this._value, value)) {
-            return;
-        }
-        this._value = value;
-        this._contextKeyService.bufferChangeEvents(() => {
-            this._resourceKey.set(value ? ( value.toString()) : null);
-            this._schemeKey.set(value ? value.scheme : null);
-            this._filenameKey.set(value ? basename(value) : null);
-            this._dirnameKey.set(value ? this.uriToPath(dirname(value)) : null);
-            this._pathKey.set(value ? this.uriToPath(value) : null);
-            this._setLangId();
-            this._extensionKey.set(value ? extname(value) : null);
-            this._hasResource.set(Boolean(value));
-            this._isFileSystemResource.set(value ? this._fileService.hasProvider(value) : false);
-        });
-    }
-    uriToPath(uri) {
-        if (uri.scheme === Schemas.file) {
-            return uri.fsPath;
-        }
-        return uri.path;
-    }
-    reset() {
-        this._value = undefined;
-        this._contextKeyService.bufferChangeEvents(() => {
-            this._resourceKey.reset();
-            this._schemeKey.reset();
-            this._filenameKey.reset();
-            this._dirnameKey.reset();
-            this._pathKey.reset();
-            this._langIdKey.reset();
-            this._extensionKey.reset();
-            this._hasResource.reset();
-            this._isFileSystemResource.reset();
-        });
-    }
-    get() {
-        return this._value;
-    }
-};
-ResourceContextKey.Scheme = ( new RawContextKey('resourceScheme', undefined, { type: 'string', description: ( localize('resourceScheme', "The scheme of the resource")) }));
-ResourceContextKey.Filename = ( new RawContextKey(
-    'resourceFilename',
-    undefined,
-    { type: 'string', description: ( localize('resourceFilename', "The file name of the resource")) }
-));
-ResourceContextKey.Dirname = ( new RawContextKey(
-    'resourceDirname',
-    undefined,
-    { type: 'string', description: ( localize('resourceDirname', "The folder name the resource is contained in")) }
-));
-ResourceContextKey.Path = ( new RawContextKey('resourcePath', undefined, { type: 'string', description: ( localize('resourcePath', "The full path of the resource")) }));
-ResourceContextKey.LangId = ( new RawContextKey('resourceLangId', undefined, { type: 'string', description: ( localize('resourceLangId', "The language identifier of the resource")) }));
-ResourceContextKey.Resource = ( new RawContextKey('resource', undefined, { type: 'URI', description: ( localize('resource', "The full value of the resource including scheme and path")) }));
-ResourceContextKey.Extension = ( new RawContextKey(
-    'resourceExtname',
-    undefined,
-    { type: 'string', description: ( localize('resourceExtname', "The extension name of the resource")) }
-));
-ResourceContextKey.HasResource = ( new RawContextKey('resourceSet', undefined, { type: 'boolean', description: ( localize('resourceSet', "Whether a resource is present or not")) }));
-ResourceContextKey.IsFileSystemResource = ( new RawContextKey(
-    'isFileSystemResource',
-    undefined,
-    { type: 'boolean', description: ( localize(
-        'isFileSystemResource',
-        "Whether the resource is backed by a file system provider"
-    )) }
-));
-ResourceContextKey = ( __decorate([
-    ( __param(0, IContextKeyService)),
-    ( __param(1, IFileService)),
-    ( __param(2, ILanguageService)),
-    ( __param(3, IModelService))
-], ResourceContextKey));
 const TAB_ACTIVE_BACKGROUND = registerColor('tab.activeBackground', {
     dark: editorBackground,
     light: editorBackground,
@@ -1206,4 +1039,4 @@ registerColor('window.inactiveBorder', {
     'windowInactiveBorder',
     "The color used for the border of the window when it is inactive. Only supported in the macOS and Linux desktop client when using the custom title bar."
 )));
-export { ActiveEditorAvailableEditorIdsContext, ActiveEditorCanSplitInGroupContext, ActiveEditorDirtyContext, ActiveEditorGroupEmptyContext, ActiveEditorGroupLockedContext, ActiveEditorLastInGroupContext, ActiveEditorPinnedContext, ActiveEditorStickyContext, AuxiliaryBarVisibleContext, EditorAreaVisibleContext, EditorGroupEditorsCountContext, EditorTabsVisibleContext, FocusedViewContext, InEditorZenModeContext, IsCenteredLayoutContext, IsFullscreenContext, MultipleEditorGroupsContext, NOTIFICATIONS_BACKGROUND, NOTIFICATIONS_CENTER_BORDER, NOTIFICATIONS_CENTER_HEADER_BACKGROUND, NOTIFICATIONS_CENTER_HEADER_FOREGROUND, NOTIFICATIONS_TOAST_BORDER, NotificationFocusedContext, NotificationsCenterVisibleContext, NotificationsToastsVisibleContext, PANEL_BACKGROUND, PanelAlignmentContext, PanelFocusContext, PanelMaximizedContext, PanelPositionContext, PanelVisibleContext, SIDE_BAR_BACKGROUND, SIDE_BY_SIDE_EDITOR_HORIZONTAL_BORDER, SIDE_BY_SIDE_EDITOR_VERTICAL_BORDER, SideBarVisibleContext, SideBySideEditorActiveContext, TextCompareEditorActiveContext, TextCompareEditorVisibleContext };
+export { ACTIVITY_BAR_BADGE_BACKGROUND, ACTIVITY_BAR_BADGE_FOREGROUND, ACTIVITY_BAR_FOREGROUND, EDITOR_DRAG_AND_DROP_BACKGROUND, EDITOR_GROUP_BORDER, NOTIFICATIONS_BACKGROUND, NOTIFICATIONS_CENTER_BORDER, NOTIFICATIONS_CENTER_HEADER_BACKGROUND, NOTIFICATIONS_CENTER_HEADER_FOREGROUND, NOTIFICATIONS_TOAST_BORDER, PANEL_ACTIVE_TITLE_FOREGROUND, PANEL_BACKGROUND, PANEL_BORDER, SIDE_BAR_BACKGROUND, SIDE_BAR_FOREGROUND, SIDE_BY_SIDE_EDITOR_HORIZONTAL_BORDER, SIDE_BY_SIDE_EDITOR_VERTICAL_BORDER, STATUS_BAR_BORDER, STATUS_BAR_FOREGROUND, TAB_ACTIVE_BACKGROUND, TAB_ACTIVE_BORDER, TAB_ACTIVE_BORDER_TOP, TAB_ACTIVE_FOREGROUND, TAB_ACTIVE_MODIFIED_BORDER, TAB_HOVER_BACKGROUND, TAB_HOVER_BORDER, TAB_HOVER_FOREGROUND, TAB_INACTIVE_BACKGROUND, TAB_INACTIVE_FOREGROUND, TAB_INACTIVE_MODIFIED_BORDER, TITLE_BAR_ACTIVE_BACKGROUND, TITLE_BAR_ACTIVE_FOREGROUND };

package/dist/vscode/vs/workbench/common/views.js

@@ -0,0 +1,20 @@
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+const defaultViewIcon = ( registerIcon('default-view-icon', Codicon.window, ( localize('defaultViewIcon', 'Default view icon.'))));
+var Extensions;
+( (function(Extensions) {
+    Extensions.ViewContainersRegistry = 'workbench.registry.view.containers';
+    Extensions.ViewsRegistry = 'workbench.registry.view';
+})(Extensions || (Extensions = {})));
+function ViewContainerLocationToString(viewContainerLocation) {
+    switch (viewContainerLocation) {
+        case 0 : return 'sidebar';
+        case 1 : return 'panel';
+        case 2 : return 'auxiliarybar';
+    }
+}
+const IViewsService = ( createDecorator('viewsService'));
+const IViewDescriptorService = ( createDecorator('viewDescriptorService'));
+export { Extensions, IViewDescriptorService, IViewsService, ViewContainerLocationToString, defaultViewIcon };

package/dist/vscode/vs/workbench/contrib/audioCues/browser/audioCueDebuggerContribution.js

@@ -0,0 +1,45 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { observableFromEvent, autorunWithStore } from 'monaco-editor/esm/vs/base/common/observable.js';
+import { AudioCue, IAudioCueService } from 'monaco-editor/esm/vs/platform/audioCues/browser/audioCueService.js';
+import { IDebugService } from '../../debug/common/debug.js';
+let AudioCueLineDebuggerContribution = class AudioCueLineDebuggerContribution extends Disposable {
+    constructor(debugService, audioCueService) {
+        super();
+        this.audioCueService = audioCueService;
+        const isEnabled = observableFromEvent(audioCueService.onEnabledChanged(AudioCue.onDebugBreak), () => audioCueService.isEnabled(AudioCue.onDebugBreak));
+        this._register(autorunWithStore((reader, store) => {
+            if (!isEnabled.read(reader)) {
+                return;
+            }
+            const sessionDisposables = ( new Map());
+            store.add(toDisposable(() => {
+                sessionDisposables.forEach(d => d.dispose());
+                sessionDisposables.clear();
+            }));
+            store.add(debugService.onDidNewSession((session) => sessionDisposables.set(session, this.handleSession(session))));
+            store.add(debugService.onDidEndSession(session => {
+                sessionDisposables.get(session)?.dispose();
+                sessionDisposables.delete(session);
+            }));
+            debugService
+                .getModel()
+                .getSessions()
+                .forEach((session) => sessionDisposables.set(session, this.handleSession(session)));
+        }, 'subscribe to debug sessions'));
+    }
+    handleSession(session) {
+        return session.onDidChangeState(e => {
+            const stoppedDetails = session.getStoppedDetails();
+            const BREAKPOINT_STOP_REASON = 'breakpoint';
+            if (stoppedDetails && stoppedDetails.reason === BREAKPOINT_STOP_REASON) {
+                this.audioCueService.playAudioCue(AudioCue.onDebugBreak);
+            }
+        });
+    }
+};
+AudioCueLineDebuggerContribution = ( __decorate([
+    ( __param(0, IDebugService)),
+    ( __param(1, IAudioCueService))
+], AudioCueLineDebuggerContribution));
+export { AudioCueLineDebuggerContribution };

package/dist/vscode/vs/workbench/contrib/audioCues/browser/audioCueLineFeatureContribution.js

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

package/dist/vscode/vs/workbench/contrib/audioCues/browser/audioCues.contribution.js

@@ -0,0 +1,160 @@
+import { ShowAudioCueHelp } from './commands.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { registerAction2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from '../../../common/contributions.js';
+import { AudioCueLineDebuggerContribution } from './audioCueDebuggerContribution.js';
+import { AudioCueLineFeatureContribution } from './audioCueLineFeatureContribution.js';
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(AudioCueLineFeatureContribution, 3 );
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(AudioCueLineDebuggerContribution, 3 );
+const audioCueFeatureBase = {
+    'type': 'string',
+    'enum': ['auto', 'on', 'off'],
+    'default': 'auto',
+    'enumDescriptions': [
+        ( localize(
+            'audioCues.enabled.auto',
+            "Enable audio cue when a screen reader is attached."
+        )),
+        ( localize('audioCues.enabled.on', "Enable audio cue.")),
+        ( localize('audioCues.enabled.off', "Disable audio cue."))
+    ],
+    tags: ['accessibility']
+};
+( Registry.as(Extensions$1.Configuration)).registerConfiguration({
+    'properties': {
+        'audioCues.enabled': {
+            markdownDeprecationMessage: 'Deprecated. Use the specific setting for each audio cue instead (`audioCues.*`).',
+            tags: ['accessibility']
+        },
+        'audioCues.volume': {
+            'description': ( localize('audioCues.volume', "The volume of the audio cues in percent (0-100).")),
+            'type': 'number',
+            'minimum': 0,
+            'maximum': 100,
+            'default': 70,
+            tags: ['accessibility']
+        },
+        'audioCues.debouncePositionChanges': {
+            'description': ( localize(
+                'audioCues.debouncePositionChanges',
+                "Whether or not position changes should be debounced"
+            )),
+            'type': 'boolean',
+            'default': false,
+            tags: ['accessibility']
+        },
+        'audioCues.lineHasBreakpoint': {
+            'description': ( localize(
+                'audioCues.lineHasBreakpoint',
+                "Plays a sound when the active line has a breakpoint."
+            )),
+            ...audioCueFeatureBase
+        },
+        'audioCues.lineHasInlineSuggestion': {
+            'description': ( localize(
+                'audioCues.lineHasInlineSuggestion',
+                "Plays a sound when the active line has an inline suggestion."
+            )),
+            ...audioCueFeatureBase
+        },
+        'audioCues.lineHasError': {
+            'description': ( localize(
+                'audioCues.lineHasError',
+                "Plays a sound when the active line has an error."
+            )),
+            ...audioCueFeatureBase,
+        },
+        'audioCues.lineHasFoldedArea': {
+            'description': ( localize(
+                'audioCues.lineHasFoldedArea',
+                "Plays a sound when the active line has a folded area that can be unfolded."
+            )),
+            ...audioCueFeatureBase,
+        },
+        'audioCues.lineHasWarning': {
+            'description': ( localize(
+                'audioCues.lineHasWarning',
+                "Plays a sound when the active line has a warning."
+            )),
+            ...audioCueFeatureBase,
+            default: 'off',
+        },
+        'audioCues.onDebugBreak': {
+            'description': ( localize(
+                'audioCues.onDebugBreak',
+                "Plays a sound when the debugger stopped on a breakpoint."
+            )),
+            ...audioCueFeatureBase,
+        },
+        'audioCues.noInlayHints': {
+            'description': ( localize(
+                'audioCues.noInlayHints',
+                "Plays a sound when trying to read a line with inlay hints that has no inlay hints."
+            )),
+            ...audioCueFeatureBase,
+        },
+        'audioCues.taskCompleted': {
+            'description': ( localize('audioCues.taskCompleted', "Plays a sound when a task is completed.")),
+            ...audioCueFeatureBase,
+        },
+        'audioCues.taskFailed': {
+            'description': ( localize(
+                'audioCues.taskFailed',
+                "Plays a sound when a task fails (non-zero exit code)."
+            )),
+            ...audioCueFeatureBase,
+        },
+        'audioCues.terminalCommandFailed': {
+            'description': ( localize(
+                'audioCues.terminalCommandFailed',
+                "Plays a sound when a terminal command fails (non-zero exit code)."
+            )),
+            ...audioCueFeatureBase,
+        },
+        'audioCues.terminalQuickFix': {
+            'description': ( localize(
+                'audioCues.terminalQuickFix',
+                "Plays a sound when terminal Quick Fixes are available."
+            )),
+            ...audioCueFeatureBase,
+        },
+        'audioCues.diffLineInserted': {
+            'description': ( localize(
+                'audioCues.diffLineInserted',
+                "Plays a sound when the focus moves to an inserted line in diff review mode or to the next/previous change"
+            )),
+            ...audioCueFeatureBase,
+        },
+        'audioCues.diffLineDeleted': {
+            'description': ( localize(
+                'audioCues.diffLineDeleted',
+                "Plays a sound when the focus moves to a deleted line in diff review mode or to the next/previous change"
+            )),
+            ...audioCueFeatureBase,
+        },
+        'audioCues.diffLineModified': {
+            'description': ( localize(
+                'audioCues.diffLineModified',
+                "Plays a sound when the focus moves to a modified line in diff review mode or to the next/previous change"
+            )),
+            ...audioCueFeatureBase,
+        },
+        'audioCues.notebookCellCompleted': {
+            'description': ( localize(
+                'audioCues.notebookCellCompleted',
+                "Plays a sound when a notebook cell execution is successfully completed."
+            )),
+            ...audioCueFeatureBase,
+        },
+        'audioCues.notebookCellFailed': {
+            'description': ( localize(
+                'audioCues.notebookCellFailed',
+                "Plays a sound when a notebook cell execution fails."
+            )),
+            ...audioCueFeatureBase,
+        },
+    }
+});
+registerAction2(ShowAudioCueHelp);

package/dist/vscode/vs/workbench/contrib/audioCues/browser/commands.js

@@ -0,0 +1,49 @@
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
+import { Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IAudioCueService, AudioCue } from 'monaco-editor/esm/vs/platform/audioCues/browser/audioCueService.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { IPreferencesService } from '../../../services/preferences/common/preferences.js';
+class ShowAudioCueHelp extends Action2 {
+    constructor() {
+        super({
+            id: ShowAudioCueHelp.ID,
+            title: {
+                value: ( (localize('audioCues.help', "Help: List Audio Cues"))),
+                original: 'Help: List Audio Cues'
+            },
+            f1: true,
+        });
+    }
+    async run(accessor) {
+        const audioCueService = accessor.get(IAudioCueService);
+        const quickPickService = accessor.get(IQuickInputService);
+        const preferencesService = accessor.get(IPreferencesService);
+        const accessibilityService = accessor.get(IAccessibilityService);
+        const items = ( (AudioCue.allAudioCues.map((cue, idx) => ({
+            label: accessibilityService.isScreenReaderOptimized() ?
+                `${cue.name}${audioCueService.isEnabled(cue) ? '' : ' (' + ( ( localize('disabled', "Disabled"))) + ')'}`
+                : `${audioCueService.isEnabled(cue) ? '$(check)' : '     '} ${cue.name}`,
+            audioCue: cue,
+            buttons: [{
+                    iconClass: ThemeIcon.asClassName(Codicon.settingsGear),
+                    tooltip: ( (localize('audioCues.help.settings', 'Enable/Disable Audio Cue'))),
+                }],
+        }))));
+        const quickPick = quickPickService.pick(items, {
+            activeItem: items[0],
+            onDidFocus: (item) => {
+                audioCueService.playSound(item.audioCue.sound, true);
+            },
+            onDidTriggerItemButton: (context) => {
+                preferencesService.openSettings({ query: context.item.audioCue.settingsKey });
+            },
+            placeHolder: ( (localize('audioCues.help.placeholder', 'Select an audio cue to play'))),
+        });
+        await quickPick;
+    }
+}
+ShowAudioCueHelp.ID = 'audioCues.help';
+export { ShowAudioCueHelp };

package/dist/vscode/vs/workbench/contrib/bulkEdit/browser/bulkCellEdits.js

@@ -0,0 +1,25 @@
+import { isObject } from 'monaco-editor/esm/vs/base/common/types.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { ResourceEdit } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
+class ResourceNotebookCellEdit extends ResourceEdit {
+    static is(candidate) {
+        if (candidate instanceof ResourceNotebookCellEdit) {
+            return true;
+        }
+        return URI.isUri(candidate.resource)
+            && isObject(candidate.cellEdit);
+    }
+    static lift(edit) {
+        if (edit instanceof ResourceNotebookCellEdit) {
+            return edit;
+        }
+        return ( new ResourceNotebookCellEdit(edit.resource, edit.cellEdit, edit.notebookVersionId, edit.metadata));
+    }
+    constructor(resource, cellEdit, notebookVersionId = undefined, metadata) {
+        super(metadata);
+        this.resource = resource;
+        this.cellEdit = cellEdit;
+        this.notebookVersionId = notebookVersionId;
+    }
+}
+export { ResourceNotebookCellEdit };