@codingame/monaco-vscode-api 1.76.2 → 1.76.3-next.0

package/dist/keybindings.js

@@ -1,11 +1,10 @@
-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 { _ as __decorate, a as __param, J as IUserDataProfilesService, n as IFileService, I as IEditorService, d as IEditorGroupsService, e as IProductService, E as Emitter, t as IHostService } from './services2.js';
+import { h as index, p as parse, j as getNodeType, f as flatten } from './polyfill.js';
+import { q as isProposedApiEnabled, bR as IKeyboardLayoutService, bp as IExtensionService, bS as IPreferencesService, bT as getKeyboardLayoutId, bU as IUserDataProfileService, bV 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 { g as getExtensionPoint, E as ExtensionsRegistry, a as ExtensionMessageCollector, c as consoleExtensionMessageHandler } from './tools.js';
+import { E as ExtensionsRegistry } from './extensionsRegistry.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, 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/base/common/themables.js';
 import { joinPath, dirname } from 'monaco-editor/esm/vs/base/common/resources.js';
@@ -49,7 +48,6 @@ import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/c
 import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
 import { g as getServiceOverride$1 } from './files.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';
@@ -141,7 +139,8 @@ if (typeof navigator === 'object' && !isElectronRenderer) {
     _userAgent.indexOf('Linux') >= 0;
     _userAgent?.indexOf('Mobi') >= 0;
     const configuredLocale = getConfiguredDefaultLocale(
-    ( (localize({ key: 'ensureLoaderPluginIsLoaded', comment: ['{Locked}'] }, '_'))));
+    (
+    (localize({ key: 'ensureLoaderPluginIsLoaded', comment: ['{Locked}'] }, '_'))));
     _locale = configuredLocale || LANGUAGE_DEFAULT;
     _language = _locale;
 }
@@ -538,6 +537,151 @@ function printStandardKeyboardEvent(e) {
     }
     return `modifiers: [${modifiers.join(',')}], code: ${e.code}, keyCode: ${e.keyCode} ('${( ( KeyCodeUtils.toString(e.keyCode)))}')`;
 }
+class KeybindingParser {
+    static _readModifiers(input) {
+        input = input.toLowerCase().trim();
+        let ctrl = false;
+        let shift = false;
+        let alt = false;
+        let meta = false;
+        let matchedModifier;
+        do {
+            matchedModifier = false;
+            if (/^ctrl(\+|\-)/.test(input)) {
+                ctrl = true;
+                input = input.substr('ctrl-'.length);
+                matchedModifier = true;
+            }
+            if (/^shift(\+|\-)/.test(input)) {
+                shift = true;
+                input = input.substr('shift-'.length);
+                matchedModifier = true;
+            }
+            if (/^alt(\+|\-)/.test(input)) {
+                alt = true;
+                input = input.substr('alt-'.length);
+                matchedModifier = true;
+            }
+            if (/^meta(\+|\-)/.test(input)) {
+                meta = true;
+                input = input.substr('meta-'.length);
+                matchedModifier = true;
+            }
+            if (/^win(\+|\-)/.test(input)) {
+                meta = true;
+                input = input.substr('win-'.length);
+                matchedModifier = true;
+            }
+            if (/^cmd(\+|\-)/.test(input)) {
+                meta = true;
+                input = input.substr('cmd-'.length);
+                matchedModifier = true;
+            }
+        } while (matchedModifier);
+        let key;
+        const firstSpaceIdx = input.indexOf(' ');
+        if (firstSpaceIdx > 0) {
+            key = input.substring(0, firstSpaceIdx);
+            input = input.substring(firstSpaceIdx);
+        }
+        else {
+            key = input;
+            input = '';
+        }
+        return {
+            remains: input,
+            ctrl,
+            shift,
+            alt,
+            meta,
+            key
+        };
+    }
+    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 ScanCodeChord(mods.ctrl, mods.shift, mods.alt, mods.meta, scanCode))), mods.remains];
+        }
+        const keyCode = KeyCodeUtils.fromUserSettings(mods.key);
+        return [( (new KeyCodeChord(mods.ctrl, mods.shift, mods.alt, mods.meta, keyCode))), mods.remains];
+    }
+    static parseKeybinding(input) {
+        if (!input) {
+            return null;
+        }
+        const chords = [];
+        let chord;
+        while (input.length > 0) {
+            [chord, input] = this.parseChord(input);
+            chords.push(chord);
+        }
+        return (chords.length > 0 ?  (new Keybinding(chords)) : null);
+    }
+}
+class KeybindingIO {
+    static writeKeybindingItem(out, item) {
+        if (!item.resolvedKeybinding) {
+            return;
+        }
+        const quotedSerializedKeybinding = JSON.stringify(item.resolvedKeybinding.getUserSettingsLabel());
+        out.write(`{ "key": ${rightPaddedString(quotedSerializedKeybinding + ',', 25)} "command": `);
+        const quotedSerializedWhen = item.when ? JSON.stringify(item.when.serialize()) : '';
+        const quotedSerializeCommand = JSON.stringify(item.command);
+        if (quotedSerializedWhen.length > 0) {
+            out.write(`${quotedSerializeCommand},`);
+            out.writeLine();
+            out.write(`                                     "when": ${quotedSerializedWhen}`);
+        }
+        else {
+            out.write(`${quotedSerializeCommand}`);
+        }
+        if (item.commandArgs) {
+            out.write(',');
+            out.writeLine();
+            out.write(`                                     "args": ${JSON.stringify(item.commandArgs)}`);
+        }
+        out.write(' }');
+    }
+    static readUserKeybindingItem(input) {
+        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 {
+            keybinding,
+            command,
+            commandArgs,
+            when,
+            _source: input
+        };
+    }
+}
+function rightPaddedString(str, minChars) {
+    if (str.length < minChars) {
+        return str + (( (new Array(minChars - str.length))).join(' '));
+    }
+    return str;
+}
+class OutputBuilder {
+    constructor() {
+        this._lines = [];
+        this._currentLine = '';
+    }
+    write(str) {
+        this._currentLine += str;
+    }
+    writeLine(str = '') {
+        this._lines.push(this._currentLine + str);
+        this._currentLine = '';
+    }
+    toString() {
+        this.writeLine();
+        return this._lines.join('\n');
+    }
+}
 const apiMenus = [
     {
         key: 'commandPalette',
@@ -1271,7 +1415,7 @@ var schema$1;
     };
 })(schema$1 || (schema$1 = {}))));
 const _commandRegistrations = ( (new DisposableStore()));
