@codingame/monaco-vscode-api 1.69.24 → 1.76.0-next.2

package/dist/keybindings.js

@@ -1,17 +1,16 @@
-import { _ as __decorate, a as __param, E as Emitter } from './workspace.js';
-import { i as index, a as flatten, b as parse, g as getNodeType } from './polyfill.js';
-import { i as isProposedApiEnabled, c as IKeyboardLayoutService, d as IExtensionService, e as IPreferencesService, g as getKeyboardLayoutId, f as IUserDataProfileService, M as MacLinuxFallbackKeyboardMapper } from './missing-services.js';
+import { _ as __decorate, a as __param, E as Emitter } from './contextkey.js';
+import { i as index, f as flatten, p as parse, g as getNodeType } from './polyfill.js';
+import { i as isProposedApiEnabled, b as IKeyboardLayoutService, c as IExtensionService, d as IPreferencesService, g as getKeyboardLayoutId, e as IUserDataProfileService, F as FallbackKeyboardMapper } from './missing-services.js';
+import { KeyCodeChord, ScanCodeChord, Keybinding } from 'monaco-editor/esm/vs/base/common/keybindings.js';
 import { KeyCodeUtils, IMMUTABLE_CODE_TO_KEY_CODE, NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE, IMMUTABLE_KEY_CODE_TO_CODE } from 'monaco-editor/esm/vs/base/common/keyCodes.js';
