@codingame/monaco-vscode-api 5.3.0 → 6.0.0

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

@@ -31,7 +31,7 @@ else {
     product = { };
     if (( Object.keys(product)).length === 0) {
         Object.assign(product, {
-            version: '1.87.0-dev',
+            version: '1.90.0-dev',
             nameShort: 'Code - OSS Dev',
             nameLong: 'Code - OSS Dev',
             applicationName: 'code-oss',

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

@@ -3,6 +3,15 @@ import { DeferredPromise } from '../../../base/common/async.js';
 import { CancellationTokenSource } from '../../../base/common/cancellation.js';
 import { Disposable, DisposableStore, toDisposable } from '../../../base/common/lifecycle.js';
 import { IProgressService } from './progress.service.js';
+var ProgressLocation;
+( (function(ProgressLocation) {
+    ProgressLocation[ProgressLocation["Explorer"] = 1] = "Explorer";
+    ProgressLocation[ProgressLocation["Scm"] = 3] = "Scm";
+    ProgressLocation[ProgressLocation["Extensions"] = 5] = "Extensions";
+    ProgressLocation[ProgressLocation["Window"] = 10] = "Window";
+    ProgressLocation[ProgressLocation["Notification"] = 15] = "Notification";
+    ProgressLocation[ProgressLocation["Dialog"] = 20] = "Dialog";
+})(ProgressLocation || (ProgressLocation = {})));
 const emptyProgressRunner = ( Object.freeze({
     total() { },
     worked() { },
@@ -19,52 +28,6 @@ class Progress {
         this.callback(this._value);
     }
 }
-class AsyncProgress {
-    get value() { return this._value; }
-    constructor(callback) {
-        this.callback = callback;
-    }
-    report(item) {
-        if (!this._asyncQueue) {
-            this._asyncQueue = [item];
-        }
-        else {
-            this._asyncQueue.push(item);
-        }
-        this._processAsyncQueue();
-    }
-    async _processAsyncQueue() {
-        if (this._processingAsyncQueue) {
-            return;
-        }
-        try {
-            this._processingAsyncQueue = true;
-            while (this._asyncQueue && this._asyncQueue.length) {
-                const item = this._asyncQueue.shift();
-                this._value = item;
-                await this.callback(this._value);
-            }
-        }
-        finally {
-            this._processingAsyncQueue = false;
-            const drainListener = this._drainListener;
-            this._drainListener = undefined;
-            drainListener?.();
-        }
-    }
-    drain() {
-        if (this._processingAsyncQueue) {
-            return ( new Promise(resolve => {
-                const prevListener = this._drainListener;
-                this._drainListener = () => {
-                    prevListener?.();
-                    resolve();
-                };
-            }));
-        }
-        return Promise.resolve();
-    }
-}
 let UnmanagedProgress = class UnmanagedProgress extends Disposable {
     constructor(options, progressService) {
         super();
@@ -125,4 +88,4 @@ class LongRunningOperation extends Disposable {
         }
     }
 }
-export { AsyncProgress, LongRunningOperation, Progress, UnmanagedProgress, emptyProgressRunner };
+export { LongRunningOperation, Progress, ProgressLocation, UnmanagedProgress, emptyProgressRunner };

package/vscode/src/vs/platform/quickinput/browser/pickerQuickAccess.js

@@ -163,6 +163,13 @@ class PickerQuickAccessProvider extends Disposable {
         disposables.add(picker.onDidChangeValue(() => updatePickerItems()));
         updatePickerItems();
         disposables.add(picker.onDidAccept(event => {
+            if (runOptions?.handleAccept) {
+                if (!event.inBackground) {
+                    picker.hide();
+                }
+                runOptions.handleAccept?.(picker.activeItems[0]);
+                return;
+            }
             const [item] = picker.selectedItems;
             if (typeof item?.accept === 'function') {
                 if (!event.inBackground) {

package/vscode/src/vs/platform/quickinput/browser/quickAccess.js

@@ -25,7 +25,7 @@ let QuickAccessController = class QuickAccessController extends Disposable {
         this.doShowOrPick(value, false, options);
     }
     doShowOrPick(value, pick, options) {
-        const [provider, descriptor] = this.getOrInstantiateProvider(value);
+        const [provider, descriptor] = this.getOrInstantiateProvider(value, options?.enabledProviderPrefixes);
         const visibleQuickAccess = this.visibleQuickAccess;
         const visibleDescriptor = visibleQuickAccess?.descriptor;
         if (visibleQuickAccess && descriptor && visibleDescriptor === descriptor) {
@@ -62,7 +62,7 @@ let QuickAccessController = class QuickAccessController extends Disposable {
         const picker = disposables.add(this.quickInputService.createQuickPick());
         picker.value = value;
         this.adjustValueSelection(picker, descriptor, options);
-        picker.placeholder = descriptor?.placeholder;
+        picker.placeholder = options?.placeholder ?? descriptor?.placeholder;
         picker.quickNavigate = options?.quickNavigateConfiguration;
         picker.hideInput = !!picker.quickNavigate && !visibleQuickAccess;
         if (typeof options?.itemActivation === 'number' || options?.quickNavigateConfiguration) {
@@ -78,7 +78,7 @@ let QuickAccessController = class QuickAccessController extends Disposable {
                 picker.hide();
             }));
         }
-        disposables.add(this.registerPickerListeners(picker, provider, descriptor, value, options?.providerOptions));
+        disposables.add(this.registerPickerListeners(picker, provider, descriptor, value, options));
         const cts = disposables.add(( new CancellationTokenSource()));
         if (provider) {
             disposables.add(provider.provide(picker, cts.token, options?.providerOptions));
@@ -108,7 +108,7 @@ let QuickAccessController = class QuickAccessController extends Disposable {
         }
         picker.valueSelection = valueSelection;
     }
-    registerPickerListeners(picker, provider, descriptor, value, providerOptions) {
+    registerPickerListeners(picker, provider, descriptor, value, options) {
         const disposables = ( new DisposableStore());
         const visibleQuickAccess = this.visibleQuickAccess = { picker, descriptor, value };
         disposables.add(toDisposable(() => {
@@ -117,11 +117,12 @@ let QuickAccessController = class QuickAccessController extends Disposable {
             }
         }));
         disposables.add(picker.onDidChangeValue(value => {
-            const [providerForValue] = this.getOrInstantiateProvider(value);
+            const [providerForValue] = this.getOrInstantiateProvider(value, options?.enabledProviderPrefixes);
             if (providerForValue !== provider) {
                 this.show(value, {
+                    enabledProviderPrefixes: options?.enabledProviderPrefixes,
                     preserveValue: true,
-                    providerOptions
+                    providerOptions: options?.providerOptions
                 });
             }
             else {
@@ -135,9 +136,9 @@ let QuickAccessController = class QuickAccessController extends Disposable {
         }
         return disposables;
     }
-    getOrInstantiateProvider(value) {
+    getOrInstantiateProvider(value, enabledProviderPrefixes) {
         const providerDescriptor = this.registry.getQuickAccessProvider(value);
-        if (!providerDescriptor) {
+        if (!providerDescriptor || enabledProviderPrefixes && !enabledProviderPrefixes?.includes(providerDescriptor.prefix)) {
             return [undefined, undefined];
         }
         let provider = this.mapProviderToDescriptor.get(providerDescriptor);

package/vscode/src/vs/platform/quickinput/browser/quickInput.js

@@ -1,31 +1,44 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { reset, EventHelper, isMouseEvent, addDisposableListener, EventType } from '../../../base/browser/dom.js';
+import { isHTMLElement, reset, isMouseEvent, addDisposableListener, EventType } from '../../../base/browser/dom.js';
 import { StandardKeyboardEvent } from '../../../base/browser/keyboardEvent.js';
 import { Toggle } from '../../../base/browser/ui/toggle/toggle.js';
 import { equals } from '../../../base/common/arrays.js';
 import { TimeoutTimer } from '../../../base/common/async.js';
 import { Codicon } from '../../../base/common/codicons.js';
-import { Emitter } from '../../../base/common/event.js';
+import { Emitter, EventBufferer } from '../../../base/common/event.js';
+import { KeyCode } from '../../../base/common/keyCodes.js';
 import { Disposable, DisposableStore } from '../../../base/common/lifecycle.js';
-import { isIOS, isMacintosh } from '../../../base/common/platform.js';
+import { isIOS } from '../../../base/common/platform.js';
 import Severity$1 from '../../../base/common/severity.js';
 import { ThemeIcon } from '../../../base/common/themables.js';
 import './media/quickInput.css.js';
 import { localizeWithPath } from '../../../nls.js';
-import { QuickInputHideReason, ItemActivation, NO_KEY_MODS } from '../common/quickInput.js';
+import { QuickInputHideReason, ItemActivation, QuickInputType, NO_KEY_MODS, QuickPickFocus } from '../common/quickInput.js';
 import { renderQuickInputDescription, quickInputButtonToAction } from './quickInputUtils.js';
 import { IConfigurationService } from '../../configuration/common/configuration.service.js';
 import { WorkbenchHoverDelegate } from '../../hover/browser/hover.js';
 import { IHoverService } from '../../hover/browser/hover.service.js';
-import { QuickInputListFocus } from './quickInputTree.js';
+import { RawContextKey, ContextKeyExpr } from '../../contextkey/common/contextkey.js';
 const _moduleId = "vs/platform/quickinput/browser/quickInput";
+const inQuickInputContextKeyValue = 'inQuickInput';
+const InQuickInputContextKey = ( (new RawContextKey(inQuickInputContextKeyValue, false, ( localizeWithPath(_moduleId, 0, "Whether keyboard focus is inside the quick input control")))));
+const inQuickInputContext = ( (ContextKeyExpr.has(inQuickInputContextKeyValue)));
+const quickInputTypeContextKeyValue = 'quickInputType';
+const QuickInputTypeContextKey = ( (new RawContextKey(quickInputTypeContextKeyValue, undefined, ( localizeWithPath(_moduleId, 1, "The type of the currently visible quick input")))));
+const endOfQuickInputBoxContextKeyValue = 'cursorAtEndOfQuickInputBox';
+const EndOfQuickInputBoxContextKey = ( (new RawContextKey(endOfQuickInputBoxContextKeyValue, false, ( localizeWithPath(
+    _moduleId,
+    2,
+    "Whether the cursor in the quick input is at the end of the input box"
+)))));
+const endOfQuickInputBoxContext = ( (ContextKeyExpr.has(endOfQuickInputBoxContextKeyValue)));
 const backButton = {
     iconClass: ThemeIcon.asClassName(Codicon.quickInputBack),
-    tooltip: ( localizeWithPath(_moduleId, 0, "Back")),
+    tooltip: ( localizeWithPath(_moduleId, 3, "Back")),
     handle: -1
 };
 class QuickInput extends Disposable {
-    static { this.noPromptMessage = ( localizeWithPath(_moduleId, 1, "Press 'Enter' to confirm your input or 'Escape' to cancel")); }
+    static { this.noPromptMessage = ( localizeWithPath(_moduleId, 4, "Press 'Enter' to confirm your input or 'Escape' to cancel")); }
     constructor(ui) {
         super();
         this.ui = ui;
@@ -68,7 +81,7 @@ class QuickInput extends Disposable {
         return this._widget;
     }
     set widget(widget) {
-        if (!(widget instanceof HTMLElement)) {
+        if (!(isHTMLElement(widget))) {
             return;
         }
         if (this._widget !== widget) {
@@ -285,7 +298,7 @@ class QuickInput extends Disposable {
     }
     getSteps() {
         if (this.step && this.totalSteps) {
-            return ( localizeWithPath(_moduleId, 2, "{0}/{1}", this.step, this.totalSteps));
+            return ( localizeWithPath(_moduleId, 5, "{0}/{1}", this.step, this.totalSteps));
         }
         if (this.step) {
             return String(this.step);
@@ -346,6 +359,8 @@ class QuickPick extends QuickInput {
         this.valueSelectionUpdated = true;
         this._ok = 'default';
         this._customButton = false;
+        this._focusEventBufferer = ( (new EventBufferer()));
+        this.type = QuickInputType.QuickPick;
         this.filterValue = (value) => value;
         this.onDidChangeValue = this.onDidChangeValueEmitter.event;
         this.onWillAccept = this.onWillAcceptEmitter.event;
@@ -356,7 +371,7 @@ class QuickPick extends QuickInput {
         this.onDidTriggerItemButton = this.onDidTriggerItemButtonEmitter.event;
         this.onDidTriggerSeparatorButton = this.onDidTriggerSeparatorButtonEmitter.event;
     }
-    static { this.DEFAULT_ARIA_LABEL = ( localizeWithPath(_moduleId, 3, "Type to narrow down results.")); }
+    static { this.DEFAULT_ARIA_LABEL = ( localizeWithPath(_moduleId, 6, "Type to narrow down results.")); }
     get quickNavigate() {
         return this._quickNavigate;
     }
@@ -564,7 +579,7 @@ class QuickPick extends QuickInput {
     }
     trySelectFirst() {
         if (!this.canSelectMany) {
-            this.ui.list.focus(QuickInputListFocus.First);
+            this.ui.list.focus(QuickPickFocus.First);
         }
     }
     show() {
@@ -572,73 +587,6 @@ class QuickPick extends QuickInput {
             this.visibleDisposables.add(this.ui.inputBox.onDidChange(value => {
                 this.doSetValue(value, true );
             }));
-            this.visibleDisposables.add((this._hideInput ? this.ui.list : this.ui.inputBox).onKeyDown((event) => {
-                switch (event.keyCode) {
-                    case 18 :
-                        if (this.quickNavigate === undefined && (isMacintosh ? event.metaKey : event.altKey)) {
-                            this.ui.list.focus(QuickInputListFocus.NextSeparator);
-                        }
-                        else {
-                            this.ui.list.focus(QuickInputListFocus.Next);
-                        }
-                        if (this.canSelectMany) {
-                            this.ui.list.domFocus();
-                        }
-                        EventHelper.stop(event, true);
-                        break;
-                    case 16 :
-                        if (this.quickNavigate === undefined && (isMacintosh ? event.metaKey : event.altKey)) {
-                            this.ui.list.focus(QuickInputListFocus.PreviousSeparator);
-                        }
-                        else {
-                            this.ui.list.focus(QuickInputListFocus.Previous);
-                        }
-                        if (this.canSelectMany) {
-                            this.ui.list.domFocus();
-                        }
-                        EventHelper.stop(event, true);
-                        break;
-                    case 12 :
-                        this.ui.list.focus(QuickInputListFocus.NextPage);
-                        if (this.canSelectMany) {
-                            this.ui.list.domFocus();
-                        }
-                        EventHelper.stop(event, true);
-                        break;
-                    case 11 :
-                        this.ui.list.focus(QuickInputListFocus.PreviousPage);
-                        if (this.canSelectMany) {
-                            this.ui.list.domFocus();
-                        }
-                        EventHelper.stop(event, true);
-                        break;
-                    case 17 :
-                        if (!this._canAcceptInBackground) {
-                            return;
-                        }
-                        if (!this.ui.inputBox.isSelectionAtEnd()) {
-                            return;
-                        }
-                        if (this.activeItems[0]) {
-                            this._selectedItems = [this.activeItems[0]];
-                            this.onDidChangeSelectionEmitter.fire(this.selectedItems);
-                            this.handleAccept(true);
-                        }
-                        break;
-                    case 14 :
-                        if ((event.ctrlKey || event.metaKey) && !event.shiftKey && !event.altKey) {
-                            this.ui.list.focus(QuickInputListFocus.First);
-                            EventHelper.stop(event, true);
-                        }
-                        break;
-                    case 13 :
-                        if ((event.ctrlKey || event.metaKey) && !event.shiftKey && !event.altKey) {
-                            this.ui.list.focus(QuickInputListFocus.Last);
-                            EventHelper.stop(event, true);
-                        }
-                        break;
-                }
-            }));
             this.visibleDisposables.add(this.ui.onDidAccept(() => {
                 if (this.canSelectMany) {
                     if (!this.ui.list.getCheckedElements().length) {
@@ -655,7 +603,8 @@ class QuickPick extends QuickInput {
             this.visibleDisposables.add(this.ui.onDidCustom(() => {
                 this.onDidCustomEmitter.fire();
             }));
-            this.visibleDisposables.add(this.ui.list.onDidChangeFocus(focusedItems => {
+            this.visibleDisposables.add(this._focusEventBufferer.wrapEvent(this.ui.list.onDidChangeFocus,
+            (_, e) => e)(focusedItems => {
                 if (this.activeItemsUpdated) {
                     return;
                 }
@@ -718,19 +667,19 @@ class QuickPick extends QuickInput {
                 if (chords.length > 1) {
                     return false;
                 }
-                if (chords[0].shiftKey && keyCode === 4 ) {
+                if (chords[0].shiftKey && keyCode === KeyCode.Shift) {
                     if (keyboardEvent.ctrlKey || keyboardEvent.altKey || keyboardEvent.metaKey) {
                         return false;
                     }
                     return true;
                 }
-                if (chords[0].altKey && keyCode === 6 ) {
+                if (chords[0].altKey && keyCode === KeyCode.Alt) {
                     return true;
                 }
-                if (chords[0].ctrlKey && keyCode === 5 ) {
+                if (chords[0].ctrlKey && keyCode === KeyCode.Ctrl) {
                     return true;
                 }
-                if (chords[0].metaKey && keyCode === 57 ) {
+                if (chords[0].metaKey && keyCode === KeyCode.Meta) {
                     return true;
                 }
                 return false;
@@ -794,32 +743,30 @@ class QuickPick extends QuickInput {
         this.ui.list.sortByLabel = this.sortByLabel;
         if (this.itemsUpdated) {
             this.itemsUpdated = false;
-            const currentActiveItems = this._activeItems;
-            this.ui.list.setElements(this.items);
-            this.ui.list.filter(this.filterValue(this.ui.inputBox.value));
-            this.ui.checkAll.checked = this.ui.list.getAllVisibleChecked();
-            this.ui.visibleCount.setCount(this.ui.list.getVisibleCount());
-            this.ui.count.setCount(this.ui.list.getCheckedCount());
-            switch (this._itemActivation) {
-                case ItemActivation.NONE:
-                    if (currentActiveItems.length > 0) {
-                        this._activeItems = [];
-                        this.onDidChangeActiveEmitter.fire(this._activeItems);
-                    }
-                    this._itemActivation = ItemActivation.FIRST;
-                    break;
-                case ItemActivation.SECOND:
-                    this.ui.list.focus(QuickInputListFocus.Second);
-                    this._itemActivation = ItemActivation.FIRST;
-                    break;
-                case ItemActivation.LAST:
-                    this.ui.list.focus(QuickInputListFocus.Last);
-                    this._itemActivation = ItemActivation.FIRST;
-                    break;
-                default:
-                    this.trySelectFirst();
-                    break;
-            }
+            this._focusEventBufferer.bufferEvents(() => {
+                this.ui.list.setElements(this.items);
+                this.ui.list.shouldLoop = !this.canSelectMany;
+                this.ui.list.filter(this.filterValue(this.ui.inputBox.value));
+                this.ui.checkAll.checked = this.ui.list.getAllVisibleChecked();
+                this.ui.visibleCount.setCount(this.ui.list.getVisibleCount());
+                this.ui.count.setCount(this.ui.list.getCheckedCount());
+                switch (this._itemActivation) {
+                    case ItemActivation.NONE:
+                        this._itemActivation = ItemActivation.FIRST;
+                        break;
+                    case ItemActivation.SECOND:
+                        this.ui.list.focus(QuickPickFocus.Second);
+                        this._itemActivation = ItemActivation.FIRST;
+                        break;
+                    case ItemActivation.LAST:
+                        this.ui.list.focus(QuickPickFocus.Last);
+                        this._itemActivation = ItemActivation.FIRST;
+                        break;
+                    default:
+                        this.trySelectFirst();
+                        break;
+                }
+            });
         }
         if (this.ui.container.classList.contains('show-checkboxes') !== !!this.canSelectMany) {
             if (this.canSelectMany) {
@@ -855,13 +802,29 @@ class QuickPick extends QuickInput {
         if (!visibilities.inputBox) {
             this.ui.list.domFocus();
             if (this.canSelectMany) {
-                this.ui.list.focus(QuickInputListFocus.First);
+                this.ui.list.focus(QuickPickFocus.First);
             }
         }
         if (this.keepScrollPosition) {
             this.scrollTop = scrollTopBefore;
         }
     }
+    focus(focus) {
+        this.ui.list.focus(focus);
+        if (this.canSelectMany) {
+            this.ui.list.domFocus();
+        }
+    }
+    accept(inBackground) {
+        if (inBackground && !this._canAcceptInBackground) {
+            return;
+        }
+        if (this.activeItems[0]) {
+            this._selectedItems = [this.activeItems[0]];
+            this.onDidChangeSelectionEmitter.fire(this.selectedItems);
+            this.handleAccept(inBackground ?? false);
+        }
+    }
 }
 class InputBox extends QuickInput {
     constructor() {
@@ -871,6 +834,7 @@ class InputBox extends QuickInput {
         this._password = false;
         this.onDidValueChangeEmitter = this._register(( (new Emitter())));
         this.onDidAcceptEmitter = this._register(( (new Emitter())));
+        this.type = QuickInputType.InputBox;
         this.onDidChangeValue = this.onDidValueChangeEmitter.event;
         this.onDidAccept = this.onDidAcceptEmitter.event;
     }
@@ -915,7 +879,7 @@ class InputBox extends QuickInput {
         this.noValidationMessage = prompt
             ? ( localizeWithPath(
             _moduleId,
-            4,
+            7,
             "{0} (Press 'Enter' to confirm or 'Escape' to cancel)",
             prompt
         ))
@@ -966,6 +930,10 @@ class InputBox extends QuickInput {
     }
 }
 class QuickWidget extends QuickInput {
+    constructor() {
+        super(...arguments);
+        this.type = QuickInputType.QuickWidget;
+    }
     update() {
         if (!this.visible) {
             return;
@@ -983,7 +951,7 @@ let QuickInputHoverDelegate = class QuickInputHoverDelegate extends WorkbenchHov
         super('element', false, (options) => this.getOverrideOptions(options), configurationService, hoverService);
     }
     getOverrideOptions(options) {
-        const showHoverHint = (options.content instanceof HTMLElement
+        const showHoverHint = (isHTMLElement(options.content)
             ? options.content.textContent ?? ''
             : typeof options.content === 'string'
                 ? options.content
@@ -1003,4 +971,4 @@ QuickInputHoverDelegate = ( (__decorate([
     ( (__param(0, IConfigurationService))),
     ( (__param(1, IHoverService)))
 ], QuickInputHoverDelegate)));
-export { InputBox, QuickInputHoverDelegate, QuickPick, QuickWidget, backButton };
+export { EndOfQuickInputBoxContextKey, InQuickInputContextKey, InputBox, QuickInputHoverDelegate, QuickInputTypeContextKey, QuickPick, QuickWidget, backButton, endOfQuickInputBoxContext, endOfQuickInputBoxContextKeyValue, inQuickInputContext, inQuickInputContextKeyValue, quickInputTypeContextKeyValue };

package/vscode/src/vs/platform/quickinput/browser/quickInputActions.js

@@ -0,0 +1,145 @@
+import { KeyMod as KeyMod$1, KeyCode } from '../../../base/common/keyCodes.js';
+import { isMacintosh } from '../../../base/common/platform.js';
+import { localizeWithPath } from '../../../nls.js';
+import { ContextKeyExpr } from '../../contextkey/common/contextkey.js';
+import { InputFocusedContext } from '../../contextkey/common/contextkeys.js';
+import { KeybindingsRegistry, KeybindingWeight } from '../../keybinding/common/keybindingsRegistry.js';
+import { endOfQuickInputBoxContext, quickInputTypeContextKeyValue, inQuickInputContext } from './quickInput.js';
+import { QuickInputType, QuickPickFocus } from '../common/quickInput.js';
+import { IQuickInputService } from '../common/quickInput.service.js';
+const _moduleId = "vs/platform/quickinput/browser/quickInputActions";
+const defaultCommandAndKeybindingRule = {
+    weight: KeybindingWeight.WorkbenchContrib,
+    when: ( (ContextKeyExpr.and(
+         (ContextKeyExpr.equals(quickInputTypeContextKeyValue, QuickInputType.QuickPick)),
+        inQuickInputContext
+    ))),
+    metadata: { description: ( localizeWithPath(
+        _moduleId,
+        0,
+        "Used while in the context of the quick pick. If you change one keybinding for this command, you should change all of the other keybindings (modifier variants) of this command as well."
+    )) }
+};
+function registerQuickPickCommandAndKeybindingRule(rule, options = {}) {
+    KeybindingsRegistry.registerCommandAndKeybindingRule({
+        ...defaultCommandAndKeybindingRule,
+        ...rule,
+        secondary: getSecondary(rule.primary, rule.secondary ?? [], options)
+    });
+}
+const ctrlKeyMod = isMacintosh ? KeyMod$1.WinCtrl : KeyMod$1.CtrlCmd;
+function getSecondary(primary, secondary, options = {}) {
+    if (options.withAltMod) {
+        secondary.push(KeyMod$1.Alt + primary);
+    }
+    if (options.withCtrlMod) {
+        secondary.push(ctrlKeyMod + primary);
+        if (options.withAltMod) {
+            secondary.push(KeyMod$1.Alt + ctrlKeyMod + primary);
+        }
+    }
+    if (options.withCmdMod && isMacintosh) {
+        secondary.push(KeyMod$1.CtrlCmd + primary);
+        if (options.withCtrlMod) {
+            secondary.push(KeyMod$1.CtrlCmd + KeyMod$1.WinCtrl + primary);
+        }
+        if (options.withAltMod) {
+            secondary.push(KeyMod$1.CtrlCmd + KeyMod$1.Alt + primary);
+            if (options.withCtrlMod) {
+                secondary.push(KeyMod$1.CtrlCmd + KeyMod$1.Alt + KeyMod$1.WinCtrl + primary);
+            }
+        }
+    }
+    return secondary;
+}
+function focusHandler(focus, focusOnQuickNatigate) {
+    return accessor => {
+        const currentQuickPick = accessor.get(IQuickInputService).currentQuickInput;
+        if (!currentQuickPick) {
+            return;
+        }
+        if (focusOnQuickNatigate && currentQuickPick.quickNavigate) {
+            return currentQuickPick.focus(focusOnQuickNatigate);
+        }
+        return currentQuickPick.focus(focus);
+    };
+}
+registerQuickPickCommandAndKeybindingRule({ id: 'quickInput.pageNext', primary: KeyCode.PageDown, handler: focusHandler(QuickPickFocus.NextPage) }, { withAltMod: true, withCtrlMod: true, withCmdMod: true });
+registerQuickPickCommandAndKeybindingRule({ id: 'quickInput.pagePrevious', primary: KeyCode.PageUp, handler: focusHandler(QuickPickFocus.PreviousPage) }, { withAltMod: true, withCtrlMod: true, withCmdMod: true });
+registerQuickPickCommandAndKeybindingRule({ id: 'quickInput.first', primary: ctrlKeyMod + KeyCode.Home, handler: focusHandler(QuickPickFocus.First) }, { withAltMod: true, withCmdMod: true });
+registerQuickPickCommandAndKeybindingRule({ id: 'quickInput.last', primary: ctrlKeyMod + KeyCode.End, handler: focusHandler(QuickPickFocus.Last) }, { withAltMod: true, withCmdMod: true });
+registerQuickPickCommandAndKeybindingRule({ id: 'quickInput.next', primary: KeyCode.DownArrow, handler: focusHandler(QuickPickFocus.Next) }, { withCtrlMod: true });
+registerQuickPickCommandAndKeybindingRule({ id: 'quickInput.previous', primary: KeyCode.UpArrow, handler: focusHandler(QuickPickFocus.Previous) }, { withCtrlMod: true });
+const nextSeparatorFallbackDesc = ( localizeWithPath(
+    _moduleId,
+    1,
+    "If we're in quick access mode, this will navigate to the next item. If we are not in quick access mode, this will navigate to the next separator."
+));
+const prevSeparatorFallbackDesc = ( localizeWithPath(
+    _moduleId,
+    2,
+    "If we're in quick access mode, this will navigate to the previous item. If we are not in quick access mode, this will navigate to the previous separator."
+));
+if (isMacintosh) {
+    registerQuickPickCommandAndKeybindingRule({
+        id: 'quickInput.nextSeparatorWithQuickAccessFallback',
+        primary: KeyMod$1.CtrlCmd + KeyCode.DownArrow,
+        handler: focusHandler(QuickPickFocus.NextSeparator, QuickPickFocus.Next),
+        metadata: { description: nextSeparatorFallbackDesc }
+    });
+    registerQuickPickCommandAndKeybindingRule({
+        id: 'quickInput.nextSeparator',
+        primary: KeyMod$1.CtrlCmd + KeyMod$1.Alt + KeyCode.DownArrow,
+        secondary: [KeyMod$1.CtrlCmd + KeyMod$1.WinCtrl + KeyCode.DownArrow],
+        handler: focusHandler(QuickPickFocus.NextSeparator)
+    }, { withCtrlMod: true });
+    registerQuickPickCommandAndKeybindingRule({
+        id: 'quickInput.previousSeparatorWithQuickAccessFallback',
+        primary: KeyMod$1.CtrlCmd + KeyCode.UpArrow,
+        handler: focusHandler(QuickPickFocus.PreviousSeparator, QuickPickFocus.Previous),
+        metadata: { description: prevSeparatorFallbackDesc }
+    });
+    registerQuickPickCommandAndKeybindingRule({
+        id: 'quickInput.previousSeparator',
+        primary: KeyMod$1.CtrlCmd + KeyMod$1.Alt + KeyCode.UpArrow,
+        secondary: [KeyMod$1.CtrlCmd + KeyMod$1.WinCtrl + KeyCode.UpArrow],
+        handler: focusHandler(QuickPickFocus.PreviousSeparator)
+    }, { withCtrlMod: true });
+}
+else {
+    registerQuickPickCommandAndKeybindingRule({
+        id: 'quickInput.nextSeparatorWithQuickAccessFallback',
+        primary: KeyMod$1.Alt + KeyCode.DownArrow,
+        handler: focusHandler(QuickPickFocus.NextSeparator, QuickPickFocus.Next),
+        metadata: { description: nextSeparatorFallbackDesc }
+    });
+    registerQuickPickCommandAndKeybindingRule({
+        id: 'quickInput.nextSeparator',
+        primary: KeyMod$1.CtrlCmd + KeyMod$1.Alt + KeyCode.DownArrow,
+        handler: focusHandler(QuickPickFocus.NextSeparator)
+    });
+    registerQuickPickCommandAndKeybindingRule({
+        id: 'quickInput.previousSeparatorWithQuickAccessFallback',
+        primary: KeyMod$1.Alt + KeyCode.UpArrow,
+        handler: focusHandler(QuickPickFocus.PreviousSeparator, QuickPickFocus.Previous),
+        metadata: { description: prevSeparatorFallbackDesc }
+    });
+    registerQuickPickCommandAndKeybindingRule({
+        id: 'quickInput.previousSeparator',
+        primary: KeyMod$1.CtrlCmd + KeyMod$1.Alt + KeyCode.UpArrow,
+        handler: focusHandler(QuickPickFocus.PreviousSeparator)
+    });
+}
+registerQuickPickCommandAndKeybindingRule({
+    id: 'quickInput.acceptInBackground',
+    when: ( (ContextKeyExpr.and(
+        defaultCommandAndKeybindingRule.when,
+         (ContextKeyExpr.or( (InputFocusedContext.negate()), endOfQuickInputBoxContext))
+    ))),
+    primary: KeyCode.RightArrow,
+    weight: KeybindingWeight.WorkbenchContrib + 50,
+    handler: (accessor) => {
+        const currentQuickPick = accessor.get(IQuickInputService).currentQuickInput;
+        currentQuickPick?.accept(true);
+    },
+}, { withAltMod: true, withCtrlMod: true, withCmdMod: true });

package/vscode/src/vs/platform/quickinput/browser/quickInputBox.js

@@ -1,5 +1,6 @@
 import { addStandardDisposableListener, EventType, append, $ as $$1 } from '../../../base/browser/dom.js';
 import { FindInput } from '../../../base/browser/ui/findinput/findInput.js';
+import { MessageType } from '../../../base/browser/ui/inputbox/inputBox.js';
 import { Disposable } from '../../../base/common/lifecycle.js';
 import Severity$1 from '../../../base/common/severity.js';
 import './media/quickInput.css.js';
@@ -75,11 +76,11 @@ class QuickInputBox extends Disposable {
             this.findInput.clearMessage();
         }
         else {
-            this.findInput.showMessage({ type: decoration === Severity$1.Info ? 1  : decoration === Severity$1.Warning ? 2  : 3 , content: '' });
+            this.findInput.showMessage({ type: decoration === Severity$1.Info ? MessageType.INFO : decoration === Severity$1.Warning ? MessageType.WARNING : MessageType.ERROR, content: '' });
         }
     }
     stylesForType(decoration) {
-        return this.findInput.inputBox.stylesForType(decoration === Severity$1.Info ? 1  : decoration === Severity$1.Warning ? 2  : 3 );
+        return this.findInput.inputBox.stylesForType(decoration === Severity$1.Info ? MessageType.INFO : decoration === Severity$1.Warning ? MessageType.WARNING : MessageType.ERROR);
     }
     setFocus() {
         this.findInput.focus();