-const commandsExtensionPoint$1 = ( (ExtensionsRegistry.registerExtensionPoint({
+const commandsExtensionPoint = ( (ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'commands',
     jsonSchema: schema$1.commandsContribution,
     activationEventsGenerator: (contribs, result) => {
@@ -1282,7 +1426,7 @@ const commandsExtensionPoint$1 = ( (ExtensionsRegistry.registerExtensionPoint({
         }
     }
 })));
-commandsExtensionPoint$1.setHandler(extensions => {
+commandsExtensionPoint.setHandler(extensions => {
     function handleCommand(userFriendlyCommand, extension) {
         if (!schema$1.isValidCommand(userFriendlyCommand, extension.collector)) {
             return;
@@ -1389,7 +1533,7 @@ submenusExtensionPoint.setHandler(extensions => {
         }
     }
 });
-const _apiMenusByKey = ( (new Map(apiMenus.map(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({
@@ -1544,174 +1688,29 @@ function getAllUnboundCommands(boundCommands) {
     }
     return unboundCommands;
 }
-class KeybindingParser {
-    static _readModifiers(input) {
-        input = input.toLowerCase().trim();
-        let ctrl = false;
-        let shift = false;
-        let alt = false;
-        let meta = false;
-        let matchedModifier;
-        do {
-            matchedModifier = false;
-            if (/^ctrl(\+|\-)/.test(input)) {
-                ctrl = true;
-                input = input.substr('ctrl-'.length);
-                matchedModifier = true;
-            }
-            if (/^shift(\+|\-)/.test(input)) {
-                shift = true;
-                input = input.substr('shift-'.length);
-                matchedModifier = true;
-            }
-            if (/^alt(\+|\-)/.test(input)) {
-                alt = true;
-                input = input.substr('alt-'.length);
-                matchedModifier = true;
-            }
-            if (/^meta(\+|\-)/.test(input)) {
-                meta = true;
-                input = input.substr('meta-'.length);
-                matchedModifier = true;
-            }
-            if (/^win(\+|\-)/.test(input)) {
-                meta = true;
-                input = input.substr('win-'.length);
-                matchedModifier = true;
-            }
-            if (/^cmd(\+|\-)/.test(input)) {
-                meta = true;
-                input = input.substr('cmd-'.length);
-                matchedModifier = true;
-            }
-        } while (matchedModifier);
-        let key;
-        const firstSpaceIdx = input.indexOf(' ');
-        if (firstSpaceIdx > 0) {
-            key = input.substring(0, firstSpaceIdx);
-            input = input.substring(firstSpaceIdx);
-        }
-        else {
-            key = input;
-            input = '';
-        }
-        return {
-            remains: input,
-            ctrl,
-            shift,
-            alt,
-            meta,
-            key
-        };
+function isContributedKeyBindingsArray(thing) {
+    return Array.isArray(thing);
+}
+function isValidContributedKeyBinding(keyBinding, rejects) {
+    if (!keyBinding) {
+        rejects.push(( (localize('nonempty', "expected non-empty value."))));
+        return false;
     }
-    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 ScanCodeChord(mods.ctrl, mods.shift, mods.alt, mods.meta, scanCode))), mods.remains];
-        }
-        const keyCode = KeyCodeUtils.fromUserSettings(mods.key);
-        return [( (new KeyCodeChord(mods.ctrl, mods.shift, mods.alt, mods.meta, keyCode))), mods.remains];
+    if (typeof keyBinding.command !== 'string') {
+        rejects.push(( (localize(
+            'requirestring',
+            "property `{0}` is mandatory and must be of type `string`",
+            'command'
+        ))));
+        return false;
     }
-    static parseKeybinding(input) {
-        if (!input) {
-            return null;
-        }
-        const chords = [];
-        let chord;
-        while (input.length > 0) {
-            [chord, input] = this.parseChord(input);
-            chords.push(chord);
-        }
-        return (chords.length > 0 ?  (new Keybinding(chords)) : null);
-    }
-}
-class KeybindingIO {
-    static writeKeybindingItem(out, item) {
-        if (!item.resolvedKeybinding) {
-            return;
-        }
-        const quotedSerializedKeybinding = JSON.stringify(item.resolvedKeybinding.getUserSettingsLabel());
-        out.write(`{ "key": ${rightPaddedString(quotedSerializedKeybinding + ',', 25)} "command": `);
-        const quotedSerializedWhen = item.when ? JSON.stringify(item.when.serialize()) : '';
-        const quotedSerializeCommand = JSON.stringify(item.command);
-        if (quotedSerializedWhen.length > 0) {
-            out.write(`${quotedSerializeCommand},`);
-            out.writeLine();
-            out.write(`                                     "when": ${quotedSerializedWhen}`);
-        }
-        else {
-            out.write(`${quotedSerializeCommand}`);
-        }
-        if (item.commandArgs) {
-            out.write(',');
-            out.writeLine();
-            out.write(`                                     "args": ${JSON.stringify(item.commandArgs)}`);
-        }
-        out.write(' }');
-    }
-    static readUserKeybindingItem(input) {
-        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 {
-            keybinding,
-            command,
-            commandArgs,
-            when,
-            _source: input
-        };
-    }
-}
-function rightPaddedString(str, minChars) {
-    if (str.length < minChars) {
-        return str + (( (new Array(minChars - str.length))).join(' '));
-    }
-    return str;
-}
-class OutputBuilder {
-    constructor() {
-        this._lines = [];
-        this._currentLine = '';
-    }
-    write(str) {
-        this._currentLine += str;
-    }
-    writeLine(str = '') {
-        this._lines.push(this._currentLine + str);
-        this._currentLine = '';
-    }
-    toString() {
-        this.writeLine();
-        return this._lines.join('\n');
-    }
-}
-function isContributedKeyBindingsArray(thing) {
-    return Array.isArray(thing);
-}
-function isValidContributedKeyBinding(keyBinding, rejects) {
-    if (!keyBinding) {
-        rejects.push(( (localize('nonempty', "expected non-empty value."))));
-        return false;
-    }
-    if (typeof keyBinding.command !== 'string') {
-        rejects.push(( (localize(
-            'requirestring',
-            "property `{0}` is mandatory and must be of type `string`",
-            'command'
-        ))));
-        return false;
-    }
-    if (keyBinding.key && typeof keyBinding.key !== 'string') {
-        rejects.push(( (localize(
-            'optstring',
-            "property `{0}` can be omitted or must be of type `string`",
-            'key'
-        ))));
-        return false;
+    if (keyBinding.key && typeof keyBinding.key !== 'string') {
+        rejects.push(( (localize(
+            'optstring',
+            "property `{0}` can be omitted or must be of type `string`",
+            'key'
+        ))));
+        return false;
     }
     if (keyBinding.when && typeof keyBinding.when !== 'string') {
         rejects.push(( (localize(
@@ -1803,7 +1802,7 @@ const keybindingType = {
 };
 const keybindingsExtPoint = ( (ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'keybindings',
-    deps: [commandsExtensionPoint$1],
+    deps: [commandsExtensionPoint],
     jsonSchema: {
         description: ( (localize('vscode.extension.contributes.keybindings', "Contributes keybindings."))),
         oneOf: [
@@ -1920,7 +1919,7 @@ let WorkbenchKeybindingService = class WorkbenchKeybindingService extends Abstra
         this.updateSchema();
     }
     updateSchema() {
-        updateSchema(flatten(this._contributions.map(x => x.getSchemaAdditions())));
+        updateSchema(flatten(( (this._contributions.map(x => x.getSchemaAdditions())))));
     }
     _printKeybinding(keybinding) {
         return UserSettingsLabelProvider.toLabel(OS, keybinding.chords, (chord) => {
@@ -1935,7 +1934,7 @@ let WorkbenchKeybindingService = class WorkbenchKeybindingService extends Abstra
         }) || '[null]';
     }
     _printResolvedKeybinding(resolvedKeybinding) {
-        return resolvedKeybinding.getDispatchChords().map(x => x || '[null]').join(' ');
+        return ( (resolvedKeybinding.getDispatchChords().map(x => x || '[null]'))).join(' ');
     }
     _printResolvedKeybindings(output, input, resolvedKeybindings) {
         const padLength = 35;
@@ -2339,7 +2338,7 @@ class UserKeybindings extends Disposable {
             return false;
         }
         this._rawKeybindings = newKeybindings;
-        this._keybindings = this._rawKeybindings.map((k) => KeybindingIO.readUserKeybindingItem(k));
+        this._keybindings = ( (this._rawKeybindings.map((k) => KeybindingIO.readUserKeybindingItem(k))));
         return true;
     }
     async readUserKeybindings() {
@@ -2465,59 +2464,353 @@ function updateSchema(additionalContributions) {
     commandsSchemas.push(...additionalContributions);
     schemaRegistry.notifySchemaChanged(schemaId);
 }
-class WindowsNativeResolvedKeybinding extends BaseResolvedKeybinding {
-    constructor(mapper, chords) {
-        super(1 , chords);
-        this._mapper = mapper;
+let CommandsQuickAccessProvider = class CommandsQuickAccessProvider extends AbstractEditorCommandsQuickAccessProvider {
+    get activeTextEditorControl() { return this.editorService.activeTextEditorControl; }
+    get defaultFilterValue() {
+        if (this.configuration.preserveInput) {
+            return DefaultQuickAccessFilterValue.LAST;
+        }
+        return undefined;
     }
-    _getLabel(chord) {
-        if (chord.isDuplicateModifierCase()) {
-            return '';
+    constructor(editorService, menuService, extensionService, instantiationService, keybindingService, commandService, telemetryService, dialogService, configurationService, editorGroupService, preferencesService, productService) {
+        super({
+            showAlias: !Language.isDefaultVariant(),
+            noResultsPick: {
+                label: ( (localize('noCommandResults', "No matching commands"))),
+                commandId: ''
+            }
+        }, instantiationService, keybindingService, commandService, telemetryService, dialogService);
+        this.editorService = editorService;
+        this.menuService = menuService;
+        this.extensionService = extensionService;
+        this.configurationService = configurationService;
+        this.editorGroupService = editorGroupService;
+        this.preferencesService = preferencesService;
+        this.productService = productService;
+        this.extensionRegistrationRace = Promise.race([
+            timeout(800),
+            this.extensionService.whenInstalledExtensionsRegistered()
+        ]);
+        this._register(configurationService.onDidChangeConfiguration((e) => this.updateSuggestedCommandIds(e)));
+        this.updateSuggestedCommandIds();
+    }
+    get configuration() {
+        const commandPaletteConfig = this.configurationService.getValue().workbench.commandPalette;
+        return {
+            preserveInput: commandPaletteConfig.preserveInput,
+            experimental: commandPaletteConfig.experimental
+        };
+    }
+    updateSuggestedCommandIds(e) {
+        if (e && !e.affectsConfiguration('workbench.commandPalette.experimental.suggestCommands')) {
+            return;
         }
-        return this._mapper.getUILabelForKeyCode(chord.keyCode);
+        const config = this.configuration;
+        const suggestedCommandIds = config.experimental.suggestCommands && this.productService.commandPaletteSuggestedCommandIds?.length
+            ? ( (new Set(this.productService.commandPaletteSuggestedCommandIds)))
+            : undefined;
+        this.options.suggestedCommandIds = suggestedCommandIds;
     }
-    _getUSLabelForKeybinding(chord) {
-        if (chord.isDuplicateModifierCase()) {
-            return '';
+    async getCommandPicks(token) {
+        await this.extensionRegistrationRace;
+        if (token.isCancellationRequested) {
+            return [];
         }
         return (
-             (KeyCodeUtils.toString(chord.keyCode))
+             ([
+                ...this.getCodeEditorCommandPicks(),
+                ...this.getGlobalCommandPicks()
+            ].map(c => ({
+                ...c,
+                buttons: [{
+                        iconClass: ThemeIcon.asClassName(Codicon.gear),
+                        tooltip: ( (localize('configure keybinding', "Configure Keybinding"))),
+                    }],
+                trigger: () => {
+                    this.preferencesService.openGlobalKeybindingSettings(false, { query: `@command:${c.commandId}` });
+                    return TriggerAction.CLOSE_PICKER;
+                },
+            })))
         );
     }
-    getUSLabel() {
-        return UILabelProvider.toLabel(this._os, this._chords, (keybinding) => this._getUSLabelForKeybinding(keybinding));
-    }
-    _getAriaLabel(chord) {
-        if (chord.isDuplicateModifierCase()) {
-            return '';
+    getGlobalCommandPicks() {
+        const globalCommandPicks = [];
+        const scopedContextKeyService = this.editorService.activeEditorPane?.scopedContextKeyService || this.editorGroupService.activeGroup.scopedContextKeyService;
+        const globalCommandsMenu = this.menuService.createMenu(MenuId.CommandPalette, scopedContextKeyService);
+        const globalCommandsMenuActions = globalCommandsMenu.getActions()
+            .reduce((r, [, actions]) => [...r, ...actions], [])
+            .filter(action => action instanceof MenuItemAction && action.enabled);
+        for (const action of globalCommandsMenuActions) {
+            let label = (typeof action.item.title === 'string' ? action.item.title : action.item.title.value) || action.item.id;
+            const category = typeof action.item.category === 'string' ? action.item.category : action.item.category?.value;
+            if (category) {
+                label = ( (localize('commandWithCategory', "{0}: {1}", category, label)));
+            }
+            const aliasLabel = typeof action.item.title !== 'string' ? action.item.title.original : undefined;
+            const aliasCategory = (category && action.item.category && typeof action.item.category !== 'string') ? action.item.category.original : undefined;
+            const commandAlias = (aliasLabel && category) ?
+                aliasCategory ? `${aliasCategory}: ${aliasLabel}` : `${category}: ${aliasLabel}` :
+                aliasLabel;
+            globalCommandPicks.push({
+                commandId: action.item.id,
+                commandAlias,
+                label: stripIcons(label)
+            });
         }
-        return this._mapper.getAriaLabelForKeyCode(chord.keyCode);
-    }
-    _getElectronAccelerator(chord) {
-        return this._mapper.getElectronAcceleratorForKeyBinding(chord);
+        globalCommandsMenu.dispose();
+        return globalCommandPicks;
     }
-    _getUserSettingsLabel(chord) {
-        if (chord.isDuplicateModifierCase()) {
-            return '';
-        }
-        const result = this._mapper.getUserSettingsLabelForKeyCode(chord.keyCode);
-        return (result ? result.toLowerCase() : result);
+};
+CommandsQuickAccessProvider = ( (__decorate([
+    ( (__param(0, IEditorService))),
+    ( (__param(1, IMenuService))),
+    ( (__param(2, IExtensionService))),
+    ( (__param(3, IInstantiationService))),
+    ( (__param(4, IKeybindingService))),
+    ( (__param(5, ICommandService))),
+    ( (__param(6, ITelemetryService))),
+    ( (__param(7, IDialogService))),
+    ( (__param(8, IConfigurationService))),
+    ( (__param(9, IEditorGroupsService))),
+    ( (__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
+        });
     }
-    _isWYSIWYG(chord) {
-        return this.__isWYSIWYG(chord.keyCode);
+    async run(accessor) {
+        accessor.get(IQuickInputService).quickAccess.show(CommandsQuickAccessProvider.PREFIX);
     }
-    __isWYSIWYG(keyCode) {
-        if (keyCode === 15
-            || keyCode === 16
-            || keyCode === 17
-            || keyCode === 18 ) {
-            return true;
+}
+ShowAllCommandsAction.ID = 'workbench.action.showCommands';
+function deserializeMapping(serializedMapping) {
+    const mapping = serializedMapping;
+    const ret = {};
+    for (const key in mapping) {
+        const result = mapping[key];
+        if (result.length) {
+            const value = result[0];
+            const withShift = result[1];
+            const withAltGr = result[2];
+            const withShiftAltGr = result[3];
+            const mask = Number(result[4]);
+            const vkey = result.length === 6 ? result[5] : undefined;
+            ret[key] = {
+                'value': value,
+                'vkey': vkey,
+                'withShift': withShift,
+                'withAltGr': withAltGr,
+                'withShiftAltGr': withShiftAltGr,
+                'valueIsDeadKey': (mask & 1) > 0,
+                'withShiftIsDeadKey': (mask & 2) > 0,
+                'withAltGrIsDeadKey': (mask & 4) > 0,
+                'withShiftAltGrIsDeadKey': (mask & 8) > 0
+            };
+        }
+        else {
+            ret[key] = {
+                'value': '',
+                'valueIsDeadKey': false,
+                'withShift': '',
+                'withShiftIsDeadKey': false,
+                'withAltGr': '',
+                'withAltGrIsDeadKey': false,
+                'withShiftAltGr': '',
+                'withShiftAltGrIsDeadKey': false
+            };
         }
-        const ariaLabel = this._mapper.getAriaLabelForKeyCode(keyCode);
-        const userSettingsLabel = this._mapper.getUserSettingsLabelForKeyCode(keyCode);
-        return (ariaLabel === userSettingsLabel);
     }
-    _getChordDispatch(chord) {
+    return ret;
+}
+class KeymapInfo {
+    constructor(layout, secondaryLayouts, keyboardMapping, isUserKeyboardLayout) {
+        this.layout = layout;
+        this.secondaryLayouts = secondaryLayouts;
+        this.mapping = deserializeMapping(keyboardMapping);
+        this.isUserKeyboardLayout = !!isUserKeyboardLayout;
+        this.layout.isUserKeyboardLayout = !!isUserKeyboardLayout;
+    }
+    static createKeyboardLayoutFromDebugInfo(layout, value, isUserKeyboardLayout) {
+        const keyboardLayoutInfo = ( (new KeymapInfo(layout, [], {}, true)));
+        keyboardLayoutInfo.mapping = value;
+        return keyboardLayoutInfo;
+    }
+    update(other) {
+        this.layout = other.layout;
+        this.secondaryLayouts = other.secondaryLayouts;
+        this.mapping = other.mapping;
+        this.isUserKeyboardLayout = other.isUserKeyboardLayout;
+        this.layout.isUserKeyboardLayout = other.isUserKeyboardLayout;
+    }
+    getScore(other) {
+        let score = 0;
+        for (const key in other) {
+            if (isWindows && (key === 'Backslash' || key === 'KeyQ')) {
+                continue;
+            }
+            if (isLinux && (key === 'Backspace' || key === 'Escape')) {
+                continue;
+            }
+            const currentMapping = this.mapping[key];
+            if (currentMapping === undefined) {
+                score -= 1;
+            }
+            const otherMapping = other[key];
+            if (currentMapping && otherMapping && currentMapping.value !== otherMapping.value) {
+                score -= 1;
+            }
+        }
+        return score;
+    }
+    equal(other) {
+        if (this.isUserKeyboardLayout !== other.isUserKeyboardLayout) {
+            return false;
+        }
+        if (getKeyboardLayoutId(this.layout) !== getKeyboardLayoutId(other.layout)) {
+            return false;
+        }
+        return this.fuzzyEqual(other.mapping);
+    }
+    fuzzyEqual(other) {
+        for (const key in other) {
+            if (isWindows && (key === 'Backslash' || key === 'KeyQ')) {
+                continue;
+            }
+            if (this.mapping[key] === undefined) {
+                return false;
+            }
+            const currentMapping = this.mapping[key];
+            const otherMapping = other[key];
+            if (currentMapping.value !== otherMapping.value) {
+                return false;
+            }
+        }
+        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;
+        this._cache = ( (new Map()));
+    }
+    dumpDebugInfo() {
+        return this._actual.dumpDebugInfo();
+    }
+    resolveKeyboardEvent(keyboardEvent) {
+        return this._actual.resolveKeyboardEvent(keyboardEvent);
+    }
+    resolveKeybinding(keybinding) {
+        const hashCode = keybinding.getHashCode();
+        const resolved = this._cache.get(hashCode);
+        if (!resolved) {
+            const r = this._actual.resolveKeybinding(keybinding);
+            this._cache.set(hashCode, r);
+            return r;
+        }
+        return resolved;
+    }
+}
+class WindowsNativeResolvedKeybinding extends BaseResolvedKeybinding {
+    constructor(mapper, chords) {
+        super(1 , chords);
+        this._mapper = mapper;
+    }
+    _getLabel(chord) {
+        if (chord.isDuplicateModifierCase()) {
+            return '';
+        }
+        return this._mapper.getUILabelForKeyCode(chord.keyCode);
+    }
+    _getUSLabelForKeybinding(chord) {
+        if (chord.isDuplicateModifierCase()) {
+            return '';
+        }
+        return (
+             (KeyCodeUtils.toString(chord.keyCode))
+        );
+    }
+    getUSLabel() {
+        return UILabelProvider.toLabel(this._os, this._chords, (keybinding) => this._getUSLabelForKeybinding(keybinding));
+    }
+    _getAriaLabel(chord) {
+        if (chord.isDuplicateModifierCase()) {
+            return '';
+        }
+        return this._mapper.getAriaLabelForKeyCode(chord.keyCode);
+    }
+    _getElectronAccelerator(chord) {
+        return this._mapper.getElectronAcceleratorForKeyBinding(chord);
+    }
+    _getUserSettingsLabel(chord) {
+        if (chord.isDuplicateModifierCase()) {
+            return '';
+        }
+        const result = this._mapper.getUserSettingsLabelForKeyCode(chord.keyCode);
+        return (result ? result.toLowerCase() : result);
+    }
+    _isWYSIWYG(chord) {
+        return this.__isWYSIWYG(chord.keyCode);
+    }
+    __isWYSIWYG(keyCode) {
+        if (keyCode === 15
+            || keyCode === 16
+            || keyCode === 17
+            || keyCode === 18 ) {
+            return true;
+        }
+        const ariaLabel = this._mapper.getAriaLabelForKeyCode(keyCode);
+        const userSettingsLabel = this._mapper.getUserSettingsLabelForKeyCode(keyCode);
+        return (ariaLabel === userSettingsLabel);
+    }
+    _getChordDispatch(chord) {
         if (chord.isModifierKey()) {
             return null;
         }
@@ -2649,462 +2942,170 @@ class WindowsKeyboardMapper {
                         producesLetter[charCode] = true;
                         producesLetters = true;
                         this._keyCodeToLabel[keyCode] = value;
-                    }
-                    else {
-                        this._keyCodeToLabel[keyCode] = value;
-                    }
-                }
-            }
-        }
-        const _registerLetterIfMissing = (charCode, keyCode) => {
-            if (!producesLetter[charCode]) {
-                this._keyCodeToLabel[keyCode] = String.fromCharCode(charCode);
-            }
-        };
-        _registerLetterIfMissing(65 , 31 );
-        _registerLetterIfMissing(66 , 32 );
-        _registerLetterIfMissing(67 , 33 );
-        _registerLetterIfMissing(68 , 34 );
-        _registerLetterIfMissing(69 , 35 );
-        _registerLetterIfMissing(70 , 36 );
-        _registerLetterIfMissing(71 , 37 );
-        _registerLetterIfMissing(72 , 38 );
-        _registerLetterIfMissing(73 , 39 );
-        _registerLetterIfMissing(74 , 40 );
-        _registerLetterIfMissing(75 , 41 );
-        _registerLetterIfMissing(76 , 42 );
-        _registerLetterIfMissing(77 , 43 );
-        _registerLetterIfMissing(78 , 44 );
-        _registerLetterIfMissing(79 , 45 );
-        _registerLetterIfMissing(80 , 46 );
-        _registerLetterIfMissing(81 , 47 );
-        _registerLetterIfMissing(82 , 48 );
-        _registerLetterIfMissing(83 , 49 );
-        _registerLetterIfMissing(84 , 50 );
-        _registerLetterIfMissing(85 , 51 );
-        _registerLetterIfMissing(86 , 52 );
-        _registerLetterIfMissing(87 , 53 );
-        _registerLetterIfMissing(88 , 54 );
-        _registerLetterIfMissing(89 , 55 );
-        _registerLetterIfMissing(90 , 56 );
-        if (!producesLetters) {
-            const _registerLabel = (keyCode, charCode) => {
-                this._keyCodeToLabel[keyCode] = String.fromCharCode(charCode);
-            };
-            _registerLabel(80 , 59 );
-            _registerLabel(81 , 61 );
-            _registerLabel(82 , 44 );
-            _registerLabel(83 , 45 );
-            _registerLabel(84 , 46 );
-            _registerLabel(85 , 47 );
-            _registerLabel(86 , 96 );
-            _registerLabel(87 , 91 );
-            _registerLabel(88 , 92 );
-            _registerLabel(89 , 93 );
-            _registerLabel(90 , 39 );
-        }
-    }
-    dumpDebugInfo() {
-        const result = [];
-        const immutableSamples = [
-            88 ,
-            104
-        ];
-        let cnt = 0;
-        result.push(`-----------------------------------------------------------------------------------------------------------------------------------------`);
-        for (let scanCode = 0 ; scanCode < 193 ; scanCode++) {
-            if (IMMUTABLE_CODE_TO_KEY_CODE[scanCode] !== -1 ) {
-                if (immutableSamples.indexOf(scanCode) === -1) {
-                    continue;
-                }
-            }
-            if (cnt % 6 === 0) {
-                result.push(`|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |`);
-                result.push(`-----------------------------------------------------------------------------------------------------------------------------------------`);
-            }
-            cnt++;
-            const mapping = this._codeInfo[scanCode];
-            const strCode = ( (ScanCodeUtils.toString(scanCode)));
-            const mods = [0b000, 0b010, 0b101, 0b111];
-            for (const mod of mods) {
-                const ctrlKey = (mod & 0b001) ? true : false;
-                const shiftKey = (mod & 0b010) ? true : false;
-                const altKey = (mod & 0b100) ? true : false;
-                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(scanCodeChord, mapping);
-                const outKb = (strKeyCode ? `${ctrlKey ? 'Ctrl+' : ''}${shiftKey ? 'Shift+' : ''}${altKey ? 'Alt+' : ''}${strKeyCode}` : null);
-                const isWYSIWYG = (resolvedKb ? resolvedKb.isWYSIWYG() : false);
-                const outWYSIWYG = (isWYSIWYG ? '       ' : '   NO  ');
-                result.push(`| ${this._leftPad(outScanCode, 30)} | ${outKey} | ${this._leftPad(outKb, 25)} | ${this._leftPad(outUILabel, 25)} |  ${this._leftPad(outUserSettings, 25)} | ${outWYSIWYG} |`);
-            }
-            result.push(`-----------------------------------------------------------------------------------------------------------------------------------------`);
-        }
-        return result.join('\n');
-    }
-    _leftPad(str, cnt) {
-        if (str === null) {
-            str = 'null';
-        }
-        while (str.length < cnt) {
-            str = ' ' + str;
-        }
-        return str;
-    }
-    getUILabelForKeyCode(keyCode) {
-        return this._getLabelForKeyCode(keyCode);
-    }
-    getAriaLabelForKeyCode(keyCode) {
-        return this._getLabelForKeyCode(keyCode);
-    }
-    getUserSettingsLabelForKeyCode(keyCode) {
-        if (this._isUSStandard) {
-            return KeyCodeUtils.toUserSettingsUS(keyCode);
-        }
-        return KeyCodeUtils.toUserSettingsGeneral(keyCode);
-    }
-    getElectronAcceleratorForKeyBinding(chord) {
-        return KeyCodeUtils.toElectronAccelerator(chord.keyCode);
-    }
-    _getLabelForKeyCode(keyCode) {
-        return this._keyCodeToLabel[keyCode] || ( (KeyCodeUtils.toString(0 )));
-    }
-    resolveKeyboardEvent(keyboardEvent) {
-        const ctrlKey = keyboardEvent.ctrlKey || (this._mapAltGrToCtrlAlt && keyboardEvent.altGraphKey);
-        const altKey = keyboardEvent.altKey || (this._mapAltGrToCtrlAlt && keyboardEvent.altGraphKey);
-        const chord = ( (new KeyCodeChord(
-            ctrlKey,
-            keyboardEvent.shiftKey,
-            altKey,
-            keyboardEvent.metaKey,
-            keyboardEvent.keyCode
-        )));
-        return (
-             (new WindowsNativeResolvedKeybinding(this, [chord]))
-        );
-    }
-    _resolveChord(chord) {
-        if (!chord) {
-            return null;
-        }
-        if (chord instanceof KeyCodeChord) {
-            if (!this._keyCodeExists[chord.keyCode]) {
-                return null;
-            }
-            return chord;
-        }
-        const keyCode = this._scanCodeToKeyCode[chord.scanCode] || 0 ;
-        if (keyCode === 0  || !this._keyCodeExists[keyCode]) {
-            return null;
-        }
-        return (
-             (new KeyCodeChord(chord.ctrlKey, chord.shiftKey, chord.altKey, chord.metaKey, keyCode))
-        );
-    }
-    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 {
-    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: {
-                label: ( (localize('noCommandResults', "No matching commands"))),
-                commandId: ''
-            }
-        }, instantiationService, keybindingService, commandService, telemetryService, dialogService);
-        this.editorService = editorService;
-        this.menuService = menuService;
-        this.extensionService = extensionService;
-        this.configurationService = configurationService;
-        this.editorGroupService = editorGroupService;
-        this.preferencesService = preferencesService;
-        this.productService = productService;
-        this.extensionRegistrationRace = Promise.race([
-            timeout(800),
-            this.extensionService.whenInstalledExtensionsRegistered()
-        ]);
-        this._register(configurationService.onDidChangeConfiguration((e) => this.updateSuggestedCommandIds(e)));
-        this.updateSuggestedCommandIds();
-    }
-    get configuration() {
-        const commandPaletteConfig = this.configurationService.getValue().workbench.commandPalette;
-        return {
-            preserveInput: commandPaletteConfig.preserveInput,
-            experimental: commandPaletteConfig.experimental
-        };
-    }
-    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()
-        ].map(c => ({
-            ...c,
-            buttons: [{
-                    iconClass: ThemeIcon.asClassName(Codicon.gear),
-                    tooltip: ( (localize('configure keybinding', "Configure Keybinding"))),
-                }],
-            trigger: () => {
-                this.preferencesService.openGlobalKeybindingSettings(false, { query: `@command:${c.commandId}` });
-                return TriggerAction.CLOSE_PICKER;
-            },
-        }));
-    }
-    getGlobalCommandPicks() {
-        const globalCommandPicks = [];
-        const scopedContextKeyService = this.editorService.activeEditorPane?.scopedContextKeyService || this.editorGroupService.activeGroup.scopedContextKeyService;
-        const globalCommandsMenu = this.menuService.createMenu(MenuId.CommandPalette, scopedContextKeyService);
-        const globalCommandsMenuActions = globalCommandsMenu.getActions()
-            .reduce((r, [, actions]) => [...r, ...actions], [])
-            .filter(action => action instanceof MenuItemAction && action.enabled);
-        for (const action of globalCommandsMenuActions) {
-            let label = (typeof action.item.title === 'string' ? action.item.title : action.item.title.value) || action.item.id;
-            const category = typeof action.item.category === 'string' ? action.item.category : action.item.category?.value;
-            if (category) {
-                label = ( (localize('commandWithCategory', "{0}: {1}", category, label)));
-            }
-            const aliasLabel = typeof action.item.title !== 'string' ? action.item.title.original : undefined;
-            const aliasCategory = (category && action.item.category && typeof action.item.category !== 'string') ? action.item.category.original : undefined;
-            const commandAlias = (aliasLabel && category) ?
-                aliasCategory ? `${aliasCategory}: ${aliasLabel}` : `${category}: ${aliasLabel}` :
-                aliasLabel;
-            globalCommandPicks.push({
-                commandId: action.item.id,
-                commandAlias,
-                label: stripIcons(label)
-            });
-        }
-        globalCommandsMenu.dispose();
-        return globalCommandPicks;
-    }
-};
-CommandsQuickAccessProvider = ( (__decorate([
-    ( (__param(0, IEditorService))),
-    ( (__param(1, IMenuService))),
-    ( (__param(2, IExtensionService))),
-    ( (__param(3, IInstantiationService))),
-    ( (__param(4, IKeybindingService))),
-    ( (__param(5, ICommandService))),
-    ( (__param(6, ITelemetryService))),
-    ( (__param(7, IDialogService))),
-    ( (__param(8, IConfigurationService))),
-    ( (__param(9, IEditorGroupsService))),
-    ( (__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 = {};
-    for (const key in mapping) {
-        const result = mapping[key];
-        if (result.length) {
-            const value = result[0];
-            const withShift = result[1];
-            const withAltGr = result[2];
-            const withShiftAltGr = result[3];
-            const mask = Number(result[4]);
-            const vkey = result.length === 6 ? result[5] : undefined;
-            ret[key] = {
-                'value': value,
-                'vkey': vkey,
-                'withShift': withShift,
-                'withAltGr': withAltGr,
-                'withShiftAltGr': withShiftAltGr,
-                'valueIsDeadKey': (mask & 1) > 0,
-                'withShiftIsDeadKey': (mask & 2) > 0,
-                'withAltGrIsDeadKey': (mask & 4) > 0,
-                'withShiftAltGrIsDeadKey': (mask & 8) > 0
-            };
-        }
-        else {
-            ret[key] = {
-                'value': '',
-                'valueIsDeadKey': false,
-                'withShift': '',
-                'withShiftIsDeadKey': false,
-                'withAltGr': '',
-                'withAltGrIsDeadKey': false,
-                'withShiftAltGr': '',
-                'withShiftAltGrIsDeadKey': false
+                    }
+                    else {
+                        this._keyCodeToLabel[keyCode] = value;
+                    }
+                }
+            }
+        }
+        const _registerLetterIfMissing = (charCode, keyCode) => {
+            if (!producesLetter[charCode]) {
+                this._keyCodeToLabel[keyCode] = String.fromCharCode(charCode);
+            }
+        };
+        _registerLetterIfMissing(65 , 31 );
+        _registerLetterIfMissing(66 , 32 );
+        _registerLetterIfMissing(67 , 33 );
+        _registerLetterIfMissing(68 , 34 );
+        _registerLetterIfMissing(69 , 35 );
+        _registerLetterIfMissing(70 , 36 );
+        _registerLetterIfMissing(71 , 37 );
+        _registerLetterIfMissing(72 , 38 );
+        _registerLetterIfMissing(73 , 39 );
+        _registerLetterIfMissing(74 , 40 );
+        _registerLetterIfMissing(75 , 41 );
+        _registerLetterIfMissing(76 , 42 );
+        _registerLetterIfMissing(77 , 43 );
+        _registerLetterIfMissing(78 , 44 );
+        _registerLetterIfMissing(79 , 45 );
+        _registerLetterIfMissing(80 , 46 );
+        _registerLetterIfMissing(81 , 47 );
+        _registerLetterIfMissing(82 , 48 );
+        _registerLetterIfMissing(83 , 49 );
+        _registerLetterIfMissing(84 , 50 );
+        _registerLetterIfMissing(85 , 51 );
+        _registerLetterIfMissing(86 , 52 );
+        _registerLetterIfMissing(87 , 53 );
+        _registerLetterIfMissing(88 , 54 );
+        _registerLetterIfMissing(89 , 55 );
+        _registerLetterIfMissing(90 , 56 );
+        if (!producesLetters) {
+            const _registerLabel = (keyCode, charCode) => {
+                this._keyCodeToLabel[keyCode] = String.fromCharCode(charCode);
             };
+            _registerLabel(80 , 59 );
+            _registerLabel(81 , 61 );
+            _registerLabel(82 , 44 );
+            _registerLabel(83 , 45 );
+            _registerLabel(84 , 46 );
+            _registerLabel(85 , 47 );
+            _registerLabel(86 , 96 );
+            _registerLabel(87 , 91 );
+            _registerLabel(88 , 92 );
+            _registerLabel(89 , 93 );
+            _registerLabel(90 , 39 );
         }
     }
-    return ret;
-}
-class KeymapInfo {
-    constructor(layout, secondaryLayouts, keyboardMapping, isUserKeyboardLayout) {
-        this.layout = layout;
-        this.secondaryLayouts = secondaryLayouts;
-        this.mapping = deserializeMapping(keyboardMapping);
-        this.isUserKeyboardLayout = !!isUserKeyboardLayout;
-        this.layout.isUserKeyboardLayout = !!isUserKeyboardLayout;
-    }
-    static createKeyboardLayoutFromDebugInfo(layout, value, isUserKeyboardLayout) {
-        const keyboardLayoutInfo = ( (new KeymapInfo(layout, [], {}, true)));
-        keyboardLayoutInfo.mapping = value;
-        return keyboardLayoutInfo;
-    }
-    update(other) {
-        this.layout = other.layout;
-        this.secondaryLayouts = other.secondaryLayouts;
-        this.mapping = other.mapping;
-        this.isUserKeyboardLayout = other.isUserKeyboardLayout;
-        this.layout.isUserKeyboardLayout = other.isUserKeyboardLayout;
-    }
-    getScore(other) {
-        let score = 0;
-        for (const key in other) {
-            if (isWindows && (key === 'Backslash' || key === 'KeyQ')) {
-                continue;
-            }
-            if (isLinux && (key === 'Backspace' || key === 'Escape')) {
-                continue;
+    dumpDebugInfo() {
+        const result = [];
+        const immutableSamples = [
+            88 ,
+            104
+        ];
+        let cnt = 0;
+        result.push(`-----------------------------------------------------------------------------------------------------------------------------------------`);
+        for (let scanCode = 0 ; scanCode < 193 ; scanCode++) {
+            if (IMMUTABLE_CODE_TO_KEY_CODE[scanCode] !== -1 ) {
+                if (immutableSamples.indexOf(scanCode) === -1) {
+                    continue;
+                }
             }
-            const currentMapping = this.mapping[key];
-            if (currentMapping === undefined) {
-                score -= 1;
+            if (cnt % 6 === 0) {
+                result.push(`|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |`);
+                result.push(`-----------------------------------------------------------------------------------------------------------------------------------------`);
             }
-            const otherMapping = other[key];
-            if (currentMapping && otherMapping && currentMapping.value !== otherMapping.value) {
-                score -= 1;
+            cnt++;
+            const mapping = this._codeInfo[scanCode];
+            const strCode = ( (ScanCodeUtils.toString(scanCode)));
+            const mods = [0b000, 0b010, 0b101, 0b111];
+            for (const mod of mods) {
+                const ctrlKey = (mod & 0b001) ? true : false;
+                const shiftKey = (mod & 0b010) ? true : false;
+                const altKey = (mod & 0b100) ? true : false;
+                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(scanCodeChord, mapping);
+                const outKb = (strKeyCode ? `${ctrlKey ? 'Ctrl+' : ''}${shiftKey ? 'Shift+' : ''}${altKey ? 'Alt+' : ''}${strKeyCode}` : null);
+                const isWYSIWYG = (resolvedKb ? resolvedKb.isWYSIWYG() : false);
+                const outWYSIWYG = (isWYSIWYG ? '       ' : '   NO  ');
+                result.push(`| ${this._leftPad(outScanCode, 30)} | ${outKey} | ${this._leftPad(outKb, 25)} | ${this._leftPad(outUILabel, 25)} |  ${this._leftPad(outUserSettings, 25)} | ${outWYSIWYG} |`);
             }
+            result.push(`-----------------------------------------------------------------------------------------------------------------------------------------`);
         }
-        return score;
+        return result.join('\n');
     }
-    equal(other) {
-        if (this.isUserKeyboardLayout !== other.isUserKeyboardLayout) {
-            return false;
+    _leftPad(str, cnt) {
+        if (str === null) {
+            str = 'null';
         }
-        if (getKeyboardLayoutId(this.layout) !== getKeyboardLayoutId(other.layout)) {
-            return false;
+        while (str.length < cnt) {
+            str = ' ' + str;
         }
-        return this.fuzzyEqual(other.mapping);
+        return str;
     }
-    fuzzyEqual(other) {
-        for (const key in other) {
-            if (isWindows && (key === 'Backslash' || key === 'KeyQ')) {
-                continue;
-            }
-            if (this.mapping[key] === undefined) {
-                return false;
-            }
-            const currentMapping = this.mapping[key];
-            const otherMapping = other[key];
-            if (currentMapping.value !== otherMapping.value) {
-                return false;
-            }
-        }
-        return true;
+    getUILabelForKeyCode(keyCode) {
+        return this._getLabelForKeyCode(keyCode);
     }
-}
-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
+    getAriaLabelForKeyCode(keyCode) {
+        return this._getLabelForKeyCode(keyCode);
+    }
+    getUserSettingsLabelForKeyCode(keyCode) {
+        if (this._isUSStandard) {
+            return KeyCodeUtils.toUserSettingsUS(keyCode);
         }
+        return KeyCodeUtils.toUserSettingsGeneral(keyCode);
     }
-};
-configurationRegistry$1.registerConfiguration(keyboardConfiguration$1);
-class CachedKeyboardMapper {
-    constructor(actual) {
-        this._actual = actual;
-        this._cache = ( (new Map()));
+    getElectronAcceleratorForKeyBinding(chord) {
+        return KeyCodeUtils.toElectronAccelerator(chord.keyCode);
     }
-    dumpDebugInfo() {
-        return this._actual.dumpDebugInfo();
+    _getLabelForKeyCode(keyCode) {
+        return this._keyCodeToLabel[keyCode] || ( (KeyCodeUtils.toString(0 )));
     }
     resolveKeyboardEvent(keyboardEvent) {
-        return this._actual.resolveKeyboardEvent(keyboardEvent);
+        const ctrlKey = keyboardEvent.ctrlKey || (this._mapAltGrToCtrlAlt && keyboardEvent.altGraphKey);
+        const altKey = keyboardEvent.altKey || (this._mapAltGrToCtrlAlt && keyboardEvent.altGraphKey);
+        const chord = ( (new KeyCodeChord(
+            ctrlKey,
+            keyboardEvent.shiftKey,
+            altKey,
+            keyboardEvent.metaKey,
+            keyboardEvent.keyCode
+        )));
+        return (
+             (new WindowsNativeResolvedKeybinding(this, [chord]))
+        );
+    }
+    _resolveChord(chord) {
+        if (!chord) {
+            return null;
+        }
+        if (chord instanceof KeyCodeChord) {
+            if (!this._keyCodeExists[chord.keyCode]) {
+                return null;
+            }
+            return chord;
+        }
+        const keyCode = this._scanCodeToKeyCode[chord.scanCode] || 0 ;
+        if (keyCode === 0  || !this._keyCodeExists[keyCode]) {
+            return null;
+        }
+        return (
+             (new KeyCodeChord(chord.ctrlKey, chord.shiftKey, chord.altKey, chord.metaKey, keyCode))
+        );
     }
     resolveKeybinding(keybinding) {
-        const hashCode = keybinding.getHashCode();
-        const resolved = this._cache.get(hashCode);
-        if (!resolved) {
-            const r = this._actual.resolveKeybinding(keybinding);
-            this._cache.set(hashCode, r);
-            return r;
+        const chords = toEmptyArrayIfContainsNull(( (keybinding.chords.map(chord => this._resolveChord(chord)))));
+        if (chords.length > 0) {
+            return [( (new WindowsNativeResolvedKeybinding(this, chords)))];
         }
-        return resolved;
+        return [];
     }
 }
 const CHAR_CODE_TO_KEY_CODE = [];
@@ -3912,7 +3913,7 @@ class MacLinuxKeyboardMapper {
         return this.keyCodeChordToScanCodeChord(chord);
     }
     resolveKeybinding(keybinding) {
-        const chords = keybinding.chords.map(chord => this._resolveChord(chord));
+        const chords = ( (keybinding.chords.map(chord => this._resolveChord(chord))));
         return this._toResolvedKeybinding(chords);
     }
     static _redirectCharCode(charCode) {
@@ -4023,7 +4024,9 @@ class BrowserKeyboardMapperFactoryBase extends Disposable {
         return this._activeKeymapInfo?.mapping ?? null;
     }
     get keyboardLayouts() {
-        return this._keymapInfos.map(keymapInfo => keymapInfo.layout);
+        return (
+             (this._keymapInfos.map(keymapInfo => keymapInfo.layout))
+        );
     }
     constructor(_configurationService) {
         super();
@@ -4307,12 +4310,12 @@ class BrowserKeyboardMapperFactory extends BrowserKeyboardMapperFactoryBase {
         const platform = isWindows ? 'win' : isMacintosh ? 'darwin' : 'linux';
         __variableDynamicImportRuntime0__('./keyboardLayouts/layout.contribution.' + platform + '.js').then((m) => {
             const keymapInfos = m.KeyboardLayoutContribution.INSTANCE.layoutInfos;
-            this._keymapInfos.push(...keymapInfos.map(info => (( (new KeymapInfo(
+            this._keymapInfos.push(...( (keymapInfos.map(info => (( (new KeymapInfo(
                 info.layout,
                 info.secondaryLayouts,
                 info.mapping,
                 info.isUserKeyboardLayout
-            ))))));
+            ))))))));
             this._mru = this._keymapInfos;
             this._initialized = true;
             this.setLayoutFromBrowserAPI();
@@ -4495,10 +4498,10 @@ if (provider != null) {
     provider.ctor = class extends CommandsQuickAccessProvider {
         get defaultFilterValue() { return undefined; }
         async getCommandPicks(token) {
-            return (await super.getCommandPicks(token)).map(pick => {
+            return ( (await super.getCommandPicks(token)).map(pick => {
                 pick.buttons = [];
                 return pick;
-            });
+            }));
         }
     };
 }
@@ -4531,22 +4534,6 @@ configurationRegistry$2.registerConfiguration({
         }
     }
 });
-const keybindingsExtensionPoint = getExtensionPoint('keybindings');
-const commandsExtensionPoint = getExtensionPoint('commands');
-function setKeybindings(grammars, extension = Services.get().extension ?? DEFAULT_EXTENSION) {
-    keybindingsExtensionPoint.acceptUsers([{
-            description: extension,
-            value: grammars,
-            collector: new ExtensionMessageCollector(consoleExtensionMessageHandler, extension, keybindingsExtensionPoint.name)
-        }]);
-}
-function setCommands(keybindings, extension = Services.get().extension ?? DEFAULT_EXTENSION) {
-    commandsExtensionPoint.acceptUsers([{
-            description: extension,
-            value: keybindings,
-            collector: new ExtensionMessageCollector(consoleExtensionMessageHandler, extension, keybindingsExtensionPoint.name)
-        }]);
-}
 async function updateUserKeybindings(keybindingsJson) {
     const userDataProfilesService = StandaloneServices.get(IUserDataProfilesService);
     await StandaloneServices.get(IFileService).writeFile(userDataProfilesService.defaultProfile.keybindingsResource, VSBuffer.fromString(keybindingsJson));
@@ -4559,4 +4546,4 @@ function getServiceOverride() {
         [( IKeyboardLayoutService.toString())]: new SyncDescriptor(BrowserKeyboardLayoutService)
     };
 }
-export { getServiceOverride as default, setCommands, setKeybindings, updateUserKeybindings };
+export { getServiceOverride as default, updateUserKeybindings };