@codingame/monaco-vscode-api 1.81.8-next.3 → 1.82.1

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

@@ -0,0 +1,216 @@
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { MultiCommand } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { registerAction2, Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { accessibleViewIsShown, accessibleViewSupportsNavigation, accessibilityHelpIsShown, accessibleViewGoToSymbolSupported, accessibleViewVerbosityEnabled, accessibleViewCurrentProviderId } from './accessibilityConfiguration.js';
+import { IAccessibleViewService } from './accessibleView.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { InlineCompletionsController } from 'monaco-editor/esm/vs/editor/contrib/inlineCompletions/browser/inlineCompletionsController.js';
+import { alert } from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
+const accessibleViewMenu = {
+    id: MenuId.AccessibleView,
+    group: 'navigation',
+    when: accessibleViewIsShown
+};
+const commandPalette = {
+    id: MenuId.CommandPalette,
+    group: '',
+    order: 1
+};
+class AccessibleViewNextAction extends Action2 {
+    constructor() {
+        super({
+            id: "editor.action.accessibleViewNext" ,
+            precondition: ( ContextKeyExpr.and(accessibleViewIsShown, accessibleViewSupportsNavigation)),
+            keybinding: {
+                primary: 512  | 94 ,
+                weight: 200
+            },
+            menu: [
+                commandPalette,
+                {
+                    ...accessibleViewMenu,
+                    when: ( ContextKeyExpr.and(accessibleViewIsShown, accessibleViewSupportsNavigation)),
+                }
+            ],
+            icon: Codicon.arrowDown,
+            title: ( localize('editor.action.accessibleViewNext', "Show Next in Accessible View"))
+        });
+    }
+    run(accessor) {
+        accessor.get(IAccessibleViewService).next();
+    }
+}
+registerAction2(AccessibleViewNextAction);
+class AccessibleViewPreviousAction extends Action2 {
+    constructor() {
+        super({
+            id: "editor.action.accessibleViewPrevious" ,
+            precondition: ( ContextKeyExpr.and(accessibleViewIsShown, accessibleViewSupportsNavigation)),
+            keybinding: {
+                primary: 512  | 92 ,
+                weight: 200
+            },
+            icon: Codicon.arrowUp,
+            menu: [
+                commandPalette,
+                {
+                    ...accessibleViewMenu,
+                    when: ( ContextKeyExpr.and(accessibleViewIsShown, accessibleViewSupportsNavigation)),
+                }
+            ],
+            title: ( localize('editor.action.accessibleViewPrevious', "Show Previous in Accessible View"))
+        });
+    }
+    run(accessor) {
+        accessor.get(IAccessibleViewService).previous();
+    }
+}
+registerAction2(AccessibleViewPreviousAction);
+class AccessibleViewGoToSymbolAction extends Action2 {
+    constructor() {
+        super({
+            id: "editor.action.accessibleViewGoToSymbol" ,
+            precondition: ( ContextKeyExpr.and(( ContextKeyExpr.or(accessibleViewIsShown, accessibilityHelpIsShown)), accessibleViewGoToSymbolSupported)),
+            keybinding: {
+                primary: 2048  | 1024  | 45 ,
+                secondary: [2048  | 1024  | 89 ],
+                weight: 200  + 10
+            },
+            icon: Codicon.symbolField,
+            menu: [
+                commandPalette,
+                {
+                    ...accessibleViewMenu,
+                    when: ( ContextKeyExpr.and(( ContextKeyExpr.or(accessibleViewIsShown, accessibilityHelpIsShown)), accessibleViewGoToSymbolSupported)),
+                }
+            ],
+            title: ( localize(
+                'editor.action.accessibleViewGoToSymbol',
+                "Go To Symbol in Accessible View"
+            ))
+        });
+    }
+    run(accessor) {
+        accessor.get(IAccessibleViewService).goToSymbol();
+    }
+}
+registerAction2(AccessibleViewGoToSymbolAction);
+function registerCommand(command) {
+    command.register();
+    return command;
+}
+const AccessibilityHelpAction = registerCommand(( new MultiCommand({
+    id: "editor.action.accessibilityHelp" ,
+    precondition: undefined,
+    kbOpts: {
+        primary: 512  | 59 ,
+        weight: 200 ,
+        linux: {
+            primary: 512  | 1024  | 59 ,
+            secondary: [512  | 59 ]
+        }
+    },
+    menuOpts: [{
+            menuId: MenuId.CommandPalette,
+            group: '',
+            title: ( localize('editor.action.accessibilityHelp', "Open Accessibility Help")),
+            order: 1
+        }],
+})));
+const AccessibleViewAction = registerCommand(( new MultiCommand({
+    id: "editor.action.accessibleView" ,
+    precondition: undefined,
+    kbOpts: {
+        primary: 512  | 60 ,
+        weight: 200 ,
+        linux: {
+            primary: 512  | 1024  | 60 ,
+            secondary: [512  | 60 ]
+        }
+    },
+    menuOpts: [{
+            menuId: MenuId.CommandPalette,
+            group: '',
+            title: ( localize('editor.action.accessibleView', "Open Accessible View")),
+            order: 1
+        }],
+})));
+class AccessibleViewDisableHintAction extends Action2 {
+    constructor() {
+        super({
+            id: "editor.action.accessibleViewDisableHint" ,
+            precondition: ( ContextKeyExpr.and(( ContextKeyExpr.or(accessibleViewIsShown, accessibilityHelpIsShown)), accessibleViewVerbosityEnabled)),
+            keybinding: {
+                primary: 512  | 64 ,
+                weight: 200
+            },
+            icon: Codicon.bellSlash,
+            menu: [
+                commandPalette,
+                {
+                    id: MenuId.AccessibleView,
+                    group: 'navigation',
+                    when: ( ContextKeyExpr.and(( ContextKeyExpr.or(accessibleViewIsShown, accessibilityHelpIsShown)), accessibleViewVerbosityEnabled)),
+                }
+            ],
+            title: ( localize('editor.action.accessibleViewDisableHint', "Disable Accessible View Hint"))
+        });
+    }
+    run(accessor) {
+        accessor.get(IAccessibleViewService).disableHint();
+    }
+}
+registerAction2(AccessibleViewDisableHintAction);
+class AccessibleViewAcceptInlineCompletionAction extends Action2 {
+    constructor() {
+        super({
+            id: "editor.action.accessibleViewAcceptInlineCompletion" ,
+            precondition: ( ContextKeyExpr.and(accessibleViewIsShown, ( ContextKeyExpr.equals(
+                accessibleViewCurrentProviderId.key,
+                "inlineCompletions"
+            )))),
+            keybinding: {
+                primary: 2048  | 90 ,
+                mac: { primary: 256  | 90  },
+                weight: 200
+            },
+            icon: Codicon.check,
+            menu: [
+                commandPalette,
+                {
+                    id: MenuId.AccessibleView,
+                    group: 'navigation',
+                    order: 0,
+                    when: ( ContextKeyExpr.and(accessibleViewIsShown, ( ContextKeyExpr.equals(
+                        accessibleViewCurrentProviderId.key,
+                        "inlineCompletions"
+                    ))))
+                }
+            ],
+            title: ( localize(
+                'editor.action.accessibleViewAcceptInlineCompletionAction',
+                "Accept Inline Completion"
+            ))
+        });
+    }
+    async run(accessor) {
+        const codeEditorService = accessor.get(ICodeEditorService);
+        const editor = codeEditorService.getActiveCodeEditor() || codeEditorService.getFocusedCodeEditor();
+        if (!editor) {
+            return;
+        }
+        const model = InlineCompletionsController.get(editor)?.model.get();
+        const state = model?.state.get();
+        if (!model || !state) {
+            return;
+        }
+        await model.accept(editor);
+        alert('Accepted');
+        model.stop();
+        editor.focus();
+    }
+}
+registerAction2(AccessibleViewAcceptInlineCompletionAction);
+export { AccessibilityHelpAction, AccessibleViewAction };

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

@@ -0,0 +1,63 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { clamp } from 'monaco-editor/esm/vs/base/common/numbers.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+let UnfocusedViewDimmingContribution = class UnfocusedViewDimmingContribution extends Disposable {
+    constructor(configurationService) {
+        super();
+        this._register(toDisposable(() => this._removeStyleElement()));
+        this._register(Event.runAndSubscribe(configurationService.onDidChangeConfiguration, e => {
+            if (e && !e.affectsConfiguration("accessibility.dimUnfocused.enabled" ) && !e.affectsConfiguration("accessibility.dimUnfocused.opacity" )) {
+                return;
+            }
+            let cssTextContent = '';
+            const enabled = ensureBoolean(configurationService.getValue("accessibility.dimUnfocused.enabled" ), false);
+            if (enabled) {
+                const opacity = clamp(ensureNumber(configurationService.getValue("accessibility.dimUnfocused.opacity" ), 0.75 ), 0.2 , 1 );
+                if (opacity !== 1) {
+                    const rules = ( new Set());
+                    const filterRule = `filter: opacity(${opacity});`;
+                    rules.add(`.monaco-workbench .pane-body.integrated-terminal:not(:focus-within) .tabs-container { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .pane-body.integrated-terminal .terminal-wrapper:not(:focus-within) { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .monaco-editor { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .tabs-breadcrumbs { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .terminal-wrapper { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .settings-editor { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .keybindings-editor { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .monaco-editor-pane-placeholder { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .gettingStartedContainer { ${filterRule} }`);
+                    cssTextContent = [...rules].join('\n');
+                }
+            }
+            if (cssTextContent.length === 0) {
+                this._removeStyleElement();
+            }
+            else {
+                this._getStyleElement().textContent = cssTextContent;
+            }
+        }));
+    }
+    _getStyleElement() {
+        if (!this._styleElement) {
+            this._styleElement = document.createElement('style');
+            this._styleElement.className = 'accessibilityUnfocusedViewOpacity';
+            document.head.appendChild(this._styleElement);
+        }
+        return this._styleElement;
+    }
+    _removeStyleElement() {
+        this._styleElement?.remove();
+        this._styleElement = undefined;
+    }
+};
+UnfocusedViewDimmingContribution = ( __decorate([
+    ( __param(0, IConfigurationService))
+], UnfocusedViewDimmingContribution));
+function ensureBoolean(value, defaultValue) {
+    return typeof value === 'boolean' ? value : defaultValue;
+}
+function ensureNumber(value, defaultValue) {
+    return typeof value === 'number' ? value : defaultValue;
+}
+export { UnfocusedViewDimmingContribution };

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