-import { SimpleKeybinding, ScanCodeBinding, ChordKeybinding } from 'monaco-editor/esm/vs/base/common/keybindings.js';
 import { g as getExtensionPoint, E as ExtensionsRegistry, a as ExtensionMessageCollector, c as consoleExtensionMessageHandler } from './tools.js';
 import { ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { S as Services, r as IUserDataProfilesService, c as IFileService, b as IEditorService, I as IEditorGroupsService, d as IHostService } from './services2.js';
-import { MenuRegistry, MenuId, MenuItemAction, IMenuService, isIMenuItem } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { S as Services, r as IUserDataProfilesService, c as IFileService, b as IEditorService, I as IEditorGroupsService, h as IProductService, d as IHostService } from './services2.js';
 import { getConfiguredDefaultLocale, localize } from 'monaco-editor/esm/vs/nls.js';
-import { ThemeIcon } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
 import { joinPath, dirname } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
-import { DisposableStore, toDisposable, dispose, Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { MenuId, MenuRegistry, MenuItemAction, Action2, IMenuService, isIMenuItem } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { DisposableStore, Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { isFalsyOrWhitespace } from 'monaco-editor/esm/vs/base/common/strings.js';
 import { EditorExtensionsRegistry } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
 import { ICommandService, CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
@@ -23,19 +22,16 @@ import { BrowserFeatures } from 'monaco-editor/esm/vs/base/browser/canIUse.js';
 import { UserSettingsLabelProvider, UILabelProvider } from 'monaco-editor/esm/vs/base/common/keybindingLabels.js';
 import { OS, isMacintosh, isWindows, isLinux } from 'monaco-editor/esm/vs/base/common/platform.js';
 import { KeybindingResolver } from 'monaco-editor/esm/vs/platform/keybinding/common/keybindingResolver.js';
-import { ResolvedKeybindingItem, removeElementsAfterNulls } from 'monaco-editor/esm/vs/platform/keybinding/common/resolvedKeybindingItem.js';
+import { ResolvedKeybindingItem, toEmptyArrayIfContainsNull } from 'monaco-editor/esm/vs/platform/keybinding/common/resolvedKeybindingItem.js';
 import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
 import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { timeout, RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
 import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { isArray } from 'monaco-editor/esm/vs/base/common/types.js';
 import { equals } from 'monaco-editor/esm/vs/base/common/objects.js';
 import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { Extensions } from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
-import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
 import { AbstractEditorCommandsQuickAccessProvider } from 'monaco-editor/esm/vs/editor/contrib/quickAccess/browser/commandsQuickAccess.js';
 import { DefaultQuickAccessFilterValue, Extensions as Extensions$2 } from 'monaco-editor/esm/vs/platform/quickinput/common/quickAccess.js';
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
@@ -44,11 +40,16 @@ import { stripIcons } from 'monaco-editor/esm/vs/base/common/iconLabels.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
 import { IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { isFirefox } from 'monaco-editor/esm/vs/base/browser/browser.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
 import { BaseResolvedKeybinding } from 'monaco-editor/esm/vs/platform/keybinding/common/baseResolvedKeybinding.js';
 import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
 import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
 import { g as getServiceOverride$1 } from './files.js';
-import { be as DEFAULT_EXTENSION } from './extHost.js';
+import getServiceOverride$2, { configurationRegistry as configurationRegistry$2 } from './configuration.js';
+import { bj as DEFAULT_EXTENSION } from './extHost.js';
 import { c as createInjectedClass } from './injection.js';
 import { StandaloneCommandsQuickAccessProvider } from 'monaco-editor/esm/vs/editor/standalone/browser/quickAccess/standaloneCommandsQuickAccess.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
@@ -106,9 +107,16 @@ const isChrome$1 = (userAgent$1.indexOf('Chrome') >= 0);
 (!isChrome$1 && (userAgent$1.indexOf('Safari') >= 0));
 (userAgent$1.indexOf('Electron/') >= 0);
 (userAgent$1.indexOf('Android') >= 0);
+let standalone = false;
 if (window.matchMedia) {
-    const matchMedia = window.matchMedia('(display-mode: standalone)');
-    addMatchMediaChangeListener(matchMedia, ({ matches }) => {
+    const standaloneMatchMedia = window.matchMedia('(display-mode: standalone) or (display-mode: window-controls-overlay)');
+    const fullScreenMatchMedia = window.matchMedia('(display-mode: fullscreen)');
+    standalone = standaloneMatchMedia.matches;
+    addMatchMediaChangeListener(standaloneMatchMedia, ({ matches }) => {
+        if (standalone && fullScreenMatchMedia.matches) {
+            return;
+        }
+        standalone = matches;
     });
 }
 const LANGUAGE_DEFAULT = 'en';
@@ -131,6 +139,7 @@ if (typeof navigator === 'object' && !isElectronRenderer) {
     _userAgent.indexOf('Macintosh') >= 0;
     (_userAgent.indexOf('Macintosh') >= 0 || _userAgent.indexOf('iPad') >= 0 || _userAgent.indexOf('iPhone') >= 0) && !!navigator.maxTouchPoints && navigator.maxTouchPoints > 0;
     _userAgent.indexOf('Linux') >= 0;
+    _userAgent?.indexOf('Mobi') >= 0;
     const configuredLocale = getConfiguredDefaultLocale(
     ( (localize({ key: 'ensureLoaderPluginIsLoaded', comment: ['{Locked}'] }, '_'))));
     _locale = configuredLocale || LANGUAGE_DEFAULT;
@@ -666,6 +675,12 @@ const apiMenus = [
         id: MenuId.ViewItemContext,
         description: ( (localize('view.itemContext', "The contributed view item context menu")))
     },
+    {
+        key: 'comments/comment/editorActions',
+        id: MenuId.CommentEditorActions,
+        description: ( (localize('commentThread.editorActions', "The contributed comment editor actions"))),
+        proposed: 'contribCommentEditorActionsMenu'
+    },
     {
         key: 'comments/commentThread/title',
         id: MenuId.CommentThreadTitle,
@@ -680,6 +695,25 @@ const apiMenus = [
         ))),
         supportsSubmenus: false
     },
+    {
+        key: 'comments/commentThread/additionalActions',
+        id: MenuId.CommentThreadAdditionalActions,
+        description: ( (localize(
+            'commentThread.actions',
+            "The contributed comment thread context menu, rendered as buttons below the comment editor"
+        ))),
+        supportsSubmenus: false,
+        proposed: 'contribCommentThreadAdditionalMenu'
+    },
+    {
+        key: 'comments/commentThread/title/context',
+        id: MenuId.CommentThreadTitleContext,
+        description: ( (localize(
+            'commentThread.titleContext',
+            "The contributed comment thread title's peek context menu, rendered as a right click menu on the comment thread's peek title."
+        ))),
+        proposed: 'contribCommentPeekContext'
+    },
     {
         key: 'comments/comment/title',
         id: MenuId.CommentTitle,
@@ -694,6 +728,15 @@ const apiMenus = [
         ))),
         supportsSubmenus: false
     },
+    {
+        key: 'comments/commentThread/comment/context',
+        id: MenuId.CommentThreadCommentContext,
+        description: ( (localize(
+            'comment.commentContext',
+            "The contributed comment context menu, rendered as a right click menu on the an individual comment in the comment thread's peek view."
+        ))),
+        proposed: 'contribCommentPeekContext'
+    },
     {
         key: 'notebook/toolbar',
         id: MenuId.NotebookToolbar,
@@ -715,15 +758,6 @@ const apiMenus = [
         id: MenuId.NotebookCellExecute,
         description: ( (localize('notebook.cell.execute', "The contributed notebook cell execution menu")))
     },
-    {
-        key: 'notebook/cell/executePrimary',
-        id: MenuId.NotebookCellExecutePrimary,
-        description: ( (localize(
-            'notebook.cell.executePrimary',
-            "The contributed primary notebook cell execution button"
-        ))),
-        proposed: 'notebookEditor'
-    },
     {
         key: 'interactive/toolbar',
         id: MenuId.InteractiveToolbar,
@@ -786,6 +820,11 @@ const apiMenus = [
         ))),
         supportsSubmenus: false,
     },
+    {
+        key: 'webview/context',
+        id: MenuId.WebviewContext,
+        description: ( (localize('webview.context', "The webview context menu")))
+    },
     {
         key: 'file/share',
         id: MenuId.MenubarShare,
@@ -803,16 +842,16 @@ const apiMenus = [
         proposed: 'inlineCompletionsAdditions'
     },
     {
-        key: 'merge/toolbar',
-        id: MenuId.MergeToolbar,
-        description: ( (localize('merge.toolbar', "The prominent botton in the merge editor"))),
-        proposed: 'contribMergeEditorToolbar'
+        key: 'editor/content',
+        id: MenuId.EditorContent,
+        description: ( (localize('merge.toolbar', "The prominent button in an editor, overlays its content"))),
+        proposed: 'contribEditorContentMenu'
     },
     {
-        key: 'webview/context',
-        id: MenuId.WebviewContext,
-        description: ( (localize('webview.context', "The webview context menu"))),
-        proposed: 'contribWebviewContext'
+        key: 'mergeEditor/result/title',
+        id: MenuId.MergeInputResultToolbar,
+        description: ( (localize('menus.mergeEditorResult', "The result toolbar of the merge editor"))),
+        proposed: 'contribMergeEditorMenus'
     },
 ];
 var schema$1;
@@ -1234,10 +1273,17 @@ var schema$1;
 const _commandRegistrations = ( (new DisposableStore()));
 const commandsExtensionPoint$1 = ( (ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'commands',
-    jsonSchema: schema$1.commandsContribution
+    jsonSchema: schema$1.commandsContribution,
+    activationEventsGenerator: (contribs, result) => {
+        for (const contrib of contribs) {
+            if (contrib.command) {
+                result.push(`onCommand:${contrib.command}`);
+            }
+        }
+    }
 })));
 commandsExtensionPoint$1.setHandler(extensions => {
-    function handleCommand(userFriendlyCommand, extension, bucket) {
+    function handleCommand(userFriendlyCommand, extension) {
         if (!schema$1.isValidCommand(userFriendlyCommand, extension.collector)) {
             return;
         }
@@ -1261,31 +1307,29 @@ commandsExtensionPoint$1.setHandler(extensions => {
                 userFriendlyCommand.command
             ))));
         }
-        bucket.push({
+        _commandRegistrations.add(MenuRegistry.addCommand({
             id: command,
             title,
-            source: extension.description.displayName ?? extension.description.name,
+            source: { id: extension.description.identifier.value, title: extension.description.displayName ?? extension.description.name },
             shortTitle,
             tooltip: title,
             category,
             precondition: ContextKeyExpr.deserialize(enablement),
             icon: absoluteIcon
-        });
+        }));
     }
     _commandRegistrations.clear();
-    const newCommands = [];
     for (const extension of extensions) {
         const { value } = extension;
         if (Array.isArray(value)) {
             for (const command of value) {
-                handleCommand(command, extension, newCommands);
+                handleCommand(command, extension);
             }
         }
         else {
-            handleCommand(value, extension, newCommands);
+            handleCommand(value, extension);
         }
     }
-    _commandRegistrations.add(MenuRegistry.addCommands(newCommands));
 });
 const _submenus = ( (new Map()));
 const submenusExtensionPoint = ( (ExtensionsRegistry.registerExtensionPoint({
@@ -1298,7 +1342,7 @@ submenusExtensionPoint.setHandler(extensions => {
         const { value, collector } = extension;
         for (const [, submenuInfo] of Object.entries(value)) {
             if (!schema$1.isValidSubmenu(submenuInfo, collector)) {
-                return;
+                continue;
             }
             if (!submenuInfo.id) {
                 collector.warn(( (localize(
@@ -1306,7 +1350,7 @@ submenusExtensionPoint.setHandler(extensions => {
                     "`{0}` is not a valid submenu identifier",
                     submenuInfo.id
                 ))));
-                return;
+                continue;
             }
             if (_submenus.has(submenuInfo.id)) {
                 collector.info(( (localize(
@@ -1314,7 +1358,7 @@ submenusExtensionPoint.setHandler(extensions => {
                     "The `{0}` submenu was already previously registered.",
                     submenuInfo.id
                 ))));
-                return;
+                continue;
             }
             if (!submenuInfo.label) {
                 collector.warn(( (localize(
@@ -1322,7 +1366,7 @@ submenusExtensionPoint.setHandler(extensions => {
                     "`{0}` is not a valid submenu label",
                     submenuInfo.label
                 ))));
-                return;
+                continue;
             }
             let absoluteIcon;
             if (submenuInfo.icon) {
@@ -1345,7 +1389,7 @@ submenusExtensionPoint.setHandler(extensions => {
         }
     }
 });
-const _apiMenusByKey = ( (new Map(Iterable.map(Iterable.from(apiMenus), menu => ([menu.key, menu])))));
+const _apiMenusByKey = ( (new Map(apiMenus.map(menu => ([menu.key, menu])))));
 const _menuRegistrations = ( (new DisposableStore()));
 const _submenuMenuItems = ( (new Map()));
 const menusExtensionPoint = ( (ExtensionsRegistry.registerExtensionPoint({
@@ -1356,7 +1400,6 @@ const menusExtensionPoint = ( (ExtensionsRegistry.registerExtensionPoint({
 menusExtensionPoint.setHandler(extensions => {
     _menuRegistrations.clear();
     _submenuMenuItems.clear();
-    const items = [];
     for (const extension of extensions) {
         const { value, collector } = extension;
         for (const entry of Object.entries(value)) {
@@ -1460,11 +1503,10 @@ menusExtensionPoint.setHandler(extensions => {
                     }
                 }
                 item.when = ContextKeyExpr.deserialize(menuItem.when);
-                items.push({ id: menu.id, item });
+                _menuRegistrations.add(MenuRegistry.appendMenuItem(menu.id, item));
             }
         }
     }
-    _menuRegistrations.add(MenuRegistry.appendMenuItems(items));
 });
 function getAllUnboundCommands(boundCommands) {
     const unboundCommands = [];
@@ -1562,47 +1604,28 @@ class KeybindingParser {
             key
         };
     }
-    static parseSimpleKeybinding(input) {
-        const mods = this._readModifiers(input);
-        const keyCode = KeyCodeUtils.fromUserSettings(mods.key);
-        return [( (new SimpleKeybinding(mods.ctrl, mods.shift, mods.alt, mods.meta, keyCode))), mods.remains];
-    }
-    static parseKeybinding(input, OS) {
-        if (!input) {
-            return null;
-        }
-        const parts = [];
-        let part;
-        do {
-            [part, input] = this.parseSimpleKeybinding(input);
-            parts.push(part);
-        } while (input.length > 0);
-        return (
-             (new ChordKeybinding(parts))
-        );
-    }
-    static parseSimpleUserBinding(input) {
+    static parseChord(input) {
         const mods = this._readModifiers(input);
         const scanCodeMatch = mods.key.match(/^\[([^\]]+)\]$/);
         if (scanCodeMatch) {
             const strScanCode = scanCodeMatch[1];
             const scanCode = ScanCodeUtils.lowerCaseToEnum(strScanCode);
-            return [( (new ScanCodeBinding(mods.ctrl, mods.shift, mods.alt, mods.meta, scanCode))), mods.remains];
+            return [( (new ScanCodeChord(mods.ctrl, mods.shift, mods.alt, mods.meta, scanCode))), mods.remains];
         }
         const keyCode = KeyCodeUtils.fromUserSettings(mods.key);
-        return [( (new SimpleKeybinding(mods.ctrl, mods.shift, mods.alt, mods.meta, keyCode))), mods.remains];
+        return [( (new KeyCodeChord(mods.ctrl, mods.shift, mods.alt, mods.meta, keyCode))), mods.remains];
     }
-    static parseUserBinding(input) {
+    static parseKeybinding(input) {
         if (!input) {
-            return [];
+            return null;
         }
-        const parts = [];
-        let part;
+        const chords = [];
+        let chord;
         while (input.length > 0) {
-            [part, input] = this.parseSimpleUserBinding(input);
-            parts.push(part);
+            [chord, input] = this.parseChord(input);
+            chords.push(chord);
         }
-        return parts;
+        return (chords.length > 0 ?  (new Keybinding(chords)) : null);
     }
 }
 class KeybindingIO {
@@ -1630,15 +1653,16 @@ class KeybindingIO {
         out.write(' }');
     }
     static readUserKeybindingItem(input) {
-        const parts = (typeof input.key === 'string' ? KeybindingParser.parseUserBinding(input.key) : []);
+        const keybinding = (typeof input.key === 'string' ? KeybindingParser.parseKeybinding(input.key) : null);
         const when = (typeof input.when === 'string' ? ContextKeyExpr.deserialize(input.when) : undefined);
         const command = (typeof input.command === 'string' ? input.command : null);
         const commandArgs = (typeof input.args !== 'undefined' ? input.args : undefined);
         return {
-            parts: parts,
-            command: command,
-            commandArgs: commandArgs,
-            when: when
+            keybinding,
+            command,
+            commandArgs,
+            when,
+            _source: input
         };
     }
 }
@@ -1665,11 +1689,6 @@ class OutputBuilder {
         return this._lines.join('\n');
     }
 }
-function getDispatchConfig(configurationService) {
-    const keyboard = configurationService.getValue('keyboard');
-    const r = (keyboard ? keyboard.dispatch : null);
-    return (r === 'keyCode' ? 1  : 0) ;
-}
 function isContributedKeyBindingsArray(thing) {
     return Array.isArray(thing);
 }
@@ -1825,26 +1844,16 @@ otherMacNumpadMapping.set(102 , 29 );
 otherMacNumpadMapping.set(103 , 30 );
 otherMacNumpadMapping.set(104 , 21 );
 let WorkbenchKeybindingService = class WorkbenchKeybindingService extends AbstractKeybindingService {
-    constructor(contextKeyService, commandService, telemetryService, notificationService, userDataProfileService, configurationService, hostService, extensionService, fileService, logService, keyboardLayoutService) {
+    constructor(contextKeyService, commandService, telemetryService, notificationService, userDataProfileService, hostService, extensionService, fileService, logService, keyboardLayoutService) {
         super(contextKeyService, commandService, telemetryService, notificationService, logService);
         this.hostService = hostService;
         this.keyboardLayoutService = keyboardLayoutService;
         this._contributions = [];
         this.isComposingGlobalContextKey = contextKeyService.createKey('isComposing', false);
         this.updateSchema();
-        let dispatchConfig = getDispatchConfig(configurationService);
-        configurationService.onDidChangeConfiguration((e) => {
-            const newDispatchConfig = getDispatchConfig(configurationService);
-            if (dispatchConfig === newDispatchConfig) {
-                return;
-            }
-            dispatchConfig = newDispatchConfig;
-            this._keyboardMapper = this.keyboardLayoutService.getKeyboardMapper(dispatchConfig);
-            this.updateResolver();
-        });
-        this._keyboardMapper = this.keyboardLayoutService.getKeyboardMapper(dispatchConfig);
+        this._keyboardMapper = this.keyboardLayoutService.getKeyboardMapper();
         this.keyboardLayoutService.onDidChangeKeyboardLayout(() => {
-            this._keyboardMapper = this.keyboardLayoutService.getKeyboardMapper(dispatchConfig);
+            this._keyboardMapper = this.keyboardLayoutService.getKeyboardMapper();
             this.updateResolver();
         });
         this._cachedResolver = null;
@@ -1913,20 +1922,20 @@ let WorkbenchKeybindingService = class WorkbenchKeybindingService extends Abstra
     updateSchema() {
         updateSchema(flatten(this._contributions.map(x => x.getSchemaAdditions())));
     }
-    _printUserBinding(parts) {
-        return UserSettingsLabelProvider.toLabel(OS, parts, (part) => {
-            if (part instanceof SimpleKeybinding) {
+    _printKeybinding(keybinding) {
+        return UserSettingsLabelProvider.toLabel(OS, keybinding.chords, (chord) => {
+            if (chord instanceof KeyCodeChord) {
                 return (
-                     (KeyCodeUtils.toString(part.keyCode))
+                     (KeyCodeUtils.toString(chord.keyCode))
                 );
             }
             return (
-                 (ScanCodeUtils.toString(part.scanCode))
+                 (ScanCodeUtils.toString(chord.scanCode))
             );
         }) || '[null]';
     }
     _printResolvedKeybinding(resolvedKeybinding) {
-        return resolvedKeybinding.getDispatchParts().map(x => x || '[null]').join(' ');
+        return resolvedKeybinding.getDispatchChords().map(x => x || '[null]').join(' ');
     }
     _printResolvedKeybindings(output, input, resolvedKeybindings) {
         const padLength = 35;
@@ -1946,29 +1955,28 @@ let WorkbenchKeybindingService = class WorkbenchKeybindingService extends Abstra
         const result = [];
         result.push(`Default Resolved Keybindings (unique only):`);
         for (const item of KeybindingsRegistry.getDefaultKeybindings()) {
-            if (!item.keybinding || item.keybinding.length === 0) {
+            if (!item.keybinding) {
                 continue;
             }
-            const input = this._printUserBinding(item.keybinding);
+            const input = this._printKeybinding(item.keybinding);
             if (seenBindings.has(input)) {
                 continue;
             }
             seenBindings.add(input);
-            const resolvedKeybindings = this._keyboardMapper.resolveUserBinding(item.keybinding);
+            const resolvedKeybindings = this._keyboardMapper.resolveKeybinding(item.keybinding);
             this._printResolvedKeybindings(result, input, resolvedKeybindings);
         }
         result.push(`User Resolved Keybindings (unique only):`);
-        for (const _item of this.userKeybindings.keybindings) {
-            const item = KeybindingIO.readUserKeybindingItem(_item);
-            if (!item.parts || item.parts.length === 0) {
+        for (const item of this.userKeybindings.keybindings) {
+            if (!item.keybinding) {
                 continue;
             }
-            const input = _item.key;
+            const input = item._source.key;
             if (seenBindings.has(input)) {
                 continue;
             }
             seenBindings.add(input);
-            const resolvedKeybindings = this._keyboardMapper.resolveUserBinding(item.parts);
+            const resolvedKeybindings = this._keyboardMapper.resolveKeybinding(item.keybinding);
             this._printResolvedKeybindings(result, input, resolvedKeybindings);
         }
         return result.join('\n');
@@ -1997,7 +2005,7 @@ let WorkbenchKeybindingService = class WorkbenchKeybindingService extends Abstra
     _getResolver() {
         if (!this._cachedResolver) {
             const defaults = this._resolveKeybindingItems(KeybindingsRegistry.getDefaultKeybindings(), true);
-            const overrides = this._resolveUserKeybindingItems(this.userKeybindings.keybindings.map((k) => KeybindingIO.readUserKeybindingItem(k)), false);
+            const overrides = this._resolveUserKeybindingItems(this.userKeybindings.keybindings, false);
             this._cachedResolver = ( (new KeybindingResolver(defaults, overrides, (str) => this._log(str))));
         }
         return this._cachedResolver;
@@ -2026,7 +2034,7 @@ let WorkbenchKeybindingService = class WorkbenchKeybindingService extends Abstra
                 if (this._assertBrowserConflicts(keybinding, item.command)) {
                     continue;
                 }
-                const resolvedKeybindings = this._keyboardMapper.resolveUserBinding(keybinding);
+                const resolvedKeybindings = this._keyboardMapper.resolveKeybinding(keybinding);
                 for (let i = resolvedKeybindings.length - 1; i >= 0; i--) {
                     const resolvedKeybinding = resolvedKeybindings[i];
                     result[resultLen++] = ( (new ResolvedKeybindingItem(
@@ -2048,12 +2056,11 @@ let WorkbenchKeybindingService = class WorkbenchKeybindingService extends Abstra
         let resultLen = 0;
         for (const item of items) {
             const when = item.when || undefined;
-            const parts = item.parts;
-            if (parts.length === 0) {
+            if (!item.keybinding) {
                 result[resultLen++] = ( (new ResolvedKeybindingItem(undefined, item.command, item.commandArgs, when, isDefault, null, false)));
             }
             else {
-                const resolvedKeybindings = this._keyboardMapper.resolveUserBinding(parts);
+                const resolvedKeybindings = this._keyboardMapper.resolveKeybinding(item.keybinding);
                 for (const resolvedKeybinding of resolvedKeybindings) {
                     result[resultLen++] = ( (new ResolvedKeybindingItem(
                         resolvedKeybinding,
@@ -2069,44 +2076,44 @@ let WorkbenchKeybindingService = class WorkbenchKeybindingService extends Abstra
         }
         return result;
     }
-    _assertBrowserConflicts(kb, commandId) {
+    _assertBrowserConflicts(keybinding, commandId) {
         if (BrowserFeatures.keyboard === 0 ) {
             return false;
         }
         if (BrowserFeatures.keyboard === 1  && isFullscreen()) {
             return false;
         }
-        for (const part of kb) {
-            if (!part.metaKey && !part.altKey && !part.ctrlKey && !part.shiftKey) {
+        for (const chord of keybinding.chords) {
+            if (!chord.metaKey && !chord.altKey && !chord.ctrlKey && !chord.shiftKey) {
                 continue;
             }
             const modifiersMask = 2048  | 512  | 1024 ;
             let partModifiersMask = 0;
-            if (part.metaKey) {
+            if (chord.metaKey) {
                 partModifiersMask |= 2048 ;
             }
-            if (part.shiftKey) {
+            if (chord.shiftKey) {
                 partModifiersMask |= 1024 ;
             }
-            if (part.altKey) {
+            if (chord.altKey) {
                 partModifiersMask |= 512 ;
             }
-            if (part.ctrlKey && OS === 2 ) {
+            if (chord.ctrlKey && OS === 2 ) {
                 partModifiersMask |= 256 ;
             }
             if ((partModifiersMask & modifiersMask) === ((2048  | 512) )) {
-                if (part instanceof ScanCodeBinding && ((part.scanCode === 86  || part.scanCode === 85) )) {
+                if (chord instanceof ScanCodeChord && ((chord.scanCode === 86  || chord.scanCode === 85) )) {
                     return true;
                 }
-                if (part instanceof SimpleKeybinding && ((part.keyCode === 15  || part.keyCode === 17) )) {
+                if (chord instanceof KeyCodeChord && ((chord.keyCode === 15  || chord.keyCode === 17) )) {
                     return true;
                 }
             }
             if ((partModifiersMask & modifiersMask) === 2048 ) {
-                if (part instanceof ScanCodeBinding && ((part.scanCode >= 36  && part.scanCode <= 45) )) {
+                if (chord instanceof ScanCodeChord && ((chord.scanCode >= 36  && chord.scanCode <= 45) )) {
                     return true;
                 }
-                if (part instanceof SimpleKeybinding && ((part.keyCode >= 21  && part.keyCode <= 30) )) {
+                if (chord instanceof KeyCodeChord && ((chord.keyCode >= 21  && chord.keyCode <= 30) )) {
                     return true;
                 }
             }
@@ -2121,8 +2128,8 @@ let WorkbenchKeybindingService = class WorkbenchKeybindingService extends Abstra
         return this._keyboardMapper.resolveKeyboardEvent(keyboardEvent);
     }
     resolveUserBinding(userBinding) {
-        const parts = KeybindingParser.parseUserBinding(userBinding);
-        return this._keyboardMapper.resolveUserBinding(parts);
+        const keybinding = KeybindingParser.parseKeybinding(userBinding);
+        return (keybinding ? this._keyboardMapper.resolveKeybinding(keybinding) : []);
     }
     _handleKeybindingsExtensionPointUser(extensionId, isBuiltin, keybindings, collector, result) {
         if (isContributedKeyBindingsArray(keybindings)) {
@@ -2199,7 +2206,7 @@ let WorkbenchKeybindingService = class WorkbenchKeybindingService extends Abstra
             args,
             when: fullWhen,
             weight: weight,
-            keybinding: KeybindingParser.parseUserBinding(keybinding),
+            keybinding: KeybindingParser.parseKeybinding(keybinding),
             extensionId: extensionId.value,
             isBuiltinExtension: isBuiltin
         };
@@ -2274,18 +2281,19 @@ WorkbenchKeybindingService = ( (__decorate([
     ( (__param(2, ITelemetryService))),
     ( (__param(3, INotificationService))),
     ( (__param(4, IUserDataProfileService))),
-    ( (__param(5, IConfigurationService))),
-    ( (__param(6, IHostService))),
-    ( (__param(7, IExtensionService))),
-    ( (__param(8, IFileService))),
-    ( (__param(9, ILogService))),
-    ( (__param(10, IKeyboardLayoutService)))
+    ( (__param(5, IHostService))),
+    ( (__param(6, IExtensionService))),
+    ( (__param(7, IFileService))),
+    ( (__param(8, ILogService))),
+    ( (__param(9, IKeyboardLayoutService)))
 ], WorkbenchKeybindingService)));
 class UserKeybindings extends Disposable {
+    get keybindings() { return this._keybindings; }
     constructor(userDataProfileService, fileService, logService) {
         super();
         this.userDataProfileService = userDataProfileService;
         this.fileService = fileService;
+        this._rawKeybindings = [];
         this._keybindings = [];
         this.watchDisposables = this._register(( (new DisposableStore())));
         this._onDidChange = this._register(( (new Emitter())));
@@ -2308,7 +2316,6 @@ class UserKeybindings extends Disposable {
         }));
         this._register(userDataProfileService.onDidChangeCurrentProfile(e => e.join(this.whenCurrentProfieChanged(e))));
     }
-    get keybindings() { return this._keybindings; }
     async whenCurrentProfieChanged(e) {
         if (e.preserveData) {
             if (await this.fileService.exists(e.previous.keybindingsResource)) {
@@ -2327,16 +2334,23 @@ class UserKeybindings extends Disposable {
         await this.reload();
     }
     async reload() {
-        const existing = this._keybindings;
+        const newKeybindings = await this.readUserKeybindings();
+        if (equals(this._rawKeybindings, newKeybindings)) {
+            return false;
+        }
+        this._rawKeybindings = newKeybindings;
+        this._keybindings = this._rawKeybindings.map((k) => KeybindingIO.readUserKeybindingItem(k));
+        return true;
+    }
+    async readUserKeybindings() {
         try {
             const content = await this.fileService.readFile(this.userDataProfileService.currentProfile.keybindingsResource);
             const value = parse(( (content.value.toString())));
-            this._keybindings = isArray(value) ? value : [];
+            return Array.isArray(value) ? value : [];
         }
         catch (e) {
-            this._keybindings = [];
+            return [];
         }
-        return existing ? !equals(existing, this._keybindings) : true;
     }
 }
 const schemaId = 'vscode://schemas/keybindings';
@@ -2451,67 +2465,46 @@ function updateSchema(additionalContributions) {
     commandsSchemas.push(...additionalContributions);
     schemaRegistry.notifySchemaChanged(schemaId);
 }
-const configurationRegistry$1 = ( (Registry.as(Extensions$1.Configuration)));
-const keyboardConfiguration$1 = {
-    'id': 'keyboard',
-    'order': 15,
-    'type': 'object',
-    'title': ( (localize('keyboardConfigurationTitle', "Keyboard"))),
-    'properties': {
-        'keyboard.dispatch': {
-            scope: 1 ,
-            type: 'string',
-            enum: ['code', 'keyCode'],
-            default: 'code',
-            markdownDescription: ( (localize(
-                'dispatch',
-                "Controls the dispatching logic for key presses to use either `code` (recommended) or `keyCode`."
-            ))),
-            included: OS === 2  || OS === 3
-        }
-    }
-};
-configurationRegistry$1.registerConfiguration(keyboardConfiguration$1);
 class WindowsNativeResolvedKeybinding extends BaseResolvedKeybinding {
-    constructor(mapper, parts) {
-        super(1 , parts);
+    constructor(mapper, chords) {
+        super(1 , chords);
         this._mapper = mapper;
     }
-    _getLabel(keybinding) {
-        if (keybinding.isDuplicateModifierCase()) {
+    _getLabel(chord) {
+        if (chord.isDuplicateModifierCase()) {
             return '';
         }
-        return this._mapper.getUILabelForKeyCode(keybinding.keyCode);
+        return this._mapper.getUILabelForKeyCode(chord.keyCode);
     }
-    _getUSLabelForKeybinding(keybinding) {
-        if (keybinding.isDuplicateModifierCase()) {
+    _getUSLabelForKeybinding(chord) {
+        if (chord.isDuplicateModifierCase()) {
             return '';
         }
         return (
-             (KeyCodeUtils.toString(keybinding.keyCode))
+             (KeyCodeUtils.toString(chord.keyCode))
         );
     }
     getUSLabel() {
-        return UILabelProvider.toLabel(this._os, this._parts, (keybinding) => this._getUSLabelForKeybinding(keybinding));
+        return UILabelProvider.toLabel(this._os, this._chords, (keybinding) => this._getUSLabelForKeybinding(keybinding));
     }
-    _getAriaLabel(keybinding) {
-        if (keybinding.isDuplicateModifierCase()) {
+    _getAriaLabel(chord) {
+        if (chord.isDuplicateModifierCase()) {
             return '';
         }
-        return this._mapper.getAriaLabelForKeyCode(keybinding.keyCode);
+        return this._mapper.getAriaLabelForKeyCode(chord.keyCode);
     }
-    _getElectronAccelerator(keybinding) {
-        return this._mapper.getElectronAcceleratorForKeyBinding(keybinding);
+    _getElectronAccelerator(chord) {
+        return this._mapper.getElectronAcceleratorForKeyBinding(chord);
     }
-    _getUserSettingsLabel(keybinding) {
-        if (keybinding.isDuplicateModifierCase()) {
+    _getUserSettingsLabel(chord) {
+        if (chord.isDuplicateModifierCase()) {
             return '';
         }
-        const result = this._mapper.getUserSettingsLabelForKeyCode(keybinding.keyCode);
+        const result = this._mapper.getUserSettingsLabelForKeyCode(chord.keyCode);
         return (result ? result.toLowerCase() : result);
     }
-    _isWYSIWYG(keybinding) {
-        return this.__isWYSIWYG(keybinding.keyCode);
+    _isWYSIWYG(chord) {
+        return this.__isWYSIWYG(chord.keyCode);
     }
     __isWYSIWYG(keyCode) {
         if (keyCode === 15
@@ -2524,58 +2517,58 @@ class WindowsNativeResolvedKeybinding extends BaseResolvedKeybinding {
         const userSettingsLabel = this._mapper.getUserSettingsLabelForKeyCode(keyCode);
         return (ariaLabel === userSettingsLabel);
     }
-    _getDispatchPart(keybinding) {
-        if (keybinding.isModifierKey()) {
+    _getChordDispatch(chord) {
+        if (chord.isModifierKey()) {
             return null;
         }
         let result = '';
-        if (keybinding.ctrlKey) {
+        if (chord.ctrlKey) {
             result += 'ctrl+';
         }
-        if (keybinding.shiftKey) {
+        if (chord.shiftKey) {
             result += 'shift+';
         }
-        if (keybinding.altKey) {
+        if (chord.altKey) {
             result += 'alt+';
         }
-        if (keybinding.metaKey) {
+        if (chord.metaKey) {
             result += 'meta+';
         }
-        result += ( (KeyCodeUtils.toString(keybinding.keyCode)));
+        result += ( (KeyCodeUtils.toString(chord.keyCode)));
         return result;
     }
-    _getSingleModifierDispatchPart(keybinding) {
-        if (keybinding.keyCode === 5  && !keybinding.shiftKey && !keybinding.altKey && !keybinding.metaKey) {
+    _getSingleModifierChordDispatch(chord) {
+        if (chord.keyCode === 5  && !chord.shiftKey && !chord.altKey && !chord.metaKey) {
             return 'ctrl';
         }
-        if (keybinding.keyCode === 4  && !keybinding.ctrlKey && !keybinding.altKey && !keybinding.metaKey) {
+        if (chord.keyCode === 4  && !chord.ctrlKey && !chord.altKey && !chord.metaKey) {
             return 'shift';
         }
-        if (keybinding.keyCode === 6  && !keybinding.ctrlKey && !keybinding.shiftKey && !keybinding.metaKey) {
+        if (chord.keyCode === 6  && !chord.ctrlKey && !chord.shiftKey && !chord.metaKey) {
             return 'alt';
         }
-        if (keybinding.keyCode === 57  && !keybinding.ctrlKey && !keybinding.shiftKey && !keybinding.altKey) {
+        if (chord.keyCode === 57  && !chord.ctrlKey && !chord.shiftKey && !chord.altKey) {
             return 'meta';
         }
         return null;
     }
-    static getProducedCharCode(kb, mapping) {
+    static getProducedCharCode(chord, mapping) {
         if (!mapping) {
             return null;
         }
-        if (kb.ctrlKey && kb.shiftKey && kb.altKey) {
+        if (chord.ctrlKey && chord.shiftKey && chord.altKey) {
             return mapping.withShiftAltGr;
         }
-        if (kb.ctrlKey && kb.altKey) {
+        if (chord.ctrlKey && chord.altKey) {
             return mapping.withAltGr;
         }
-        if (kb.shiftKey) {
+        if (chord.shiftKey) {
             return mapping.withShift;
         }
         return mapping.value;
     }
-    static getProducedChar(kb, mapping) {
-        const char = this.getProducedCharCode(kb, mapping);
+    static getProducedChar(chord, mapping) {
+        const char = this.getProducedCharCode(chord, mapping);
         if (char === null || char.length === 0) {
             return ' --- ';
         }
@@ -2583,9 +2576,10 @@ class WindowsNativeResolvedKeybinding extends BaseResolvedKeybinding {
     }
 }
 class WindowsKeyboardMapper {
-    constructor(isUSStandard, rawMappings) {
+    constructor(_isUSStandard, rawMappings, _mapAltGrToCtrlAlt) {
+        this._isUSStandard = _isUSStandard;
+        this._mapAltGrToCtrlAlt = _mapAltGrToCtrlAlt;
         this._keyCodeToLabel = [];
-        this.isUSStandard = isUSStandard;
         this._scanCodeToKeyCode = [];
         this._keyCodeToLabel = [];
         this._keyCodeExists = [];
@@ -2736,15 +2730,15 @@ class WindowsKeyboardMapper {
                 const ctrlKey = (mod & 0b001) ? true : false;
                 const shiftKey = (mod & 0b010) ? true : false;
                 const altKey = (mod & 0b100) ? true : false;
-                const scanCodeBinding = ( (new ScanCodeBinding(ctrlKey, shiftKey, altKey, false, scanCode)));
-                const kb = this._resolveSimpleUserBinding(scanCodeBinding);
-                const strKeyCode = (kb ? ( (KeyCodeUtils.toString(kb.keyCode))) : null);
-                const resolvedKb = (kb ? ( (new WindowsNativeResolvedKeybinding(this, [kb]))) : null);
+                const scanCodeChord = ( (new ScanCodeChord(ctrlKey, shiftKey, altKey, false, scanCode)));
+                const keyCodeChord = this._resolveChord(scanCodeChord);
+                const strKeyCode = (keyCodeChord ? ( (KeyCodeUtils.toString(keyCodeChord.keyCode))) : null);
+                const resolvedKb = (keyCodeChord ? ( (new WindowsNativeResolvedKeybinding(this, [keyCodeChord]))) : null);
                 const outScanCode = `${ctrlKey ? 'Ctrl+' : ''}${shiftKey ? 'Shift+' : ''}${altKey ? 'Alt+' : ''}${strCode}`;
                 const ariaLabel = (resolvedKb ? resolvedKb.getAriaLabel() : null);
                 const outUILabel = (ariaLabel ? ariaLabel.replace(/Control\+/, 'Ctrl+') : null);
                 const outUserSettings = (resolvedKb ? resolvedKb.getUserSettingsLabel() : null);
-                const outKey = WindowsNativeResolvedKeybinding.getProducedChar(scanCodeBinding, mapping);
+                const outKey = WindowsNativeResolvedKeybinding.getProducedChar(scanCodeChord, mapping);
                 const outKb = (strKeyCode ? `${ctrlKey ? 'Ctrl+' : ''}${shiftKey ? 'Shift+' : ''}${altKey ? 'Alt+' : ''}${strKeyCode}` : null);
                 const isWYSIWYG = (resolvedKb ? resolvedKb.isWYSIWYG() : false);
                 const outWYSIWYG = (isWYSIWYG ? '       ' : '   NO  ');
@@ -2770,73 +2764,66 @@ class WindowsKeyboardMapper {
         return this._getLabelForKeyCode(keyCode);
     }
     getUserSettingsLabelForKeyCode(keyCode) {
-        if (this.isUSStandard) {
+        if (this._isUSStandard) {
             return KeyCodeUtils.toUserSettingsUS(keyCode);
         }
         return KeyCodeUtils.toUserSettingsGeneral(keyCode);
     }
-    getElectronAcceleratorForKeyBinding(keybinding) {
-        return KeyCodeUtils.toElectronAccelerator(keybinding.keyCode);
+    getElectronAcceleratorForKeyBinding(chord) {
+        return KeyCodeUtils.toElectronAccelerator(chord.keyCode);
     }
     _getLabelForKeyCode(keyCode) {
         return this._keyCodeToLabel[keyCode] || ( (KeyCodeUtils.toString(0 )));
     }
-    resolveKeybinding(keybinding) {
-        const parts = keybinding.parts;
-        for (let i = 0, len = parts.length; i < len; i++) {
-            const part = parts[i];
-            if (!this._keyCodeExists[part.keyCode]) {
-                return [];
-            }
-        }
-        return [( (new WindowsNativeResolvedKeybinding(this, parts)))];
-    }
     resolveKeyboardEvent(keyboardEvent) {
-        const keybinding = ( (new SimpleKeybinding(
-            keyboardEvent.ctrlKey,
+        const ctrlKey = keyboardEvent.ctrlKey || (this._mapAltGrToCtrlAlt && keyboardEvent.altGraphKey);
+        const altKey = keyboardEvent.altKey || (this._mapAltGrToCtrlAlt && keyboardEvent.altGraphKey);
+        const chord = ( (new KeyCodeChord(
+            ctrlKey,
             keyboardEvent.shiftKey,
-            keyboardEvent.altKey,
+            altKey,
             keyboardEvent.metaKey,
             keyboardEvent.keyCode
         )));
         return (
-             (new WindowsNativeResolvedKeybinding(this, [keybinding]))
+             (new WindowsNativeResolvedKeybinding(this, [chord]))
         );
     }
-    _resolveSimpleUserBinding(binding) {
-        if (!binding) {
+    _resolveChord(chord) {
+        if (!chord) {
             return null;
         }
-        if (binding instanceof SimpleKeybinding) {
-            if (!this._keyCodeExists[binding.keyCode]) {
+        if (chord instanceof KeyCodeChord) {
+            if (!this._keyCodeExists[chord.keyCode]) {
                 return null;
             }
-            return binding;
+            return chord;
         }
-        const keyCode = this._scanCodeToKeyCode[binding.scanCode] || 0 ;
+        const keyCode = this._scanCodeToKeyCode[chord.scanCode] || 0 ;
         if (keyCode === 0  || !this._keyCodeExists[keyCode]) {
             return null;
         }
         return (
-             (new SimpleKeybinding(
-                binding.ctrlKey,
-                binding.shiftKey,
-                binding.altKey,
-                binding.metaKey,
-                keyCode
-            ))
+             (new KeyCodeChord(chord.ctrlKey, chord.shiftKey, chord.altKey, chord.metaKey, keyCode))
         );
     }
-    resolveUserBinding(input) {
-        const parts = removeElementsAfterNulls(input.map(keybinding => this._resolveSimpleUserBinding(keybinding)));
-        if (parts.length > 0) {
-            return [( (new WindowsNativeResolvedKeybinding(this, parts)))];
+    resolveKeybinding(keybinding) {
+        const chords = toEmptyArrayIfContainsNull(keybinding.chords.map(chord => this._resolveChord(chord)));
+        if (chords.length > 0) {
+            return [( (new WindowsNativeResolvedKeybinding(this, chords)))];
         }
         return [];
     }
 }
 let CommandsQuickAccessProvider = class CommandsQuickAccessProvider extends AbstractEditorCommandsQuickAccessProvider {
-    constructor(editorService, menuService, extensionService, instantiationService, keybindingService, commandService, telemetryService, dialogService, configurationService, editorGroupService, preferencesService) {
+    get activeTextEditorControl() { return this.editorService.activeTextEditorControl; }
+    get defaultFilterValue() {
+        if (this.configuration.preserveInput) {
+            return DefaultQuickAccessFilterValue.LAST;
+        }
+        return undefined;
+    }
+    constructor(editorService, menuService, extensionService, instantiationService, keybindingService, commandService, telemetryService, dialogService, configurationService, editorGroupService, preferencesService, productService) {
         super({
             showAlias: !Language.isDefaultVariant(),
             noResultsPick: {
@@ -2850,36 +2837,43 @@ let CommandsQuickAccessProvider = class CommandsQuickAccessProvider extends Abst
         this.configurationService = configurationService;
         this.editorGroupService = editorGroupService;
         this.preferencesService = preferencesService;
+        this.productService = productService;
         this.extensionRegistrationRace = Promise.race([
             timeout(800),
             this.extensionService.whenInstalledExtensionsRegistered()
         ]);
-    }
-    get activeTextEditorControl() { return this.editorService.activeTextEditorControl; }
-    get defaultFilterValue() {
-        if (this.configuration.preserveInput) {
-            return DefaultQuickAccessFilterValue.LAST;
-        }
-        return undefined;
+        this._register(configurationService.onDidChangeConfiguration((e) => this.updateSuggestedCommandIds(e)));
+        this.updateSuggestedCommandIds();
     }
     get configuration() {
         const commandPaletteConfig = this.configurationService.getValue().workbench.commandPalette;
         return {
-            preserveInput: commandPaletteConfig.preserveInput
+            preserveInput: commandPaletteConfig.preserveInput,
+            experimental: commandPaletteConfig.experimental
         };
     }
-    async getCommandPicks(disposables, token) {
+    updateSuggestedCommandIds(e) {
+        if (e && !e.affectsConfiguration('workbench.commandPalette.experimental.suggestCommands')) {
+            return;
+        }
+        const config = this.configuration;
+        const suggestedCommandIds = config.experimental.suggestCommands && this.productService.commandPaletteSuggestedCommandIds?.length
+            ? ( (new Set(this.productService.commandPaletteSuggestedCommandIds)))
+            : undefined;
+        this.options.suggestedCommandIds = suggestedCommandIds;
+    }
+    async getCommandPicks(token) {
         await this.extensionRegistrationRace;
         if (token.isCancellationRequested) {
             return [];
         }
         return [
             ...this.getCodeEditorCommandPicks(),
-            ...this.getGlobalCommandPicks(disposables)
+            ...this.getGlobalCommandPicks()
         ].map(c => ({
             ...c,
             buttons: [{
-                    iconClass: Codicon.gear.classNames,
+                    iconClass: ThemeIcon.asClassName(Codicon.gear),
                     tooltip: ( (localize('configure keybinding', "Configure Keybinding"))),
                 }],
             trigger: () => {
@@ -2888,7 +2882,7 @@ let CommandsQuickAccessProvider = class CommandsQuickAccessProvider extends Abst
             },
         }));
     }
-    getGlobalCommandPicks(disposables) {
+    getGlobalCommandPicks() {
         const globalCommandPicks = [];
         const scopedContextKeyService = this.editorService.activeEditorPane?.scopedContextKeyService || this.editorGroupService.activeGroup.scopedContextKeyService;
         const globalCommandsMenu = this.menuService.createMenu(MenuId.CommandPalette, scopedContextKeyService);
@@ -2913,7 +2907,6 @@ let CommandsQuickAccessProvider = class CommandsQuickAccessProvider extends Abst
             });
         }
         globalCommandsMenu.dispose();
-        disposables.add(toDisposable(() => dispose(globalCommandsMenuActions)));
         return globalCommandPicks;
     }
 };
@@ -2928,8 +2921,28 @@ CommandsQuickAccessProvider = ( (__decorate([
     ( (__param(7, IDialogService))),
     ( (__param(8, IConfigurationService))),
     ( (__param(9, IEditorGroupsService))),
-    ( (__param(10, IPreferencesService)))
+    ( (__param(10, IPreferencesService))),
+    ( (__param(11, IProductService)))
 ], CommandsQuickAccessProvider)));
+class ShowAllCommandsAction extends Action2 {
+    constructor() {
+        super({
+            id: ShowAllCommandsAction.ID,
+            title: { value: ( (localize('showTriggerActions', "Show All Commands"))), original: 'Show All Commands' },
+            keybinding: {
+                weight: 200 ,
+                when: undefined,
+                primary: !isFirefox ? ((2048  | 1024  | 46) ) : undefined,
+                secondary: [59 ]
+            },
+            f1: true
+        });
+    }
+    async run(accessor) {
+        accessor.get(IQuickInputService).quickAccess.show(CommandsQuickAccessProvider.PREFIX);
+    }
+}
+ShowAllCommandsAction.ID = 'workbench.action.showCommands';
 function deserializeMapping(serializedMapping) {
     const mapping = serializedMapping;
     const ret = {};
@@ -3035,6 +3048,43 @@ class KeymapInfo {
         return true;
     }
 }
+function readKeyboardConfig(configurationService) {
+    const keyboard = configurationService.getValue('keyboard');
+    const dispatch = ((keyboard?.dispatch === 'keyCode' ? 1  : 0) );
+    const mapAltGrToCtrlAlt = Boolean(keyboard?.mapAltGrToCtrlAlt);
+    return { dispatch, mapAltGrToCtrlAlt };
+}
+const configurationRegistry$1 = ( (Registry.as(Extensions$1.Configuration)));
+const keyboardConfiguration$1 = {
+    'id': 'keyboard',
+    'order': 15,
+    'type': 'object',
+    'title': ( (localize('keyboardConfigurationTitle', "Keyboard"))),
+    'properties': {
+        'keyboard.dispatch': {
+            scope: 1 ,
+            type: 'string',
+            enum: ['code', 'keyCode'],
+            default: 'code',
+            markdownDescription: ( (localize(
+                'dispatch',
+                "Controls the dispatching logic for key presses to use either `code` (recommended) or `keyCode`."
+            ))),
+            included: OS === 2  || OS === 3
+        },
+        'keyboard.mapAltGrToCtrlAlt': {
+            scope: 1 ,
+            type: 'boolean',
+            default: false,
+            markdownDescription: ( (localize(
+                'mapAltGrToCtrlAlt',
+                "Controls if the AltGraph+ modifier should be treated as Ctrl+Alt+."
+            ))),
+            included: OS === 1
+        }
+    }
+};
+configurationRegistry$1.registerConfiguration(keyboardConfiguration$1);
 class CachedKeyboardMapper {
     constructor(actual) {
         this._actual = actual;
@@ -3043,6 +3093,9 @@ class CachedKeyboardMapper {
     dumpDebugInfo() {
         return this._actual.dumpDebugInfo();
     }
+    resolveKeyboardEvent(keyboardEvent) {
+        return this._actual.resolveKeyboardEvent(keyboardEvent);
+    }
     resolveKeybinding(keybinding) {
         const hashCode = keybinding.getHashCode();
         const resolved = this._cache.get(hashCode);
@@ -3053,30 +3106,24 @@ class CachedKeyboardMapper {
         }
         return resolved;
     }
-    resolveKeyboardEvent(keyboardEvent) {
-        return this._actual.resolveKeyboardEvent(keyboardEvent);
-    }
-    resolveUserBinding(parts) {
-        return this._actual.resolveUserBinding(parts);
-    }
 }
 const CHAR_CODE_TO_KEY_CODE = [];
 class NativeResolvedKeybinding extends BaseResolvedKeybinding {
-    constructor(mapper, os, parts) {
-        super(os, parts);
+    constructor(mapper, os, chords) {
+        super(os, chords);
         this._mapper = mapper;
     }
-    _getLabel(keybinding) {
-        return this._mapper.getUILabelForScanCodeBinding(keybinding);
+    _getLabel(chord) {
+        return this._mapper.getUILabelForScanCodeChord(chord);
     }
-    _getAriaLabel(keybinding) {
-        return this._mapper.getAriaLabelForScanCodeBinding(keybinding);
+    _getAriaLabel(chord) {
+        return this._mapper.getAriaLabelForScanCodeChord(chord);
     }
-    _getElectronAccelerator(keybinding) {
-        return this._mapper.getElectronAcceleratorLabelForScanCodeBinding(keybinding);
+    _getElectronAccelerator(chord) {
+        return this._mapper.getElectronAcceleratorLabelForScanCodeChord(chord);
     }
-    _getUserSettingsLabel(keybinding) {
-        return this._mapper.getUserSettingsLabelForScanCodeBinding(keybinding);
+    _getUserSettingsLabel(chord) {
+        return this._mapper.getUserSettingsLabelForScanCodeChord(chord);
     }
     _isWYSIWYG(binding) {
         if (!binding) {
@@ -3085,8 +3132,8 @@ class NativeResolvedKeybinding extends BaseResolvedKeybinding {
         if (IMMUTABLE_CODE_TO_KEY_CODE[binding.scanCode] !== -1 ) {
             return true;
         }
-        const a = this._mapper.getAriaLabelForScanCodeBinding(binding);
-        const b = this._mapper.getUserSettingsLabelForScanCodeBinding(binding);
+        const a = this._mapper.getAriaLabelForScanCodeChord(binding);
+        const b = this._mapper.getUserSettingsLabelForScanCodeChord(binding);
         if (!a && !b) {
             return true;
         }
@@ -3095,20 +3142,20 @@ class NativeResolvedKeybinding extends BaseResolvedKeybinding {
         }
         return (a.toLowerCase() === b.toLowerCase());
     }
-    _getDispatchPart(keybinding) {
-        return this._mapper.getDispatchStrForScanCodeBinding(keybinding);
+    _getChordDispatch(chord) {
+        return this._mapper.getDispatchStrForScanCodeChord(chord);
     }
-    _getSingleModifierDispatchPart(keybinding) {
-        if (((keybinding.scanCode === 157  || keybinding.scanCode === 161) ) && !keybinding.shiftKey && !keybinding.altKey && !keybinding.metaKey) {
+    _getSingleModifierChordDispatch(chord) {
+        if (((chord.scanCode === 157  || chord.scanCode === 161) ) && !chord.shiftKey && !chord.altKey && !chord.metaKey) {
             return 'ctrl';
         }
-        if (((keybinding.scanCode === 159  || keybinding.scanCode === 163) ) && !keybinding.ctrlKey && !keybinding.shiftKey && !keybinding.metaKey) {
+        if (((chord.scanCode === 159  || chord.scanCode === 163) ) && !chord.ctrlKey && !chord.shiftKey && !chord.metaKey) {
             return 'alt';
         }
-        if (((keybinding.scanCode === 158  || keybinding.scanCode === 162) ) && !keybinding.ctrlKey && !keybinding.altKey && !keybinding.metaKey) {
+        if (((chord.scanCode === 158  || chord.scanCode === 162) ) && !chord.ctrlKey && !chord.altKey && !chord.metaKey) {
             return 'shift';
         }
-        if (((keybinding.scanCode === 160  || keybinding.scanCode === 164) ) && !keybinding.ctrlKey && !keybinding.shiftKey && !keybinding.altKey) {
+        if (((chord.scanCode === 160  || chord.scanCode === 164) ) && !chord.ctrlKey && !chord.shiftKey && !chord.altKey) {
             return 'meta';
         }
         return null;
@@ -3306,11 +3353,12 @@ class ScanCodeKeyCodeMapper {
     }
 }
 class MacLinuxKeyboardMapper {
-    constructor(isUSStandard, rawMappings, OS) {
+    constructor(_isUSStandard, rawMappings, _mapAltGrToCtrlAlt, _OS) {
+        this._isUSStandard = _isUSStandard;
+        this._mapAltGrToCtrlAlt = _mapAltGrToCtrlAlt;
+        this._OS = _OS;
         this._scanCodeToLabel = [];
         this._scanCodeToDispatch = [];
-        this._isUSStandard = isUSStandard;
-        this._OS = OS;
         this._codeInfo = [];
         this._scanCodeKeyCodeMapper = ( (new ScanCodeKeyCodeMapper()));
         this._scanCodeToLabel = [];
@@ -3594,6 +3642,7 @@ class MacLinuxKeyboardMapper {
                     shiftKey: scanCodeCombo.shiftKey,
                     altKey: scanCodeCombo.altKey,
                     metaKey: false,
+                    altGraphKey: false,
                     keyCode: -1 ,
                     code: ( (ScanCodeUtils.toString(scanCode)))
                 });
@@ -3603,7 +3652,7 @@ class MacLinuxKeyboardMapper {
                 const outUILabel = (ariaLabel ? ariaLabel.replace(/Control\+/, 'Ctrl+') : null);
                 const outUserSettings = resolvedKb.getUserSettingsLabel();
                 const outElectronAccelerator = resolvedKb.getElectronAccelerator();
-                const outDispatchStr = resolvedKb.getDispatchParts()[0];
+                const outDispatchStr = resolvedKb.getDispatchChords()[0];
                 const isWYSIWYG = (resolvedKb ? resolvedKb.isWYSIWYG() : false);
                 const outWYSIWYG = (isWYSIWYG ? '       ' : '   NO  ');
                 const kbCombos = this._scanCodeKeyCodeMapper.lookupScanCodeCombo(scanCodeCombo);
@@ -3651,44 +3700,39 @@ class MacLinuxKeyboardMapper {
         }
         return str;
     }
-    simpleKeybindingToScanCodeBinding(keybinding) {
-        if (keybinding.keyCode === 3 ) {
-            return [( (new ScanCodeBinding(
-                keybinding.ctrlKey,
-                keybinding.shiftKey,
-                keybinding.altKey,
-                keybinding.metaKey,
+    keyCodeChordToScanCodeChord(chord) {
+        if (chord.keyCode === 3 ) {
+            return [( (new ScanCodeChord(
+                chord.ctrlKey,
+                chord.shiftKey,
+                chord.altKey,
+                chord.metaKey,
                 46
             )))];
         }
-        const scanCodeCombos = this._scanCodeKeyCodeMapper.lookupKeyCodeCombo(( (new KeyCodeCombo(
-            keybinding.ctrlKey,
-            keybinding.shiftKey,
-            keybinding.altKey,
-            keybinding.keyCode
-        ))));
+        const scanCodeCombos = this._scanCodeKeyCodeMapper.lookupKeyCodeCombo(( (new KeyCodeCombo(chord.ctrlKey, chord.shiftKey, chord.altKey, chord.keyCode))));
         const result = [];
         for (let i = 0, len = scanCodeCombos.length; i < len; i++) {
             const scanCodeCombo = scanCodeCombos[i];
-            result[i] = ( (new ScanCodeBinding(
+            result[i] = ( (new ScanCodeChord(
                 scanCodeCombo.ctrlKey,
                 scanCodeCombo.shiftKey,
                 scanCodeCombo.altKey,
-                keybinding.metaKey,
+                chord.metaKey,
                 scanCodeCombo.scanCode
             )));
         }
         return result;
     }
-    getUILabelForScanCodeBinding(binding) {
-        if (!binding) {
+    getUILabelForScanCodeChord(chord) {
+        if (!chord) {
             return null;
         }
-        if (binding.isDuplicateModifierCase()) {
+        if (chord.isDuplicateModifierCase()) {
             return '';
         }
         if (this._OS === 2 ) {
-            switch (binding.scanCode) {
+            switch (chord.scanCode) {
                 case 86 :
                     return '←';
                 case 88 :
@@ -3699,76 +3743,76 @@ class MacLinuxKeyboardMapper {
                     return '↓';
             }
         }
-        return this._scanCodeToLabel[binding.scanCode];
+        return this._scanCodeToLabel[chord.scanCode];
     }
-    getAriaLabelForScanCodeBinding(binding) {
-        if (!binding) {
+    getAriaLabelForScanCodeChord(chord) {
+        if (!chord) {
             return null;
         }
-        if (binding.isDuplicateModifierCase()) {
+        if (chord.isDuplicateModifierCase()) {
             return '';
         }
-        return this._scanCodeToLabel[binding.scanCode];
+        return this._scanCodeToLabel[chord.scanCode];
     }
-    getDispatchStrForScanCodeBinding(keypress) {
-        const codeDispatch = this._scanCodeToDispatch[keypress.scanCode];
+    getDispatchStrForScanCodeChord(chord) {
+        const codeDispatch = this._scanCodeToDispatch[chord.scanCode];
         if (!codeDispatch) {
             return null;
         }
         let result = '';
-        if (keypress.ctrlKey) {
+        if (chord.ctrlKey) {
             result += 'ctrl+';
         }
-        if (keypress.shiftKey) {
+        if (chord.shiftKey) {
             result += 'shift+';
         }
-        if (keypress.altKey) {
+        if (chord.altKey) {
             result += 'alt+';
         }
-        if (keypress.metaKey) {
+        if (chord.metaKey) {
             result += 'meta+';
         }
         result += codeDispatch;
         return result;
     }
-    getUserSettingsLabelForScanCodeBinding(binding) {
-        if (!binding) {
+    getUserSettingsLabelForScanCodeChord(chord) {
+        if (!chord) {
             return null;
         }
-        if (binding.isDuplicateModifierCase()) {
+        if (chord.isDuplicateModifierCase()) {
             return '';
         }
-        const immutableKeyCode = IMMUTABLE_CODE_TO_KEY_CODE[binding.scanCode];
+        const immutableKeyCode = IMMUTABLE_CODE_TO_KEY_CODE[chord.scanCode];
         if (immutableKeyCode !== -1 ) {
             return KeyCodeUtils.toUserSettingsUS(immutableKeyCode).toLowerCase();
         }
-        const constantKeyCode = this._scanCodeKeyCodeMapper.guessStableKeyCode(binding.scanCode);
+        const constantKeyCode = this._scanCodeKeyCodeMapper.guessStableKeyCode(chord.scanCode);
         if (constantKeyCode !== -1 ) {
-            const reverseBindings = this.simpleKeybindingToScanCodeBinding(( (new SimpleKeybinding(
-                binding.ctrlKey,
-                binding.shiftKey,
-                binding.altKey,
-                binding.metaKey,
+            const reverseChords = this.keyCodeChordToScanCodeChord(( (new KeyCodeChord(
+                chord.ctrlKey,
+                chord.shiftKey,
+                chord.altKey,
+                chord.metaKey,
                 constantKeyCode
             ))));
-            for (let i = 0, len = reverseBindings.length; i < len; i++) {
-                const reverseBinding = reverseBindings[i];
-                if (reverseBinding.scanCode === binding.scanCode) {
+            for (let i = 0, len = reverseChords.length; i < len; i++) {
+                const reverseChord = reverseChords[i];
+                if (reverseChord.scanCode === chord.scanCode) {
                     return KeyCodeUtils.toUserSettingsUS(constantKeyCode).toLowerCase();
                 }
             }
         }
-        return this._scanCodeToDispatch[binding.scanCode];
+        return this._scanCodeToDispatch[chord.scanCode];
     }
-    getElectronAcceleratorLabelForScanCodeBinding(binding) {
-        if (!binding) {
+    getElectronAcceleratorLabelForScanCodeChord(chord) {
+        if (!chord) {
             return null;
         }
-        const immutableKeyCode = IMMUTABLE_CODE_TO_KEY_CODE[binding.scanCode];
+        const immutableKeyCode = IMMUTABLE_CODE_TO_KEY_CODE[chord.scanCode];
         if (immutableKeyCode !== -1 ) {
             return KeyCodeUtils.toElectronAccelerator(immutableKeyCode);
         }
-        const constantKeyCode = this._scanCodeKeyCodeMapper.guessStableKeyCode(binding.scanCode);
+        const constantKeyCode = this._scanCodeKeyCodeMapper.guessStableKeyCode(chord.scanCode);
         if (this._OS === 3  && !this._isUSStandard) {
             const isOEMKey = ((constantKeyCode === 80
                 || constantKeyCode === 81
@@ -3788,13 +3832,6 @@ class MacLinuxKeyboardMapper {
         }
         return null;
     }
-    resolveKeybinding(keybinding) {
-        const chordParts = [];
-        for (const part of keybinding.parts) {
-            chordParts.push(this.simpleKeybindingToScanCodeBinding(part));
-        }
-        return this._toResolvedKeybinding(chordParts);
-    }
     _toResolvedKeybinding(chordParts) {
         if (chordParts.length === 0) {
             return [];
@@ -3858,29 +3895,25 @@ class MacLinuxKeyboardMapper {
                 }
             }
         }
-        const keypress = ( (new ScanCodeBinding(
-            keyboardEvent.ctrlKey,
-            keyboardEvent.shiftKey,
-            keyboardEvent.altKey,
-            keyboardEvent.metaKey,
-            code
-        )));
+        const ctrlKey = keyboardEvent.ctrlKey || (this._mapAltGrToCtrlAlt && keyboardEvent.altGraphKey);
+        const altKey = keyboardEvent.altKey || (this._mapAltGrToCtrlAlt && keyboardEvent.altGraphKey);
+        const chord = ( (new ScanCodeChord(ctrlKey, keyboardEvent.shiftKey, altKey, keyboardEvent.metaKey, code)));
         return (
-             (new NativeResolvedKeybinding(this, this._OS, [keypress]))
+             (new NativeResolvedKeybinding(this, this._OS, [chord]))
         );
     }
-    _resolveSimpleUserBinding(binding) {
-        if (!binding) {
+    _resolveChord(chord) {
+        if (!chord) {
             return [];
         }
-        if (binding instanceof ScanCodeBinding) {
-            return [binding];
+        if (chord instanceof ScanCodeChord) {
+            return [chord];
         }
-        return this.simpleKeybindingToScanCodeBinding(binding);
+        return this.keyCodeChordToScanCodeChord(chord);
     }
-    resolveUserBinding(input) {
-        const parts = input.map(keybinding => this._resolveSimpleUserBinding(keybinding));
-        return this._toResolvedKeybinding(parts);
+    resolveKeybinding(keybinding) {
+        const chords = keybinding.chords.map(chord => this._resolveChord(chord));
+        return this._toResolvedKeybinding(chords);
     }
     static _redirectCharCode(charCode) {
         switch (charCode) {
@@ -3970,27 +4003,7 @@ function __variableDynamicImportRuntime0__(path) {
     })
    }
  }
-class BrowserKeyboardMapperFactoryBase {
-    constructor(
-    ) {
-        this._onDidChangeKeyboardMapper = ( (new Emitter()));
-        this.onDidChangeKeyboardMapper = this._onDidChangeKeyboardMapper.event;
-        this._keyboardMapper = null;
-        this._initialized = false;
-        this._keymapInfos = [];
-        this._mru = [];
-        this._activeKeymapInfo = null;
-        if (navigator.keyboard && navigator.keyboard.addEventListener) {
-            navigator.keyboard.addEventListener('layoutchange', () => {
-                this._getBrowserKeyMapping().then((mapping) => {
-                    if (this.isKeyMappingActive(mapping)) {
-                        return;
-                    }
-                    this.setLayoutFromBrowserAPI();
-                });
-            });
-        }
-    }
+class BrowserKeyboardMapperFactoryBase extends Disposable {
     get activeKeymap() {
         return this._activeKeymapInfo;
     }
@@ -4001,17 +4014,44 @@ class BrowserKeyboardMapperFactoryBase {
         if (!this._initialized) {
             return null;
         }
-        return this._activeKeymapInfo && this._activeKeymapInfo.layout;
+        return this._activeKeymapInfo?.layout ?? null;
     }
     get activeKeyMapping() {
         if (!this._initialized) {
             return null;
         }
-        return this._activeKeymapInfo && this._activeKeymapInfo.mapping;
+        return this._activeKeymapInfo?.mapping ?? null;
     }
     get keyboardLayouts() {
         return this._keymapInfos.map(keymapInfo => keymapInfo.layout);
     }
+    constructor(_configurationService) {
+        super();
+        this._configurationService = _configurationService;
+        this._onDidChangeKeyboardMapper = ( (new Emitter()));
+        this.onDidChangeKeyboardMapper = this._onDidChangeKeyboardMapper.event;
+        this._keyboardMapper = null;
+        this._initialized = false;
+        this._keymapInfos = [];
+        this._mru = [];
+        this._activeKeymapInfo = null;
+        if (navigator.keyboard && navigator.keyboard.addEventListener) {
+            navigator.keyboard.addEventListener('layoutchange', () => {
+                this._getBrowserKeyMapping().then((mapping) => {
+                    if (this.isKeyMappingActive(mapping)) {
+                        return;
+                    }
+                    this.setLayoutFromBrowserAPI();
+                });
+            });
+        }
+        this._register(this._configurationService.onDidChangeConfiguration((e) => {
+            if (e.affectsConfiguration('keyboard')) {
+                this._keyboardMapper = null;
+                this._onDidChangeKeyboardMapper.fire();
+            }
+        }));
+    }
     registerKeyboardLayout(layout) {
         this._keymapInfos.push(layout);
         this._mru = this._keymapInfos;
@@ -4128,16 +4168,17 @@ class BrowserKeyboardMapperFactoryBase {
             this.setActiveKeyMapping(keyMap);
         });
     }
-    getKeyboardMapper(dispatchConfig) {
-        if (!this._initialized) {
+    getKeyboardMapper() {
+        const config = readKeyboardConfig(this._configurationService);
+        if (config.dispatch === 1  || !this._initialized || !this._activeKeymapInfo) {
             return (
-                 (new MacLinuxFallbackKeyboardMapper(OS))
+                 (new FallbackKeyboardMapper(config.mapAltGrToCtrlAlt, OS))
             );
         }
-        if (dispatchConfig === 1 ) {
-            return (
-                 (new MacLinuxFallbackKeyboardMapper(OS))
-            );
+        if (!this._keyboardMapper) {
+            this._keyboardMapper = ( (new CachedKeyboardMapper(
+                BrowserKeyboardMapperFactory._createKeyboardMapper(this._activeKeymapInfo, config.mapAltGrToCtrlAlt)
+            )));
         }
         return this._keyboardMapper;
     }
@@ -4159,24 +4200,24 @@ class BrowserKeyboardMapperFactoryBase {
     }
     _setKeyboardData(keymapInfo) {
         this._initialized = true;
-        this._keyboardMapper = ( (new CachedKeyboardMapper(BrowserKeyboardMapperFactory._createKeyboardMapper(keymapInfo))));
+        this._keyboardMapper = null;
         this._onDidChangeKeyboardMapper.fire();
     }
-    static _createKeyboardMapper(keymapInfo) {
+    static _createKeyboardMapper(keymapInfo, mapAltGrToCtrlAlt) {
         const rawMapping = keymapInfo.mapping;
         const isUSStandard = !!keymapInfo.layout.isUSStandard;
         if (OS === 1 ) {
             return (
-                 (new WindowsKeyboardMapper(isUSStandard, rawMapping))
+                 (new WindowsKeyboardMapper(isUSStandard, rawMapping, mapAltGrToCtrlAlt))
             );
         }
         if (( (Object.keys(rawMapping))).length === 0) {
             return (
-                 (new MacLinuxFallbackKeyboardMapper(OS))
+                 (new FallbackKeyboardMapper(mapAltGrToCtrlAlt, OS))
             );
         }
         return (
-             (new MacLinuxKeyboardMapper(isUSStandard, rawMapping, OS))
+             (new MacLinuxKeyboardMapper(isUSStandard, rawMapping, mapAltGrToCtrlAlt, OS))
         );
     }
     _validateCurrentKeyboardMapping(keyboardEvent) {
@@ -4261,8 +4302,8 @@ class BrowserKeyboardMapperFactoryBase {
     }
 }
 class BrowserKeyboardMapperFactory extends BrowserKeyboardMapperFactoryBase {
-    constructor(notificationService, storageService, commandService) {
-        super();
+    constructor(configurationService, notificationService, storageService, commandService) {
+        super(configurationService);
         const platform = isWindows ? 'win' : isMacintosh ? 'darwin' : 'linux';
         __variableDynamicImportRuntime0__('./keyboardLayouts/layout.contribution.' + platform + '.js').then((m) => {
             const keymapInfos = m.KeyboardLayoutContribution.INSTANCE.layoutInfos;
@@ -4279,6 +4320,7 @@ class BrowserKeyboardMapperFactory extends BrowserKeyboardMapperFactoryBase {
     }
 }
 class UserKeyboardLayout extends Disposable {
+    get keyboardLayout() { return this._keyboardLayout; }
     constructor(keyboardLayoutResource, fileService) {
         super();
         this.keyboardLayoutResource = keyboardLayoutResource;
@@ -4293,7 +4335,6 @@ class UserKeyboardLayout extends Disposable {
         }), 50))));
         this._register(Event.filter(this.fileService.onDidFilesChange, e => e.contains(this.keyboardLayoutResource))(() => this.reloadConfigurationScheduler.schedule()));
     }
-    get keyboardLayout() { return this._keyboardLayout; }
     async initialize() {
         await this.reload();
     }
@@ -4326,7 +4367,7 @@ let BrowserKeyboardLayoutService = class BrowserKeyboardLayoutService extends Di
         const keyboardConfig = configurationService.getValue('keyboard');
         const layout = keyboardConfig.layout;
         this._keyboardLayoutMode = layout ?? 'autodetect';
-        this._factory = ( (new BrowserKeyboardMapperFactory(notificationService, storageService, commandService)));
+        this._factory = ( (new BrowserKeyboardMapperFactory(configurationService, notificationService, storageService, commandService)));
         this._register(this._factory.onDidChangeKeyboardMapper(() => {
             this._onDidChangeKeyboardLayout.fire();
         }));
@@ -4334,7 +4375,7 @@ let BrowserKeyboardLayoutService = class BrowserKeyboardLayoutService extends Di
             this._factory.setKeyboardLayout(layout);
         }
         this._register(configurationService.onDidChangeConfiguration(e => {
-            if (e.affectedKeys.indexOf('keyboard.layout') >= 0) {
+            if (e.affectsConfiguration('keyboard.layout')) {
                 const keyboardConfig = configurationService.getValue('keyboard');
                 const layout = keyboardConfig.layout;
                 this._keyboardLayoutMode = layout;
@@ -4382,8 +4423,8 @@ let BrowserKeyboardLayoutService = class BrowserKeyboardLayoutService extends Di
             }
         }
     }
-    getKeyboardMapper(dispatchConfig) {
-        return this._factory.getKeyboardMapper(dispatchConfig);
+    getKeyboardMapper() {
+        return this._factory.getKeyboardMapper();
     }
     getCurrentKeyboardLayout() {
         return this._factory.activeKeyboardLayout;
@@ -4453,14 +4494,43 @@ const provider = quickAccessRegistry.getQuickAccessProviders().find(provider =>
 if (provider != null) {
     provider.ctor = class extends CommandsQuickAccessProvider {
         get defaultFilterValue() { return undefined; }
-        async getCommandPicks(disposables, token) {
-            return (await super.getCommandPicks(disposables, token)).map(pick => {
+        async getCommandPicks(token) {
+            return (await super.getCommandPicks(token)).map(pick => {
                 pick.buttons = [];
                 return pick;
             });
         }
     };
 }
+configurationRegistry$2.registerConfiguration({
+    properties: {
+        'workbench.commandPalette.history': {
+            type: 'number',
+            description: ( localize(
+                'commandHistory',
+                'Controls the number of recently used commands to keep in history for the command palette. Set to 0 to disable command history.'
+            )),
+            default: 50,
+            minimum: 0
+        },
+        'workbench.commandPalette.preserveInput': {
+            type: 'boolean',
+            description: ( localize(
+                'preserveInput',
+                'Controls whether the last typed input to the command palette should be restored when opening it the next time.'
+            )),
+            default: false
+        },
+        'workbench.commandPalette.experimental.suggestCommands': {
+            type: 'boolean',
+            description: ( localize(
+                'suggestCommands',
+                'Controls whether the command palette should have a list of commonly used commands.'
+            )),
+            default: false
+        }
+    }
+});
 const keybindingsExtensionPoint = getExtensionPoint('keybindings');
 const commandsExtensionPoint = getExtensionPoint('commands');
 function setKeybindings(grammars, extension = Services.get().extension ?? DEFAULT_EXTENSION) {
@@ -4484,6 +4554,7 @@ async function updateUserKeybindings(keybindingsJson) {
 function getServiceOverride() {
     return {
         ...getServiceOverride$1(),
+        ...getServiceOverride$2(),
         [( IKeybindingService.toString())]: new SyncDescriptor(DelegateStandaloneKeybindingService),
         [( IKeyboardLayoutService.toString())]: new SyncDescriptor(BrowserKeyboardLayoutService)
     };