@codingame/monaco-vscode-keybindings-service-override 1.83.8 → 1.83.10-next.0

package/external/tslib/tslib.es6.js

@@ -0,0 +1,11 @@
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+export { __decorate, __param };

package/index.js

@@ -1,2 +1 @@
-export * from 'vscode/service-override/keybindings';
-export { default } from 'vscode/service-override/keybindings';
+export { default, defaultUserKeybindindsFile, initUserKeybindings, updateUserKeybindings } from './keybindings.js';

package/keybindings.js

@@ -0,0 +1,100 @@
+import { __decorate, __param } from './external/tslib/tslib.es6.js';
+import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { WorkbenchKeybindingService } from './vscode/src/vs/workbench/services/keybinding/browser/keybindingService.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { IUserDataProfilesService } from 'monaco-editor/esm/vs/platform/userDataProfile/common/userDataProfile.js';
+import { IKeyboardLayoutService } from 'vscode/vscode/vs/platform/keyboardLayout/common/keyboardLayout';
+import { BrowserKeyboardLayoutService } from './vscode/src/vs/workbench/services/keybinding/browser/keyboardLayoutService.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { CommandService } from './vscode/src/vs/workbench/services/commands/common/commandService.js';
+import { DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.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 { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { WorkbenchContextKeysHandler } from './vscode/src/vs/workbench/browser/contextkeys.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import getServiceOverride$1, { initFile } from '@codingame/monaco-vscode-files-service-override';
+import './monaco.js';
+import { onRenderWorkbench } from 'vscode/lifecycle';
+import 'vscode/vscode/vs/workbench/browser/workbench.contribution';
+import './vscode/src/vs/workbench/contrib/keybindings/browser/keybindings.contribution.js';
+
+const defaultUserKeybindindsFile = ( URI.from({ scheme: Schemas.vscodeUserData, path: '/User/keybindings.json' }));
+async function initUserKeybindings(configurationJson, options, file = defaultUserKeybindindsFile) {
+    await initFile(file, configurationJson, options);
+}
+async function updateUserKeybindings(keybindingsJson) {
+    const userDataProfilesService = StandaloneServices.get(IUserDataProfilesService);
+    await StandaloneServices.get(IFileService).writeFile(userDataProfilesService.defaultProfile.keybindingsResource, VSBuffer.fromString(keybindingsJson));
+}
+let DynamicWorkbenchKeybindingService = class DynamicWorkbenchKeybindingService extends WorkbenchKeybindingService {
+    constructor(shouldUseGlobalKeybindings, contextKeyService, commandService, telemetryService, notificationService, userDataProfileService, hostService, extensionService, fileService, uriIdentityService, logService, keyboardLayoutService) {
+        super(contextKeyService, commandService, telemetryService, notificationService, userDataProfileService, hostService, extensionService, fileService, uriIdentityService, logService, keyboardLayoutService);
+        this.shouldUseGlobalKeybindings = shouldUseGlobalKeybindings;
+        this.keybindingProviders = [];
+    }
+    registerKeybindingProvider(provider) {
+        this.keybindingProviders.push(provider);
+        this.updateResolver();
+        const store = new DisposableStore();
+        store.add(provider.onDidChangeKeybindings(() => {
+            this.updateResolver();
+        }));
+        store.add(toDisposable(() => {
+            const idx = this.keybindingProviders.indexOf(provider);
+            if (idx >= 0) {
+                this.keybindingProviders.splice(idx, 1);
+                this.updateResolver();
+            }
+        }));
+        return store;
+    }
+    _getResolver() {
+        return super._getResolver();
+    }
+    _dispatch(e, target) {
+        if (!this.shouldUseGlobalKeybindings()) {
+            return false;
+        }
+        return super._dispatch(e, target);
+    }
+    getUserKeybindingItems() {
+        return [...super.getUserKeybindingItems(), ...this.keybindingProviders.flatMap(provider => provider.provideKeybindings())];
+    }
+};
+DynamicWorkbenchKeybindingService = __decorate([
+    ( __param(1, IContextKeyService)),
+    ( __param(2, ICommandService)),
+    ( __param(3, ITelemetryService)),
+    ( __param(4, INotificationService)),
+    ( __param(5, IUserDataProfileService)),
+    ( __param(6, IHostService)),
+    ( __param(7, IExtensionService)),
+    ( __param(8, IFileService)),
+    ( __param(9, IUriIdentityService)),
+    ( __param(10, ILogService)),
+    ( __param(11, IKeyboardLayoutService))
+], DynamicWorkbenchKeybindingService);
+onRenderWorkbench((accessor) => {
+    accessor.get(IInstantiationService).createInstance(WorkbenchContextKeysHandler);
+});
+function getServiceOverride({ shouldUseGlobalKeybindings = () => false } = {}) {
+    return {
+        ...getServiceOverride$1(),
+        [( IKeybindingService.toString())]: new SyncDescriptor(DynamicWorkbenchKeybindingService, [shouldUseGlobalKeybindings], false),
+        [( IKeyboardLayoutService.toString())]: new SyncDescriptor(BrowserKeyboardLayoutService, undefined, true),
+        [( ICommandService.toString())]: new SyncDescriptor(CommandService, [], true)
+    };
+}
+
+export { getServiceOverride as default, defaultUserKeybindindsFile, initUserKeybindings, updateUserKeybindings };

package/monaco.js

@@ -0,0 +1,231 @@
+import { __decorate, __param } from './external/tslib/tslib.es6.js';
+import { StandaloneKeybindingService } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
+import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { StandaloneEditor, StandaloneDiffEditor2 } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneCodeEditor.js';
+import { isObject } from 'monaco-editor/esm/vs/base/common/types.js';
+import { distinct, deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
+export { errorHandler } from 'monaco-editor/esm/vs/base/common/errors.js';
+export { FoldingModel, setCollapseStateForMatchingLines } from 'monaco-editor/esm/vs/editor/contrib/folding/browser/foldingModel.js';
+export { FoldingController } from 'monaco-editor/esm/vs/editor/contrib/folding/browser/folding.js';
+export { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+export { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+export { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+export { MenuId, MenuRegistry } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+export { KeybindingsRegistry } from 'monaco-editor/esm/vs/platform/keybinding/common/keybindingsRegistry.js';
+import { Extensions as Extensions$2 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { EditorOptionsUtil } from 'vscode/vscode/vs/editor/browser/config/editorConfiguration';
+export { registerColor } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import 'monaco-editor/esm/vs/platform/files/common/files.js';
+import 'monaco-editor/esm/vs/base/common/buffer.js';
+import { JSONValidationExtensionPoint } from 'vscode/vscode/vs/workbench/api/common/jsonValidationExtensionPoint';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { ColorExtensionPoint } from 'vscode/vscode/vs/workbench/services/themes/common/colorExtensionPoint';
+import 'monaco-editor/esm/vs/platform/instantiation/common/serviceCollection.js';
+import 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import 'monaco-editor/esm/vs/editor/standalone/browser/quickInput/standaloneQuickInputService.js';
+import 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+export { ContextKeyExpr, RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.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 { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { Emitter } from 'monaco-editor';
+import { createInjectedClass } from './tools/injection.js';
+import 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/workbenchReferenceSearch';
+import 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/menuPreventer';
+import 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/diffEditorHelper';
+import 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/largeFileOptimizations';
+import 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/inspectEditorTokens/inspectEditorTokens';
+import 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/saveParticipants';
+import 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/toggleMinimap';
+import 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/toggleMultiCursorModifier';
+import 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/toggleRenderControlCharacter';
+import 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/toggleWordWrap';
+import 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/toggleRenderWhitespace';
+import 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/editorLineNumberMenu';
+import 'vscode/vscode/vs/workbench/contrib/folding/browser/folding.contribution';
+import 'vscode/vscode/vs/workbench/contrib/inlayHints/browser/inlayHintsAccessibilty';
+import 'vscode/vscode/vs/workbench/contrib/codeActions/browser/codeActions.contribution';
+import 'vscode/vscode/vs/workbench/contrib/list/browser/list.contribution';
+import 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/editorFeatures';
+
+let ExtensionPoints = class ExtensionPoints {
+    constructor(instantiationService) {
+        this.instantiationService = instantiationService;
+        this.instantiationService.createInstance(JSONValidationExtensionPoint);
+        this.instantiationService.createInstance(ColorExtensionPoint);
+    }
+};
+ExtensionPoints = __decorate([
+    ( __param(0, IInstantiationService))
+], ExtensionPoints);
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(ExtensionPoints, 1 );
+function computeConfiguration(configuration, overrides) {
+    const editorConfiguration = isObject(configuration.editor) ? deepClone(configuration.editor) : Object.create(null);
+    Object.assign(editorConfiguration, deepClone(overrides));
+    return editorConfiguration;
+}
+function computeDiffConfiguration(configuration, overrides) {
+    const editorConfiguration = computeConfiguration(configuration);
+    if (isObject(configuration.diffEditor)) {
+        const diffEditorConfiguration = deepClone(configuration.diffEditor);
+        diffEditorConfiguration.diffCodeLens = diffEditorConfiguration.codeLens;
+        delete diffEditorConfiguration.codeLens;
+        diffEditorConfiguration.diffWordWrap = diffEditorConfiguration.wordWrap;
+        delete diffEditorConfiguration.wordWrap;
+        Object.assign(editorConfiguration, diffEditorConfiguration);
+    }
+    editorConfiguration.accessibilityVerbose = configuration.accessibility?.verbosity?.diffEditor ?? false;
+    Object.assign(editorConfiguration, deepClone(overrides));
+    return editorConfiguration;
+}
+let ConfiguredStandaloneEditor = class ConfiguredStandaloneEditor extends createInjectedClass(StandaloneEditor) {
+    constructor(domElement, _options = {}, instantiationService, textResourceConfigurationService) {
+        const { theme, autoDetectHighContrast, model, value, language, accessibilityHelpUrl, ariaContainerElement, overflowWidgetsDomNode, dimension, ...options } = _options;
+        const computedOptions = computeConfiguration(textResourceConfigurationService.getValue(_options.model?.uri), options);
+        super(instantiationService, domElement, { ...computedOptions, overflowWidgetsDomNode, dimension, theme, autoDetectHighContrast, model, value, language, accessibilityHelpUrl, ariaContainerElement });
+        this.textResourceConfigurationService = textResourceConfigurationService;
+        this.optionsOverrides = {};
+        this.lastAppliedEditorOptions = computedOptions;
+        this.optionsOverrides = options;
+        this._register(textResourceConfigurationService.onDidChangeConfiguration((e) => {
+            const resource = this.getModel()?.uri;
+            if (resource != null && e.affectsConfiguration(resource, 'editor')) {
+                this.updateEditorConfiguration();
+            }
+        }));
+        this._register(this.onDidChangeModelLanguage(() => this.updateEditorConfiguration()));
+        this._register(this.onDidChangeModel(() => this.updateEditorConfiguration()));
+        this.updateEditorConfiguration();
+    }
+    updateEditorConfiguration() {
+        if (!this.hasModel() || this.textResourceConfigurationService == null) {
+            return;
+        }
+        const resource = this.getModel().uri;
+        const configuration = this.textResourceConfigurationService.getValue(resource);
+        if (configuration == null) {
+            return;
+        }
+        const editorConfiguration = computeConfiguration(configuration, this.optionsOverrides);
+        let editorSettingsToApply = editorConfiguration;
+        if (this.lastAppliedEditorOptions != null) {
+            editorSettingsToApply = distinct(this.lastAppliedEditorOptions, editorSettingsToApply);
+        }
+        if (( Object.keys(editorSettingsToApply)).length > 0) {
+            this.lastAppliedEditorOptions = editorConfiguration;
+            super.updateOptions(editorSettingsToApply);
+        }
+    }
+    updateOptions(newOptions) {
+        this.optionsOverrides ?? (this.optionsOverrides = {});
+        const didChange = EditorOptionsUtil.applyUpdate(this.optionsOverrides, newOptions);
+        if (!didChange) {
+            return;
+        }
+        this.updateEditorConfiguration();
+    }
+};
+ConfiguredStandaloneEditor = __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, ITextResourceConfigurationService))
+], ConfiguredStandaloneEditor);
+let ConfiguredStandaloneDiffEditor = class ConfiguredStandaloneDiffEditor extends createInjectedClass(StandaloneDiffEditor2) {
+    constructor(domElement, _options = {}, instantiationService, textResourceConfigurationService) {
+        const { theme, autoDetectHighContrast, modifiedAriaLabel, originalAriaLabel, overflowWidgetsDomNode, dimension, ...options } = _options;
+        const computedOptions = computeDiffConfiguration(textResourceConfigurationService.getValue(undefined), options);
+        super(instantiationService, domElement, { ...computedOptions, overflowWidgetsDomNode, dimension, theme, autoDetectHighContrast, modifiedAriaLabel, originalAriaLabel });
+        this.textResourceConfigurationService = textResourceConfigurationService;
+        this.optionsOverrides = {};
+        this.lastAppliedEditorOptions = computedOptions;
+        this.optionsOverrides = options;
+        this._register(textResourceConfigurationService.onDidChangeConfiguration((e) => {
+            const resource = this._targetEditor.getModel()?.uri;
+            if (resource != null && (e.affectsConfiguration(resource, 'editor') || e.affectsConfiguration(resource, 'diffEditor') || e.affectsConfiguration(resource, 'accessibility.verbosity.diffEditor'))) {
+                this.updateEditorConfiguration();
+            }
+        }));
+        this._register(this._targetEditor.onDidChangeModelLanguage(() => this.updateEditorConfiguration()));
+        this._register(this.onDidChangeModel(() => this.updateEditorConfiguration()));
+        this.updateEditorConfiguration();
+    }
+    updateEditorConfiguration() {
+        if (this.getModel() == null || this.textResourceConfigurationService == null) {
+            return;
+        }
+        const resource = this._targetEditor.getModel()?.uri;
+        const configuration = this.textResourceConfigurationService.getValue(resource);
+        if (configuration == null) {
+            return;
+        }
+        const editorConfiguration = computeDiffConfiguration(configuration, this.optionsOverrides);
+        let editorSettingsToApply = editorConfiguration;
+        if (this.lastAppliedEditorOptions != null) {
+            editorSettingsToApply = distinct(this.lastAppliedEditorOptions, editorSettingsToApply);
+        }
+        if (( Object.keys(editorSettingsToApply)).length > 0) {
+            this.lastAppliedEditorOptions = editorConfiguration;
+            super.updateOptions(editorSettingsToApply);
+        }
+    }
+    updateOptions(newOptions) {
+        this.optionsOverrides ?? (this.optionsOverrides = {});
+        this.optionsOverrides = {
+            ...this.optionsOverrides,
+            ...newOptions
+        };
+        this.updateEditorConfiguration();
+    }
+    _createInnerEditor(instantiationService, container, options) {
+        return instantiationService.createInstance(ConfiguredStandaloneEditor, container, options);
+    }
+};
+ConfiguredStandaloneDiffEditor = __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, ITextResourceConfigurationService))
+], ConfiguredStandaloneDiffEditor);
+let DelegateStandaloneKeybindingService = class DelegateStandaloneKeybindingService extends StandaloneKeybindingService {
+    constructor(delegate, contextKeyService, commandService, telemetryService, notificationService, logService, codeEditorService) {
+        super(contextKeyService, commandService, telemetryService, notificationService, logService, codeEditorService);
+        this.delegate = delegate;
+        this._onDidChangeKeybindings = new Emitter();
+        this._register(delegate.registerKeybindingProvider({
+            provideKeybindings: () => {
+                return this.getUserKeybindingItems();
+            },
+            onDidChangeKeybindings: this._onDidChangeKeybindings.event
+        }));
+    }
+    _getResolver() {
+        return this.delegate._getResolver();
+    }
+    updateResolver() {
+        super.updateResolver();
+        this._onDidChangeKeybindings.fire();
+    }
+    resolveKeyboardEvent(keyboardEvent) {
+        return this.delegate.resolveKeyboardEvent(keyboardEvent);
+    }
+    resolveKeybinding(keybinding) {
+        return this.delegate.resolveKeybinding(keybinding);
+    }
+};
+DelegateStandaloneKeybindingService = __decorate([
+    ( __param(1, IContextKeyService)),
+    ( __param(2, ICommandService)),
+    ( __param(3, ITelemetryService)),
+    ( __param(4, INotificationService)),
+    ( __param(5, ILogService)),
+    ( __param(6, ICodeEditorService))
+], DelegateStandaloneKeybindingService);
+({
+    ...Extensions$1,
+    ...Extensions$2
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-keybindings-service-override",
-  "version": "1.83.8",
+  "version": "1.83.10-next.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,7 +18,8 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@1.83.8",
-    "monaco-editor": "0.44.0"
+    "vscode": "npm:@codingame/monaco-vscode-api@1.83.10-next.0",
+    "monaco-editor": "0.44.0",
+    "@codingame/monaco-vscode-files-service-override": "1.83.10-next.0"
   }
 }

package/tools/injection.js

@@ -0,0 +1,17 @@
+import { _util } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+
+function getInjectedParameters(instantiationService, ctor) {
+    return instantiationService.invokeFunction((accessor) => {
+        return ( _util.getServiceDependencies(ctor).sort((a, b) => a.index - b.index).map(d => accessor.get(d.id)));
+    });
+}
+function createInjectedClass(ctor) {
+    const _ctor = ctor;
+    return class extends _ctor {
+        constructor(...args) {
+            super(...args.slice(1), ...getInjectedParameters(args[0], ctor));
+        }
+    };
+}
+
+export { createInjectedClass };

package/vscode/src/vs/base/common/keybindingParser.js

@@ -0,0 +1,89 @@
+import { ScanCodeUtils, KeyCodeUtils } from 'monaco-editor/esm/vs/base/common/keyCodes.js';
+import { ScanCodeChord, KeyCodeChord, Keybinding } from 'monaco-editor/esm/vs/base/common/keybindings.js';
+
+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);
+    }
+}
+
+export { KeybindingParser };