@@ -26,7 +26,7 @@ let AudioCueLineDebuggerContribution = class AudioCueLineDebuggerContribution ex
                 .getModel()
                 .getSessions()
                 .forEach((session) => sessionDisposables.set(session, this.handleSession(session)));
-        }, 'subscribe to debug sessions'));
+        }));
     }
     handleSession(session) {
         return session.onDidChangeState(e => {

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

@@ -1,16 +1,16 @@
 import { __decorate, __param } from '../../../../../../../external/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 { CachedFunction } from 'monaco-editor/esm/vs/base/common/cache.js';
 import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { observableFromEvent, derived, autorun, debouncedObservable, wasEventTriggeredRecently, autorunDelta, constObservable, observableFromPromise, derivedOpts } from 'monaco-editor/esm/vs/base/common/observable.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';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { MarkerSeverity, IMarkerService } from 'monaco-editor/esm/vs/platform/markers/common/markers.js';
+import { IDebugService } from '../../debug/common/debug.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
 let AudioCueLineFeatureContribution = class AudioCueLineFeatureContribution extends Disposable {
     constructor(editorService, instantiationService, audioCueService, _configurationService) {
         super();
@@ -28,7 +28,7 @@ let AudioCueLineFeatureContribution = class AudioCueLineFeatureContribution exte
         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 someAudioCueFeatureIsEnabled = derived((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)
@@ -38,7 +38,7 @@ let AudioCueLineFeatureContribution = class AudioCueLineFeatureContribution exte
                     : undefined;
             return editor && editor.hasModel() ? { editor, model: editor.getModel() } : undefined;
         });
-        this._register(autorun('updateAudioCuesEnabled', (reader) => {
+        this._register(autorun(reader => {
             this.store.clear();
             if (!someAudioCueFeatureIsEnabled.read(reader)) {
                 return;
@@ -62,7 +62,7 @@ let AudioCueLineFeatureContribution = class AudioCueLineFeatureContribution exte
         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) => {
+            const isFeaturePresent = derivedOpts({ debugName: `isPresentInLine:${feature.audioCue.name}` }, (reader) => {
                 if (!this.isEnabledCache.get(feature.audioCue).read(reader)) {
                     return false;
                 }
@@ -72,18 +72,18 @@ let AudioCueLineFeatureContribution = class AudioCueLineFeatureContribution exte
                 }
                 return lineFeatureState.read(reader).isPresent(position);
             });
-            return derived(`typingDebouncedFeatureState:\n${feature.audioCue.name}`, (reader) => feature.debounceWhileTyping && isTyping.read(reader)
+            return derivedOpts({ debugName: `typingDebouncedFeatureState:\n${feature.audioCue.name}` }, (reader) => feature.debounceWhileTyping && isTyping.read(reader)
                 ? (debouncedPosition.read(reader), isFeaturePresent.get())
                 : isFeaturePresent.read(reader));
         }));
-        const state = derived('states', (reader) => ({
+        const state = derived((reader) =>  ({
             lineNumber: debouncedPosition.read(reader),
             featureStates: ( new Map(( this.features.map((feature, idx) => [
                 feature,
                 featureStates[idx].read(reader),
             ])))),
         }));
-        store.add(autorunDelta('Play Audio Cue', state, ({ lastValue, newValue }) => {
+        store.add(autorunDelta(state, ({ lastValue, newValue }) => {
             const newFeatures = this.features.filter(feature => newValue?.featureStates.get(feature) &&
                 (!lastValue?.featureStates?.get(feature) || newValue.lineNumber !== lastValue.lineNumber));
             this.audioCueService.playAudioCues(( newFeatures.map(f => f.audioCue)));

package/vscode/src/vs/workbench/contrib/bulkEdit/browser/bulkEditService.js

@@ -3,7 +3,7 @@ import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation
 import { toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { LinkedList } from 'monaco-editor/esm/vs/base/common/linkedList.js';
 import { ResourceMap, ResourceSet } from 'monaco-editor/esm/vs/base/common/map.js';
-import { isCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import { isCodeEditor, isDiffEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
 import { ResourceTextEdit, ResourceFileEdit } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
@@ -183,6 +183,9 @@ let BulkEditService = class BulkEditService {
             if (isCodeEditor(candidate)) {
                 codeEditor = candidate;
             }
+            else if (isDiffEditor(candidate)) {
+                codeEditor = candidate.getModifiedEditor();
+            }
         }
         if (codeEditor && codeEditor.getOption(89 )) {
             codeEditor = undefined;

package/vscode/src/vs/workbench/contrib/bulkEdit/browser/bulkFileEdits.js

@@ -8,6 +8,8 @@ import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
 import { tail } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+var RenameOperation_1;
 class Noop {
     constructor() {
         this.uris = [];
@@ -25,7 +27,7 @@ class RenameEdit {
         this.type = 'rename';
     }
 }
-let RenameOperation = class RenameOperation {
+let RenameOperation = RenameOperation_1 = class RenameOperation {
     constructor(_edits, _undoRedoInfo, _workingCopyFileService, _fileService) {
         this._edits = _edits;
         this._undoRedoInfo = _undoRedoInfo;
@@ -55,7 +57,7 @@ let RenameOperation = class RenameOperation {
         }
         await this._workingCopyFileService.move(moves, token, this._undoRedoInfo);
         return (
-             (new RenameOperation(
+             (new RenameOperation_1(
                 undoes,
                 { isUndoing: true },
                 this._workingCopyFileService,
@@ -67,7 +69,7 @@ let RenameOperation = class RenameOperation {
         return `(rename ${( ( this._edits.map(edit => `${edit.oldUri} to ${edit.newUri}`))).join(', ')})`;
     }
 };
-RenameOperation = ( (__decorate([
+RenameOperation = RenameOperation_1 = ( (__decorate([
     ( (__param(2, IWorkingCopyFileService))),
     ( (__param(3, IFileService)))
 ], RenameOperation)));
@@ -152,6 +154,9 @@ let CreateOperation = class CreateOperation {
         const fileCreates = [];
         const undoes = [];
         for (const edit of this._edits) {
+            if (edit.newUri.scheme === Schemas.untitled) {
+                continue;
+            }
             if (edit.options.overwrite === undefined && edit.options.ignoreIfExists && (await this._fileService.exists(edit.newUri))) {
                 continue;
             }

package/vscode/src/vs/workbench/contrib/callHierarchy/browser/callHierarchy.contribution.js

@@ -17,6 +17,7 @@ import { registerAction2, MenuId } from 'monaco-editor/esm/vs/platform/actions/c
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
 import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+var CallHierarchyController_1;
 const _ctxHasCallHierarchyProvider = ( new RawContextKey('editorHasCallHierarchyProvider', false, ( localize(
     'editorHasCallHierarchyProvider',
     'Whether a call hierarchy provider is available'
@@ -36,9 +37,10 @@ function sanitizedDirection(candidate) {
         : "incomingCalls" ;
 }
 let CallHierarchyController = class CallHierarchyController {
+    static { CallHierarchyController_1 = this; }
     static { this.Id = 'callHierarchy'; }
     static get(editor) {
-        return editor.getContribution(CallHierarchyController.Id);
+        return editor.getContribution(CallHierarchyController_1.Id);
     }
     static { this._StorageDirection = 'callHierarchy/defaultDirection'; }
     constructor(_editor, _contextKeyService, _storageService, _editorService, _instantiationService) {
@@ -74,7 +76,7 @@ let CallHierarchyController = class CallHierarchyController {
         }
         const cts = ( new CancellationTokenSource());
         const model = CallHierarchyModel.create(document, position, cts.token);
-        const direction = sanitizedDirection(this._storageService.get(CallHierarchyController._StorageDirection, 0 , "incomingCalls" ));
+        const direction = sanitizedDirection(this._storageService.get(CallHierarchyController_1._StorageDirection, 0 , "incomingCalls" ));
         this._showCallHierarchyWidget(position, direction, model, cts);
     }
     async startCallHierarchyFromCallHierarchy() {
@@ -92,7 +94,7 @@ let CallHierarchyController = class CallHierarchyController {
         }
         const newModel = model.fork(call.item);
         this._sessionDisposables.clear();
-        CallHierarchyController.get(newEditor)?._showCallHierarchyWidget(Range.lift(newModel.root.selectionRange).getStartPosition(), this._widget.direction, Promise.resolve(newModel), ( new CancellationTokenSource()));
+        CallHierarchyController_1.get(newEditor)?._showCallHierarchyWidget(Range.lift(newModel.root.selectionRange).getStartPosition(), this._widget.direction, Promise.resolve(newModel), ( new CancellationTokenSource()));
     }
     _showCallHierarchyWidget(position, direction, model, cts) {
         this._ctxIsVisible.set(true);
@@ -102,7 +104,7 @@ let CallHierarchyController = class CallHierarchyController {
         this._widget.showLoading();
         this._sessionDisposables.add(this._widget.onDidClose(() => {
             this.endCallHierarchy();
-            this._storageService.store(CallHierarchyController._StorageDirection, this._widget.direction, 0 , 0 );
+            this._storageService.store(CallHierarchyController_1._StorageDirection, this._widget.direction, 0 , 0 );
         }));
         this._sessionDisposables.add({ dispose() { cts.dispose(true); } });
         this._sessionDisposables.add(this._widget);
@@ -139,14 +141,14 @@ let CallHierarchyController = class CallHierarchyController {
         this._editor.focus();
     }
 };
-CallHierarchyController = ( __decorate([
+CallHierarchyController = CallHierarchyController_1 = ( __decorate([
     ( __param(1, IContextKeyService)),
     ( __param(2, IStorageService)),
     ( __param(3, ICodeEditorService)),
     ( __param(4, IInstantiationService))
 ], CallHierarchyController));
 registerEditorContribution(CallHierarchyController.Id, CallHierarchyController, 0 );
-registerAction2(class extends EditorAction2 {
+registerAction2(class PeekCallHierarchyAction extends EditorAction2 {
     constructor() {
         super({
             id: 'editor.showCallHierarchy',
@@ -162,7 +164,8 @@ registerAction2(class extends EditorAction2 {
                 weight: 200 ,
                 primary: 1024  + 512  + 38
             },
-            precondition: ( ContextKeyExpr.and(_ctxHasCallHierarchyProvider, PeekContext.notInPeekEditor))
+            precondition: ( ContextKeyExpr.and(_ctxHasCallHierarchyProvider, PeekContext.notInPeekEditor)),
+            f1: true
         });
     }
     async runEditorCommand(_accessor, editor) {

package/vscode/src/vs/workbench/contrib/callHierarchy/browser/callHierarchyPeek.js

@@ -21,6 +21,7 @@ import { TreeMouseEventTarget } from 'monaco-editor/esm/vs/base/browser/ui/tree/
 import { MenuId, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { createAndFillInActionBarActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+var CallHierarchyTreePeekWidget_1;
 class LayoutInfo {
     static store(info, storageService) {
         storageService.store('callHierarchyPeekLayout', JSON.stringify(info), 0 , 1 );
@@ -43,6 +44,7 @@ class LayoutInfo {
 class CallHierarchyTree extends WorkbenchAsyncDataTree {
 }
 let CallHierarchyTreePeekWidget = class CallHierarchyTreePeekWidget extends peekView.PeekViewWidget {
+    static { CallHierarchyTreePeekWidget_1 = this; }
     static { this.TitleMenu = ( new MenuId('callhierarchy/title')); }
     constructor(editor, _where, _direction, themeService, _peekViewService, _editorService, _textModelService, _storageService, _menuService, _contextKeyService, _instantiationService) {
         super(editor, { showFrame: true, showArrow: true, isResizeable: true, isAccessible: true }, _instantiationService);
@@ -85,7 +87,7 @@ let CallHierarchyTreePeekWidget = class CallHierarchyTreePeekWidget extends peek
     }
     _fillHead(container) {
         super._fillHead(container, true);
-        const menu = this._menuService.createMenu(CallHierarchyTreePeekWidget.TitleMenu, this._contextKeyService);
+        const menu = this._menuService.createMenu(CallHierarchyTreePeekWidget_1.TitleMenu, this._contextKeyService);
         const updateToolbar = () => {
             const actions = [];
             createAndFillInActionBarActions(menu, undefined, actions);
@@ -324,7 +326,7 @@ let CallHierarchyTreePeekWidget = class CallHierarchyTreePeekWidget extends peek
         }
     }
 };
-CallHierarchyTreePeekWidget = ( __decorate([
+CallHierarchyTreePeekWidget = CallHierarchyTreePeekWidget_1 = ( __decorate([
     ( __param(3, IThemeService)),
     ( __param(4, peekView.IPeekViewService)),
     ( __param(5, IEditorService)),

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatQuickInputActions.js

@@ -0,0 +1,2 @@
+const ASK_QUICK_QUESTION_ACTION_ID = 'workbench.action.quickchat.toggle';
+export { ASK_QUICK_QUESTION_ACTION_ID };

package/vscode/src/vs/workbench/contrib/chat/browser/chat.js

@@ -1,3 +1,4 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 const IChatWidgetService = ( createDecorator('chatWidgetService'));
-export { IChatWidgetService };
+const IQuickChatService = ( createDecorator('quickChatService'));
+export { IChatWidgetService, IQuickChatService };