package/vscode/src/vs/platform/keyboardLayout/common/keyboardConfig.js

@@ -0,0 +1,50 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { OS } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+
+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 = ( Registry.as(Extensions.Configuration));
+const keyboardConfiguration = {
+    'id': 'keyboard',
+    'order': 15,
+    'type': 'object',
+    'title': ( nls.localizeWithPath(
+        'vs/platform/keyboardLayout/common/keyboardConfig',
+        'keyboardConfigurationTitle',
+        "Keyboard"
+    )),
+    'properties': {
+        'keyboard.dispatch': {
+            scope: 1 ,
+            type: 'string',
+            enum: ['code', 'keyCode'],
+            default: 'code',
+            markdownDescription: ( nls.localizeWithPath(
+                'vs/platform/keyboardLayout/common/keyboardConfig',
+                '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: ( nls.localizeWithPath(
+                'vs/platform/keyboardLayout/common/keyboardConfig',
+                'mapAltGrToCtrlAlt',
+                "Controls if the AltGraph+ modifier should be treated as Ctrl+Alt+."
+            )),
+            included: OS === 1
+        }
+    }
+};
+configurationRegistry.registerConfiguration(keyboardConfiguration);
+
+export { readKeyboardConfig };

package/vscode/src/vs/platform/keyboardLayout/common/keyboardMapper.js

@@ -0,0 +1,24 @@
+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;
+    }
+}
+
+export { CachedKeyboardMapper };