Merge commit 'be3e8236086165e5e45a5a10783823874b3f3ebd' as 'lib/vscode'

lib/vscode/src/vs/workbench/services/keybinding/browser/keybindingService.ts

@@ -0,0 +1,832 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as nls from 'vs/nls';
+import * as browser from 'vs/base/browser/browser';
+import * as dom from 'vs/base/browser/dom';
+import { printKeyboardEvent, printStandardKeyboardEvent, StandardKeyboardEvent } from 'vs/base/browser/keyboardEvent';
+import { Emitter, Event } from 'vs/base/common/event';
+import { IJSONSchema } from 'vs/base/common/jsonSchema';
+import { Keybinding, ResolvedKeybinding, KeyCode, KeyMod } from 'vs/base/common/keyCodes';
+import { KeybindingParser } from 'vs/base/common/keybindingParser';
+import { OS, OperatingSystem, isMacintosh } from 'vs/base/common/platform';
+import { ICommandService, CommandsRegistry } from 'vs/platform/commands/common/commands';
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
+import { Extensions as ConfigExtensions, IConfigurationNode, IConfigurationRegistry } from 'vs/platform/configuration/common/configurationRegistry';
+import { ContextKeyExpr, IContextKeyService, ContextKeyExpression, IContextKey } from 'vs/platform/contextkey/common/contextkey';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { Extensions, IJSONContributionRegistry } from 'vs/platform/jsonschemas/common/jsonContributionRegistry';
+import { AbstractKeybindingService } from 'vs/platform/keybinding/common/abstractKeybindingService';
+import { IKeyboardEvent, IUserFriendlyKeybinding, KeybindingSource, IKeybindingService, IKeybindingEvent, KeybindingsSchemaContribution } from 'vs/platform/keybinding/common/keybinding';
+import { KeybindingResolver } from 'vs/platform/keybinding/common/keybindingResolver';
+import { IKeybindingItem, IKeybindingRule2, KeybindingWeight, KeybindingsRegistry } from 'vs/platform/keybinding/common/keybindingsRegistry';
+import { ResolvedKeybindingItem } from 'vs/platform/keybinding/common/resolvedKeybindingItem';
+import { INotificationService } from 'vs/platform/notification/common/notification';
+import { Registry } from 'vs/platform/registry/common/platform';
+import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
+import { ExtensionMessageCollector, ExtensionsRegistry } from 'vs/workbench/services/extensions/common/extensionsRegistry';
+import { IUserKeybindingItem, KeybindingIO, OutputBuilder } from 'vs/workbench/services/keybinding/common/keybindingIO';
+import { IKeyboardMapper } from 'vs/workbench/services/keybinding/common/keyboardMapper';
+import { IHostService } from 'vs/workbench/services/host/browser/host';
+import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
+import { MenuRegistry } from 'vs/platform/actions/common/actions';
+import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
+import { commandsExtensionPoint } from 'vs/workbench/api/common/menusExtensionPoint';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { RunOnceScheduler } from 'vs/base/common/async';
+import { URI } from 'vs/base/common/uri';
+import { IFileService } from 'vs/platform/files/common/files';
+import { parse } from 'vs/base/common/json';
+import * as objects from 'vs/base/common/objects';
+import { IKeymapService } from 'vs/workbench/services/keybinding/common/keymapInfo';
+import { getDispatchConfig } from 'vs/workbench/services/keybinding/common/dispatchConfig';
+import { isArray } from 'vs/base/common/types';
+import { INavigatorWithKeyboard, IKeyboard } from 'vs/workbench/services/keybinding/browser/navigatorKeyboard';
+import { ScanCode, ScanCodeUtils, IMMUTABLE_CODE_TO_KEY_CODE } from 'vs/base/common/scanCode';
+import { flatten } from 'vs/base/common/arrays';
+import { BrowserFeatures, KeyboardSupport } from 'vs/base/browser/canIUse';
+import { ILogService } from 'vs/platform/log/common/log';
+import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
+
+interface ContributedKeyBinding {
+	command: string;
+	args?: any;
+	key: string;
+	when?: string;
+	mac?: string;
+	linux?: string;
+	win?: string;
+}
+
+function isContributedKeyBindingsArray(thing: ContributedKeyBinding | ContributedKeyBinding[]): thing is ContributedKeyBinding[] {
+	return Array.isArray(thing);
+}
+
+function isValidContributedKeyBinding(keyBinding: ContributedKeyBinding, rejects: string[]): boolean {
+	if (!keyBinding) {
+		rejects.push(nls.localize('nonempty', "expected non-empty value."));
+		return false;
+	}
+	if (typeof keyBinding.command !== 'string') {
+		rejects.push(nls.localize('requirestring', "property `{0}` is mandatory and must be of type `string`", 'command'));
+		return false;
+	}
+	if (keyBinding.key && typeof keyBinding.key !== 'string') {
+		rejects.push(nls.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(nls.localize('optstring', "property `{0}` can be omitted or must be of type `string`", 'when'));
+		return false;
+	}
+	if (keyBinding.mac && typeof keyBinding.mac !== 'string') {
+		rejects.push(nls.localize('optstring', "property `{0}` can be omitted or must be of type `string`", 'mac'));
+		return false;
+	}
+	if (keyBinding.linux && typeof keyBinding.linux !== 'string') {
+		rejects.push(nls.localize('optstring', "property `{0}` can be omitted or must be of type `string`", 'linux'));
+		return false;
+	}
+	if (keyBinding.win && typeof keyBinding.win !== 'string') {
+		rejects.push(nls.localize('optstring', "property `{0}` can be omitted or must be of type `string`", 'win'));
+		return false;
+	}
+	return true;
+}
+
+let keybindingType: IJSONSchema = {
+	type: 'object',
+	default: { command: '', key: '' },
+	properties: {
+		command: {
+			description: nls.localize('vscode.extension.contributes.keybindings.command', 'Identifier of the command to run when keybinding is triggered.'),
+			type: 'string'
+		},
+		args: {
+			description: nls.localize('vscode.extension.contributes.keybindings.args', "Arguments to pass to the command to execute.")
+		},
+		key: {
+			description: nls.localize('vscode.extension.contributes.keybindings.key', 'Key or key sequence (separate keys with plus-sign and sequences with space, e.g. Ctrl+O and Ctrl+L L for a chord).'),
+			type: 'string'
+		},
+		mac: {
+			description: nls.localize('vscode.extension.contributes.keybindings.mac', 'Mac specific key or key sequence.'),
+			type: 'string'
+		},
+		linux: {
+			description: nls.localize('vscode.extension.contributes.keybindings.linux', 'Linux specific key or key sequence.'),
+			type: 'string'
+		},
+		win: {
+			description: nls.localize('vscode.extension.contributes.keybindings.win', 'Windows specific key or key sequence.'),
+			type: 'string'
+		},
+		when: {
+			description: nls.localize('vscode.extension.contributes.keybindings.when', 'Condition when the key is active.'),
+			type: 'string'
+		},
+	}
+};
+
+const keybindingsExtPoint = ExtensionsRegistry.registerExtensionPoint<ContributedKeyBinding | ContributedKeyBinding[]>({
+	extensionPoint: 'keybindings',
+	deps: [commandsExtensionPoint],
+	jsonSchema: {
+		description: nls.localize('vscode.extension.contributes.keybindings', "Contributes keybindings."),
+		oneOf: [
+			keybindingType,
+			{
+				type: 'array',
+				items: keybindingType
+			}
+		]
+	}
+});
+
+const NUMPAD_PRINTABLE_SCANCODES = [
+	ScanCode.NumpadDivide,
+	ScanCode.NumpadMultiply,
+	ScanCode.NumpadSubtract,
+	ScanCode.NumpadAdd,
+	ScanCode.Numpad1,
+	ScanCode.Numpad2,
+	ScanCode.Numpad3,
+	ScanCode.Numpad4,
+	ScanCode.Numpad5,
+	ScanCode.Numpad6,
+	ScanCode.Numpad7,
+	ScanCode.Numpad8,
+	ScanCode.Numpad9,
+	ScanCode.Numpad0,
+	ScanCode.NumpadDecimal
+];
+
+const otherMacNumpadMapping = new Map<ScanCode, KeyCode>();
+otherMacNumpadMapping.set(ScanCode.Numpad1, KeyCode.KEY_1);
+otherMacNumpadMapping.set(ScanCode.Numpad2, KeyCode.KEY_2);
+otherMacNumpadMapping.set(ScanCode.Numpad3, KeyCode.KEY_3);
+otherMacNumpadMapping.set(ScanCode.Numpad4, KeyCode.KEY_4);
+otherMacNumpadMapping.set(ScanCode.Numpad5, KeyCode.KEY_5);
+otherMacNumpadMapping.set(ScanCode.Numpad6, KeyCode.KEY_6);
+otherMacNumpadMapping.set(ScanCode.Numpad7, KeyCode.KEY_7);
+otherMacNumpadMapping.set(ScanCode.Numpad8, KeyCode.KEY_8);
+otherMacNumpadMapping.set(ScanCode.Numpad9, KeyCode.KEY_9);
+otherMacNumpadMapping.set(ScanCode.Numpad0, KeyCode.KEY_0);
+
+export class WorkbenchKeybindingService extends AbstractKeybindingService {
+
+	private _keyboardMapper: IKeyboardMapper;
+	private _cachedResolver: KeybindingResolver | null;
+	private userKeybindings: UserKeybindings;
+	private isComposingGlobalContextKey: IContextKey<boolean>;
+	private readonly _contributions: KeybindingsSchemaContribution[] = [];
+
+	constructor(
+		@IContextKeyService contextKeyService: IContextKeyService,
+		@ICommandService commandService: ICommandService,
+		@ITelemetryService telemetryService: ITelemetryService,
+		@INotificationService notificationService: INotificationService,
+		@IEnvironmentService environmentService: IEnvironmentService,
+		@IConfigurationService configurationService: IConfigurationService,
+		@IHostService private readonly hostService: IHostService,
+		@IExtensionService extensionService: IExtensionService,
+		@IFileService fileService: IFileService,
+		@ILogService logService: ILogService,
+		@IKeymapService private readonly keymapService: IKeymapService
+	) {
+		super(contextKeyService, commandService, telemetryService, notificationService, logService);
+
+		this.isComposingGlobalContextKey = contextKeyService.createKey('isComposing', false);
+		this.updateSchema();
+
+		let dispatchConfig = getDispatchConfig(configurationService);
+		configurationService.onDidChangeConfiguration((e) => {
+			let newDispatchConfig = getDispatchConfig(configurationService);
+			if (dispatchConfig === newDispatchConfig) {
+				return;
+			}
+
+			dispatchConfig = newDispatchConfig;
+			this._keyboardMapper = this.keymapService.getKeyboardMapper(dispatchConfig);
+			this.updateResolver({ source: KeybindingSource.Default });
+		});
+
+		this._keyboardMapper = this.keymapService.getKeyboardMapper(dispatchConfig);
+		this.keymapService.onDidChangeKeyboardMapper(() => {
+			this._keyboardMapper = this.keymapService.getKeyboardMapper(dispatchConfig);
+			this.updateResolver({ source: KeybindingSource.Default });
+		});
+
+		this._cachedResolver = null;
+
+		this.userKeybindings = this._register(new UserKeybindings(environmentService.keybindingsResource, fileService, logService));
+		this.userKeybindings.initialize().then(() => {
+			if (this.userKeybindings.keybindings.length) {
+				this.updateResolver({ source: KeybindingSource.User });
+			}
+		});
+		this._register(this.userKeybindings.onDidChange(() => {
+			logService.debug('User keybindings changed');
+			this.updateResolver({
+				source: KeybindingSource.User,
+				keybindings: this.userKeybindings.keybindings
+			});
+		}));
+
+		keybindingsExtPoint.setHandler((extensions) => {
+
+			let keybindings: IKeybindingRule2[] = [];
+			for (let extension of extensions) {
+				this._handleKeybindingsExtensionPointUser(extension.description.identifier, extension.description.isBuiltin, extension.value, extension.collector, keybindings);
+			}
+
+			KeybindingsRegistry.setExtensionKeybindings(keybindings);
+			this.updateResolver({ source: KeybindingSource.Default });
+		});
+
+		this.updateSchema();
+		this._register(extensionService.onDidRegisterExtensions(() => this.updateSchema()));
+
+		this._register(dom.addDisposableListener(window, dom.EventType.KEY_DOWN, (e: KeyboardEvent) => {
+			this.isComposingGlobalContextKey.set(e.isComposing);
+			const keyEvent = new StandardKeyboardEvent(e);
+			this._log(`/ Received  keydown event - ${printKeyboardEvent(e)}`);
+			this._log(`| Converted keydown event - ${printStandardKeyboardEvent(keyEvent)}`);
+			const shouldPreventDefault = this._dispatch(keyEvent, keyEvent.target);
+			if (shouldPreventDefault) {
+				keyEvent.preventDefault();
+			}
+			this.isComposingGlobalContextKey.set(false);
+		}));
+
+		let data = this.keymapService.getCurrentKeyboardLayout();
+		/* __GDPR__FRAGMENT__
+			"IKeyboardLayoutInfo" : {
+				"name" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+				"id": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+				"text": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
+			}
+		*/
+		/* __GDPR__FRAGMENT__
+			"IKeyboardLayoutInfo" : {
+				"model" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+				"layout": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+				"variant": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+				"options": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+				"rules": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
+			}
+		*/
+		/* __GDPR__FRAGMENT__
+			"IKeyboardLayoutInfo" : {
+				"id" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+				"lang": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
+			}
+		*/
+		/* __GDPR__
+			"keyboardLayout" : {
+				"currentKeyboardLayout": { "${inline}": [ "${IKeyboardLayoutInfo}" ] }
+			}
+		*/
+		telemetryService.publicLog('keyboardLayout', {
+			currentKeyboardLayout: data
+		});
+
+		this._register(browser.onDidChangeFullscreen(() => {
+			const keyboard: IKeyboard | null = (<INavigatorWithKeyboard>navigator).keyboard;
+
+			if (BrowserFeatures.keyboard === KeyboardSupport.None) {
+				return;
+			}
+
+			if (browser.isFullscreen()) {
+				keyboard?.lock(['Escape']);
+			} else {
+				keyboard?.unlock();
+			}
+
+			// update resolver which will bring back all unbound keyboard shortcuts
+			this._cachedResolver = null;
+			this._onDidUpdateKeybindings.fire({ source: KeybindingSource.User });
+		}));
+	}
+
+	public registerSchemaContribution(contribution: KeybindingsSchemaContribution): void {
+		this._contributions.push(contribution);
+		if (contribution.onDidChange) {
+			this._register(contribution.onDidChange(() => this.updateSchema()));
+		}
+		this.updateSchema();
+	}
+
+	private updateSchema() {
+		updateSchema(flatten(this._contributions.map(x => x.getSchemaAdditions())));
+	}
+
+	public _dumpDebugInfo(): string {
+		const layoutInfo = JSON.stringify(this.keymapService.getCurrentKeyboardLayout(), null, '\t');
+		const mapperInfo = this._keyboardMapper.dumpDebugInfo();
+		const rawMapping = JSON.stringify(this.keymapService.getRawKeyboardMapping(), null, '\t');
+		return `Layout info:\n${layoutInfo}\n${mapperInfo}\n\nRaw mapping:\n${rawMapping}`;
+	}
+
+	public _dumpDebugInfoJSON(): string {
+		const info = {
+			layout: this.keymapService.getCurrentKeyboardLayout(),
+			rawMapping: this.keymapService.getRawKeyboardMapping()
+		};
+		return JSON.stringify(info, null, '\t');
+	}
+
+	public customKeybindingsCount(): number {
+		return this.userKeybindings.keybindings.length;
+	}
+
+	private updateResolver(event: IKeybindingEvent): void {
+		this._cachedResolver = null;
+		this._onDidUpdateKeybindings.fire(event);
+	}
+
+	protected _getResolver(): KeybindingResolver {
+		if (!this._cachedResolver) {
+			const defaults = this._resolveKeybindingItems(KeybindingsRegistry.getDefaultKeybindings(), true);
+			const overrides = this._resolveUserKeybindingItems(this.userKeybindings.keybindings.map((k) => KeybindingIO.readUserKeybindingItem(k)), false);
+			this._cachedResolver = new KeybindingResolver(defaults, overrides, (str) => this._log(str));
+		}
+		return this._cachedResolver;
+	}
+
+	protected _documentHasFocus(): boolean {
+		// it is possible that the document has lost focus, but the
+		// window is still focused, e.g. when a <webview> element
+		// has focus
+		return this.hostService.hasFocus;
+	}
+
+	private _resolveKeybindingItems(items: IKeybindingItem[], isDefault: boolean): ResolvedKeybindingItem[] {
+		let result: ResolvedKeybindingItem[] = [], resultLen = 0;
+		for (const item of items) {
+			const when = item.when || undefined;
+			const keybinding = item.keybinding;
+			if (!keybinding) {
+				// This might be a removal keybinding item in user settings => accept it
+				result[resultLen++] = new ResolvedKeybindingItem(undefined, item.command, item.commandArgs, when, isDefault, item.extensionId);
+			} else {
+				if (this._assertBrowserConflicts(keybinding, item.command)) {
+					continue;
+				}
+
+				const resolvedKeybindings = this.resolveKeybinding(keybinding);
+				for (let i = resolvedKeybindings.length - 1; i >= 0; i--) {
+					const resolvedKeybinding = resolvedKeybindings[i];
+					result[resultLen++] = new ResolvedKeybindingItem(resolvedKeybinding, item.command, item.commandArgs, when, isDefault, item.extensionId);
+				}
+			}
+		}
+
+		return result;
+	}
+
+	private _resolveUserKeybindingItems(items: IUserKeybindingItem[], isDefault: boolean): ResolvedKeybindingItem[] {
+		let result: ResolvedKeybindingItem[] = [], resultLen = 0;
+		for (const item of items) {
+			const when = item.when || undefined;
+			const parts = item.parts;
+			if (parts.length === 0) {
+				// This might be a removal keybinding item in user settings => accept it
+				result[resultLen++] = new ResolvedKeybindingItem(undefined, item.command, item.commandArgs, when, isDefault, null);
+			} else {
+				const resolvedKeybindings = this._keyboardMapper.resolveUserBinding(parts);
+				for (const resolvedKeybinding of resolvedKeybindings) {
+					result[resultLen++] = new ResolvedKeybindingItem(resolvedKeybinding, item.command, item.commandArgs, when, isDefault, null);
+				}
+			}
+		}
+
+		return result;
+	}
+
+	private _assertBrowserConflicts(kb: Keybinding, commandId: string): boolean {
+		if (BrowserFeatures.keyboard === KeyboardSupport.Always) {
+			return false;
+		}
+
+		if (BrowserFeatures.keyboard === KeyboardSupport.FullScreen && browser.isFullscreen()) {
+			return false;
+		}
+
+		for (let part of kb.parts) {
+			if (!part.metaKey && !part.altKey && !part.ctrlKey && !part.shiftKey) {
+				continue;
+			}
+
+			const modifiersMask = KeyMod.CtrlCmd | KeyMod.Alt | KeyMod.Shift;
+
+			let partModifiersMask = 0;
+			if (part.metaKey) {
+				partModifiersMask |= KeyMod.CtrlCmd;
+			}
+
+			if (part.shiftKey) {
+				partModifiersMask |= KeyMod.Shift;
+			}
+
+			if (part.altKey) {
+				partModifiersMask |= KeyMod.Alt;
+			}
+
+			if (part.ctrlKey && OS === OperatingSystem.Macintosh) {
+				partModifiersMask |= KeyMod.WinCtrl;
+			}
+
+			if ((partModifiersMask & modifiersMask) === KeyMod.CtrlCmd && part.keyCode === KeyCode.KEY_W) {
+				// console.warn('Ctrl/Cmd+W keybindings should not be used by default in web. Offender: ', kb.getHashCode(), ' for ', commandId);
+
+				return true;
+			}
+
+			if ((partModifiersMask & modifiersMask) === KeyMod.CtrlCmd && part.keyCode === KeyCode.KEY_N) {
+				// console.warn('Ctrl/Cmd+N keybindings should not be used by default in web. Offender: ', kb.getHashCode(), ' for ', commandId);
+
+				return true;
+			}
+
+			if ((partModifiersMask & modifiersMask) === KeyMod.CtrlCmd && part.keyCode === KeyCode.KEY_T) {
+				// console.warn('Ctrl/Cmd+T keybindings should not be used by default in web. Offender: ', kb.getHashCode(), ' for ', commandId);
+
+				return true;
+			}
+
+			if ((partModifiersMask & modifiersMask) === (KeyMod.CtrlCmd | KeyMod.Alt) && (part.keyCode === KeyCode.LeftArrow || part.keyCode === KeyCode.RightArrow)) {
+				// console.warn('Ctrl/Cmd+Arrow keybindings should not be used by default in web. Offender: ', kb.getHashCode(), ' for ', commandId);
+
+				return true;
+			}
+
+			if ((partModifiersMask & modifiersMask) === KeyMod.CtrlCmd && part.keyCode >= KeyCode.KEY_0 && part.keyCode <= KeyCode.KEY_9) {
+				// console.warn('Ctrl/Cmd+Num keybindings should not be used by default in web. Offender: ', kb.getHashCode(), ' for ', commandId);
+
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	public resolveKeybinding(kb: Keybinding): ResolvedKeybinding[] {
+		return this._keyboardMapper.resolveKeybinding(kb);
+	}
+
+	public resolveKeyboardEvent(keyboardEvent: IKeyboardEvent): ResolvedKeybinding {
+		this.keymapService.validateCurrentKeyboardMapping(keyboardEvent);
+		return this._keyboardMapper.resolveKeyboardEvent(keyboardEvent);
+	}
+
+	public resolveUserBinding(userBinding: string): ResolvedKeybinding[] {
+		const parts = KeybindingParser.parseUserBinding(userBinding);
+		return this._keyboardMapper.resolveUserBinding(parts);
+	}
+
+	private _handleKeybindingsExtensionPointUser(extensionId: ExtensionIdentifier, isBuiltin: boolean, keybindings: ContributedKeyBinding | ContributedKeyBinding[], collector: ExtensionMessageCollector, result: IKeybindingRule2[]): void {
+		if (isContributedKeyBindingsArray(keybindings)) {
+			for (let i = 0, len = keybindings.length; i < len; i++) {
+				this._handleKeybinding(extensionId, isBuiltin, i + 1, keybindings[i], collector, result);
+			}
+		} else {
+			this._handleKeybinding(extensionId, isBuiltin, 1, keybindings, collector, result);
+		}
+	}
+
+	private _handleKeybinding(extensionId: ExtensionIdentifier, isBuiltin: boolean, idx: number, keybindings: ContributedKeyBinding, collector: ExtensionMessageCollector, result: IKeybindingRule2[]): void {
+
+		let rejects: string[] = [];
+
+		if (isValidContributedKeyBinding(keybindings, rejects)) {
+			let rule = this._asCommandRule(extensionId, isBuiltin, idx++, keybindings);
+			if (rule) {
+				result.push(rule);
+			}
+		}
+
+		if (rejects.length > 0) {
+			collector.error(nls.localize(
+				'invalid.keybindings',
+				"Invalid `contributes.{0}`: {1}",
+				keybindingsExtPoint.name,
+				rejects.join('\n')
+			));
+		}
+	}
+
+	private _asCommandRule(extensionId: ExtensionIdentifier, isBuiltin: boolean, idx: number, binding: ContributedKeyBinding): IKeybindingRule2 | undefined {
+
+		let { command, args, when, key, mac, linux, win } = binding;
+
+		let weight: number;
+		if (isBuiltin) {
+			weight = KeybindingWeight.BuiltinExtension + idx;
+		} else {
+			weight = KeybindingWeight.ExternalExtension + idx;
+		}
+
+		let commandAction = MenuRegistry.getCommand(command);
+		let precondition = commandAction && commandAction.precondition;
+		let fullWhen: ContextKeyExpression | undefined;
+		if (when && precondition) {
+			fullWhen = ContextKeyExpr.and(precondition, ContextKeyExpr.deserialize(when));
+		} else if (when) {
+			fullWhen = ContextKeyExpr.deserialize(when);
+		} else if (precondition) {
+			fullWhen = precondition;
+		}
+
+		let desc: IKeybindingRule2 = {
+			id: command,
+			args,
+			when: fullWhen,
+			weight: weight,
+			primary: KeybindingParser.parseKeybinding(key, OS),
+			mac: mac ? { primary: KeybindingParser.parseKeybinding(mac, OS) } : null,
+			linux: linux ? { primary: KeybindingParser.parseKeybinding(linux, OS) } : null,
+			win: win ? { primary: KeybindingParser.parseKeybinding(win, OS) } : null,
+			extensionId: extensionId.value
+		};
+
+		if (!desc.primary && !desc.mac && !desc.linux && !desc.win) {
+			return undefined;
+		}
+
+		return desc;
+	}
+
+	public getDefaultKeybindingsContent(): string {
+		const resolver = this._getResolver();
+		const defaultKeybindings = resolver.getDefaultKeybindings();
+		const boundCommands = resolver.getDefaultBoundCommands();
+		return (
+			WorkbenchKeybindingService._getDefaultKeybindings(defaultKeybindings)
+			+ '\n\n'
+			+ WorkbenchKeybindingService._getAllCommandsAsComment(boundCommands)
+		);
+	}
+
+	private static _getDefaultKeybindings(defaultKeybindings: readonly ResolvedKeybindingItem[]): string {
+		let out = new OutputBuilder();
+		out.writeLine('[');
+
+		let lastIndex = defaultKeybindings.length - 1;
+		defaultKeybindings.forEach((k, index) => {
+			KeybindingIO.writeKeybindingItem(out, k);
+			if (index !== lastIndex) {
+				out.writeLine(',');
+			} else {
+				out.writeLine();
+			}
+		});
+		out.writeLine(']');
+		return out.toString();
+	}
+
+	private static _getAllCommandsAsComment(boundCommands: Map<string, boolean>): string {
+		const unboundCommands = KeybindingResolver.getAllUnboundCommands(boundCommands);
+		let pretty = unboundCommands.sort().join('\n// - ');
+		return '// ' + nls.localize('unboundCommands', "Here are other available commands: ") + '\n// - ' + pretty;
+	}
+
+	mightProducePrintableCharacter(event: IKeyboardEvent): boolean {
+		if (event.ctrlKey || event.metaKey || event.altKey) {
+			// ignore ctrl/cmd/alt-combination but not shift-combinatios
+			return false;
+		}
+		const code = ScanCodeUtils.toEnum(event.code);
+
+		if (NUMPAD_PRINTABLE_SCANCODES.indexOf(code) !== -1) {
+			// This is a numpad key that might produce a printable character based on NumLock.
+			// Let's check if NumLock is on or off based on the event's keyCode.
+			// e.g.
+			// - when NumLock is off, ScanCode.Numpad4 produces KeyCode.LeftArrow
+			// - when NumLock is on, ScanCode.Numpad4 produces KeyCode.NUMPAD_4
+			// However, ScanCode.NumpadAdd always produces KeyCode.NUMPAD_ADD
+			if (event.keyCode === IMMUTABLE_CODE_TO_KEY_CODE[code]) {
+				// NumLock is on or this is /, *, -, + on the numpad
+				return true;
+			}
+			if (isMacintosh && event.keyCode === otherMacNumpadMapping.get(code)) {
+				// on macOS, the numpad keys can also map to keys 1 - 0.
+				return true;
+			}
+			return false;
+		}
+
+		const keycode = IMMUTABLE_CODE_TO_KEY_CODE[code];
+		if (keycode !== -1) {
+			// https://github.com/microsoft/vscode/issues/74934
+			return false;
+		}
+		// consult the KeyboardMapperFactory to check the given event for
+		// a printable value.
+		const mapping = this.keymapService.getRawKeyboardMapping();
+		if (!mapping) {
+			return false;
+		}
+		const keyInfo = mapping[event.code];
+		if (!keyInfo) {
+			return false;
+		}
+		if (!keyInfo.value || /\s/.test(keyInfo.value)) {
+			return false;
+		}
+		return true;
+	}
+}
+
+class UserKeybindings extends Disposable {
+
+	private _keybindings: IUserFriendlyKeybinding[] = [];
+	get keybindings(): IUserFriendlyKeybinding[] { return this._keybindings; }
+
+	private readonly reloadConfigurationScheduler: RunOnceScheduler;
+
+	private readonly _onDidChange: Emitter<void> = this._register(new Emitter<void>());
+	readonly onDidChange: Event<void> = this._onDidChange.event;
+
+	constructor(
+		private readonly keybindingsResource: URI,
+		private readonly fileService: IFileService,
+		logService: ILogService,
+	) {
+		super();
+
+		this.reloadConfigurationScheduler = this._register(new RunOnceScheduler(() => this.reload().then(changed => {
+			if (changed) {
+				this._onDidChange.fire();
+			}
+		}), 50));
+		this._register(Event.filter(this.fileService.onDidFilesChange, e => e.contains(this.keybindingsResource))(() => {
+			logService.debug('Keybindings file changed');
+			this.reloadConfigurationScheduler.schedule();
+		}));
+	}
+
+	async initialize(): Promise<void> {
+		await this.reload();
+	}
+
+	private async reload(): Promise<boolean> {
+		const existing = this._keybindings;
+		try {
+			const content = await this.fileService.readFile(this.keybindingsResource);
+			const value = parse(content.value.toString());
+			this._keybindings = isArray(value) ? value : [];
+		} catch (e) {
+			this._keybindings = [];
+		}
+		return existing ? !objects.equals(existing, this._keybindings) : true;
+	}
+}
+
+let schemaId = 'vscode://schemas/keybindings';
+let commandsSchemas: IJSONSchema[] = [];
+let commandsEnum: string[] = [];
+let commandsEnumDescriptions: (string | undefined)[] = [];
+let schema: IJSONSchema = {
+	id: schemaId,
+	type: 'array',
+	title: nls.localize('keybindings.json.title', "Keybindings configuration"),
+	allowTrailingCommas: true,
+	allowComments: true,
+	definitions: {
+		'editorGroupsSchema': {
+			'type': 'array',
+			'items': {
+				'type': 'object',
+				'properties': {
+					'groups': {
+						'$ref': '#/definitions/editorGroupsSchema',
+						'default': [{}, {}]
+					},
+					'size': {
+						'type': 'number',
+						'default': 0.5
+					}
+				}
+			}
+		}
+	},
+	items: {
+		'required': ['key'],
+		'type': 'object',
+		'defaultSnippets': [{ 'body': { 'key': '$1', 'command': '$2', 'when': '$3' } }],
+		'properties': {
+			'key': {
+				'type': 'string',
+				'description': nls.localize('keybindings.json.key', "Key or key sequence (separated by space)"),
+			},
+			'command': {
+				'anyOf': [
+					{
+						'type': 'string',
+						'enum': commandsEnum,
+						'enumDescriptions': <any>commandsEnumDescriptions,
+						'description': nls.localize('keybindings.json.command', "Name of the command to execute"),
+					},
+					{
+						'type': 'string'
+					}
+				]
+			},
+			'when': {
+				'type': 'string',
+				'description': nls.localize('keybindings.json.when', "Condition when the key is active.")
+			},
+			'args': {
+				'description': nls.localize('keybindings.json.args', "Arguments to pass to the command to execute.")
+			}
+		},
+		'allOf': commandsSchemas
+	}
+};
+
+let schemaRegistry = Registry.as<IJSONContributionRegistry>(Extensions.JSONContribution);
+schemaRegistry.registerSchema(schemaId, schema);
+
+function updateSchema(additionalContributions: readonly IJSONSchema[]) {
+	commandsSchemas.length = 0;
+	commandsEnum.length = 0;
+	commandsEnumDescriptions.length = 0;
+
+	const knownCommands = new Set<string>();
+	const addKnownCommand = (commandId: string, description?: string | undefined) => {
+		if (!/^_/.test(commandId)) {
+			if (!knownCommands.has(commandId)) {
+				knownCommands.add(commandId);
+
+				commandsEnum.push(commandId);
+				commandsEnumDescriptions.push(description);
+
+				// Also add the negative form for keybinding removal
+				commandsEnum.push(`-${commandId}`);
+				commandsEnumDescriptions.push(description);
+			}
+		}
+	};
+
+	const allCommands = CommandsRegistry.getCommands();
+	for (const [commandId, command] of allCommands) {
+		const commandDescription = command.description;
+
+		addKnownCommand(commandId, commandDescription ? commandDescription.description : undefined);
+
+		if (!commandDescription || !commandDescription.args || commandDescription.args.length !== 1 || !commandDescription.args[0].schema) {
+			continue;
+		}
+
+		const argsSchema = commandDescription.args[0].schema;
+		const argsRequired = Array.isArray(argsSchema.required) && argsSchema.required.length > 0;
+		const addition = {
+			'if': {
+				'properties': {
+					'command': { 'const': commandId }
+				}
+			},
+			'then': {
+				'required': (<string[]>[]).concat(argsRequired ? ['args'] : []),
+				'properties': {
+					'args': argsSchema
+				}
+			}
+		};
+
+		commandsSchemas.push(addition);
+	}
+
+	const menuCommands = MenuRegistry.getCommands();
+	for (const commandId of menuCommands.keys()) {
+		addKnownCommand(commandId);
+	}
+
+	commandsSchemas.push(...additionalContributions);
+	schemaRegistry.notifySchemaChanged(schemaId);
+}
+
+const configurationRegistry = Registry.as<IConfigurationRegistry>(ConfigExtensions.Configuration);
+const keyboardConfiguration: IConfigurationNode = {
+	'id': 'keyboard',
+	'order': 15,
+	'type': 'object',
+	'title': nls.localize('keyboardConfigurationTitle', "Keyboard"),
+	'properties': {
+		'keyboard.dispatch': {
+			'type': 'string',
+			'enum': ['code', 'keyCode'],
+			'default': 'code',
+			'markdownDescription': nls.localize('dispatch', "Controls the dispatching logic for key presses to use either `code` (recommended) or `keyCode`."),
+			'included': OS === OperatingSystem.Macintosh || OS === OperatingSystem.Linux
+		}
+	}
+};
+
+configurationRegistry.registerConfiguration(keyboardConfiguration);
+
+registerSingleton(IKeybindingService, WorkbenchKeybindingService);

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution.ts

@@ -0,0 +1,23 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IKeymapInfo } from 'vs/workbench/services/keybinding/common/keymapInfo';
+
+export class KeyboardLayoutContribution {
+	public static readonly INSTANCE: KeyboardLayoutContribution = new KeyboardLayoutContribution();
+
+	private _layoutInfos: IKeymapInfo[] = [];
+
+	get layoutInfos() {
+		return this._layoutInfos;
+	}
+
+	private constructor() {
+	}
+
+	registerKeyboardLayout(layout: IKeymapInfo) {
+		this._layoutInfos.push(layout);
+	}
+}

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/cz.win.ts

@@ -0,0 +1,168 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { name: '00000405', id: '', text: 'Czech' },
+	secondaryLayouts: [],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['a', 'A', '', '', 0, 'VK_A'],
+		KeyB: ['b', 'B', '{', '', 0, 'VK_B'],
+		KeyC: ['c', 'C', '&', '', 0, 'VK_C'],
+		KeyD: ['d', 'D', 'Đ', '', 0, 'VK_D'],
+		KeyE: ['e', 'E', '€', '', 0, 'VK_E'],
+		KeyF: ['f', 'F', '[', '', 0, 'VK_F'],
+		KeyG: ['g', 'G', ']', '', 0, 'VK_G'],
+		KeyH: ['h', 'H', '', '', 0, 'VK_H'],
+		KeyI: ['i', 'I', '', '', 0, 'VK_I'],
+		KeyJ: ['j', 'J', '', '', 0, 'VK_J'],
+		KeyK: ['k', 'K', 'ł', '', 0, 'VK_K'],
+		KeyL: ['l', 'L', 'Ł', '', 0, 'VK_L'],
+		KeyM: ['m', 'M', '', '', 0, 'VK_M'],
+		KeyN: ['n', 'N', '}', '', 0, 'VK_N'],
+		KeyO: ['o', 'O', '', '', 0, 'VK_O'],
+		KeyP: ['p', 'P', '', '', 0, 'VK_P'],
+		KeyQ: ['q', 'Q', '\\', '', 0, 'VK_Q'],
+		KeyR: ['r', 'R', '', '', 0, 'VK_R'],
+		KeyS: ['s', 'S', 'đ', '', 0, 'VK_S'],
+		KeyT: ['t', 'T', '', '', 0, 'VK_T'],
+		KeyU: ['u', 'U', '', '', 0, 'VK_U'],
+		KeyV: ['v', 'V', '@', '', 0, 'VK_V'],
+		KeyW: ['w', 'W', '|', '', 0, 'VK_W'],
+		KeyX: ['x', 'X', '#', '', 0, 'VK_X'],
+		KeyY: ['z', 'Z', '', '', 0, 'VK_Z'],
+		KeyZ: ['y', 'Y', '', '', 0, 'VK_Y'],
+		Digit1: ['+', '1', '~', '', 0, 'VK_1'],
+		Digit2: ['ě', '2', 'ˇ', '', 0, 'VK_2'],
+		Digit3: ['š', '3', '^', '', 0, 'VK_3'],
+		Digit4: ['č', '4', '˘', '', 0, 'VK_4'],
+		Digit5: ['ř', '5', '°', '', 0, 'VK_5'],
+		Digit6: ['ž', '6', '˛', '', 0, 'VK_6'],
+		Digit7: ['ý', '7', '`', '', 0, 'VK_7'],
+		Digit8: ['á', '8', '˙', '', 0, 'VK_8'],
+		Digit9: ['í', '9', '´', '', 0, 'VK_9'],
+		Digit0: ['é', '0', '˝', '', 0, 'VK_0'],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', '', '', 0, 'VK_SPACE'],
+		Minus: ['=', '%', '¨', '', 0, 'VK_OEM_PLUS'],
+		Equal: ['´', 'ˇ', '¸', '', 0, 'VK_OEM_2'],
+		BracketLeft: ['ú', '/', '÷', '', 0, 'VK_OEM_4'],
+		BracketRight: [')', '(', '×', '', 0, 'VK_OEM_6'],
+		Backslash: ['¨', '\'', '¤', '', 0, 'VK_OEM_5'],
+		Semicolon: ['ů', '"', '$', '', 0, 'VK_OEM_1'],
+		Quote: ['§', '!', 'ß', '', 0, 'VK_OEM_7'],
+		Backquote: [';', '°', '', '', 0, 'VK_OEM_3'],
+		Comma: [',', '?', '<', '', 0, 'VK_OEM_COMMA'],
+		Period: ['.', ':', '>', '', 0, 'VK_OEM_PERIOD'],
+		Slash: ['-', '_', '*', '', 0, 'VK_OEM_MINUS'],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: [],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '', '', 0, 'VK_DIVIDE'],
+		NumpadMultiply: ['*', '*', '', '', 0, 'VK_MULTIPLY'],
+		NumpadSubtract: ['-', '-', '', '', 0, 'VK_SUBTRACT'],
+		NumpadAdd: ['+', '+', '', '', 0, 'VK_ADD'],
+		NumpadEnter: [],
+		Numpad1: [],
+		Numpad2: [],
+		Numpad3: [],
+		Numpad4: [],
+		Numpad5: [],
+		Numpad6: [],
+		Numpad7: [],
+		Numpad8: [],
+		Numpad9: [],
+		Numpad0: [],
+		NumpadDecimal: [],
+		IntlBackslash: ['\\', '|', '', '', 0, 'VK_OEM_102'],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: [],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Help: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/de-swiss.win.ts

@@ -0,0 +1,169 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { name: '00000807', id: '', text: 'Swiss German' },
+	secondaryLayouts: [],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['a', 'A', '', '', 0, 'VK_A'],
+		KeyB: ['b', 'B', '', '', 0, 'VK_B'],
+		KeyC: ['c', 'C', '', '', 0, 'VK_C'],
+		KeyD: ['d', 'D', '', '', 0, 'VK_D'],
+		KeyE: ['e', 'E', '€', '', 0, 'VK_E'],
+		KeyF: ['f', 'F', '', '', 0, 'VK_F'],
+		KeyG: ['g', 'G', '', '', 0, 'VK_G'],
+		KeyH: ['h', 'H', '', '', 0, 'VK_H'],
+		KeyI: ['i', 'I', '', '', 0, 'VK_I'],
+		KeyJ: ['j', 'J', '', '', 0, 'VK_J'],
+		KeyK: ['k', 'K', '', '', 0, 'VK_K'],
+		KeyL: ['l', 'L', '', '', 0, 'VK_L'],
+		KeyM: ['m', 'M', '', '', 0, 'VK_M'],
+		KeyN: ['n', 'N', '', '', 0, 'VK_N'],
+		KeyO: ['o', 'O', '', '', 0, 'VK_O'],
+		KeyP: ['p', 'P', '', '', 0, 'VK_P'],
+		KeyQ: ['q', 'Q', '', '', 0, 'VK_Q'],
+		KeyR: ['r', 'R', '', '', 0, 'VK_R'],
+		KeyS: ['s', 'S', '', '', 0, 'VK_S'],
+		KeyT: ['t', 'T', '', '', 0, 'VK_T'],
+		KeyU: ['u', 'U', '', '', 0, 'VK_U'],
+		KeyV: ['v', 'V', '', '', 0, 'VK_V'],
+		KeyW: ['w', 'W', '', '', 0, 'VK_W'],
+		KeyX: ['x', 'X', '', '', 0, 'VK_X'],
+		KeyY: ['z', 'Z', '', '', 0, 'VK_Z'],
+		KeyZ: ['y', 'Y', '', '', 0, 'VK_Y'],
+		Digit1: ['1', '+', '¦', '', 0, 'VK_1'],
+		Digit2: ['2', '"', '@', '', 0, 'VK_2'],
+		Digit3: ['3', '*', '#', '', 0, 'VK_3'],
+		Digit4: ['4', 'ç', '°', '', 0, 'VK_4'],
+		Digit5: ['5', '%', '§', '', 0, 'VK_5'],
+		Digit6: ['6', '&', '¬', '', 0, 'VK_6'],
+		Digit7: ['7', '/', '|', '', 0, 'VK_7'],
+		Digit8: ['8', '(', '¢', '', 0, 'VK_8'],
+		Digit9: ['9', ')', '', '', 0, 'VK_9'],
+		Digit0: ['0', '=', '', '', 0, 'VK_0'],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', '', '', 0, 'VK_SPACE'],
+		Minus: ['\'', '?', '´', '', 0, 'VK_OEM_4'],
+		Equal: ['^', '`', '~', '', 0, 'VK_OEM_6'],
+		BracketLeft: ['ü', 'è', '[', '', 0, 'VK_OEM_1'],
+		BracketRight: ['¨', '!', ']', '', 0, 'VK_OEM_3'],
+		Backslash: ['$', '£', '}', '', 0, 'VK_OEM_8'],
+		Semicolon: ['ö', 'é', '', '', 0, 'VK_OEM_7'],
+		Quote: ['ä', 'à', '{', '', 0, 'VK_OEM_5'],
+		Backquote: ['§', '°', '', '', 0, 'VK_OEM_2'],
+		Comma: [',', ';', '', '', 0, 'VK_OEM_COMMA'],
+		Period: ['.', ':', '', '', 0, 'VK_OEM_PERIOD'],
+		Slash: ['-', '_', '', '', 0, 'VK_OEM_MINUS'],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: [],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '', '', 0, 'VK_DIVIDE'],
+		NumpadMultiply: ['*', '*', '', '', 0, 'VK_MULTIPLY'],
+		NumpadSubtract: ['-', '-', '', '', 0, 'VK_SUBTRACT'],
+		NumpadAdd: ['+', '+', '', '', 0, 'VK_ADD'],
+		NumpadEnter: [],
+		Numpad1: [],
+		Numpad2: [],
+		Numpad3: [],
+		Numpad4: [],
+		Numpad5: [],
+		Numpad6: [],
+		Numpad7: [],
+		Numpad8: [],
+		Numpad9: [],
+		Numpad0: [],
+		NumpadDecimal: [],
+		IntlBackslash: ['<', '>', '\\', '', 0, 'VK_OEM_102'],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: [],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Help: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/de.darwin.ts

@@ -0,0 +1,132 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { id: 'com.apple.keylayout.German', lang: 'de', localizedName: 'German' },
+	secondaryLayouts: [],
+	mapping: {
+		KeyA: ['a', 'A', 'å', 'Å', 0],
+		KeyB: ['b', 'B', '∫', '‹', 0],
+		KeyC: ['c', 'C', 'ç', 'Ç', 0],
+		KeyD: ['d', 'D', '∂', '™', 0],
+		KeyE: ['e', 'E', '€', '‰', 0],
+		KeyF: ['f', 'F', 'ƒ', 'Ï', 0],
+		KeyG: ['g', 'G', '©', 'Ì', 0],
+		KeyH: ['h', 'H', 'ª', 'Ó', 0],
+		KeyI: ['i', 'I', '⁄', 'Û', 0],
+		KeyJ: ['j', 'J', 'º', 'ı', 0],
+		KeyK: ['k', 'K', '∆', 'ˆ', 0],
+		KeyL: ['l', 'L', '@', 'fl', 0],
+		KeyM: ['m', 'M', 'µ', '˘', 0],
+		KeyN: ['n', 'N', '~', '›', 4],
+		KeyO: ['o', 'O', 'ø', 'Ø', 0],
+		KeyP: ['p', 'P', 'π', '∏', 0],
+		KeyQ: ['q', 'Q', '«', '»', 0],
+		KeyR: ['r', 'R', '®', '¸', 0],
+		KeyS: ['s', 'S', '‚', 'Í', 0],
+		KeyT: ['t', 'T', '†', '˝', 0],
+		KeyU: ['u', 'U', '¨', 'Á', 4],
+		KeyV: ['v', 'V', '√', '◊', 0],
+		KeyW: ['w', 'W', '∑', '„', 0],
+		KeyX: ['x', 'X', '≈', 'Ù', 0],
+		KeyY: ['z', 'Z', 'Ω', 'ˇ', 0],
+		KeyZ: ['y', 'Y', '¥', '‡', 0],
+		Digit1: ['1', '!', '¡', '¬', 0],
+		Digit2: ['2', '"', '“', '”', 0],
+		Digit3: ['3', '§', '¶', '#', 0],
+		Digit4: ['4', '$', '¢', '£', 0],
+		Digit5: ['5', '%', '[', 'fi', 0],
+		Digit6: ['6', '&', ']', '^', 8],
+		Digit7: ['7', '/', '|', '\\', 0],
+		Digit8: ['8', '(', '{', '˜', 0],
+		Digit9: ['9', ')', '}', '·', 0],
+		Digit0: ['0', '=', '≠', '¯', 0],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', ' ', ' ', 0],
+		Minus: ['ß', '?', '¿', '˙', 0],
+		Equal: ['´', '`', '\'', '˚', 3],
+		BracketLeft: ['ü', 'Ü', '•', '°', 0],
+		BracketRight: ['+', '*', '±', '', 0],
+		Backslash: ['#', '\'', '‘', '’', 0],
+		Semicolon: ['ö', 'Ö', 'œ', 'Œ', 0],
+		Quote: ['ä', 'Ä', 'æ', 'Æ', 0],
+		Backquote: ['<', '>', '≤', '≥', 0],
+		Comma: [',', ';', '∞', '˛', 0],
+		Period: ['.', ':', '…', '÷', 0],
+		Slash: ['-', '_', '–', '—', 0],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '/', '/', 0],
+		NumpadMultiply: ['*', '*', '*', '*', 0],
+		NumpadSubtract: ['-', '-', '-', '-', 0],
+		NumpadAdd: ['+', '+', '+', '+', 0],
+		NumpadEnter: [],
+		Numpad1: ['1', '1', '1', '1', 0],
+		Numpad2: ['2', '2', '2', '2', 0],
+		Numpad3: ['3', '3', '3', '3', 0],
+		Numpad4: ['4', '4', '4', '4', 0],
+		Numpad5: ['5', '5', '5', '5', 0],
+		Numpad6: ['6', '6', '6', '6', 0],
+		Numpad7: ['7', '7', '7', '7', 0],
+		Numpad8: ['8', '8', '8', '8', 0],
+		Numpad9: ['9', '9', '9', '9', 0],
+		Numpad0: ['0', '0', '0', '0', 0],
+		NumpadDecimal: [',', ',', '.', '.', 0],
+		IntlBackslash: ['^', '°', '„', '“', 1],
+		ContextMenu: [],
+		NumpadEqual: ['=', '=', '=', '=', 0],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: ['', '=', '', '=', 0],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/de.linux.ts

@@ -0,0 +1,187 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { model: 'pc104', layout: 'de', variant: '', options: '', rules: 'base' },
+	secondaryLayouts: [],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['a', 'A', 'æ', 'Æ', 0],
+		KeyB: ['b', 'B', '“', '‘', 0],
+		KeyC: ['c', 'C', '¢', '©', 0],
+		KeyD: ['d', 'D', 'ð', 'Ð', 0],
+		KeyE: ['e', 'E', '€', '€', 0],
+		KeyF: ['f', 'F', 'đ', 'ª', 0],
+		KeyG: ['g', 'G', 'ŋ', 'Ŋ', 0],
+		KeyH: ['h', 'H', 'ħ', 'Ħ', 0],
+		KeyI: ['i', 'I', '→', 'ı', 0],
+		KeyJ: ['j', 'J', '̣', '̇', 0],
+		KeyK: ['k', 'K', 'ĸ', '&', 0],
+		KeyL: ['l', 'L', 'ł', 'Ł', 0],
+		KeyM: ['m', 'M', 'µ', 'º', 0],
+		KeyN: ['n', 'N', '”', '’', 0],
+		KeyO: ['o', 'O', 'ø', 'Ø', 0],
+		KeyP: ['p', 'P', 'þ', 'Þ', 0],
+		KeyQ: ['q', 'Q', '@', 'Ω', 0],
+		KeyR: ['r', 'R', '¶', '®', 0],
+		KeyS: ['s', 'S', 'ſ', 'ẞ', 0],
+		KeyT: ['t', 'T', 'ŧ', 'Ŧ', 0],
+		KeyU: ['u', 'U', '↓', '↑', 0],
+		KeyV: ['v', 'V', '„', '‚', 0],
+		KeyW: ['w', 'W', 'ł', 'Ł', 0],
+		KeyX: ['x', 'X', '«', '‹', 0],
+		KeyY: ['z', 'Z', '←', '¥', 0],
+		KeyZ: ['y', 'Y', '»', '›', 0],
+		Digit1: ['1', '!', '¹', '¡', 0],
+		Digit2: ['2', '"', '²', '⅛', 0],
+		Digit3: ['3', '§', '³', '£', 0],
+		Digit4: ['4', '$', '¼', '¤', 0],
+		Digit5: ['5', '%', '½', '⅜', 0],
+		Digit6: ['6', '&', '¬', '⅝', 0],
+		Digit7: ['7', '/', '{', '⅞', 0],
+		Digit8: ['8', '(', '[', '™', 0],
+		Digit9: ['9', ')', ']', '±', 0],
+		Digit0: ['0', '=', '}', '°', 0],
+		Enter: ['\r', '\r', '\r', '\r', 0],
+		Escape: ['\u001b', '\u001b', '\u001b', '\u001b', 0],
+		Backspace: ['\b', '\b', '\b', '\b', 0],
+		Tab: ['\t', '', '\t', '', 0],
+		Space: [' ', ' ', ' ', ' ', 0],
+		Minus: ['ß', '?', '\\', '¿', 0],
+		Equal: ['́', '̀', '̧', '̨', 0],
+		BracketLeft: ['ü', 'Ü', '̈', '̊', 0],
+		BracketRight: ['+', '*', '~', '¯', 0],
+		Backslash: ['#', '\'', '’', '̆', 0],
+		Semicolon: ['ö', 'Ö', '̋', '̣', 0],
+		Quote: ['ä', 'Ä', '̂', '̌', 0],
+		Backquote: ['̂', '°', '′', '″', 0],
+		Comma: [',', ';', '·', '×', 0],
+		Period: ['.', ':', '…', '÷', 0],
+		Slash: ['-', '_', '–', '—', 0],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: ['', '', '', '', 0],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: ['/', '/', '/', '/', 0],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: [],
+		NumpadMultiply: ['*', '*', '*', '*', 0],
+		NumpadSubtract: ['-', '-', '-', '-', 0],
+		NumpadAdd: ['+', '+', '+', '+', 0],
+		NumpadEnter: [],
+		Numpad1: ['', '1', '', '1', 0],
+		Numpad2: ['', '2', '', '2', 0],
+		Numpad3: ['', '3', '', '3', 0],
+		Numpad4: ['', '4', '', '4', 0],
+		Numpad5: ['', '5', '', '5', 0],
+		Numpad6: ['', '6', '', '6', 0],
+		Numpad7: ['', '7', '', '7', 0],
+		Numpad8: ['', '8', '', '8', 0],
+		Numpad9: ['', '9', '', '9', 0],
+		Numpad0: ['', '0', '', '0', 0],
+		NumpadDecimal: ['', ',', '', ',', 0],
+		IntlBackslash: ['<', '>', '|', '̱', 0],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: [],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Open: [],
+		Help: [],
+		Select: [],
+		Again: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		Find: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		Lang5: [],
+		NumpadParenLeft: [],
+		NumpadParenRight: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: ['\r', '\r', '\r', '\r', 0],
+		MetaRight: ['.', '.', '.', '.', 0],
+		BrightnessUp: [],
+		BrightnessDown: [],
+		MediaPlay: [],
+		MediaRecord: [],
+		MediaFastForward: [],
+		MediaRewind: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		SelectTask: [],
+		LaunchScreenSaver: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: [],
+		MailReply: [],
+		MailForward: [],
+		MailSend: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/de.win.ts

@@ -0,0 +1,169 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { name: '00000407', id: '', text: 'German' },
+	secondaryLayouts: [],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['a', 'A', '', '', 0, 'VK_A'],
+		KeyB: ['b', 'B', '', '', 0, 'VK_B'],
+		KeyC: ['c', 'C', '', '', 0, 'VK_C'],
+		KeyD: ['d', 'D', '', '', 0, 'VK_D'],
+		KeyE: ['e', 'E', '€', '', 0, 'VK_E'],
+		KeyF: ['f', 'F', '', '', 0, 'VK_F'],
+		KeyG: ['g', 'G', '', '', 0, 'VK_G'],
+		KeyH: ['h', 'H', '', '', 0, 'VK_H'],
+		KeyI: ['i', 'I', '', '', 0, 'VK_I'],
+		KeyJ: ['j', 'J', '', '', 0, 'VK_J'],
+		KeyK: ['k', 'K', '', '', 0, 'VK_K'],
+		KeyL: ['l', 'L', '', '', 0, 'VK_L'],
+		KeyM: ['m', 'M', 'µ', '', 0, 'VK_M'],
+		KeyN: ['n', 'N', '', '', 0, 'VK_N'],
+		KeyO: ['o', 'O', '', '', 0, 'VK_O'],
+		KeyP: ['p', 'P', '', '', 0, 'VK_P'],
+		KeyQ: ['q', 'Q', '@', '', 0, 'VK_Q'],
+		KeyR: ['r', 'R', '', '', 0, 'VK_R'],
+		KeyS: ['s', 'S', '', '', 0, 'VK_S'],
+		KeyT: ['t', 'T', '', '', 0, 'VK_T'],
+		KeyU: ['u', 'U', '', '', 0, 'VK_U'],
+		KeyV: ['v', 'V', '', '', 0, 'VK_V'],
+		KeyW: ['w', 'W', '', '', 0, 'VK_W'],
+		KeyX: ['x', 'X', '', '', 0, 'VK_X'],
+		KeyY: ['z', 'Z', '', '', 0, 'VK_Z'],
+		KeyZ: ['y', 'Y', '', '', 0, 'VK_Y'],
+		Digit1: ['1', '!', '', '', 0, 'VK_1'],
+		Digit2: ['2', '"', '²', '', 0, 'VK_2'],
+		Digit3: ['3', '§', '³', '', 0, 'VK_3'],
+		Digit4: ['4', '$', '', '', 0, 'VK_4'],
+		Digit5: ['5', '%', '', '', 0, 'VK_5'],
+		Digit6: ['6', '&', '', '', 0, 'VK_6'],
+		Digit7: ['7', '/', '{', '', 0, 'VK_7'],
+		Digit8: ['8', '(', '[', '', 0, 'VK_8'],
+		Digit9: ['9', ')', ']', '', 0, 'VK_9'],
+		Digit0: ['0', '=', '}', '', 0, 'VK_0'],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', '', '', 0, 'VK_SPACE'],
+		Minus: ['ß', '?', '\\', 'ẞ', 0, 'VK_OEM_4'],
+		Equal: ['´', '`', '', '', 0, 'VK_OEM_6'],
+		BracketLeft: ['ü', 'Ü', '', '', 0, 'VK_OEM_1'],
+		BracketRight: ['+', '*', '~', '', 0, 'VK_OEM_PLUS'],
+		Backslash: ['#', '\'', '', '', 0, 'VK_OEM_2'],
+		Semicolon: ['ö', 'Ö', '', '', 0, 'VK_OEM_3'],
+		Quote: ['ä', 'Ä', '', '', 0, 'VK_OEM_7'],
+		Backquote: ['^', '°', '', '', 0, 'VK_OEM_5'],
+		Comma: [',', ';', '', '', 0, 'VK_OEM_COMMA'],
+		Period: ['.', ':', '', '', 0, 'VK_OEM_PERIOD'],
+		Slash: ['-', '_', '', '', 0, 'VK_OEM_MINUS'],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: [],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '', '', 0, 'VK_DIVIDE'],
+		NumpadMultiply: ['*', '*', '', '', 0, 'VK_MULTIPLY'],
+		NumpadSubtract: ['-', '-', '', '', 0, 'VK_SUBTRACT'],
+		NumpadAdd: ['+', '+', '', '', 0, 'VK_ADD'],
+		NumpadEnter: [],
+		Numpad1: [],
+		Numpad2: [],
+		Numpad3: [],
+		Numpad4: [],
+		Numpad5: [],
+		Numpad6: [],
+		Numpad7: [],
+		Numpad8: [],
+		Numpad9: [],
+		Numpad0: [],
+		NumpadDecimal: [],
+		IntlBackslash: ['<', '>', '|', '', 0, 'VK_OEM_102'],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: [],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Help: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/dk.win.ts

@@ -0,0 +1,170 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { name: '00000406', id: '', text: 'Danish' },
+	secondaryLayouts: [],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['a', 'A', '', '', 0, 'VK_A'],
+		KeyB: ['b', 'B', '', '', 0, 'VK_B'],
+		KeyC: ['c', 'C', '', '', 0, 'VK_C'],
+		KeyD: ['d', 'D', '', '', 0, 'VK_D'],
+		KeyE: ['e', 'E', '€', '', 0, 'VK_E'],
+		KeyF: ['f', 'F', '', '', 0, 'VK_F'],
+		KeyG: ['g', 'G', '', '', 0, 'VK_G'],
+		KeyH: ['h', 'H', '', '', 0, 'VK_H'],
+		KeyI: ['i', 'I', '', '', 0, 'VK_I'],
+		KeyJ: ['j', 'J', '', '', 0, 'VK_J'],
+		KeyK: ['k', 'K', '', '', 0, 'VK_K'],
+		KeyL: ['l', 'L', '', '', 0, 'VK_L'],
+		KeyM: ['m', 'M', 'µ', '', 0, 'VK_M'],
+		KeyN: ['n', 'N', '', '', 0, 'VK_N'],
+		KeyO: ['o', 'O', '', '', 0, 'VK_O'],
+		KeyP: ['p', 'P', '', '', 0, 'VK_P'],
+		KeyQ: ['q', 'Q', '', '', 0, 'VK_Q'],
+		KeyR: ['r', 'R', '', '', 0, 'VK_R'],
+		KeyS: ['s', 'S', '', '', 0, 'VK_S'],
+		KeyT: ['t', 'T', '', '', 0, 'VK_T'],
+		KeyU: ['u', 'U', '', '', 0, 'VK_U'],
+		KeyV: ['v', 'V', '', '', 0, 'VK_V'],
+		KeyW: ['w', 'W', '', '', 0, 'VK_W'],
+		KeyX: ['x', 'X', '', '', 0, 'VK_X'],
+		KeyY: ['y', 'Y', '', '', 0, 'VK_Y'],
+		KeyZ: ['z', 'Z', '', '', 0, 'VK_Z'],
+		Digit1: ['1', '!', '', '', 0, 'VK_1'],
+		Digit2: ['2', '"', '@', '', 0, 'VK_2'],
+		Digit3: ['3', '#', '£', '', 0, 'VK_3'],
+		Digit4: ['4', '¤', '$', '', 0, 'VK_4'],
+		Digit5: ['5', '%', '€', '', 0, 'VK_5'],
+		Digit6: ['6', '&', '', '', 0, 'VK_6'],
+		Digit7: ['7', '/', '{', '', 0, 'VK_7'],
+		Digit8: ['8', '(', '[', '', 0, 'VK_8'],
+		Digit9: ['9', ')', ']', '', 0, 'VK_9'],
+		Digit0: ['0', '=', '}', '', 0, 'VK_0'],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', '', '', 0, 'VK_SPACE'],
+		Minus: ['+', '?', '', '', 0, 'VK_OEM_PLUS'],
+		Equal: ['´', '`', '|', '', 0, 'VK_OEM_4'],
+		BracketLeft: ['å', 'Å', '', '', 0, 'VK_OEM_6'],
+		BracketRight: ['¨', '^', '~', '', 0, 'VK_OEM_1'],
+		Backslash: ['\'', '*', '', '', 0, 'VK_OEM_2'],
+		Semicolon: ['æ', 'Æ', '', '', 0, 'VK_OEM_3'],
+		Quote: ['ø', 'Ø', '', '', 0, 'VK_OEM_7'],
+		Backquote: ['½', '§', '', '', 0, 'VK_OEM_5'],
+		Comma: [',', ';', '', '', 0, 'VK_OEM_COMMA'],
+		Period: ['.', ':', '', '', 0, 'VK_OEM_PERIOD'],
+		Slash: ['-', '_', '', '', 0, 'VK_OEM_MINUS'],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: [],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '', '', 0, 'VK_DIVIDE'],
+		NumpadMultiply: ['*', '*', '', '', 0, 'VK_MULTIPLY'],
+		NumpadSubtract: ['-', '-', '', '', 0, 'VK_SUBTRACT'],
+		NumpadAdd: ['+', '+', '', '', 0, 'VK_ADD'],
+		NumpadEnter: [],
+		Numpad1: [],
+		Numpad2: [],
+		Numpad3: [],
+		Numpad4: [],
+		Numpad5: [],
+		Numpad6: [],
+		Numpad7: [],
+		Numpad8: [],
+		Numpad9: [],
+		Numpad0: [],
+		NumpadDecimal: [],
+		IntlBackslash: ['<', '>', '\\', '', 0, 'VK_OEM_102'],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: [],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Help: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: []
+	}
+
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/dvorak.darwin.ts

@@ -0,0 +1,131 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { id: 'com.apple.keylayout.Dvorak', localizedName: 'Dvorak', lang: 'en' },
+	secondaryLayouts: [],
+	mapping: {
+		KeyA: ['a', 'A', 'å', 'Å', 0],
+		KeyB: ['x', 'X', '≈', '˛', 0],
+		KeyC: ['j', 'J', '∆', 'Ô', 0],
+		KeyD: ['e', 'E', '´', '´', 4],
+		KeyE: ['.', '>', '≥', '˘', 0],
+		KeyF: ['u', 'U', '¨', '¨', 4],
+		KeyG: ['i', 'I', 'ˆ', 'ˆ', 4],
+		KeyH: ['d', 'D', '∂', 'Î', 0],
+		KeyI: ['c', 'C', 'ç', 'Ç', 0],
+		KeyJ: ['h', 'H', '˙', 'Ó', 0],
+		KeyK: ['t', 'T', '†', 'ˇ', 0],
+		KeyL: ['n', 'N', '˜', '˜', 4],
+		KeyM: ['m', 'M', 'µ', 'Â', 0],
+		KeyN: ['b', 'B', '∫', 'ı', 0],
+		KeyO: ['r', 'R', '®', '‰', 0],
+		KeyP: ['l', 'L', '¬', 'Ò', 0],
+		KeyQ: ['\'', '"', 'æ', 'Æ', 0],
+		KeyR: ['p', 'P', 'π', '∏', 0],
+		KeyS: ['o', 'O', 'ø', 'Ø', 0],
+		KeyT: ['y', 'Y', '¥', 'Á', 0],
+		KeyU: ['g', 'G', '©', '˝', 0],
+		KeyV: ['k', 'K', '˚', '', 0],
+		KeyW: [',', '<', '≤', '¯', 0],
+		KeyX: ['q', 'Q', 'œ', 'Œ', 0],
+		KeyY: ['f', 'F', 'ƒ', 'Ï', 0],
+		KeyZ: [';', ':', '…', 'Ú', 0],
+		Digit1: ['1', '!', '¡', '⁄', 0],
+		Digit2: ['2', '@', '™', '€', 0],
+		Digit3: ['3', '#', '£', '‹', 0],
+		Digit4: ['4', '$', '¢', '›', 0],
+		Digit5: ['5', '%', '∞', 'fi', 0],
+		Digit6: ['6', '^', '§', 'fl', 0],
+		Digit7: ['7', '&', '¶', '‡', 0],
+		Digit8: ['8', '*', '•', '°', 0],
+		Digit9: ['9', '(', 'ª', '·', 0],
+		Digit0: ['0', ')', 'º', '‚', 0],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', ' ', ' ', 0],
+		Minus: ['[', '{', '“', '”', 0],
+		Equal: [']', '}', '‘', '’', 0],
+		BracketLeft: ['/', '?', '÷', '¿', 0],
+		BracketRight: ['=', '+', '≠', '±', 0],
+		Backslash: ['\\', '|', '«', '»', 0],
+		Semicolon: ['s', 'S', 'ß', 'Í', 0],
+		Quote: ['-', '_', '–', '—', 0],
+		Backquote: ['`', '~', '`', '`', 4],
+		Comma: ['w', 'W', '∑', '„', 0],
+		Period: ['v', 'V', '√', '◊', 0],
+		Slash: ['z', 'Z', 'Ω', '¸', 0],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '/', '/', 0],
+		NumpadMultiply: ['*', '*', '*', '*', 0],
+		NumpadSubtract: ['-', '-', '-', '-', 0],
+		NumpadAdd: ['+', '+', '+', '+', 0],
+		NumpadEnter: [],
+		Numpad1: ['1', '1', '1', '1', 0],
+		Numpad2: ['2', '2', '2', '2', 0],
+		Numpad3: ['3', '3', '3', '3', 0],
+		Numpad4: ['4', '4', '4', '4', 0],
+		Numpad5: ['5', '5', '5', '5', 0],
+		Numpad6: ['6', '6', '6', '6', 0],
+		Numpad7: ['7', '7', '7', '7', 0],
+		Numpad8: ['8', '8', '8', '8', 0],
+		Numpad9: ['9', '9', '9', '9', 0],
+		Numpad0: ['0', '0', '0', '0', 0],
+		NumpadDecimal: ['.', '.', '.', '.', 0],
+		IntlBackslash: ['§', '±', '§', '±', 0],
+		ContextMenu: [],
+		NumpadEqual: ['=', '=', '=', '=', 0],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: ['', '=', '', '=', 0],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/en-belgian.win.ts

@@ -0,0 +1,169 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { name: '00000813', id: '', text: 'Belgian (Period)' },
+	secondaryLayouts: [],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['q', 'Q', '', '', 0, 'VK_Q'],
+		KeyB: ['b', 'B', '', '', 0, 'VK_B'],
+		KeyC: ['c', 'C', '', '', 0, 'VK_C'],
+		KeyD: ['d', 'D', '', '', 0, 'VK_D'],
+		KeyE: ['e', 'E', '€', '', 0, 'VK_E'],
+		KeyF: ['f', 'F', '', '', 0, 'VK_F'],
+		KeyG: ['g', 'G', '', '', 0, 'VK_G'],
+		KeyH: ['h', 'H', '', '', 0, 'VK_H'],
+		KeyI: ['i', 'I', '', '', 0, 'VK_I'],
+		KeyJ: ['j', 'J', '', '', 0, 'VK_J'],
+		KeyK: ['k', 'K', '', '', 0, 'VK_K'],
+		KeyL: ['l', 'L', '', '', 0, 'VK_L'],
+		KeyM: [',', '?', '', '', 0, 'VK_OEM_COMMA'],
+		KeyN: ['n', 'N', '', '', 0, 'VK_N'],
+		KeyO: ['o', 'O', '', '', 0, 'VK_O'],
+		KeyP: ['p', 'P', '', '', 0, 'VK_P'],
+		KeyQ: ['a', 'A', '', '', 0, 'VK_A'],
+		KeyR: ['r', 'R', '', '', 0, 'VK_R'],
+		KeyS: ['s', 'S', '', '', 0, 'VK_S'],
+		KeyT: ['t', 'T', '', '', 0, 'VK_T'],
+		KeyU: ['u', 'U', '', '', 0, 'VK_U'],
+		KeyV: ['v', 'V', '', '', 0, 'VK_V'],
+		KeyW: ['z', 'Z', '', '', 0, 'VK_Z'],
+		KeyX: ['x', 'X', '', '', 0, 'VK_X'],
+		KeyY: ['y', 'Y', '', '', 0, 'VK_Y'],
+		KeyZ: ['w', 'W', '', '', 0, 'VK_W'],
+		Digit1: ['&', '1', '|', '', 0, 'VK_1'],
+		Digit2: ['é', '2', '@', '', 0, 'VK_2'],
+		Digit3: ['"', '3', '#', '', 0, 'VK_3'],
+		Digit4: ['\'', '4', '{', '', 0, 'VK_4'],
+		Digit5: ['(', '5', '[', '', 0, 'VK_5'],
+		Digit6: ['§', '6', '^', '', 0, 'VK_6'],
+		Digit7: ['è', '7', '', '', 0, 'VK_7'],
+		Digit8: ['!', '8', '', '', 0, 'VK_8'],
+		Digit9: ['ç', '9', '{', '', 0, 'VK_9'],
+		Digit0: ['à', '0', '}', '', 0, 'VK_0'],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', '', '', 0, 'VK_SPACE'],
+		Minus: [')', '°', '', '', 0, 'VK_OEM_4'],
+		Equal: ['-', '_', '', '', 0, 'VK_OEM_MINUS'],
+		BracketLeft: ['^', '¨', '[', '', 0, 'VK_OEM_6'],
+		BracketRight: ['$', '*', ']', '', 0, 'VK_OEM_1'],
+		Backslash: ['µ', '£', '`', '`', 0, 'VK_OEM_5'],
+		Semicolon: ['m', 'M', '', '', 0, 'VK_M'],
+		Quote: ['ù', '%', '´', '´', 0, 'VK_OEM_3'],
+		Backquote: ['²', '³', '', '', 0, 'VK_OEM_7'],
+		Comma: [';', '.', '', '', 0, 'VK_OEM_PERIOD'],
+		Period: [':', '/', '', '', 0, 'VK_OEM_2'],
+		Slash: ['=', '+', '~', '~', 0, 'VK_OEM_PLUS'],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: [],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '', '', 0, 'VK_DIVIDE'],
+		NumpadMultiply: ['*', '*', '', '', 0, 'VK_MULTIPLY'],
+		NumpadSubtract: ['-', '-', '', '', 0, 'VK_SUBTRACT'],
+		NumpadAdd: ['+', '+', '', '', 0, 'VK_ADD'],
+		NumpadEnter: [],
+		Numpad1: [],
+		Numpad2: [],
+		Numpad3: [],
+		Numpad4: [],
+		Numpad5: [],
+		Numpad6: [],
+		Numpad7: [],
+		Numpad8: [],
+		Numpad9: [],
+		Numpad0: [],
+		NumpadDecimal: [],
+		IntlBackslash: ['<', '>', '\\', '', 0, 'VK_OEM_102'],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: [],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Help: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/en-ext.darwin.ts

@@ -0,0 +1,132 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { id: 'com.apple.keylayout.USExtended', lang: 'en', localizedName: 'ABC - Extended' },
+	secondaryLayouts: [],
+	mapping: {
+		KeyA: ['a', 'A', '¯', '̄', 4],
+		KeyB: ['b', 'B', '˘', '̆', 4],
+		KeyC: ['c', 'C', '¸', '̧', 4],
+		KeyD: ['d', 'D', 'ð', 'Ð', 0],
+		KeyE: ['e', 'E', '´', '́', 4],
+		KeyF: ['f', 'F', 'ƒ', '', 0],
+		KeyG: ['g', 'G', '©', '‸', 8],
+		KeyH: ['h', 'H', 'ˍ', '̱', 4],
+		KeyI: ['i', 'I', 'ʼ', '̛', 4],
+		KeyJ: ['j', 'J', '˝', '̋', 4],
+		KeyK: ['k', 'K', '˚', '̊', 4],
+		KeyL: ['l', 'L', '-', '̵', 4],
+		KeyM: ['m', 'M', '˛', '̨', 4],
+		KeyN: ['n', 'N', '˜', '̃', 4],
+		KeyO: ['o', 'O', 'ø', 'Ø', 0],
+		KeyP: ['p', 'P', ',', '̦', 4],
+		KeyQ: ['q', 'Q', 'œ', 'Œ', 0],
+		KeyR: ['r', 'R', '®', '‰', 0],
+		KeyS: ['s', 'S', 'ß', '', 0],
+		KeyT: ['t', 'T', 'þ', 'Þ', 0],
+		KeyU: ['u', 'U', '¨', '̈', 4],
+		KeyV: ['v', 'V', 'ˇ', '̌', 4],
+		KeyW: ['w', 'W', '˙', '̇', 4],
+		KeyX: ['x', 'X', '.', '̣', 4],
+		KeyY: ['y', 'Y', '¥', '', 0],
+		KeyZ: ['z', 'Z', 'ˀ', '̉', 4],
+		Digit1: ['1', '!', '¡', '⁄', 0],
+		Digit2: ['2', '@', '™', '€', 0],
+		Digit3: ['3', '#', '£', '‹', 0],
+		Digit4: ['4', '$', '¢', '›', 0],
+		Digit5: ['5', '%', '§', '†', 0],
+		Digit6: ['6', '^', 'ˆ', '̂', 4],
+		Digit7: ['7', '&', '¶', '‡', 0],
+		Digit8: ['8', '*', '•', '°', 0],
+		Digit9: ['9', '(', 'ª', '·', 0],
+		Digit0: ['0', ')', 'º', '‚', 0],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', ' ', ' ', 0],
+		Minus: ['-', '_', '–', '—', 0],
+		Equal: ['=', '+', '≠', '±', 0],
+		BracketLeft: ['[', '{', '“', '”', 0],
+		BracketRight: [']', '}', '‘', '’', 0],
+		Backslash: ['\\', '|', '«', '»', 0],
+		Semicolon: [';', ':', '…', '№', 8],
+		Quote: ['\'', '"', 'æ', 'Æ', 0],
+		Backquote: ['`', '~', '`', '̀', 4],
+		Comma: [',', '<', '≤', '„', 0],
+		Period: ['.', '>', '≥', 'ʔ', 8],
+		Slash: ['/', '?', '÷', '¿', 0],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '/', '/', 0],
+		NumpadMultiply: ['*', '*', '*', '*', 0],
+		NumpadSubtract: ['-', '-', '-', '-', 0],
+		NumpadAdd: ['+', '+', '+', '+', 0],
+		NumpadEnter: [],
+		Numpad1: ['1', '1', '1', '1', 0],
+		Numpad2: ['2', '2', '2', '2', 0],
+		Numpad3: ['3', '3', '3', '3', 0],
+		Numpad4: ['4', '4', '4', '4', 0],
+		Numpad5: ['5', '5', '5', '5', 0],
+		Numpad6: ['6', '6', '6', '6', 0],
+		Numpad7: ['7', '7', '7', '7', 0],
+		Numpad8: ['8', '8', '8', '8', 0],
+		Numpad9: ['9', '9', '9', '9', 0],
+		Numpad0: ['0', '0', '0', '0', 0],
+		NumpadDecimal: ['.', '.', '.', '.', 0],
+		IntlBackslash: ['§', '±', '§', '±', 0],
+		ContextMenu: [],
+		NumpadEqual: ['=', '=', '=', '=', 0],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: ['', '=', '', '=', 0],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/en-in.win.ts

@@ -0,0 +1,169 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { name: '00004009', id: '', text: 'India' },
+	secondaryLayouts: [],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['a', 'A', 'ā', 'Ā', 0, 'VK_A'],
+		KeyB: ['b', 'B', '', '', 0, 'VK_B'],
+		KeyC: ['c', 'C', '', '', 0, 'VK_C'],
+		KeyD: ['d', 'D', 'ḍ', 'Ḍ', 0, 'VK_D'],
+		KeyE: ['e', 'E', 'ē', 'Ē', 0, 'VK_E'],
+		KeyF: ['f', 'F', '', '', 0, 'VK_F'],
+		KeyG: ['g', 'G', 'ṅ', 'Ṅ', 0, 'VK_G'],
+		KeyH: ['h', 'H', 'ḥ', 'Ḥ', 0, 'VK_H'],
+		KeyI: ['i', 'I', 'ī', 'Ī', 0, 'VK_I'],
+		KeyJ: ['j', 'J', '', '', 0, 'VK_J'],
+		KeyK: ['k', 'K', '', '', 0, 'VK_K'],
+		KeyL: ['l', 'L', 'l̥', 'L̥', 0, 'VK_L'],
+		KeyM: ['m', 'M', 'ṁ', 'Ṁ', 0, 'VK_M'],
+		KeyN: ['n', 'N', 'ṇ', 'Ṇ', 0, 'VK_N'],
+		KeyO: ['o', 'O', 'ō', 'Ō', 0, 'VK_O'],
+		KeyP: ['p', 'P', '', '', 0, 'VK_P'],
+		KeyQ: ['q', 'Q', 'æ', 'Æ', 0, 'VK_Q'],
+		KeyR: ['r', 'R', 'r̥', 'R̥', 0, 'VK_R'],
+		KeyS: ['s', 'S', 'ś', 'Ś', 0, 'VK_S'],
+		KeyT: ['t', 'T', 'ṭ', 'Ṭ', 0, 'VK_T'],
+		KeyU: ['u', 'U', 'ū', 'Ū', 0, 'VK_U'],
+		KeyV: ['v', 'V', '', '', 0, 'VK_V'],
+		KeyW: ['w', 'W', '', '', 0, 'VK_W'],
+		KeyX: ['x', 'X', 'ṣ', 'Ṣ', 0, 'VK_X'],
+		KeyY: ['y', 'Y', 'ñ', 'Ñ', 0, 'VK_Y'],
+		KeyZ: ['z', 'Z', '', '', 0, 'VK_Z'],
+		Digit1: ['1', '!', '', '', 0, 'VK_1'],
+		Digit2: ['2', '@', '', '', 0, 'VK_2'],
+		Digit3: ['3', '#', '', '', 0, 'VK_3'],
+		Digit4: ['4', '$', '₹', '', 0, 'VK_4'],
+		Digit5: ['5', '%', '', '', 0, 'VK_5'],
+		Digit6: ['6', '^', '', 'ˆ', 0, 'VK_6'],
+		Digit7: ['7', '&', '', '', 0, 'VK_7'],
+		Digit8: ['8', '*', '', '', 0, 'VK_8'],
+		Digit9: ['9', '(', '', '˘', 0, 'VK_9'],
+		Digit0: ['0', ')', '', '', 0, 'VK_0'],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', '', '', 0, 'VK_SPACE'],
+		Minus: ['-', '_', '-', 'ˍ', 0, 'VK_OEM_MINUS'],
+		Equal: ['=', '+', '', '', 0, 'VK_OEM_PLUS'],
+		BracketLeft: ['[', '{', '', '', 0, 'VK_OEM_4'],
+		BracketRight: [']', '}', '', '', 0, 'VK_OEM_6'],
+		Backslash: ['\\', '|', '', '', 0, 'VK_OEM_5'],
+		Semicolon: [';', ':', '', '', 0, 'VK_OEM_1'],
+		Quote: ['\'', '"', '', '', 0, 'VK_OEM_7'],
+		Backquote: ['`', '~', '', '~', 0, 'VK_OEM_3'],
+		Comma: [',', '<', ',', '<', 0, 'VK_OEM_COMMA'],
+		Period: ['.', '>', '.', '', 0, 'VK_OEM_PERIOD'],
+		Slash: ['/', '?', '', '', 0, 'VK_OEM_2'],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: [],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '', '', 0, 'VK_DIVIDE'],
+		NumpadMultiply: ['*', '*', '', '', 0, 'VK_MULTIPLY'],
+		NumpadSubtract: ['-', '-', '', '', 0, 'VK_SUBTRACT'],
+		NumpadAdd: ['+', '+', '', '', 0, 'VK_ADD'],
+		NumpadEnter: [],
+		Numpad1: [],
+		Numpad2: [],
+		Numpad3: [],
+		Numpad4: [],
+		Numpad5: [],
+		Numpad6: [],
+		Numpad7: [],
+		Numpad8: [],
+		Numpad9: [],
+		Numpad0: [],
+		NumpadDecimal: [],
+		IntlBackslash: ['\\', '|', '', '', 0, 'VK_OEM_102'],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: [],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Help: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/en-intl.darwin.ts

@@ -0,0 +1,132 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { id: 'com.apple.keylayout.USInternational-PC', lang: 'en', localizedName: 'U.S. International - PC' },
+	secondaryLayouts: [],
+	mapping: {
+		KeyA: ['a', 'A', 'å', 'Å', 0],
+		KeyB: ['b', 'B', '∫', 'ı', 0],
+		KeyC: ['c', 'C', 'ç', 'Ç', 0],
+		KeyD: ['d', 'D', '∂', 'Î', 0],
+		KeyE: ['e', 'E', '´', '´', 4],
+		KeyF: ['f', 'F', 'ƒ', 'Ï', 0],
+		KeyG: ['g', 'G', '©', '˝', 0],
+		KeyH: ['h', 'H', '˙', 'Ó', 0],
+		KeyI: ['i', 'I', 'ˆ', 'ˆ', 4],
+		KeyJ: ['j', 'J', '∆', 'Ô', 0],
+		KeyK: ['k', 'K', '˚', '', 0],
+		KeyL: ['l', 'L', '¬', 'Ò', 0],
+		KeyM: ['m', 'M', 'µ', 'Â', 0],
+		KeyN: ['n', 'N', '˜', '˜', 4],
+		KeyO: ['o', 'O', 'ø', 'Ø', 0],
+		KeyP: ['p', 'P', 'π', '∏', 0],
+		KeyQ: ['q', 'Q', 'œ', 'Œ', 0],
+		KeyR: ['r', 'R', '®', '‰', 0],
+		KeyS: ['s', 'S', 'ß', 'Í', 0],
+		KeyT: ['t', 'T', '†', 'ˇ', 0],
+		KeyU: ['u', 'U', '¨', '¨', 4],
+		KeyV: ['v', 'V', '√', '◊', 0],
+		KeyW: ['w', 'W', '∑', '„', 0],
+		KeyX: ['x', 'X', '≈', '˛', 0],
+		KeyY: ['y', 'Y', '¥', 'Á', 0],
+		KeyZ: ['z', 'Z', 'Ω', '¸', 0],
+		Digit1: ['1', '!', '¡', '⁄', 0],
+		Digit2: ['2', '@', '™', '€', 0],
+		Digit3: ['3', '#', '£', '‹', 0],
+		Digit4: ['4', '$', '¢', '›', 0],
+		Digit5: ['5', '%', '∞', 'fi', 0],
+		Digit6: ['6', 'ˆ', '§', 'fl', 2],
+		Digit7: ['7', '&', '¶', '‡', 0],
+		Digit8: ['8', '*', '•', '°', 0],
+		Digit9: ['9', '(', 'ª', '·', 0],
+		Digit0: ['0', ')', 'º', '‚', 0],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', ' ', ' ', 0],
+		Minus: ['-', '_', '–', '—', 0],
+		Equal: ['=', '+', '≠', '±', 0],
+		BracketLeft: ['[', '{', '“', '”', 0],
+		BracketRight: [']', '}', '‘', '’', 0],
+		Backslash: ['\\', '|', '«', '»', 0],
+		Semicolon: [';', ':', '…', 'Ú', 0],
+		Quote: ['\'', '"', 'æ', 'Æ', 3],
+		Backquote: ['`', '˜', '`', '`', 7],
+		Comma: [',', '<', '≤', '¯', 0],
+		Period: ['.', '>', '≥', '˘', 0],
+		Slash: ['/', '?', '÷', '¿', 0],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '/', '/', 0],
+		NumpadMultiply: ['*', '*', '*', '*', 0],
+		NumpadSubtract: ['-', '-', '-', '-', 0],
+		NumpadAdd: ['+', '+', '+', '+', 0],
+		NumpadEnter: [],
+		Numpad1: ['1', '1', '1', '1', 0],
+		Numpad2: ['2', '2', '2', '2', 0],
+		Numpad3: ['3', '3', '3', '3', 0],
+		Numpad4: ['4', '4', '4', '4', 0],
+		Numpad5: ['5', '5', '5', '5', 0],
+		Numpad6: ['6', '6', '6', '6', 0],
+		Numpad7: ['7', '7', '7', '7', 0],
+		Numpad8: ['8', '8', '8', '8', 0],
+		Numpad9: ['9', '9', '9', '9', 0],
+		Numpad0: ['0', '0', '0', '0', 0],
+		NumpadDecimal: ['.', '.', '.', '.', 0],
+		IntlBackslash: ['§', '±', '§', '±', 0],
+		ContextMenu: [],
+		NumpadEqual: ['=', '=', '=', '=', 0],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: ['', '=', '', '=', 0],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/en-intl.win.ts

@@ -0,0 +1,169 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { name: '00020409', id: '0001', text: 'United States-International' },
+	secondaryLayouts: [],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['a', 'A', 'á', 'Á', 0, 'VK_A'],
+		KeyB: ['b', 'B', '', '', 0, 'VK_B'],
+		KeyC: ['c', 'C', '©', '¢', 0, 'VK_C'],
+		KeyD: ['d', 'D', 'ð', 'Ð', 0, 'VK_D'],
+		KeyE: ['e', 'E', 'é', 'É', 0, 'VK_E'],
+		KeyF: ['f', 'F', '', '', 0, 'VK_F'],
+		KeyG: ['g', 'G', '', '', 0, 'VK_G'],
+		KeyH: ['h', 'H', '', '', 0, 'VK_H'],
+		KeyI: ['i', 'I', 'í', 'Í', 0, 'VK_I'],
+		KeyJ: ['j', 'J', '', '', 0, 'VK_J'],
+		KeyK: ['k', 'K', '', '', 0, 'VK_K'],
+		KeyL: ['l', 'L', 'ø', 'Ø', 0, 'VK_L'],
+		KeyM: ['m', 'M', 'µ', '', 0, 'VK_M'],
+		KeyN: ['n', 'N', 'ñ', 'Ñ', 0, 'VK_N'],
+		KeyO: ['o', 'O', 'ó', 'Ó', 0, 'VK_O'],
+		KeyP: ['p', 'P', 'ö', 'Ö', 0, 'VK_P'],
+		KeyQ: ['q', 'Q', 'ä', 'Ä', 0, 'VK_Q'],
+		KeyR: ['r', 'R', '®', '', 0, 'VK_R'],
+		KeyS: ['s', 'S', 'ß', '§', 0, 'VK_S'],
+		KeyT: ['t', 'T', 'þ', 'Þ', 0, 'VK_T'],
+		KeyU: ['u', 'U', 'ú', 'Ú', 0, 'VK_U'],
+		KeyV: ['v', 'V', '', '', 0, 'VK_V'],
+		KeyW: ['w', 'W', 'å', 'Å', 0, 'VK_W'],
+		KeyX: ['x', 'X', '', '', 0, 'VK_X'],
+		KeyY: ['y', 'Y', 'ü', 'Ü', 0, 'VK_Y'],
+		KeyZ: ['z', 'Z', 'æ', 'Æ', 0, 'VK_Z'],
+		Digit1: ['1', '!', '¡', '¹', 0, 'VK_1'],
+		Digit2: ['2', '@', '²', '', 0, 'VK_2'],
+		Digit3: ['3', '#', '³', '', 0, 'VK_3'],
+		Digit4: ['4', '$', '¤', '£', 0, 'VK_4'],
+		Digit5: ['5', '%', '€', '', 0, 'VK_5'],
+		Digit6: ['6', '^', '¼', '', 0, 'VK_6'],
+		Digit7: ['7', '&', '½', '', 0, 'VK_7'],
+		Digit8: ['8', '*', '¾', '', 0, 'VK_8'],
+		Digit9: ['9', '(', '‘', '', 0, 'VK_9'],
+		Digit0: ['0', ')', '’', '', 0, 'VK_0'],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', '', '', 0, 'VK_SPACE'],
+		Minus: ['-', '_', '¥', '', 0, 'VK_OEM_MINUS'],
+		Equal: ['=', '+', '×', '÷', 0, 'VK_OEM_PLUS'],
+		BracketLeft: ['[', '{', '«', '', 0, 'VK_OEM_4'],
+		BracketRight: [']', '}', '»', '', 0, 'VK_OEM_6'],
+		Backslash: ['\\', '|', '¬', '¦', 0, 'VK_OEM_5'],
+		Semicolon: [';', ':', '¶', '°', 0, 'VK_OEM_1'],
+		Quote: ['\'', '"', '´', '¨', 0, 'VK_OEM_7'],
+		Backquote: ['`', '~', '', '', 0, 'VK_OEM_3'],
+		Comma: [',', '<', 'ç', 'Ç', 0, 'VK_OEM_COMMA'],
+		Period: ['.', '>', '', '', 0, 'VK_OEM_PERIOD'],
+		Slash: ['/', '?', '¿', '', 0, 'VK_OEM_2'],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: [],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '', '', 0, 'VK_DIVIDE'],
+		NumpadMultiply: ['*', '*', '', '', 0, 'VK_MULTIPLY'],
+		NumpadSubtract: ['-', '-', '', '', 0, 'VK_SUBTRACT'],
+		NumpadAdd: ['+', '+', '', '', 0, 'VK_ADD'],
+		NumpadEnter: [],
+		Numpad1: [],
+		Numpad2: [],
+		Numpad3: [],
+		Numpad4: [],
+		Numpad5: [],
+		Numpad6: [],
+		Numpad7: [],
+		Numpad8: [],
+		Numpad9: [],
+		Numpad0: [],
+		NumpadDecimal: [],
+		IntlBackslash: ['\\', '|', '', '', 0, 'VK_OEM_102'],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: [],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Help: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/en-uk.darwin.ts

@@ -0,0 +1,131 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { id: 'com.apple.keylayout.British', lang: 'en', localizedName: 'British' },
+	secondaryLayouts: [],
+	mapping: {
+		KeyA: ['a', 'A', 'å', 'Å', 0],
+		KeyB: ['b', 'B', '∫', 'ı', 0],
+		KeyC: ['c', 'C', 'ç', 'Ç', 0],
+		KeyD: ['d', 'D', '∂', 'Î', 0],
+		KeyE: ['e', 'E', '´', '‰', 4],
+		KeyF: ['f', 'F', 'ƒ', 'Ï', 0],
+		KeyG: ['g', 'G', '©', 'Ì', 0],
+		KeyH: ['h', 'H', '˙', 'Ó', 0],
+		KeyI: ['i', 'I', '^', 'È', 4],
+		KeyJ: ['j', 'J', '∆', 'Ô', 0],
+		KeyK: ['k', 'K', '˚', '', 0],
+		KeyL: ['l', 'L', '¬', 'Ò', 0],
+		KeyM: ['m', 'M', 'µ', '˜', 0],
+		KeyN: ['n', 'N', '~', 'ˆ', 4],
+		KeyO: ['o', 'O', 'ø', 'Ø', 0],
+		KeyP: ['p', 'P', 'π', '∏', 0],
+		KeyQ: ['q', 'Q', 'œ', 'Œ', 0],
+		KeyR: ['r', 'R', '®', 'Â', 0],
+		KeyS: ['s', 'S', 'ß', 'Í', 0],
+		KeyT: ['t', 'T', '†', 'Ê', 0],
+		KeyU: ['u', 'U', '¨', 'Ë', 4],
+		KeyV: ['v', 'V', '√', '◊', 0],
+		KeyW: ['w', 'W', '∑', '„', 0],
+		KeyX: ['x', 'X', '≈', 'Ù', 0],
+		KeyY: ['y', 'Y', '¥', 'Á', 0],
+		KeyZ: ['z', 'Z', 'Ω', 'Û', 0],
+		Digit1: ['1', '!', '¡', '⁄', 0],
+		Digit2: ['2', '@', '€', '™', 0],
+		Digit3: ['3', '£', '#', '‹', 0],
+		Digit4: ['4', '$', '¢', '›', 0],
+		Digit5: ['5', '%', '∞', 'fi', 0],
+		Digit6: ['6', '^', '§', 'fl', 0],
+		Digit7: ['7', '&', '¶', '‡', 0],
+		Digit8: ['8', '*', '•', '°', 0],
+		Digit9: ['9', '(', 'ª', '·', 0],
+		Digit0: ['0', ')', 'º', '‚', 0],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', ' ', ' ', 0],
+		Minus: ['-', '_', '–', '—', 0],
+		Equal: ['=', '+', '≠', '±', 0],
+		BracketLeft: ['[', '{', '“', '”', 0],
+		BracketRight: [']', '}', '‘', '’', 0],
+		Backslash: ['\\', '|', '«', '»', 0],
+		Semicolon: [';', ':', '…', 'Ú', 0],
+		Quote: ['\'', '"', 'æ', 'Æ', 0],
+		Backquote: ['`', '~', '`', 'Ÿ', 4],
+		Comma: [',', '<', '≤', '¯', 0],
+		Period: ['.', '>', '≥', '˘', 0],
+		Slash: ['/', '?', '÷', '¿', 0],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '/', '/', 0],
+		NumpadMultiply: ['*', '*', '*', '*', 0],
+		NumpadSubtract: ['-', '-', '-', '-', 0],
+		NumpadAdd: ['+', '+', '+', '+', 0],
+		NumpadEnter: [],
+		Numpad1: ['1', '1', '1', '1', 0],
+		Numpad2: ['2', '2', '2', '2', 0],
+		Numpad3: ['3', '3', '3', '3', 0],
+		Numpad4: ['4', '4', '4', '4', 0],
+		Numpad5: ['5', '5', '5', '5', 0],
+		Numpad6: ['6', '6', '6', '6', 0],
+		Numpad7: ['7', '7', '7', '7', 0],
+		Numpad8: ['8', '8', '8', '8', 0],
+		Numpad9: ['9', '9', '9', '9', 0],
+		Numpad0: ['0', '0', '0', '0', 0],
+		NumpadDecimal: ['.', '.', '.', '.', 0],
+		IntlBackslash: ['§', '±', '', '', 0],
+		ContextMenu: [],
+		NumpadEqual: ['=', '=', '=', '=', 0],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: ['', '=', '', '=', 0],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/en-uk.win.ts

@@ -0,0 +1,170 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { name: '00000809', id: '', text: 'United Kingdom' },
+	secondaryLayouts: [],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['a', 'A', 'á', 'Á', 0, 'VK_A'],
+		KeyB: ['b', 'B', '', '', 0, 'VK_B'],
+		KeyC: ['c', 'C', '', '', 0, 'VK_C'],
+		KeyD: ['d', 'D', '', '', 0, 'VK_D'],
+		KeyE: ['e', 'E', 'é', 'É', 0, 'VK_E'],
+		KeyF: ['f', 'F', '', '', 0, 'VK_F'],
+		KeyG: ['g', 'G', '', '', 0, 'VK_G'],
+		KeyH: ['h', 'H', '', '', 0, 'VK_H'],
+		KeyI: ['i', 'I', 'í', 'Í', 0, 'VK_I'],
+		KeyJ: ['j', 'J', '', '', 0, 'VK_J'],
+		KeyK: ['k', 'K', '', '', 0, 'VK_K'],
+		KeyL: ['l', 'L', '', '', 0, 'VK_L'],
+		KeyM: ['m', 'M', '', '', 0, 'VK_M'],
+		KeyN: ['n', 'N', '', '', 0, 'VK_N'],
+		KeyO: ['o', 'O', 'ó', 'Ó', 0, 'VK_O'],
+		KeyP: ['p', 'P', '', '', 0, 'VK_P'],
+		KeyQ: ['q', 'Q', '', '', 0, 'VK_Q'],
+		KeyR: ['r', 'R', '', '', 0, 'VK_R'],
+		KeyS: ['s', 'S', '', '', 0, 'VK_S'],
+		KeyT: ['t', 'T', '', '', 0, 'VK_T'],
+		KeyU: ['u', 'U', 'ú', 'Ú', 0, 'VK_U'],
+		KeyV: ['v', 'V', '', '', 0, 'VK_V'],
+		KeyW: ['w', 'W', '', '', 0, 'VK_W'],
+		KeyX: ['x', 'X', '', '', 0, 'VK_X'],
+		KeyY: ['y', 'Y', '', '', 0, 'VK_Y'],
+		KeyZ: ['z', 'Z', '', '', 0, 'VK_Z'],
+		Digit1: ['1', '!', '', '', 0, 'VK_1'],
+		Digit2: ['2', '"', '', '', 0, 'VK_2'],
+		Digit3: ['3', '£', '', '', 0, 'VK_3'],
+		Digit4: ['4', '$', '€', '', 0, 'VK_4'],
+		Digit5: ['5', '%', '', '', 0, 'VK_5'],
+		Digit6: ['6', '^', '', '', 0, 'VK_6'],
+		Digit7: ['7', '&', '', '', 0, 'VK_7'],
+		Digit8: ['8', '*', '', '', 0, 'VK_8'],
+		Digit9: ['9', '(', '', '', 0, 'VK_9'],
+		Digit0: ['0', ')', '', '', 0, 'VK_0'],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', '', '', 0, 'VK_SPACE'],
+		Minus: ['-', '_', '', '', 0, 'VK_OEM_MINUS'],
+		Equal: ['=', '+', '', '', 0, 'VK_OEM_PLUS'],
+		BracketLeft: ['[', '{', '', '', 0, 'VK_OEM_4'],
+		BracketRight: [']', '}', '', '', 0, 'VK_OEM_6'],
+		Backslash: ['#', '~', '\\', '|', 0, 'VK_OEM_7'],
+		Semicolon: [';', ':', '', '', 0, 'VK_OEM_1'],
+		Quote: ['\'', '@', '', '', 0, 'VK_OEM_3'],
+		Backquote: ['`', '¬', '¦', '', 0, 'VK_OEM_8'],
+		Comma: [',', '<', '', '', 0, 'VK_OEM_COMMA'],
+		Period: ['.', '>', '', '', 0, 'VK_OEM_PERIOD'],
+		Slash: ['/', '?', '', '', 0, 'VK_OEM_2'],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: [],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '', '', 0, 'VK_DIVIDE'],
+		NumpadMultiply: ['*', '*', '', '', 0, 'VK_MULTIPLY'],
+		NumpadSubtract: ['-', '-', '', '', 0, 'VK_SUBTRACT'],
+		NumpadAdd: ['+', '+', '', '', 0, 'VK_ADD'],
+		NumpadEnter: [],
+		Numpad1: [],
+		Numpad2: [],
+		Numpad3: [],
+		Numpad4: [],
+		Numpad5: [],
+		Numpad6: [],
+		Numpad7: [],
+		Numpad8: [],
+		Numpad9: [],
+		Numpad0: [],
+		NumpadDecimal: [],
+		IntlBackslash: ['\\', '|', '', '', 0, 'VK_OEM_5'],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: [],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Help: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: []
+	}
+
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/en.darwin.ts

@@ -0,0 +1,140 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { id: 'com.apple.keylayout.US', lang: 'en', localizedName: 'U.S.', isUSStandard: true },
+	secondaryLayouts: [
+		{ id: 'com.apple.keylayout.ABC', lang: 'en', localizedName: 'ABC' },
+		{ id: 'com.sogou.inputmethod.sogou.pinyin', lang: 'zh-Hans', localizedName: 'Pinyin - Simplified' },
+		{ id: 'com.apple.inputmethod.Kotoeri.Roman', lang: 'en', localizedName: 'Romaji' },
+		{ id: 'com.apple.inputmethod.Kotoeri.Japanese', lang: 'ja', localizedName: 'Hiragana' },
+		{ id: 'com.apple.keylayout.Australian', lang: 'en', localizedName: 'Australian' },
+		{ id: 'com.apple.keylayout.Canadian', lang: 'en', localizedName: 'Canadian English' },
+		{ id: 'com.apple.keylayout.Brazilian', lang: 'pt', localizedName: 'Brazilian' },
+	],
+	mapping: {
+		KeyA: ['a', 'A', 'å', 'Å', 0],
+		KeyB: ['b', 'B', '∫', 'ı', 0],
+		KeyC: ['c', 'C', 'ç', 'Ç', 0],
+		KeyD: ['d', 'D', '∂', 'Î', 0],
+		KeyE: ['e', 'E', '´', '´', 4],
+		KeyF: ['f', 'F', 'ƒ', 'Ï', 0],
+		KeyG: ['g', 'G', '©', '˝', 0],
+		KeyH: ['h', 'H', '˙', 'Ó', 0],
+		KeyI: ['i', 'I', 'ˆ', 'ˆ', 4],
+		KeyJ: ['j', 'J', '∆', 'Ô', 0],
+		KeyK: ['k', 'K', '˚', '', 0],
+		KeyL: ['l', 'L', '¬', 'Ò', 0],
+		KeyM: ['m', 'M', 'µ', 'Â', 0],
+		KeyN: ['n', 'N', '˜', '˜', 4],
+		KeyO: ['o', 'O', 'ø', 'Ø', 0],
+		KeyP: ['p', 'P', 'π', '∏', 0],
+		KeyQ: ['q', 'Q', 'œ', 'Œ', 0],
+		KeyR: ['r', 'R', '®', '‰', 0],
+		KeyS: ['s', 'S', 'ß', 'Í', 0],
+		KeyT: ['t', 'T', '†', 'ˇ', 0],
+		KeyU: ['u', 'U', '¨', '¨', 4],
+		KeyV: ['v', 'V', '√', '◊', 0],
+		KeyW: ['w', 'W', '∑', '„', 0],
+		KeyX: ['x', 'X', '≈', '˛', 0],
+		KeyY: ['y', 'Y', '¥', 'Á', 0],
+		KeyZ: ['z', 'Z', 'Ω', '¸', 0],
+		Digit1: ['1', '!', '¡', '⁄', 0],
+		Digit2: ['2', '@', '™', '€', 0],
+		Digit3: ['3', '#', '£', '‹', 0],
+		Digit4: ['4', '$', '¢', '›', 0],
+		Digit5: ['5', '%', '∞', 'fi', 0],
+		Digit6: ['6', '^', '§', 'fl', 0],
+		Digit7: ['7', '&', '¶', '‡', 0],
+		Digit8: ['8', '*', '•', '°', 0],
+		Digit9: ['9', '(', 'ª', '·', 0],
+		Digit0: ['0', ')', 'º', '‚', 0],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', ' ', ' ', 0],
+		Minus: ['-', '_', '–', '—', 0],
+		Equal: ['=', '+', '≠', '±', 0],
+		BracketLeft: ['[', '{', '“', '”', 0],
+		BracketRight: [']', '}', '‘', '’', 0],
+		Backslash: ['\\', '|', '«', '»', 0],
+		Semicolon: [';', ':', '…', 'Ú', 0],
+		Quote: ['\'', '"', 'æ', 'Æ', 0],
+		Backquote: ['`', '~', '`', '`', 4],
+		Comma: [',', '<', '≤', '¯', 0],
+		Period: ['.', '>', '≥', '˘', 0],
+		Slash: ['/', '?', '÷', '¿', 0],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '/', '/', 0],
+		NumpadMultiply: ['*', '*', '*', '*', 0],
+		NumpadSubtract: ['-', '-', '-', '-', 0],
+		NumpadAdd: ['+', '+', '+', '+', 0],
+		NumpadEnter: [],
+		Numpad1: ['1', '1', '1', '1', 0],
+		Numpad2: ['2', '2', '2', '2', 0],
+		Numpad3: ['3', '3', '3', '3', 0],
+		Numpad4: ['4', '4', '4', '4', 0],
+		Numpad5: ['5', '5', '5', '5', 0],
+		Numpad6: ['6', '6', '6', '6', 0],
+		Numpad7: ['7', '7', '7', '7', 0],
+		Numpad8: ['8', '8', '8', '8', 0],
+		Numpad9: ['9', '9', '9', '9', 0],
+		Numpad0: ['0', '0', '0', '0', 0],
+		NumpadDecimal: ['.', '.', '.', '.', 0],
+		IntlBackslash: ['§', '±', '§', '±', 0],
+		ContextMenu: [],
+		NumpadEqual: ['=', '=', '=', '=', 0],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: ['', '=', '', '=', 0],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/en.linux.ts

@@ -0,0 +1,190 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { model: 'pc105', layout: 'us', variant: '', options: '', rules: 'evdev', isUSStandard: true },
+	secondaryLayouts: [
+		{ model: 'pc105', layout: 'cn', variant: '', options: '', rules: 'evdev' },
+	],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['a', 'A', 'a', 'A', 0],
+		KeyB: ['b', 'B', 'b', 'B', 0],
+		KeyC: ['c', 'C', 'c', 'C', 0],
+		KeyD: ['d', 'D', 'd', 'D', 0],
+		KeyE: ['e', 'E', 'e', 'E', 0],
+		KeyF: ['f', 'F', 'f', 'F', 0],
+		KeyG: ['g', 'G', 'g', 'G', 0],
+		KeyH: ['h', 'H', 'h', 'H', 0],
+		KeyI: ['i', 'I', 'i', 'I', 0],
+		KeyJ: ['j', 'J', 'j', 'J', 0],
+		KeyK: ['k', 'K', 'k', 'K', 0],
+		KeyL: ['l', 'L', 'l', 'L', 0],
+		KeyM: ['m', 'M', 'm', 'M', 0],
+		KeyN: ['n', 'N', 'n', 'N', 0],
+		KeyO: ['o', 'O', 'o', 'O', 0],
+		KeyP: ['p', 'P', 'p', 'P', 0],
+		KeyQ: ['q', 'Q', 'q', 'Q', 0],
+		KeyR: ['r', 'R', 'r', 'R', 0],
+		KeyS: ['s', 'S', 's', 'S', 0],
+		KeyT: ['t', 'T', 't', 'T', 0],
+		KeyU: ['u', 'U', 'u', 'U', 0],
+		KeyV: ['v', 'V', 'v', 'V', 0],
+		KeyW: ['w', 'W', 'w', 'W', 0],
+		KeyX: ['x', 'X', 'x', 'X', 0],
+		KeyY: ['y', 'Y', 'y', 'Y', 0],
+		KeyZ: ['z', 'Z', 'z', 'Z', 0],
+		Digit1: ['1', '!', '1', '!', 0],
+		Digit2: ['2', '@', '2', '@', 0],
+		Digit3: ['3', '#', '3', '#', 0],
+		Digit4: ['4', '$', '4', '$', 0],
+		Digit5: ['5', '%', '5', '%', 0],
+		Digit6: ['6', '^', '6', '^', 0],
+		Digit7: ['7', '&', '7', '&', 0],
+		Digit8: ['8', '*', '8', '*', 0],
+		Digit9: ['9', '(', '9', '(', 0],
+		Digit0: ['0', ')', '0', ')', 0],
+		Enter: ['\r', '\r', '\r', '\r', 0],
+		Escape: ['\u001b', '\u001b', '\u001b', '\u001b', 0],
+		Backspace: ['\b', '\b', '\b', '\b', 0],
+		Tab: ['\t', '', '\t', '', 0],
+		Space: [' ', ' ', ' ', ' ', 0],
+		Minus: ['-', '_', '-', '_', 0],
+		Equal: ['=', '+', '=', '+', 0],
+		BracketLeft: ['[', '{', '[', '{', 0],
+		BracketRight: [']', '}', ']', '}', 0],
+		Backslash: ['\\', '|', '\\', '|', 0],
+		Semicolon: [';', ':', ';', ':', 0],
+		Quote: ['\'', '"', '\'', '"', 0],
+		Backquote: ['`', '~', '`', '~', 0],
+		Comma: [',', '<', ',', '<', 0],
+		Period: ['.', '>', '.', '>', 0],
+		Slash: ['/', '?', '/', '?', 0],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: [],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: ['', '', '', '', 0],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '/', '/', 0],
+		NumpadMultiply: ['*', '*', '*', '*', 0],
+		NumpadSubtract: ['-', '-', '-', '-', 0],
+		NumpadAdd: ['+', '+', '+', '+', 0],
+		NumpadEnter: ['\r', '\r', '\r', '\r', 0],
+		Numpad1: ['', '1', '', '1', 0],
+		Numpad2: ['', '2', '', '2', 0],
+		Numpad3: ['', '3', '', '3', 0],
+		Numpad4: ['', '4', '', '4', 0],
+		Numpad5: ['', '5', '', '5', 0],
+		Numpad6: ['', '6', '', '6', 0],
+		Numpad7: ['', '7', '', '7', 0],
+		Numpad8: ['', '8', '', '8', 0],
+		Numpad9: ['', '9', '', '9', 0],
+		Numpad0: ['', '0', '', '0', 0],
+		NumpadDecimal: ['', '.', '', '.', 0],
+		IntlBackslash: ['<', '>', '|', '¦', 0],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: ['=', '=', '=', '=', 0],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Open: [],
+		Help: [],
+		Select: [],
+		Again: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		Find: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: ['.', '.', '.', '.', 0],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		Lang5: [],
+		NumpadParenLeft: ['(', '(', '(', '(', 0],
+		NumpadParenRight: [')', ')', ')', ')', 0],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: [],
+		BrightnessUp: [],
+		BrightnessDown: [],
+		MediaPlay: [],
+		MediaRecord: [],
+		MediaFastForward: [],
+		MediaRewind: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		SelectTask: [],
+		LaunchScreenSaver: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: [],
+		MailReply: [],
+		MailForward: [],
+		MailSend: []
+	}
+
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/en.win.ts

@@ -0,0 +1,174 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { name: '00000409', id: '', text: 'US', isUSStandard: true },
+	secondaryLayouts: [
+		{ name: '00000804', id: '', text: 'Chinese (Simplified) - US Keyboard' },
+		{ name: '00000411', id: '', text: 'Japanese' },
+		{ name: '00000412', id: '', text: 'Korean' },
+		{ name: '00000404', id: '', text: 'Chinese (Traditional) - US Keyboard' }
+	],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['a', 'A', '', '', 0, 'VK_A'],
+		KeyB: ['b', 'B', '', '', 0, 'VK_B'],
+		KeyC: ['c', 'C', '', '', 0, 'VK_C'],
+		KeyD: ['d', 'D', '', '', 0, 'VK_D'],
+		KeyE: ['e', 'E', '', '', 0, 'VK_E'],
+		KeyF: ['f', 'F', '', '', 0, 'VK_F'],
+		KeyG: ['g', 'G', '', '', 0, 'VK_G'],
+		KeyH: ['h', 'H', '', '', 0, 'VK_H'],
+		KeyI: ['i', 'I', '', '', 0, 'VK_I'],
+		KeyJ: ['j', 'J', '', '', 0, 'VK_J'],
+		KeyK: ['k', 'K', '', '', 0, 'VK_K'],
+		KeyL: ['l', 'L', '', '', 0, 'VK_L'],
+		KeyM: ['m', 'M', '', '', 0, 'VK_M'],
+		KeyN: ['n', 'N', '', '', 0, 'VK_N'],
+		KeyO: ['o', 'O', '', '', 0, 'VK_O'],
+		KeyP: ['p', 'P', '', '', 0, 'VK_P'],
+		KeyQ: ['q', 'Q', '', '', 0, 'VK_Q'],
+		KeyR: ['r', 'R', '', '', 0, 'VK_R'],
+		KeyS: ['s', 'S', '', '', 0, 'VK_S'],
+		KeyT: ['t', 'T', '', '', 0, 'VK_T'],
+		KeyU: ['u', 'U', '', '', 0, 'VK_U'],
+		KeyV: ['v', 'V', '', '', 0, 'VK_V'],
+		KeyW: ['w', 'W', '', '', 0, 'VK_W'],
+		KeyX: ['x', 'X', '', '', 0, 'VK_X'],
+		KeyY: ['y', 'Y', '', '', 0, 'VK_Y'],
+		KeyZ: ['z', 'Z', '', '', 0, 'VK_Z'],
+		Digit1: ['1', '!', '', '', 0, 'VK_1'],
+		Digit2: ['2', '@', '', '', 0, 'VK_2'],
+		Digit3: ['3', '#', '', '', 0, 'VK_3'],
+		Digit4: ['4', '$', '', '', 0, 'VK_4'],
+		Digit5: ['5', '%', '', '', 0, 'VK_5'],
+		Digit6: ['6', '^', '', '', 0, 'VK_6'],
+		Digit7: ['7', '&', '', '', 0, 'VK_7'],
+		Digit8: ['8', '*', '', '', 0, 'VK_8'],
+		Digit9: ['9', '(', '', '', 0, 'VK_9'],
+		Digit0: ['0', ')', '', '', 0, 'VK_0'],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', '', '', 0, 'VK_SPACE'],
+		Minus: ['-', '_', '', '', 0, 'VK_OEM_MINUS'],
+		Equal: ['=', '+', '', '', 0, 'VK_OEM_PLUS'],
+		BracketLeft: ['[', '{', '', '', 0, 'VK_OEM_4'],
+		BracketRight: [']', '}', '', '', 0, 'VK_OEM_6'],
+		Backslash: ['\\', '|', '', '', 0, 'VK_OEM_5'],
+		Semicolon: [';', ':', '', '', 0, 'VK_OEM_1'],
+		Quote: ['\'', '"', '', '', 0, 'VK_OEM_7'],
+		Backquote: ['`', '~', '', '', 0, 'VK_OEM_3'],
+		Comma: [',', '<', '', '', 0, 'VK_OEM_COMMA'],
+		Period: ['.', '>', '', '', 0, 'VK_OEM_PERIOD'],
+		Slash: ['/', '?', '', '', 0, 'VK_OEM_2'],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: [],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '', '', 0, 'VK_DIVIDE'],
+		NumpadMultiply: ['*', '*', '', '', 0, 'VK_MULTIPLY'],
+		NumpadSubtract: ['-', '-', '', '', 0, 'VK_SUBTRACT'],
+		NumpadAdd: ['+', '+', '', '', 0, 'VK_ADD'],
+		NumpadEnter: [],
+		Numpad1: [],
+		Numpad2: [],
+		Numpad3: [],
+		Numpad4: [],
+		Numpad5: [],
+		Numpad6: [],
+		Numpad7: [],
+		Numpad8: [],
+		Numpad9: [],
+		Numpad0: [],
+		NumpadDecimal: [],
+		IntlBackslash: ['\\', '|', '', '', 0, 'VK_OEM_102'],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: [],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Help: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/es-latin.win.ts

@@ -0,0 +1,170 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { name: '0000080A', id: '', text: 'Latin American' },
+	secondaryLayouts: [],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['a', 'A', '', '', 0, 'VK_A'],
+		KeyB: ['b', 'B', '', '', 0, 'VK_B'],
+		KeyC: ['c', 'C', '', '', 0, 'VK_C'],
+		KeyD: ['d', 'D', '', '', 0, 'VK_D'],
+		KeyE: ['e', 'E', '', '', 0, 'VK_E'],
+		KeyF: ['f', 'F', '', '', 0, 'VK_F'],
+		KeyG: ['g', 'G', '', '', 0, 'VK_G'],
+		KeyH: ['h', 'H', '', '', 0, 'VK_H'],
+		KeyI: ['i', 'I', '', '', 0, 'VK_I'],
+		KeyJ: ['j', 'J', '', '', 0, 'VK_J'],
+		KeyK: ['k', 'K', '', '', 0, 'VK_K'],
+		KeyL: ['l', 'L', '', '', 0, 'VK_L'],
+		KeyM: ['m', 'M', '', '', 0, 'VK_M'],
+		KeyN: ['n', 'N', '', '', 0, 'VK_N'],
+		KeyO: ['o', 'O', '', '', 0, 'VK_O'],
+		KeyP: ['p', 'P', '', '', 0, 'VK_P'],
+		KeyQ: ['q', 'Q', '@', '', 0, 'VK_Q'],
+		KeyR: ['r', 'R', '', '', 0, 'VK_R'],
+		KeyS: ['s', 'S', '', '', 0, 'VK_S'],
+		KeyT: ['t', 'T', '', '', 0, 'VK_T'],
+		KeyU: ['u', 'U', '', '', 0, 'VK_U'],
+		KeyV: ['v', 'V', '', '', 0, 'VK_V'],
+		KeyW: ['w', 'W', '', '', 0, 'VK_W'],
+		KeyX: ['x', 'X', '', '', 0, 'VK_X'],
+		KeyY: ['y', 'Y', '', '', 0, 'VK_Y'],
+		KeyZ: ['z', 'Z', '', '', 0, 'VK_Z'],
+		Digit1: ['1', '!', '', '', 0, 'VK_1'],
+		Digit2: ['2', '"', '', '', 0, 'VK_2'],
+		Digit3: ['3', '#', '', '', 0, 'VK_3'],
+		Digit4: ['4', '$', '', '', 0, 'VK_4'],
+		Digit5: ['5', '%', '', '', 0, 'VK_5'],
+		Digit6: ['6', '&', '', '', 0, 'VK_6'],
+		Digit7: ['7', '/', '', '', 0, 'VK_7'],
+		Digit8: ['8', '(', '', '', 0, 'VK_8'],
+		Digit9: ['9', ')', '', '', 0, 'VK_9'],
+		Digit0: ['0', '=', '', '', 0, 'VK_0'],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', '', '', 0, 'VK_SPACE'],
+		Minus: ['\'', '?', '\\', '', 0, 'VK_OEM_4'],
+		Equal: ['¿', '¡', '', '', 0, 'VK_OEM_6'],
+		BracketLeft: ['´', '¨', '', '', 0, 'VK_OEM_1'],
+		BracketRight: ['+', '*', '~', '', 0, 'VK_OEM_PLUS'],
+		Backslash: ['}', ']', '`', '', 0, 'VK_OEM_2'],
+		Semicolon: ['ñ', 'Ñ', '', '', 0, 'VK_OEM_3'],
+		Quote: ['{', '[', '^', '', 0, 'VK_OEM_7'],
+		Backquote: ['|', '°', '¬', '', 0, 'VK_OEM_5'],
+		Comma: [',', ';', '', '', 0, 'VK_OEM_COMMA'],
+		Period: ['.', ':', '', '', 0, 'VK_OEM_PERIOD'],
+		Slash: ['-', '_', '', '', 0, 'VK_OEM_MINUS'],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: [],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '', '', 0, 'VK_DIVIDE'],
+		NumpadMultiply: ['*', '*', '', '', 0, 'VK_MULTIPLY'],
+		NumpadSubtract: ['-', '-', '', '', 0, 'VK_SUBTRACT'],
+		NumpadAdd: ['+', '+', '', '', 0, 'VK_ADD'],
+		NumpadEnter: [],
+		Numpad1: [],
+		Numpad2: [],
+		Numpad3: [],
+		Numpad4: [],
+		Numpad5: [],
+		Numpad6: [],
+		Numpad7: [],
+		Numpad8: [],
+		Numpad9: [],
+		Numpad0: [],
+		NumpadDecimal: [],
+		IntlBackslash: ['<', '>', '', '', 0, 'VK_OEM_102'],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: [],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Help: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: []
+	}
+
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/es.darwin.ts

@@ -0,0 +1,132 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { id: 'com.apple.keylayout.Spanish-ISO', lang: 'es', localizedName: 'Spanish - ISO' },
+	secondaryLayouts: [],
+	mapping: {
+		KeyA: ['a', 'A', 'å', 'Å', 0],
+		KeyB: ['b', 'B', 'ß', '', 0],
+		KeyC: ['c', 'C', '©', ' ', 0],
+		KeyD: ['d', 'D', '∂', '∆', 0],
+		KeyE: ['e', 'E', '€', '€', 0],
+		KeyF: ['f', 'F', 'ƒ', 'fi', 0],
+		KeyG: ['g', 'G', '', 'fl', 0],
+		KeyH: ['h', 'H', '™', ' ', 0],
+		KeyI: ['i', 'I', ' ', ' ', 0],
+		KeyJ: ['j', 'J', '¶', '¯', 0],
+		KeyK: ['k', 'K', '§', 'ˇ', 0],
+		KeyL: ['l', 'L', ' ', '˘', 0],
+		KeyM: ['m', 'M', 'µ', '˚', 0],
+		KeyN: ['n', 'N', ' ', '˙', 0],
+		KeyO: ['o', 'O', 'ø', 'Ø', 0],
+		KeyP: ['p', 'P', 'π', '∏', 0],
+		KeyQ: ['q', 'Q', 'œ', 'Œ', 0],
+		KeyR: ['r', 'R', '®', ' ', 0],
+		KeyS: ['s', 'S', '∫', ' ', 0],
+		KeyT: ['t', 'T', '†', '‡', 0],
+		KeyU: ['u', 'U', ' ', ' ', 0],
+		KeyV: ['v', 'V', '√', '◊', 0],
+		KeyW: ['w', 'W', 'æ', 'Æ', 0],
+		KeyX: ['x', 'X', '∑', '›', 0],
+		KeyY: ['y', 'Y', '¥', ' ', 0],
+		KeyZ: ['z', 'Z', 'Ω', '‹', 0],
+		Digit1: ['1', '!', '|', 'ı', 0],
+		Digit2: ['2', '"', '@', '˝', 0],
+		Digit3: ['3', '·', '#', '•', 0],
+		Digit4: ['4', '$', '¢', '£', 0],
+		Digit5: ['5', '%', '∞', '‰', 0],
+		Digit6: ['6', '&', '¬', ' ', 0],
+		Digit7: ['7', '/', '÷', '⁄', 0],
+		Digit8: ['8', '(', '“', '‘', 0],
+		Digit9: ['9', ')', '”', '’', 0],
+		Digit0: ['0', '=', '≠', '≈', 0],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', ' ', ' ', 0],
+		Minus: ['\'', '?', '´', '¸', 0],
+		Equal: ['¡', '¿', '‚', '˛', 0],
+		BracketLeft: ['`', '^', '[', 'ˆ', 3],
+		BracketRight: ['+', '*', ']', '±', 0],
+		Backslash: ['ç', 'Ç', '}', '»', 0],
+		Semicolon: ['ñ', 'Ñ', '~', '˜', 4],
+		Quote: ['´', '¨', '{', '«', 3],
+		Backquote: ['<', '>', '≤', '≥', 0],
+		Comma: [',', ';', '„', '', 0],
+		Period: ['.', ':', '…', '…', 0],
+		Slash: ['-', '_', '–', '—', 0],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '/', '/', 0],
+		NumpadMultiply: ['*', '*', '*', '*', 0],
+		NumpadSubtract: ['-', '-', '-', '-', 0],
+		NumpadAdd: ['+', '+', '+', '+', 0],
+		NumpadEnter: [],
+		Numpad1: ['1', '1', '1', '1', 0],
+		Numpad2: ['2', '2', '2', '2', 0],
+		Numpad3: ['3', '3', '3', '3', 0],
+		Numpad4: ['4', '4', '4', '4', 0],
+		Numpad5: ['5', '5', '5', '5', 0],
+		Numpad6: ['6', '6', '6', '6', 0],
+		Numpad7: ['7', '7', '7', '7', 0],
+		Numpad8: ['8', '8', '8', '8', 0],
+		Numpad9: ['9', '9', '9', '9', 0],
+		Numpad0: ['0', '0', '0', '0', 0],
+		NumpadDecimal: [',', ',', ',', ',', 0],
+		IntlBackslash: ['º', 'ª', '\\', '°', 0],
+		ContextMenu: [],
+		NumpadEqual: ['=', '=', '=', '=', 0],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: ['', '=', '', '=', 0],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/es.linux.ts

@@ -0,0 +1,187 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { model: 'pc105', layout: 'es', variant: '', options: '', rules: 'evdev' },
+	secondaryLayouts: [],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['a', 'A', 'æ', 'Æ', 0],
+		KeyB: ['b', 'B', '”', '’', 0],
+		KeyC: ['c', 'C', '¢', '©', 0],
+		KeyD: ['d', 'D', 'ð', 'Ð', 0],
+		KeyE: ['e', 'E', '€', '¢', 0],
+		KeyF: ['f', 'F', 'đ', 'ª', 0],
+		KeyG: ['g', 'G', 'ŋ', 'Ŋ', 0],
+		KeyH: ['h', 'H', 'ħ', 'Ħ', 0],
+		KeyI: ['i', 'I', '→', 'ı', 0],
+		KeyJ: ['j', 'J', '̉', '̛', 0],
+		KeyK: ['k', 'K', 'ĸ', '&', 0],
+		KeyL: ['l', 'L', 'ł', 'Ł', 0],
+		KeyM: ['m', 'M', 'µ', 'º', 0],
+		KeyN: ['n', 'N', 'n', 'N', 0],
+		KeyO: ['o', 'O', 'ø', 'Ø', 0],
+		KeyP: ['p', 'P', 'þ', 'Þ', 0],
+		KeyQ: ['q', 'Q', '@', 'Ω', 0],
+		KeyR: ['r', 'R', '¶', '®', 0],
+		KeyS: ['s', 'S', 'ß', '§', 0],
+		KeyT: ['t', 'T', 'ŧ', 'Ŧ', 0],
+		KeyU: ['u', 'U', '↓', '↑', 0],
+		KeyV: ['v', 'V', '“', '‘', 0],
+		KeyW: ['w', 'W', 'ł', 'Ł', 0],
+		KeyX: ['x', 'X', '»', '>', 0],
+		KeyY: ['y', 'Y', '←', '¥', 0],
+		KeyZ: ['z', 'Z', '«', '<', 0],
+		Digit1: ['1', '!', '|', '¡', 0],
+		Digit2: ['2', '"', '@', '⅛', 0],
+		Digit3: ['3', '·', '#', '£', 0],
+		Digit4: ['4', '$', '~', '$', 0],
+		Digit5: ['5', '%', '½', '⅜', 0],
+		Digit6: ['6', '&', '¬', '⅝', 0],
+		Digit7: ['7', '/', '{', '⅞', 0],
+		Digit8: ['8', '(', '[', '™', 0],
+		Digit9: ['9', ')', ']', '±', 0],
+		Digit0: ['0', '=', '}', '°', 0],
+		Enter: ['\r', '\r', '\r', '\r', 0],
+		Escape: ['\u001b', '\u001b', '\u001b', '\u001b', 0],
+		Backspace: ['\b', '\b', '\b', '\b', 0],
+		Tab: ['\t', '', '\t', '', 0],
+		Space: [' ', ' ', ' ', ' ', 0],
+		Minus: ['\'', '?', '\\', '¿', 0],
+		Equal: ['¡', '¿', '̃', '~', 0],
+		BracketLeft: ['̀', '̂', '[', '̊', 0],
+		BracketRight: ['+', '*', ']', '̄', 0],
+		Backslash: ['ç', 'Ç', '}', '̆', 0],
+		Semicolon: ['ñ', 'Ñ', '~', '̋', 0],
+		Quote: ['́', '̈', '{', '{', 0],
+		Backquote: ['º', 'ª', '\\', '\\', 0],
+		Comma: [',', ';', '─', '×', 0],
+		Period: ['.', ':', '·', '÷', 0],
+		Slash: ['-', '_', '̣', '̇', 0],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: [],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: ['', '', '', '', 0],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '/', '/', 0],
+		NumpadMultiply: ['*', '*', '*', '*', 0],
+		NumpadSubtract: ['-', '-', '-', '-', 0],
+		NumpadAdd: ['+', '+', '+', '+', 0],
+		NumpadEnter: ['\r', '\r', '\r', '\r', 0],
+		Numpad1: ['', '1', '', '1', 0],
+		Numpad2: ['', '2', '', '2', 0],
+		Numpad3: ['', '3', '', '3', 0],
+		Numpad4: ['', '4', '', '4', 0],
+		Numpad5: ['', '5', '', '5', 0],
+		Numpad6: ['', '6', '', '6', 0],
+		Numpad7: ['', '7', '', '7', 0],
+		Numpad8: ['', '8', '', '8', 0],
+		Numpad9: ['', '9', '', '9', 0],
+		Numpad0: ['', '0', '', '0', 0],
+		NumpadDecimal: ['', '.', '', '.', 0],
+		IntlBackslash: ['<', '>', '|', '¦', 0],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: ['=', '=', '=', '=', 0],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Open: [],
+		Help: [],
+		Select: [],
+		Again: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		Find: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: ['.', '.', '.', '.', 0],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		Lang5: [],
+		NumpadParenLeft: ['(', '(', '(', '(', 0],
+		NumpadParenRight: [')', ')', ')', ')', 0],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: [],
+		BrightnessUp: [],
+		BrightnessDown: [],
+		MediaPlay: [],
+		MediaRecord: [],
+		MediaFastForward: [],
+		MediaRewind: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		SelectTask: [],
+		LaunchScreenSaver: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: [],
+		MailReply: [],
+		MailForward: [],
+		MailSend: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/es.win.ts

@@ -0,0 +1,169 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { name: '0000040A', id: '', text: 'Spanish' },
+	secondaryLayouts: [],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['a', 'A', '', '', 0, 'VK_A'],
+		KeyB: ['b', 'B', '', '', 0, 'VK_B'],
+		KeyC: ['c', 'C', '', '', 0, 'VK_C'],
+		KeyD: ['d', 'D', '', '', 0, 'VK_D'],
+		KeyE: ['e', 'E', '€', '', 0, 'VK_E'],
+		KeyF: ['f', 'F', '', '', 0, 'VK_F'],
+		KeyG: ['g', 'G', '', '', 0, 'VK_G'],
+		KeyH: ['h', 'H', '', '', 0, 'VK_H'],
+		KeyI: ['i', 'I', '', '', 0, 'VK_I'],
+		KeyJ: ['j', 'J', '', '', 0, 'VK_J'],
+		KeyK: ['k', 'K', '', '', 0, 'VK_K'],
+		KeyL: ['l', 'L', '', '', 0, 'VK_L'],
+		KeyM: ['m', 'M', '', '', 0, 'VK_M'],
+		KeyN: ['n', 'N', '', '', 0, 'VK_N'],
+		KeyO: ['o', 'O', '', '', 0, 'VK_O'],
+		KeyP: ['p', 'P', '', '', 0, 'VK_P'],
+		KeyQ: ['q', 'Q', '', '', 0, 'VK_Q'],
+		KeyR: ['r', 'R', '', '', 0, 'VK_R'],
+		KeyS: ['s', 'S', '', '', 0, 'VK_S'],
+		KeyT: ['t', 'T', '', '', 0, 'VK_T'],
+		KeyU: ['u', 'U', '', '', 0, 'VK_U'],
+		KeyV: ['v', 'V', '', '', 0, 'VK_V'],
+		KeyW: ['w', 'W', '', '', 0, 'VK_W'],
+		KeyX: ['x', 'X', '', '', 0, 'VK_X'],
+		KeyY: ['y', 'Y', '', '', 0, 'VK_Y'],
+		KeyZ: ['z', 'Z', '', '', 0, 'VK_Z'],
+		Digit1: ['1', '!', '|', '', 0, 'VK_1'],
+		Digit2: ['2', '"', '@', '', 0, 'VK_2'],
+		Digit3: ['3', '·', '#', '', 0, 'VK_3'],
+		Digit4: ['4', '$', '~', '', 0, 'VK_4'],
+		Digit5: ['5', '%', '€', '', 0, 'VK_5'],
+		Digit6: ['6', '&', '¬', '', 0, 'VK_6'],
+		Digit7: ['7', '/', '', '', 0, 'VK_7'],
+		Digit8: ['8', '(', '', '', 0, 'VK_8'],
+		Digit9: ['9', ')', '', '', 0, 'VK_9'],
+		Digit0: ['0', '=', '', '', 0, 'VK_0'],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', '', '', 0, 'VK_SPACE'],
+		Minus: ['\'', '?', '', '', 0, 'VK_OEM_4'],
+		Equal: ['¡', '¿', '', '', 0, 'VK_OEM_6'],
+		BracketLeft: ['`', '^', '[', '', 0, 'VK_OEM_1'],
+		BracketRight: ['+', '*', ']', '', 0, 'VK_OEM_PLUS'],
+		Backslash: ['ç', 'Ç', '}', '', 0, 'VK_OEM_2'],
+		Semicolon: ['ñ', 'Ñ', '', '', 0, 'VK_OEM_3'],
+		Quote: ['´', '¨', '{', '', 0, 'VK_OEM_7'],
+		Backquote: ['º', 'ª', '\\', '', 0, 'VK_OEM_5'],
+		Comma: [',', ';', '', '', 0, 'VK_OEM_COMMA'],
+		Period: ['.', ':', '', '', 0, 'VK_OEM_PERIOD'],
+		Slash: ['-', '_', '', '', 0, 'VK_OEM_MINUS'],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: [],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '', '', 0, 'VK_DIVIDE'],
+		NumpadMultiply: ['*', '*', '', '', 0, 'VK_MULTIPLY'],
+		NumpadSubtract: ['-', '-', '', '', 0, 'VK_SUBTRACT'],
+		NumpadAdd: ['+', '+', '', '', 0, 'VK_ADD'],
+		NumpadEnter: [],
+		Numpad1: [],
+		Numpad2: [],
+		Numpad3: [],
+		Numpad4: [],
+		Numpad5: [],
+		Numpad6: [],
+		Numpad7: [],
+		Numpad8: [],
+		Numpad9: [],
+		Numpad0: [],
+		NumpadDecimal: [],
+		IntlBackslash: ['<', '>', '', '', 0, 'VK_OEM_102'],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: [],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Help: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/fr.darwin.ts

@@ -0,0 +1,132 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { id: 'com.apple.keylayout.French', lang: 'fr', localizedName: 'French' },
+	secondaryLayouts: [],
+	mapping: {
+		KeyA: ['q', 'Q', '‡', 'Ω', 0],
+		KeyB: ['b', 'B', 'ß', '∫', 0],
+		KeyC: ['c', 'C', '©', '¢', 0],
+		KeyD: ['d', 'D', '∂', '∆', 0],
+		KeyE: ['e', 'E', 'ê', 'Ê', 0],
+		KeyF: ['f', 'F', 'ƒ', '·', 0],
+		KeyG: ['g', 'G', 'fi', 'fl', 0],
+		KeyH: ['h', 'H', 'Ì', 'Î', 0],
+		KeyI: ['i', 'I', 'î', 'ï', 0],
+		KeyJ: ['j', 'J', 'Ï', 'Í', 0],
+		KeyK: ['k', 'K', 'È', 'Ë', 0],
+		KeyL: ['l', 'L', '¬', '|', 0],
+		KeyM: [',', '?', '∞', '¿', 0],
+		KeyN: ['n', 'N', '~', 'ı', 4],
+		KeyO: ['o', 'O', 'œ', 'Œ', 0],
+		KeyP: ['p', 'P', 'π', '∏', 0],
+		KeyQ: ['a', 'A', 'æ', 'Æ', 0],
+		KeyR: ['r', 'R', '®', '‚', 0],
+		KeyS: ['s', 'S', 'Ò', '∑', 0],
+		KeyT: ['t', 'T', '†', '™', 0],
+		KeyU: ['u', 'U', 'º', 'ª', 0],
+		KeyV: ['v', 'V', '◊', '√', 0],
+		KeyW: ['z', 'Z', 'Â', 'Å', 0],
+		KeyX: ['x', 'X', '≈', '⁄', 0],
+		KeyY: ['y', 'Y', 'Ú', 'Ÿ', 0],
+		KeyZ: ['w', 'W', '‹', '›', 0],
+		Digit1: ['&', '1', '', '´', 8],
+		Digit2: ['é', '2', 'ë', '„', 0],
+		Digit3: ['"', '3', '“', '”', 0],
+		Digit4: ['\'', '4', '‘', '’', 0],
+		Digit5: ['(', '5', '{', '[', 0],
+		Digit6: ['§', '6', '¶', 'å', 0],
+		Digit7: ['è', '7', '«', '»', 0],
+		Digit8: ['!', '8', '¡', 'Û', 0],
+		Digit9: ['ç', '9', 'Ç', 'Á', 0],
+		Digit0: ['à', '0', 'ø', 'Ø', 0],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', ' ', ' ', 0],
+		Minus: [')', '°', '}', ']', 0],
+		Equal: ['-', '_', '—', '–', 0],
+		BracketLeft: ['^', '¨', 'ô', 'Ô', 3],
+		BracketRight: ['$', '*', '€', '¥', 0],
+		Backslash: ['`', '£', '@', '#', 1],
+		Semicolon: ['m', 'M', 'µ', 'Ó', 0],
+		Quote: ['ù', '%', 'Ù', '‰', 0],
+		Backquote: ['<', '>', '≤', '≥', 0],
+		Comma: [';', '.', '…', '•', 0],
+		Period: [':', '/', '÷', '\\', 0],
+		Slash: ['=', '+', '≠', '±', 0],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '/', '/', 0],
+		NumpadMultiply: ['*', '*', '*', '*', 0],
+		NumpadSubtract: ['-', '-', '-', '-', 0],
+		NumpadAdd: ['+', '+', '+', '+', 0],
+		NumpadEnter: [],
+		Numpad1: ['1', '1', '1', '1', 0],
+		Numpad2: ['2', '2', '2', '2', 0],
+		Numpad3: ['3', '3', '3', '3', 0],
+		Numpad4: ['4', '4', '4', '4', 0],
+		Numpad5: ['5', '5', '5', '5', 0],
+		Numpad6: ['6', '6', '6', '6', 0],
+		Numpad7: ['7', '7', '7', '7', 0],
+		Numpad8: ['8', '8', '8', '8', 0],
+		Numpad9: ['9', '9', '9', '9', 0],
+		Numpad0: ['0', '0', '0', '0', 0],
+		NumpadDecimal: [',', '.', ',', '.', 0],
+		IntlBackslash: ['@', '#', '•', 'Ÿ', 0],
+		ContextMenu: [],
+		NumpadEqual: ['=', '=', '=', '=', 0],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: ['', '=', '', '=', 0],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/fr.linux.ts

@@ -0,0 +1,187 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { model: 'pc104', layout: 'fr', variant: '', options: '', rules: 'base' },
+	secondaryLayouts: [],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['q', 'Q', '@', 'Ω', 0],
+		KeyB: ['b', 'B', '”', '’', 0],
+		KeyC: ['c', 'C', '¢', '©', 0],
+		KeyD: ['d', 'D', 'ð', 'Ð', 0],
+		KeyE: ['e', 'E', '€', '¢', 0],
+		KeyF: ['f', 'F', 'đ', 'ª', 0],
+		KeyG: ['g', 'G', 'ŋ', 'Ŋ', 0],
+		KeyH: ['h', 'H', 'ħ', 'Ħ', 0],
+		KeyI: ['i', 'I', '→', 'ı', 0],
+		KeyJ: ['j', 'J', '̉', '̛', 0],
+		KeyK: ['k', 'K', 'ĸ', '&', 0],
+		KeyL: ['l', 'L', 'ł', 'Ł', 0],
+		KeyM: [',', '?', '́', '̋', 0],
+		KeyN: ['n', 'N', 'n', 'N', 0],
+		KeyO: ['o', 'O', 'ø', 'Ø', 0],
+		KeyP: ['p', 'P', 'þ', 'Þ', 0],
+		KeyQ: ['a', 'A', 'æ', 'Æ', 0],
+		KeyR: ['r', 'R', '¶', '®', 0],
+		KeyS: ['s', 'S', 'ß', '§', 0],
+		KeyT: ['t', 'T', 'ŧ', 'Ŧ', 0],
+		KeyU: ['u', 'U', '↓', '↑', 0],
+		KeyV: ['v', 'V', '“', '‘', 0],
+		KeyW: ['z', 'Z', '«', '<', 0],
+		KeyX: ['x', 'X', '»', '>', 0],
+		KeyY: ['y', 'Y', '←', '¥', 0],
+		KeyZ: ['w', 'W', 'ł', 'Ł', 0],
+		Digit1: ['&', '1', '¹', '¡', 0],
+		Digit2: ['é', '2', '~', '⅛', 0],
+		Digit3: ['"', '3', '#', '£', 0],
+		Digit4: ['\'', '4', '{', '$', 0],
+		Digit5: ['(', '5', '[', '⅜', 0],
+		Digit6: ['-', '6', '|', '⅝', 0],
+		Digit7: ['è', '7', '`', '⅞', 0],
+		Digit8: ['_', '8', '\\', '™', 0],
+		Digit9: ['ç', '9', '^', '±', 0],
+		Digit0: ['à', '0', '@', '°', 0],
+		Enter: ['\r', '\r', '\r', '\r', 0],
+		Escape: ['\u001b', '\u001b', '\u001b', '\u001b', 0],
+		Backspace: ['\b', '\b', '\b', '\b', 0],
+		Tab: ['\t', '', '\t', '', 0],
+		Space: [' ', ' ', ' ', ' ', 0],
+		Minus: [')', '°', ']', '¿', 0],
+		Equal: ['=', '+', '}', '̨', 0],
+		BracketLeft: ['̂', '̈', '̈', '̊', 0],
+		BracketRight: ['$', '£', '¤', '̄', 0],
+		Backslash: ['*', 'µ', '̀', '̆', 0],
+		Semicolon: ['m', 'M', 'µ', 'º', 0],
+		Quote: ['ù', '%', '̂', '̌', 0],
+		Backquote: ['²', '~', '¬', '¬', 0],
+		Comma: [';', '.', '─', '×', 0],
+		Period: [':', '/', '·', '÷', 0],
+		Slash: ['!', '§', '̣', '̇', 0],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: ['', '', '', '', 0],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: ['/', '/', '/', '/', 0],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: [],
+		NumpadMultiply: ['*', '*', '*', '*', 0],
+		NumpadSubtract: ['-', '-', '-', '-', 0],
+		NumpadAdd: ['+', '+', '+', '+', 0],
+		NumpadEnter: [],
+		Numpad1: ['', '1', '', '1', 0],
+		Numpad2: ['', '2', '', '2', 0],
+		Numpad3: ['', '3', '', '3', 0],
+		Numpad4: ['', '4', '', '4', 0],
+		Numpad5: ['', '5', '', '5', 0],
+		Numpad6: ['', '6', '', '6', 0],
+		Numpad7: ['', '7', '', '7', 0],
+		Numpad8: ['', '8', '', '8', 0],
+		Numpad9: ['', '9', '', '9', 0],
+		Numpad0: ['', '0', '', '0', 0],
+		NumpadDecimal: ['', '.', '', '.', 0],
+		IntlBackslash: ['<', '>', '|', '¦', 0],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: [],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Open: [],
+		Help: [],
+		Select: [],
+		Again: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		Find: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		Lang5: [],
+		NumpadParenLeft: [],
+		NumpadParenRight: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: ['\r', '\r', '\r', '\r', 0],
+		MetaRight: ['.', '.', '.', '.', 0],
+		BrightnessUp: [],
+		BrightnessDown: [],
+		MediaPlay: [],
+		MediaRecord: [],
+		MediaFastForward: [],
+		MediaRewind: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		SelectTask: [],
+		LaunchScreenSaver: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: [],
+		MailReply: [],
+		MailForward: [],
+		MailSend: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/fr.win.ts

@@ -0,0 +1,169 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { name: '0000040C', id: '', text: 'French' },
+	secondaryLayouts: [],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['q', 'Q', '', '', 0, 'VK_Q'],
+		KeyB: ['b', 'B', '', '', 0, 'VK_B'],
+		KeyC: ['c', 'C', '', '', 0, 'VK_C'],
+		KeyD: ['d', 'D', '', '', 0, 'VK_D'],
+		KeyE: ['e', 'E', '€', '', 0, 'VK_E'],
+		KeyF: ['f', 'F', '', '', 0, 'VK_F'],
+		KeyG: ['g', 'G', '', '', 0, 'VK_G'],
+		KeyH: ['h', 'H', '', '', 0, 'VK_H'],
+		KeyI: ['i', 'I', '', '', 0, 'VK_I'],
+		KeyJ: ['j', 'J', '', '', 0, 'VK_J'],
+		KeyK: ['k', 'K', '', '', 0, 'VK_K'],
+		KeyL: ['l', 'L', '', '', 0, 'VK_L'],
+		KeyM: [',', '?', '', '', 0, 'VK_OEM_COMMA'],
+		KeyN: ['n', 'N', '', '', 0, 'VK_N'],
+		KeyO: ['o', 'O', '', '', 0, 'VK_O'],
+		KeyP: ['p', 'P', '', '', 0, 'VK_P'],
+		KeyQ: ['a', 'A', '', '', 0, 'VK_A'],
+		KeyR: ['r', 'R', '', '', 0, 'VK_R'],
+		KeyS: ['s', 'S', '', '', 0, 'VK_S'],
+		KeyT: ['t', 'T', '', '', 0, 'VK_T'],
+		KeyU: ['u', 'U', '', '', 0, 'VK_U'],
+		KeyV: ['v', 'V', '', '', 0, 'VK_V'],
+		KeyW: ['z', 'Z', '', '', 0, 'VK_Z'],
+		KeyX: ['x', 'X', '', '', 0, 'VK_X'],
+		KeyY: ['y', 'Y', '', '', 0, 'VK_Y'],
+		KeyZ: ['w', 'W', '', '', 0, 'VK_W'],
+		Digit1: ['&', '1', '', '', 0, 'VK_1'],
+		Digit2: ['é', '2', '~', '', 0, 'VK_2'],
+		Digit3: ['"', '3', '#', '', 0, 'VK_3'],
+		Digit4: ['\'', '4', '{', '', 0, 'VK_4'],
+		Digit5: ['(', '5', '[', '', 0, 'VK_5'],
+		Digit6: ['-', '6', '|', '', 0, 'VK_6'],
+		Digit7: ['è', '7', '`', '', 0, 'VK_7'],
+		Digit8: ['_', '8', '\\', '', 0, 'VK_8'],
+		Digit9: ['ç', '9', '^', '', 0, 'VK_9'],
+		Digit0: ['à', '0', '@', '', 0, 'VK_0'],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', '', '', 0, 'VK_SPACE'],
+		Minus: [')', '°', ']', '', 0, 'VK_OEM_4'],
+		Equal: ['=', '+', '}', '', 0, 'VK_OEM_PLUS'],
+		BracketLeft: ['^', '¨', '', '', 0, 'VK_OEM_6'],
+		BracketRight: ['$', '£', '¤', '', 0, 'VK_OEM_1'],
+		Backslash: ['*', 'µ', '', '', 0, 'VK_OEM_5'],
+		Semicolon: ['m', 'M', '', '', 0, 'VK_M'],
+		Quote: ['ù', '%', '', '', 0, 'VK_OEM_3'],
+		Backquote: ['²', '', '', '', 0, 'VK_OEM_7'],
+		Comma: [';', '.', '', '', 0, 'VK_OEM_PERIOD'],
+		Period: [':', '/', '', '', 0, 'VK_OEM_2'],
+		Slash: ['!', '§', '', '', 0, 'VK_OEM_8'],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: [],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '', '', 0, 'VK_DIVIDE'],
+		NumpadMultiply: ['*', '*', '', '', 0, 'VK_MULTIPLY'],
+		NumpadSubtract: ['-', '-', '', '', 0, 'VK_SUBTRACT'],
+		NumpadAdd: ['+', '+', '', '', 0, 'VK_ADD'],
+		NumpadEnter: [],
+		Numpad1: [],
+		Numpad2: [],
+		Numpad3: [],
+		Numpad4: [],
+		Numpad5: [],
+		Numpad6: [],
+		Numpad7: [],
+		Numpad8: [],
+		Numpad9: [],
+		Numpad0: [],
+		NumpadDecimal: [],
+		IntlBackslash: ['<', '>', '', '', 0, 'VK_OEM_102'],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: [],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Help: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/hu.win.ts

@@ -0,0 +1,169 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { name: '0000040E', id: '', text: 'Hungarian' },
+	secondaryLayouts: [],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['a', 'A', 'ä', '', 0, 'VK_A'],
+		KeyB: ['b', 'B', '{', '', 0, 'VK_B'],
+		KeyC: ['c', 'C', '&', '', 0, 'VK_C'],
+		KeyD: ['d', 'D', 'Đ', '', 0, 'VK_D'],
+		KeyE: ['e', 'E', 'Ä', '', 0, 'VK_E'],
+		KeyF: ['f', 'F', '[', '', 0, 'VK_F'],
+		KeyG: ['g', 'G', ']', '', 0, 'VK_G'],
+		KeyH: ['h', 'H', '', '', 0, 'VK_H'],
+		KeyI: ['i', 'I', 'Í', '', 0, 'VK_I'],
+		KeyJ: ['j', 'J', 'í', '', 0, 'VK_J'],
+		KeyK: ['k', 'K', 'ł', '', 0, 'VK_K'],
+		KeyL: ['l', 'L', 'Ł', '', 0, 'VK_L'],
+		KeyM: ['m', 'M', '<', '', 0, 'VK_M'],
+		KeyN: ['n', 'N', '}', '', 0, 'VK_N'],
+		KeyO: ['o', 'O', '', '', 0, 'VK_O'],
+		KeyP: ['p', 'P', '', '', 0, 'VK_P'],
+		KeyQ: ['q', 'Q', '\\', '', 0, 'VK_Q'],
+		KeyR: ['r', 'R', '', '', 0, 'VK_R'],
+		KeyS: ['s', 'S', 'đ', '', 0, 'VK_S'],
+		KeyT: ['t', 'T', '', '', 0, 'VK_T'],
+		KeyU: ['u', 'U', '€', '', 0, 'VK_U'],
+		KeyV: ['v', 'V', '@', '', 0, 'VK_V'],
+		KeyW: ['w', 'W', '|', '', 0, 'VK_W'],
+		KeyX: ['x', 'X', '#', '', 0, 'VK_X'],
+		KeyY: ['z', 'Z', '', '', 0, 'VK_Z'],
+		KeyZ: ['y', 'Y', '>', '', 0, 'VK_Y'],
+		Digit1: ['1', '\'', '~', '', 0, 'VK_1'],
+		Digit2: ['2', '"', 'ˇ', '', 0, 'VK_2'],
+		Digit3: ['3', '+', '^', '', 0, 'VK_3'],
+		Digit4: ['4', '!', '˘', '', 0, 'VK_4'],
+		Digit5: ['5', '%', '°', '', 0, 'VK_5'],
+		Digit6: ['6', '/', '˛', '', 0, 'VK_6'],
+		Digit7: ['7', '=', '`', '', 0, 'VK_7'],
+		Digit8: ['8', '(', '˙', '', 0, 'VK_8'],
+		Digit9: ['9', ')', '´', '', 0, 'VK_9'],
+		Digit0: ['ö', 'Ö', '˝', '', 0, 'VK_OEM_3'],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', '', '', 0, 'VK_SPACE'],
+		Minus: ['ü', 'Ü', '¨', '', 0, 'VK_OEM_2'],
+		Equal: ['ó', 'Ó', '¸', '', 0, 'VK_OEM_PLUS'],
+		BracketLeft: ['ő', 'Ő', '÷', '', 0, 'VK_OEM_4'],
+		BracketRight: ['ú', 'Ú', '×', '', 0, 'VK_OEM_6'],
+		Backslash: ['ű', 'Ű', '¤', '', 0, 'VK_OEM_5'],
+		Semicolon: ['é', 'É', '$', '', 0, 'VK_OEM_1'],
+		Quote: ['á', 'Á', 'ß', '', 0, 'VK_OEM_7'],
+		Backquote: ['0', '§', '', '', 0, 'VK_0'],
+		Comma: [',', '?', ';', '', 0, 'VK_OEM_COMMA'],
+		Period: ['.', ':', '>', '', 0, 'VK_OEM_PERIOD'],
+		Slash: ['-', '_', '*', '', 0, 'VK_OEM_MINUS'],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: [],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '', '', 0, 'VK_DIVIDE'],
+		NumpadMultiply: ['*', '*', '', '', 0, 'VK_MULTIPLY'],
+		NumpadSubtract: ['-', '-', '', '', 0, 'VK_SUBTRACT'],
+		NumpadAdd: ['+', '+', '', '', 0, 'VK_ADD'],
+		NumpadEnter: [],
+		Numpad1: [],
+		Numpad2: [],
+		Numpad3: [],
+		Numpad4: [],
+		Numpad5: [],
+		Numpad6: [],
+		Numpad7: [],
+		Numpad8: [],
+		Numpad9: [],
+		Numpad0: [],
+		NumpadDecimal: [],
+		IntlBackslash: ['í', 'Í', '<', '', 0, 'VK_OEM_102'],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: [],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Help: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/it.darwin.ts

@@ -0,0 +1,132 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { id: 'com.apple.keylayout.Italian-Pro', lang: 'it', localizedName: 'Italian' },
+	secondaryLayouts: [],
+	mapping: {
+		KeyA: ['a', 'A', 'å', 'Å', 0],
+		KeyB: ['b', 'B', '∫', 'Í', 0],
+		KeyC: ['c', 'C', '©', 'Á', 0],
+		KeyD: ['d', 'D', '∂', '˘', 0],
+		KeyE: ['e', 'E', '€', 'È', 0],
+		KeyF: ['f', 'F', 'ƒ', '˙', 0],
+		KeyG: ['g', 'G', '∞', '˚', 0],
+		KeyH: ['h', 'H', '∆', '¸', 0],
+		KeyI: ['i', 'I', 'œ', 'Œ', 0],
+		KeyJ: ['j', 'J', 'ª', '˝', 0],
+		KeyK: ['k', 'K', 'º', '˛', 0],
+		KeyL: ['l', 'L', '¬', 'ˇ', 0],
+		KeyM: ['m', 'M', 'µ', 'Ú', 0],
+		KeyN: ['n', 'N', '˜', 'Ó', 4],
+		KeyO: ['o', 'O', 'ø', 'Ø', 0],
+		KeyP: ['p', 'P', 'π', '∏', 0],
+		KeyQ: ['q', 'Q', '„', '‚', 0],
+		KeyR: ['r', 'R', '®', 'Ì', 0],
+		KeyS: ['s', 'S', 'ß', '¯', 0],
+		KeyT: ['t', 'T', '™', 'Ò', 0],
+		KeyU: ['u', 'U', '¨', 'Ù', 4],
+		KeyV: ['v', 'V', '√', 'É', 0],
+		KeyW: ['w', 'W', 'Ω', 'À', 0],
+		KeyX: ['x', 'X', '†', '‡', 0],
+		KeyY: ['y', 'Y', 'æ', 'Æ', 0],
+		KeyZ: ['z', 'Z', '∑', ' ', 0],
+		Digit1: ['1', '!', '«', '»', 0],
+		Digit2: ['2', '"', '“', '”', 0],
+		Digit3: ['3', '£', '‘', '’', 0],
+		Digit4: ['4', '$', '¥', '¢', 0],
+		Digit5: ['5', '%', '~', '‰', 0],
+		Digit6: ['6', '&', '‹', '›', 0],
+		Digit7: ['7', '/', '÷', '⁄', 0],
+		Digit8: ['8', '(', '´', '', 4],
+		Digit9: ['9', ')', '`', ' ', 4],
+		Digit0: ['0', '=', '≠', '≈', 0],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', ' ', ' ', 0],
+		Minus: ['\'', '?', '¡', '¿', 0],
+		Equal: ['ì', '^', 'ˆ', '±', 4],
+		BracketLeft: ['è', 'é', '[', '{', 0],
+		BracketRight: ['+', '*', ']', '}', 0],
+		Backslash: ['ù', '§', '¶', '◊', 0],
+		Semicolon: ['ò', 'ç', '@', 'Ç', 0],
+		Quote: ['à', '°', '#', '∞', 0],
+		Backquote: ['<', '>', '≤', '≥', 0],
+		Comma: [',', ';', '…', ' ', 0],
+		Period: ['.', ':', '•', '·', 0],
+		Slash: ['-', '_', '–', '—', 0],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '/', '/', 0],
+		NumpadMultiply: ['*', '*', '*', '*', 0],
+		NumpadSubtract: ['-', '-', '-', '-', 0],
+		NumpadAdd: ['+', '+', '+', '+', 0],
+		NumpadEnter: [],
+		Numpad1: ['1', '1', '1', '1', 0],
+		Numpad2: ['2', '2', '2', '2', 0],
+		Numpad3: ['3', '3', '3', '3', 0],
+		Numpad4: ['4', '4', '4', '4', 0],
+		Numpad5: ['5', '5', '5', '5', 0],
+		Numpad6: ['6', '6', '6', '6', 0],
+		Numpad7: ['7', '7', '7', '7', 0],
+		Numpad8: ['8', '8', '8', '8', 0],
+		Numpad9: ['9', '9', '9', '9', 0],
+		Numpad0: ['0', '0', '0', '0', 0],
+		NumpadDecimal: [',', '.', ',', '.', 0],
+		IntlBackslash: ['\\', '|', '`', 'ı', 0],
+		ContextMenu: [],
+		NumpadEqual: ['=', '=', '=', '=', 0],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: ['', '=', '', '=', 0],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/it.win.ts

@@ -0,0 +1,169 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { name: '00000410', id: '', text: 'Italian' },
+	secondaryLayouts: [],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['a', 'A', '', '', 0, 'VK_A'],
+		KeyB: ['b', 'B', '', '', 0, 'VK_B'],
+		KeyC: ['c', 'C', '', '', 0, 'VK_C'],
+		KeyD: ['d', 'D', '', '', 0, 'VK_D'],
+		KeyE: ['e', 'E', '€', '', 0, 'VK_E'],
+		KeyF: ['f', 'F', '', '', 0, 'VK_F'],
+		KeyG: ['g', 'G', '', '', 0, 'VK_G'],
+		KeyH: ['h', 'H', '', '', 0, 'VK_H'],
+		KeyI: ['i', 'I', '', '', 0, 'VK_I'],
+		KeyJ: ['j', 'J', '', '', 0, 'VK_J'],
+		KeyK: ['k', 'K', '', '', 0, 'VK_K'],
+		KeyL: ['l', 'L', '', '', 0, 'VK_L'],
+		KeyM: ['m', 'M', '', '', 0, 'VK_M'],
+		KeyN: ['n', 'N', '', '', 0, 'VK_N'],
+		KeyO: ['o', 'O', '', '', 0, 'VK_O'],
+		KeyP: ['p', 'P', '', '', 0, 'VK_P'],
+		KeyQ: ['q', 'Q', '', '', 0, 'VK_Q'],
+		KeyR: ['r', 'R', '', '', 0, 'VK_R'],
+		KeyS: ['s', 'S', '', '', 0, 'VK_S'],
+		KeyT: ['t', 'T', '', '', 0, 'VK_T'],
+		KeyU: ['u', 'U', '', '', 0, 'VK_U'],
+		KeyV: ['v', 'V', '', '', 0, 'VK_V'],
+		KeyW: ['w', 'W', '', '', 0, 'VK_W'],
+		KeyX: ['x', 'X', '', '', 0, 'VK_X'],
+		KeyY: ['y', 'Y', '', '', 0, 'VK_Y'],
+		KeyZ: ['z', 'Z', '', '', 0, 'VK_Z'],
+		Digit1: ['1', '!', '', '', 0, 'VK_1'],
+		Digit2: ['2', '"', '', '', 0, 'VK_2'],
+		Digit3: ['3', '£', '', '', 0, 'VK_3'],
+		Digit4: ['4', '$', '', '', 0, 'VK_4'],
+		Digit5: ['5', '%', '€', '', 0, 'VK_5'],
+		Digit6: ['6', '&', '', '', 0, 'VK_6'],
+		Digit7: ['7', '/', '', '', 0, 'VK_7'],
+		Digit8: ['8', '(', '', '', 0, 'VK_8'],
+		Digit9: ['9', ')', '', '', 0, 'VK_9'],
+		Digit0: ['0', '=', '', '', 0, 'VK_0'],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', '', '', 0, 'VK_SPACE'],
+		Minus: ['\'', '?', '', '', 0, 'VK_OEM_4'],
+		Equal: ['ì', '^', '', '', 0, 'VK_OEM_6'],
+		BracketLeft: ['è', 'é', '[', '{', 0, 'VK_OEM_1'],
+		BracketRight: ['+', '*', ']', '}', 0, 'VK_OEM_PLUS'],
+		Backslash: ['ù', '§', '', '', 0, 'VK_OEM_2'],
+		Semicolon: ['ò', 'ç', '@', '', 0, 'VK_OEM_3'],
+		Quote: ['à', '°', '#', '', 0, 'VK_OEM_7'],
+		Backquote: ['\\', '|', '', '', 0, 'VK_OEM_5'],
+		Comma: [',', ';', '', '', 0, 'VK_OEM_COMMA'],
+		Period: ['.', ':', '', '', 0, 'VK_OEM_PERIOD'],
+		Slash: ['-', '_', '', '', 0, 'VK_OEM_MINUS'],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: [],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '', '', 0, 'VK_DIVIDE'],
+		NumpadMultiply: ['*', '*', '', '', 0, 'VK_MULTIPLY'],
+		NumpadSubtract: ['-', '-', '', '', 0, 'VK_SUBTRACT'],
+		NumpadAdd: ['+', '+', '', '', 0, 'VK_ADD'],
+		NumpadEnter: [],
+		Numpad1: [],
+		Numpad2: [],
+		Numpad3: [],
+		Numpad4: [],
+		Numpad5: [],
+		Numpad6: [],
+		Numpad7: [],
+		Numpad8: [],
+		Numpad9: [],
+		Numpad0: [],
+		NumpadDecimal: [],
+		IntlBackslash: ['<', '>', '', '', 0, 'VK_OEM_102'],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: [],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Help: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/jp-roman.darwin.ts

@@ -0,0 +1,132 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { id: 'com.google.inputmethod.Japanese.Roman', lang: 'en', localizedName: 'Alphanumeric (Google)' },
+	secondaryLayouts: [],
+	mapping: {
+		KeyA: ['a', 'A', '¯', '̄', 4],
+		KeyB: ['b', 'B', '˘', '̆', 4],
+		KeyC: ['c', 'C', '¸', '̧', 4],
+		KeyD: ['d', 'D', 'ð', 'Ð', 0],
+		KeyE: ['e', 'E', '´', '́', 4],
+		KeyF: ['f', 'F', 'ƒ', '', 0],
+		KeyG: ['g', 'G', '©', '‸', 8],
+		KeyH: ['h', 'H', 'ˍ', '̱', 4],
+		KeyI: ['i', 'I', 'ʼ', '̛', 4],
+		KeyJ: ['j', 'J', '˝', '̋', 4],
+		KeyK: ['k', 'K', '˚', '̊', 4],
+		KeyL: ['l', 'L', '-', '̵', 4],
+		KeyM: ['m', 'M', '˛', '̨', 4],
+		KeyN: ['n', 'N', '˜', '̃', 4],
+		KeyO: ['o', 'O', 'ø', 'Ø', 0],
+		KeyP: ['p', 'P', ',', '̦', 4],
+		KeyQ: ['q', 'Q', 'œ', 'Œ', 0],
+		KeyR: ['r', 'R', '®', '‰', 0],
+		KeyS: ['s', 'S', 'ß', '', 0],
+		KeyT: ['t', 'T', 'þ', 'Þ', 0],
+		KeyU: ['u', 'U', '¨', '̈', 4],
+		KeyV: ['v', 'V', 'ˇ', '̌', 4],
+		KeyW: ['w', 'W', '˙', '̇', 4],
+		KeyX: ['x', 'X', '.', '̣', 4],
+		KeyY: ['y', 'Y', '¥', '', 0],
+		KeyZ: ['z', 'Z', 'ˀ', '̉', 4],
+		Digit1: ['1', '!', '¡', '⁄', 0],
+		Digit2: ['2', '@', '™', '€', 0],
+		Digit3: ['3', '#', '£', '‹', 0],
+		Digit4: ['4', '$', '¢', '›', 0],
+		Digit5: ['5', '%', '§', '†', 0],
+		Digit6: ['6', '^', 'ˆ', '̂', 4],
+		Digit7: ['7', '&', '¶', '‡', 0],
+		Digit8: ['8', '*', '•', '°', 0],
+		Digit9: ['9', '(', 'ª', '·', 0],
+		Digit0: ['0', ')', 'º', '‚', 0],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', ' ', ' ', 0],
+		Minus: ['-', '_', '–', '—', 0],
+		Equal: ['=', '+', '≠', '±', 0],
+		BracketLeft: ['[', '{', '“', '”', 0],
+		BracketRight: [']', '}', '‘', '’', 0],
+		Backslash: ['\\', '|', '«', '»', 0],
+		Semicolon: [';', ':', '…', '№', 8],
+		Quote: ['\'', '"', 'æ', 'Æ', 0],
+		Backquote: ['`', '~', '`', '̀', 4],
+		Comma: [',', '<', '≤', '„', 0],
+		Period: ['.', '>', '≥', 'ʔ', 8],
+		Slash: ['/', '?', '÷', '¿', 0],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '/', '/', 0],
+		NumpadMultiply: ['*', '*', '*', '*', 0],
+		NumpadSubtract: ['-', '-', '-', '-', 0],
+		NumpadAdd: ['+', '+', '+', '+', 0],
+		NumpadEnter: [],
+		Numpad1: ['1', '1', '1', '1', 0],
+		Numpad2: ['2', '2', '2', '2', 0],
+		Numpad3: ['3', '3', '3', '3', 0],
+		Numpad4: ['4', '4', '4', '4', 0],
+		Numpad5: ['5', '5', '5', '5', 0],
+		Numpad6: ['6', '6', '6', '6', 0],
+		Numpad7: ['7', '7', '7', '7', 0],
+		Numpad8: ['8', '8', '8', '8', 0],
+		Numpad9: ['9', '9', '9', '9', 0],
+		Numpad0: ['0', '0', '0', '0', 0],
+		NumpadDecimal: ['.', '.', '.', '.', 0],
+		IntlBackslash: ['§', '±', '§', '±', 0],
+		ContextMenu: [],
+		NumpadEqual: ['=', '=', '=', '=', 0],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: ['', '=', '', '=', 0],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/jp.darwin.ts

@@ -0,0 +1,132 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { id: 'com.apple.inputmethod.Kotoeri.Japanese', lang: 'ja', localizedName: 'Hiragana' },
+	secondaryLayouts: [],
+	mapping: {
+		KeyA: ['a', 'A', 'å', 'Å', 0],
+		KeyB: ['b', 'B', '∫', 'ı', 0],
+		KeyC: ['c', 'C', 'ç', 'Ç', 0],
+		KeyD: ['d', 'D', '∂', 'Î', 0],
+		KeyE: ['e', 'E', '´', '´', 4],
+		KeyF: ['f', 'F', 'ƒ', 'Ï', 0],
+		KeyG: ['g', 'G', '©', '˝', 0],
+		KeyH: ['h', 'H', '˙', 'Ó', 0],
+		KeyI: ['i', 'I', 'ˆ', 'ˆ', 4],
+		KeyJ: ['j', 'J', '∆', 'Ô', 0],
+		KeyK: ['k', 'K', '˚', '', 0],
+		KeyL: ['l', 'L', '¬', 'Ò', 0],
+		KeyM: ['m', 'M', 'µ', 'Â', 0],
+		KeyN: ['n', 'N', '˜', '˜', 4],
+		KeyO: ['o', 'O', 'ø', 'Ø', 0],
+		KeyP: ['p', 'P', 'π', '∏', 0],
+		KeyQ: ['q', 'Q', 'œ', 'Œ', 0],
+		KeyR: ['r', 'R', '®', '‰', 0],
+		KeyS: ['s', 'S', 'ß', 'Í', 0],
+		KeyT: ['t', 'T', '†', 'ˇ', 0],
+		KeyU: ['u', 'U', '¨', '¨', 4],
+		KeyV: ['v', 'V', '√', '◊', 0],
+		KeyW: ['w', 'W', '∑', '„', 0],
+		KeyX: ['x', 'X', '≈', '˛', 0],
+		KeyY: ['y', 'Y', '¥', 'Á', 0],
+		KeyZ: ['z', 'Z', 'Ω', '¸', 0],
+		Digit1: ['1', '!', '¡', '⁄', 0],
+		Digit2: ['2', '@', '™', '€', 0],
+		Digit3: ['3', '#', '£', '‹', 0],
+		Digit4: ['4', '$', '¢', '›', 0],
+		Digit5: ['5', '%', '∞', 'fi', 0],
+		Digit6: ['6', '^', '§', 'fl', 0],
+		Digit7: ['7', '&', '¶', '‡', 0],
+		Digit8: ['8', '*', '•', '°', 0],
+		Digit9: ['9', '(', 'ª', '·', 0],
+		Digit0: ['0', ')', 'º', '‚', 0],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', ' ', ' ', 0],
+		Minus: ['-', '_', '–', '—', 0],
+		Equal: ['=', '+', '≠', '±', 0],
+		BracketLeft: ['[', '{', '“', '”', 0],
+		BracketRight: [']', '}', '‘', '’', 0],
+		Backslash: ['\\', '|', '«', '»', 0],
+		Semicolon: [';', ':', '…', 'Ú', 0],
+		Quote: ['\'', '"', 'æ', 'Æ', 0],
+		Backquote: ['`', '~', '`', '`', 4],
+		Comma: [',', '<', '≤', '¯', 0],
+		Period: ['.', '>', '≥', '˘', 0],
+		Slash: ['/', '?', '÷', '¿', 0],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '/', '/', 0],
+		NumpadMultiply: ['*', '*', '*', '*', 0],
+		NumpadSubtract: ['-', '-', '-', '-', 0],
+		NumpadAdd: ['+', '+', '+', '+', 0],
+		NumpadEnter: [],
+		Numpad1: ['1', '1', '1', '1', 0],
+		Numpad2: ['2', '2', '2', '2', 0],
+		Numpad3: ['3', '3', '3', '3', 0],
+		Numpad4: ['4', '4', '4', '4', 0],
+		Numpad5: ['5', '5', '5', '5', 0],
+		Numpad6: ['6', '6', '6', '6', 0],
+		Numpad7: ['7', '7', '7', '7', 0],
+		Numpad8: ['8', '8', '8', '8', 0],
+		Numpad9: ['9', '9', '9', '9', 0],
+		Numpad0: ['0', '0', '0', '0', 0],
+		NumpadDecimal: ['.', '.', '.', '.', 0],
+		IntlBackslash: ['§', '±', '§', '±', 0],
+		ContextMenu: [],
+		NumpadEqual: ['=', '=', '=', '=', 0],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: ['', '=', '', '=', 0],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/ko.darwin.ts

@@ -0,0 +1,132 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { id: 'com.apple.inputmethod.Korean.2SetKorean', lang: 'ko', localizedName: '2-Set Korean' },
+	secondaryLayouts: [],
+	mapping: {
+		KeyA: ['ㅁ', 'ㅁ', 'a', 'A', 0],
+		KeyB: ['ㅠ', 'ㅠ', 'b', 'B', 0],
+		KeyC: ['ㅊ', 'ㅊ', 'c', 'C', 0],
+		KeyD: ['ㅇ', 'ㅇ', 'd', 'D', 0],
+		KeyE: ['ㄷ', 'ㄸ', 'e', 'E', 0],
+		KeyF: ['ㄹ', 'ㄹ', 'f', 'F', 0],
+		KeyG: ['ㅎ', 'ㅎ', 'g', 'G', 0],
+		KeyH: ['ㅗ', 'ㅗ', 'h', 'H', 0],
+		KeyI: ['ㅑ', 'ㅑ', 'i', 'I', 0],
+		KeyJ: ['ㅓ', 'ㅓ', 'j', 'J', 0],
+		KeyK: ['ㅏ', 'ㅏ', 'k', 'K', 0],
+		KeyL: ['ㅣ', 'ㅣ', 'l', 'L', 0],
+		KeyM: ['ㅡ', 'ㅡ', 'm', 'M', 0],
+		KeyN: ['ㅜ', 'ㅜ', 'n', 'N', 0],
+		KeyO: ['ㅐ', 'ㅒ', 'o', 'O', 0],
+		KeyP: ['ㅔ', 'ㅖ', 'p', 'P', 0],
+		KeyQ: ['ㅂ', 'ㅃ', 'q', 'Q', 0],
+		KeyR: ['ㄱ', 'ㄲ', 'r', 'R', 0],
+		KeyS: ['ㄴ', 'ㄴ', 's', 'S', 0],
+		KeyT: ['ㅅ', 'ㅆ', 't', 'T', 0],
+		KeyU: ['ㅕ', 'ㅕ', 'u', 'U', 0],
+		KeyV: ['ㅍ', 'ㅍ', 'v', 'V', 0],
+		KeyW: ['ㅈ', 'ㅉ', 'w', 'W', 0],
+		KeyX: ['ㅌ', 'ㅌ', 'x', 'X', 0],
+		KeyY: ['ㅛ', 'ㅛ', 'y', 'Y', 0],
+		KeyZ: ['ㅋ', 'ㅋ', 'z', 'Z', 0],
+		Digit1: ['1', '!', '1', '!', 0],
+		Digit2: ['2', '@', '2', '@', 0],
+		Digit3: ['3', '#', '3', '#', 0],
+		Digit4: ['4', '$', '4', '$', 0],
+		Digit5: ['5', '%', '5', '%', 0],
+		Digit6: ['6', '^', '6', '^', 0],
+		Digit7: ['7', '&', '7', '&', 0],
+		Digit8: ['8', '*', '8', '*', 0],
+		Digit9: ['9', '(', '9', '(', 0],
+		Digit0: ['0', ')', '0', ')', 0],
+		Enter: [],
+		Escape: ['', '', '', '‌', 0],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', ' ', ' ', 0],
+		Minus: ['-', '_', '-', '_', 0],
+		Equal: ['=', '+', '=', '+', 0],
+		BracketLeft: ['[', '{', '[', '{', 0],
+		BracketRight: [']', '}', ']', '}', 0],
+		Backslash: ['\\', '|', '\\', '|', 0],
+		Semicolon: [';', ':', ';', ':', 0],
+		Quote: ['\'', '"', '\'', '"', 0],
+		Backquote: ['₩', '~', '`', '~', 0],
+		Comma: [',', '<', ',', '<', 0],
+		Period: ['.', '>', '.', '>', 0],
+		Slash: ['/', '?', '/', '?', 0],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '/', '/', 0],
+		NumpadMultiply: ['*', '*', '*', '*', 0],
+		NumpadSubtract: ['-', '-', '-', '-', 0],
+		NumpadAdd: ['+', '+', '+', '+', 0],
+		NumpadEnter: [],
+		Numpad1: ['1', '1', '1', '1', 0],
+		Numpad2: ['2', '2', '2', '2', 0],
+		Numpad3: ['3', '3', '3', '3', 0],
+		Numpad4: ['4', '4', '4', '4', 0],
+		Numpad5: ['5', '5', '5', '5', 0],
+		Numpad6: ['6', '6', '6', '6', 0],
+		Numpad7: ['7', '7', '7', '7', 0],
+		Numpad8: ['8', '8', '8', '8', 0],
+		Numpad9: ['9', '9', '9', '9', 0],
+		Numpad0: ['0', '0', '0', '0', 0],
+		NumpadDecimal: ['.', '.', '.', '.', 0],
+		IntlBackslash: ['§', '±', '§', '±', 0],
+		ContextMenu: [],
+		NumpadEqual: ['=', '=', '=', '=', 0],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: ['', '=', '', '=', 0],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/layout.contribution.darwin.ts

@@ -0,0 +1,23 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/en.darwin'; // 15%
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/zh-hans.darwin';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/en-uk.darwin';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/es.darwin';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/jp-roman.darwin';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/de.darwin';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/en-intl.darwin';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/en-ext.darwin';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/fr.darwin';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/jp.darwin';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/pl.darwin';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/it.darwin';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/ru.darwin';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/pt.darwin';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/ko.darwin';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/dvorak.darwin';
+
+export { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/layout.contribution.linux.ts

@@ -0,0 +1,12 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/en.linux';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/es.linux';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/de.linux';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/fr.linux';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/ru.linux';
+
+export { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/layout.contribution.win.ts

@@ -0,0 +1,29 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/en.win'; // 40%
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/es-latin.win';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/en-in.win';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/de.win';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/en-uk.win';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/fr.win';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/pt-br.win';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/es.win';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/en-intl.win';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/ru.win';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/pl.win';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/it.win';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/sv.win';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/tr.win';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/pt.win';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/dk.win';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/no.win';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/thai.win';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/hu.win';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/de-swiss.win';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/en-belgian.win';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/cz.win';
+
+export { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/no.win.ts

@@ -0,0 +1,169 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { name: '00000414', id: '', text: 'Norwegian' },
+	secondaryLayouts: [],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['a', 'A', '', '', 0, 'VK_A'],
+		KeyB: ['b', 'B', '', '', 0, 'VK_B'],
+		KeyC: ['c', 'C', '', '', 0, 'VK_C'],
+		KeyD: ['d', 'D', '', '', 0, 'VK_D'],
+		KeyE: ['e', 'E', '€', '', 0, 'VK_E'],
+		KeyF: ['f', 'F', '', '', 0, 'VK_F'],
+		KeyG: ['g', 'G', '', '', 0, 'VK_G'],
+		KeyH: ['h', 'H', '', '', 0, 'VK_H'],
+		KeyI: ['i', 'I', '', '', 0, 'VK_I'],
+		KeyJ: ['j', 'J', '', '', 0, 'VK_J'],
+		KeyK: ['k', 'K', '', '', 0, 'VK_K'],
+		KeyL: ['l', 'L', '', '', 0, 'VK_L'],
+		KeyM: ['m', 'M', 'µ', '', 0, 'VK_M'],
+		KeyN: ['n', 'N', '', '', 0, 'VK_N'],
+		KeyO: ['o', 'O', '', '', 0, 'VK_O'],
+		KeyP: ['p', 'P', '', '', 0, 'VK_P'],
+		KeyQ: ['q', 'Q', '', '', 0, 'VK_Q'],
+		KeyR: ['r', 'R', '', '', 0, 'VK_R'],
+		KeyS: ['s', 'S', '', '', 0, 'VK_S'],
+		KeyT: ['t', 'T', '', '', 0, 'VK_T'],
+		KeyU: ['u', 'U', '', '', 0, 'VK_U'],
+		KeyV: ['v', 'V', '', '', 0, 'VK_V'],
+		KeyW: ['w', 'W', '', '', 0, 'VK_W'],
+		KeyX: ['x', 'X', '', '', 0, 'VK_X'],
+		KeyY: ['y', 'Y', '', '', 0, 'VK_Y'],
+		KeyZ: ['z', 'Z', '', '', 0, 'VK_Z'],
+		Digit1: ['1', '!', '', '', 0, 'VK_1'],
+		Digit2: ['2', '"', '@', '', 0, 'VK_2'],
+		Digit3: ['3', '#', '£', '', 0, 'VK_3'],
+		Digit4: ['4', '¤', '$', '', 0, 'VK_4'],
+		Digit5: ['5', '%', '€', '', 0, 'VK_5'],
+		Digit6: ['6', '&', '', '', 0, 'VK_6'],
+		Digit7: ['7', '/', '{', '', 0, 'VK_7'],
+		Digit8: ['8', '(', '[', '', 0, 'VK_8'],
+		Digit9: ['9', ')', ']', '', 0, 'VK_9'],
+		Digit0: ['0', '=', '}', '', 0, 'VK_0'],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', '', '', 0, 'VK_SPACE'],
+		Minus: ['+', '?', '', '', 0, 'VK_OEM_PLUS'],
+		Equal: ['\\', '`', '´', '', 0, 'VK_OEM_4'],
+		BracketLeft: ['å', 'Å', '', '', 0, 'VK_OEM_6'],
+		BracketRight: ['¨', '^', '~', '', 0, 'VK_OEM_1'],
+		Backslash: ['\'', '*', '', '', 0, 'VK_OEM_2'],
+		Semicolon: ['ø', 'Ø', '', '', 0, 'VK_OEM_3'],
+		Quote: ['æ', 'Æ', '', '', 0, 'VK_OEM_7'],
+		Backquote: ['|', '§', '', '', 0, 'VK_OEM_5'],
+		Comma: [',', ';', '', '', 0, 'VK_OEM_COMMA'],
+		Period: ['.', ':', '', '', 0, 'VK_OEM_PERIOD'],
+		Slash: ['-', '_', '', '', 0, 'VK_OEM_MINUS'],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: [],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '', '', 0, 'VK_DIVIDE'],
+		NumpadMultiply: ['*', '*', '', '', 0, 'VK_MULTIPLY'],
+		NumpadSubtract: ['-', '-', '', '', 0, 'VK_SUBTRACT'],
+		NumpadAdd: ['+', '+', '', '', 0, 'VK_ADD'],
+		NumpadEnter: [],
+		Numpad1: [],
+		Numpad2: [],
+		Numpad3: [],
+		Numpad4: [],
+		Numpad5: [],
+		Numpad6: [],
+		Numpad7: [],
+		Numpad8: [],
+		Numpad9: [],
+		Numpad0: [],
+		NumpadDecimal: [],
+		IntlBackslash: ['<', '>', '', '', 0, 'VK_OEM_102'],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: [],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Help: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/pl.darwin.ts

@@ -0,0 +1,132 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { id: 'com.apple.keylayout.PolishPro', lang: 'pl', localizedName: 'Polish - Pro' },
+	secondaryLayouts: [],
+	mapping: {
+		KeyA: ['a', 'A', 'ą', 'Ą', 0],
+		KeyB: ['b', 'B', 'ļ', 'ű', 0],
+		KeyC: ['c', 'C', 'ć', 'Ć', 0],
+		KeyD: ['d', 'D', '∂', 'Ž', 0],
+		KeyE: ['e', 'E', 'ę', 'Ę', 0],
+		KeyF: ['f', 'F', 'ń', 'ž', 0],
+		KeyG: ['g', 'G', '©', 'Ū', 0],
+		KeyH: ['h', 'H', 'ķ', 'Ó', 0],
+		KeyI: ['i', 'I', '^', 'ť', 4],
+		KeyJ: ['j', 'J', '∆', 'Ô', 0],
+		KeyK: ['k', 'K', 'Ż', 'ū', 0],
+		KeyL: ['l', 'L', 'ł', 'Ł', 0],
+		KeyM: ['m', 'M', 'Ķ', 'ų', 0],
+		KeyN: ['n', 'N', 'ń', 'Ń', 0],
+		KeyO: ['o', 'O', 'ó', 'Ó', 0],
+		KeyP: ['p', 'P', 'Ļ', 'ł', 0],
+		KeyQ: ['q', 'Q', 'Ō', 'ő', 0],
+		KeyR: ['r', 'R', '®', '£', 0],
+		KeyS: ['s', 'S', 'ś', 'Ś', 0],
+		KeyT: ['t', 'T', '†', 'ś', 0],
+		KeyU: ['u', 'U', '¨', 'Ť', 4],
+		KeyV: ['v', 'V', '√', '◊', 0],
+		KeyW: ['w', 'W', '∑', '„', 0],
+		KeyX: ['x', 'X', 'ź', 'Ź', 0],
+		KeyY: ['y', 'Y', 'ī', 'Á', 0],
+		KeyZ: ['z', 'Z', 'ż', 'Ż', 0],
+		Digit1: ['1', '!', 'Ń', 'ŕ', 0],
+		Digit2: ['2', '@', '™', 'Ř', 0],
+		Digit3: ['3', '#', '€', '‹', 0],
+		Digit4: ['4', '$', 'ß', '›', 0],
+		Digit5: ['5', '%', 'į', 'ř', 0],
+		Digit6: ['6', '^', '§', 'Ŗ', 0],
+		Digit7: ['7', '&', '¶', 'ŗ', 0],
+		Digit8: ['8', '*', '•', '°', 0],
+		Digit9: ['9', '(', 'Ľ', 'Š', 0],
+		Digit0: ['0', ')', 'ľ', '‚', 0],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', ' ', ' ', 0],
+		Minus: ['-', '_', '–', '—', 0],
+		Equal: ['=', '+', '≠', 'Ī', 0],
+		BracketLeft: ['[', '{', '„', '”', 0],
+		BracketRight: [']', '}', '‚', '’', 0],
+		Backslash: ['\\', '|', '«', '»', 0],
+		Semicolon: [';', ':', '…', 'Ú', 0],
+		Quote: ['\'', '"', 'ĺ', 'ģ', 0],
+		Backquote: ['`', '~', '`', 'Ŕ', 4],
+		Comma: [',', '<', '≤', 'Ý', 0],
+		Period: ['.', '>', '≥', 'ý', 0],
+		Slash: ['/', '?', '÷', 'ņ', 0],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '/', '/', 0],
+		NumpadMultiply: ['*', '*', '*', '*', 0],
+		NumpadSubtract: ['-', '-', '-', '-', 0],
+		NumpadAdd: ['+', '+', '+', '+', 0],
+		NumpadEnter: [],
+		Numpad1: ['1', '1', '1', '1', 0],
+		Numpad2: ['2', '2', '2', '2', 0],
+		Numpad3: ['3', '3', '3', '3', 0],
+		Numpad4: ['4', '4', '4', '4', 0],
+		Numpad5: ['5', '5', '5', '5', 0],
+		Numpad6: ['6', '6', '6', '6', 0],
+		Numpad7: ['7', '7', '7', '7', 0],
+		Numpad8: ['8', '8', '8', '8', 0],
+		Numpad9: ['9', '9', '9', '9', 0],
+		Numpad0: ['0', '0', '0', '0', 0],
+		NumpadDecimal: ['.', '.', '.', '.', 0],
+		IntlBackslash: ['§', '£', '¬', '¬', 0],
+		ContextMenu: [],
+		NumpadEqual: ['=', '=', '=', '=', 0],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: ['', '=', '', '=', 0],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/pl.win.ts

@@ -0,0 +1,169 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { name: '00000415', id: '', text: 'Polish (Programmers)' },
+	secondaryLayouts: [],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['a', 'A', 'ą', 'Ą', 0, 'VK_A'],
+		KeyB: ['b', 'B', '', '', 0, 'VK_B'],
+		KeyC: ['c', 'C', 'ć', 'Ć', 0, 'VK_C'],
+		KeyD: ['d', 'D', '', '', 0, 'VK_D'],
+		KeyE: ['e', 'E', 'ę', 'Ę', 0, 'VK_E'],
+		KeyF: ['f', 'F', '', '', 0, 'VK_F'],
+		KeyG: ['g', 'G', '', '', 0, 'VK_G'],
+		KeyH: ['h', 'H', '', '', 0, 'VK_H'],
+		KeyI: ['i', 'I', '', '', 0, 'VK_I'],
+		KeyJ: ['j', 'J', '', '', 0, 'VK_J'],
+		KeyK: ['k', 'K', '', '', 0, 'VK_K'],
+		KeyL: ['l', 'L', 'ł', 'Ł', 0, 'VK_L'],
+		KeyM: ['m', 'M', '', '', 0, 'VK_M'],
+		KeyN: ['n', 'N', 'ń', 'Ń', 0, 'VK_N'],
+		KeyO: ['o', 'O', 'ó', 'Ó', 0, 'VK_O'],
+		KeyP: ['p', 'P', '', '', 0, 'VK_P'],
+		KeyQ: ['q', 'Q', '', '', 0, 'VK_Q'],
+		KeyR: ['r', 'R', '', '', 0, 'VK_R'],
+		KeyS: ['s', 'S', 'ś', 'Ś', 0, 'VK_S'],
+		KeyT: ['t', 'T', '', '', 0, 'VK_T'],
+		KeyU: ['u', 'U', '€', '', 0, 'VK_U'],
+		KeyV: ['v', 'V', '', '', 0, 'VK_V'],
+		KeyW: ['w', 'W', '', '', 0, 'VK_W'],
+		KeyX: ['x', 'X', 'ź', 'Ź', 0, 'VK_X'],
+		KeyY: ['y', 'Y', '', '', 0, 'VK_Y'],
+		KeyZ: ['z', 'Z', 'ż', 'Ż', 0, 'VK_Z'],
+		Digit1: ['1', '!', '', '', 0, 'VK_1'],
+		Digit2: ['2', '@', '', '', 0, 'VK_2'],
+		Digit3: ['3', '#', '', '', 0, 'VK_3'],
+		Digit4: ['4', '$', '', '', 0, 'VK_4'],
+		Digit5: ['5', '%', '', '', 0, 'VK_5'],
+		Digit6: ['6', '^', '', '', 0, 'VK_6'],
+		Digit7: ['7', '&', '', '', 0, 'VK_7'],
+		Digit8: ['8', '*', '', '', 0, 'VK_8'],
+		Digit9: ['9', '(', '', '', 0, 'VK_9'],
+		Digit0: ['0', ')', '', '', 0, 'VK_0'],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', '', '', 0, 'VK_SPACE'],
+		Minus: ['-', '_', '', '', 0, 'VK_OEM_MINUS'],
+		Equal: ['=', '+', '', '', 0, 'VK_OEM_PLUS'],
+		BracketLeft: ['[', '{', '', '', 0, 'VK_OEM_4'],
+		BracketRight: [']', '}', '', '', 0, 'VK_OEM_6'],
+		Backslash: ['\\', '|', '', '', 0, 'VK_OEM_5'],
+		Semicolon: [';', ':', '', '', 0, 'VK_OEM_1'],
+		Quote: ['\'', '"', '', '', 0, 'VK_OEM_7'],
+		Backquote: ['`', '~', '', '', 0, 'VK_OEM_3'],
+		Comma: [',', '<', '', '', 0, 'VK_OEM_COMMA'],
+		Period: ['.', '>', '', '', 0, 'VK_OEM_PERIOD'],
+		Slash: ['/', '?', '', '', 0, 'VK_OEM_2'],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: [],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '', '', 0, 'VK_DIVIDE'],
+		NumpadMultiply: ['*', '*', '', '', 0, 'VK_MULTIPLY'],
+		NumpadSubtract: ['-', '-', '', '', 0, 'VK_SUBTRACT'],
+		NumpadAdd: ['+', '+', '', '', 0, 'VK_ADD'],
+		NumpadEnter: [],
+		Numpad1: [],
+		Numpad2: [],
+		Numpad3: [],
+		Numpad4: [],
+		Numpad5: [],
+		Numpad6: [],
+		Numpad7: [],
+		Numpad8: [],
+		Numpad9: [],
+		Numpad0: [],
+		NumpadDecimal: [],
+		IntlBackslash: ['\\', '|', '', '', 0, 'VK_OEM_102'],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: [],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Help: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/pt-br.win.ts

@@ -0,0 +1,170 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { name: '00000416', id: '', text: 'Portuguese (Brazilian ABNT)' },
+	secondaryLayouts: [],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['a', 'A', '', '', 0, 'VK_A'],
+		KeyB: ['b', 'B', '', '', 0, 'VK_B'],
+		KeyC: ['c', 'C', '₢', '', 0, 'VK_C'],
+		KeyD: ['d', 'D', '', '', 0, 'VK_D'],
+		KeyE: ['e', 'E', '°', '', 0, 'VK_E'],
+		KeyF: ['f', 'F', '', '', 0, 'VK_F'],
+		KeyG: ['g', 'G', '', '', 0, 'VK_G'],
+		KeyH: ['h', 'H', '', '', 0, 'VK_H'],
+		KeyI: ['i', 'I', '', '', 0, 'VK_I'],
+		KeyJ: ['j', 'J', '', '', 0, 'VK_J'],
+		KeyK: ['k', 'K', '', '', 0, 'VK_K'],
+		KeyL: ['l', 'L', '', '', 0, 'VK_L'],
+		KeyM: ['m', 'M', '', '', 0, 'VK_M'],
+		KeyN: ['n', 'N', '', '', 0, 'VK_N'],
+		KeyO: ['o', 'O', '', '', 0, 'VK_O'],
+		KeyP: ['p', 'P', '', '', 0, 'VK_P'],
+		KeyQ: ['q', 'Q', '/', '', 0, 'VK_Q'],
+		KeyR: ['r', 'R', '', '', 0, 'VK_R'],
+		KeyS: ['s', 'S', '', '', 0, 'VK_S'],
+		KeyT: ['t', 'T', '', '', 0, 'VK_T'],
+		KeyU: ['u', 'U', '', '', 0, 'VK_U'],
+		KeyV: ['v', 'V', '', '', 0, 'VK_V'],
+		KeyW: ['w', 'W', '?', '', 0, 'VK_W'],
+		KeyX: ['x', 'X', '', '', 0, 'VK_X'],
+		KeyY: ['y', 'Y', '', '', 0, 'VK_Y'],
+		KeyZ: ['z', 'Z', '', '', 0, 'VK_Z'],
+		Digit1: ['1', '!', '¹', '', 0, 'VK_1'],
+		Digit2: ['2', '@', '²', '', 0, 'VK_2'],
+		Digit3: ['3', '#', '³', '', 0, 'VK_3'],
+		Digit4: ['4', '$', '£', '', 0, 'VK_4'],
+		Digit5: ['5', '%', '¢', '', 0, 'VK_5'],
+		Digit6: ['6', '¨', '¬', '', 0, 'VK_6'],
+		Digit7: ['7', '&', '', '', 0, 'VK_7'],
+		Digit8: ['8', '*', '', '', 0, 'VK_8'],
+		Digit9: ['9', '(', '', '', 0, 'VK_9'],
+		Digit0: ['0', ')', '', '', 0, 'VK_0'],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', '', '', 0, 'VK_SPACE'],
+		Minus: ['-', '_', '', '', 0, 'VK_OEM_MINUS'],
+		Equal: ['=', '+', '§', '', 0, 'VK_OEM_PLUS'],
+		BracketLeft: ['´', '`', '', '', 0, 'VK_OEM_4'],
+		BracketRight: ['[', '{', 'ª', '', 0, 'VK_OEM_6'],
+		Backslash: [']', '}', 'º', '', 0, 'VK_OEM_5'],
+		Semicolon: ['ç', 'Ç', '', '', 0, 'VK_OEM_1'],
+		Quote: ['~', '^', '', '', 0, 'VK_OEM_7'],
+		Backquote: ['\'', '"', '', '', 0, 'VK_OEM_3'],
+		Comma: [',', '<', '', '', 0, 'VK_OEM_COMMA'],
+		Period: ['.', '>', '', '', 0, 'VK_OEM_PERIOD'],
+		Slash: [';', ':', '', '', 0, 'VK_OEM_2'],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: [],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '', '', 0, 'VK_DIVIDE'],
+		NumpadMultiply: ['*', '*', '', '', 0, 'VK_MULTIPLY'],
+		NumpadSubtract: ['-', '-', '', '', 0, 'VK_SUBTRACT'],
+		NumpadAdd: ['+', '+', '', '', 0, 'VK_ADD'],
+		NumpadEnter: [],
+		Numpad1: [],
+		Numpad2: [],
+		Numpad3: [],
+		Numpad4: [],
+		Numpad5: [],
+		Numpad6: [],
+		Numpad7: [],
+		Numpad8: [],
+		Numpad9: [],
+		Numpad0: [],
+		NumpadDecimal: [],
+		IntlBackslash: ['\\', '|', '', '', 0, 'VK_OEM_102'],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: [],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Help: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: ['.', '.', '', '', 0, 'VK_ABNT_C2'],
+		IntlRo: ['/', '?', '°', '', 0, 'VK_ABNT_C1'],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/pt.darwin.ts

@@ -0,0 +1,132 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { id: 'com.apple.keylayout.Brazilian-Pro', lang: 'pt' },
+	secondaryLayouts: [],
+	mapping: {
+		KeyA: ['a', 'A', 'å', 'Å', 0],
+		KeyB: ['b', 'B', '∫', 'ı', 0],
+		KeyC: ['c', 'C', 'ç', 'Ç', 0],
+		KeyD: ['d', 'D', '∂', 'Î', 0],
+		KeyE: ['e', 'E', '´', '´', 4],
+		KeyF: ['f', 'F', 'ƒ', 'Ï', 0],
+		KeyG: ['g', 'G', '©', '˝', 0],
+		KeyH: ['h', 'H', '˙', 'Ó', 0],
+		KeyI: ['i', 'I', 'ˆ', 'ˆ', 4],
+		KeyJ: ['j', 'J', '∆', 'Ô', 0],
+		KeyK: ['k', 'K', '˚', '', 0],
+		KeyL: ['l', 'L', '¬', 'Ò', 0],
+		KeyM: ['m', 'M', 'µ', 'Â', 0],
+		KeyN: ['n', 'N', '˜', '˜', 4],
+		KeyO: ['o', 'O', 'ø', 'Ø', 0],
+		KeyP: ['p', 'P', 'π', '∏', 0],
+		KeyQ: ['q', 'Q', 'œ', 'Œ', 0],
+		KeyR: ['r', 'R', '®', '‰', 0],
+		KeyS: ['s', 'S', 'ß', 'Í', 0],
+		KeyT: ['t', 'T', '†', 'ˇ', 0],
+		KeyU: ['u', 'U', '¨', '¨', 4],
+		KeyV: ['v', 'V', '√', '◊', 0],
+		KeyW: ['w', 'W', '∑', '„', 0],
+		KeyX: ['x', 'X', '≈', '˛', 0],
+		KeyY: ['y', 'Y', '¥', 'Á', 0],
+		KeyZ: ['z', 'Z', 'Ω', '¸', 0],
+		Digit1: ['1', '!', '¡', '⁄', 0],
+		Digit2: ['2', '@', '™', '€', 0],
+		Digit3: ['3', '#', '£', '‹', 0],
+		Digit4: ['4', '$', '¢', '›', 0],
+		Digit5: ['5', '%', '∞', 'fi', 0],
+		Digit6: ['6', 'ˆ', '§', 'fl', 2],
+		Digit7: ['7', '&', '¶', '‡', 0],
+		Digit8: ['8', '*', '•', '°', 0],
+		Digit9: ['9', '(', 'ª', '·', 0],
+		Digit0: ['0', ')', 'º', '‚', 0],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', ' ', ' ', 0],
+		Minus: ['-', '_', '–', '—', 0],
+		Equal: ['=', '+', '≠', '±', 0],
+		BracketLeft: ['[', '{', '“', '”', 0],
+		BracketRight: [']', '}', '‘', '’', 0],
+		Backslash: ['\\', '|', '«', '»', 0],
+		Semicolon: [';', ':', '…', 'Ú', 0],
+		Quote: ['\'', '"', 'æ', 'Æ', 3],
+		Backquote: ['`', '˜', '`', '`', 7],
+		Comma: [',', '<', '≤', '¯', 0],
+		Period: ['.', '>', '≥', '˘', 0],
+		Slash: ['/', '?', '÷', '¿', 0],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '/', '/', 0],
+		NumpadMultiply: ['*', '*', '*', '*', 0],
+		NumpadSubtract: ['-', '-', '-', '-', 0],
+		NumpadAdd: ['+', '+', '+', '+', 0],
+		NumpadEnter: [],
+		Numpad1: ['1', '1', '1', '1', 0],
+		Numpad2: ['2', '2', '2', '2', 0],
+		Numpad3: ['3', '3', '3', '3', 0],
+		Numpad4: ['4', '4', '4', '4', 0],
+		Numpad5: ['5', '5', '5', '5', 0],
+		Numpad6: ['6', '6', '6', '6', 0],
+		Numpad7: ['7', '7', '7', '7', 0],
+		Numpad8: ['8', '8', '8', '8', 0],
+		Numpad9: ['9', '9', '9', '9', 0],
+		Numpad0: ['0', '0', '0', '0', 0],
+		NumpadDecimal: ['.', '.', '.', '.', 0],
+		IntlBackslash: ['§', '±', '§', '±', 0],
+		ContextMenu: [],
+		NumpadEqual: ['=', '=', '=', '=', 0],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: ['', '=', '', '=', 0],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/pt.win.ts

@@ -0,0 +1,170 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { name: '00000816', id: '', text: 'Portuguese' },
+	secondaryLayouts: [],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['a', 'A', '', '', 0, 'VK_A'],
+		KeyB: ['b', 'B', '', '', 0, 'VK_B'],
+		KeyC: ['c', 'C', '', '', 0, 'VK_C'],
+		KeyD: ['d', 'D', '', '', 0, 'VK_D'],
+		KeyE: ['e', 'E', '€', '', 0, 'VK_E'],
+		KeyF: ['f', 'F', '', '', 0, 'VK_F'],
+		KeyG: ['g', 'G', '', '', 0, 'VK_G'],
+		KeyH: ['h', 'H', '', '', 0, 'VK_H'],
+		KeyI: ['i', 'I', '', '', 0, 'VK_I'],
+		KeyJ: ['j', 'J', '', '', 0, 'VK_J'],
+		KeyK: ['k', 'K', '', '', 0, 'VK_K'],
+		KeyL: ['l', 'L', '', '', 0, 'VK_L'],
+		KeyM: ['m', 'M', '', '', 0, 'VK_M'],
+		KeyN: ['n', 'N', '', '', 0, 'VK_N'],
+		KeyO: ['o', 'O', '', '', 0, 'VK_O'],
+		KeyP: ['p', 'P', '', '', 0, 'VK_P'],
+		KeyQ: ['q', 'Q', '', '', 0, 'VK_Q'],
+		KeyR: ['r', 'R', '', '', 0, 'VK_R'],
+		KeyS: ['s', 'S', '', '', 0, 'VK_S'],
+		KeyT: ['t', 'T', '', '', 0, 'VK_T'],
+		KeyU: ['u', 'U', '', '', 0, 'VK_U'],
+		KeyV: ['v', 'V', '', '', 0, 'VK_V'],
+		KeyW: ['w', 'W', '', '', 0, 'VK_W'],
+		KeyX: ['x', 'X', '', '', 0, 'VK_X'],
+		KeyY: ['y', 'Y', '', '', 0, 'VK_Y'],
+		KeyZ: ['z', 'Z', '', '', 0, 'VK_Z'],
+		Digit1: ['1', '!', '', '', 0, 'VK_1'],
+		Digit2: ['2', '"', '@', '', 0, 'VK_2'],
+		Digit3: ['3', '#', '£', '', 0, 'VK_3'],
+		Digit4: ['4', '$', '§', '', 0, 'VK_4'],
+		Digit5: ['5', '%', '€', '', 0, 'VK_5'],
+		Digit6: ['6', '&', '', '', 0, 'VK_6'],
+		Digit7: ['7', '/', '{', '', 0, 'VK_7'],
+		Digit8: ['8', '(', '[', '', 0, 'VK_8'],
+		Digit9: ['9', ')', ']', '', 0, 'VK_9'],
+		Digit0: ['0', '=', '}', '', 0, 'VK_0'],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', '', '', 0, 'VK_SPACE'],
+		Minus: ['\'', '?', '', '', 0, 'VK_OEM_4'],
+		Equal: ['«', '»', '', '', 0, 'VK_OEM_6'],
+		BracketLeft: ['+', '*', '¨', '', 0, 'VK_OEM_PLUS'],
+		BracketRight: ['´', '`', ']', '', 0, 'VK_OEM_1'],
+		Backslash: ['~', '^', '', '', 0, 'VK_OEM_2'],
+		Semicolon: ['ç', 'Ç', '', '', 0, 'VK_OEM_3'],
+		Quote: ['º', 'ª', '', '', 0, 'VK_OEM_7'],
+		Backquote: ['\\', '|', '', '', 0, 'VK_OEM_5'],
+		Comma: [',', ';', '', '', 0, 'VK_OEM_COMMA'],
+		Period: ['.', ':', '', '', 0, 'VK_OEM_PERIOD'],
+		Slash: ['-', '_', '', '', 0, 'VK_OEM_MINUS'],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: [],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '', '', 0, 'VK_DIVIDE'],
+		NumpadMultiply: ['*', '*', '', '', 0, 'VK_MULTIPLY'],
+		NumpadSubtract: ['-', '-', '', '', 0, 'VK_SUBTRACT'],
+		NumpadAdd: ['+', '+', '', '', 0, 'VK_ADD'],
+		NumpadEnter: [],
+		Numpad1: [],
+		Numpad2: [],
+		Numpad3: [],
+		Numpad4: [],
+		Numpad5: [],
+		Numpad6: [],
+		Numpad7: [],
+		Numpad8: [],
+		Numpad9: [],
+		Numpad0: [],
+		NumpadDecimal: [],
+		IntlBackslash: ['<', '>', '', '', 0, 'VK_OEM_102'],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: [],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Help: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: []
+	}
+
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/ru.darwin.ts

@@ -0,0 +1,132 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { id: 'com.apple.keylayout.Russian', lang: 'ru', localizedName: 'Russian' },
+	secondaryLayouts: [],
+	mapping: {
+		KeyA: ['ф', 'Ф', 'ƒ', 'ƒ', 0],
+		KeyB: ['и', 'И', 'и', 'И', 0],
+		KeyC: ['с', 'С', '≠', '≠', 0],
+		KeyD: ['в', 'В', 'ћ', 'Ћ', 0],
+		KeyE: ['у', 'У', 'ќ', 'Ќ', 0],
+		KeyF: ['а', 'А', '÷', '÷', 0],
+		KeyG: ['п', 'П', '©', '©', 0],
+		KeyH: ['р', 'Р', '₽', '₽', 0],
+		KeyI: ['ш', 'Ш', 'ѕ', 'Ѕ', 0],
+		KeyJ: ['о', 'О', '°', '•', 0],
+		KeyK: ['л', 'Л', 'љ', 'Љ', 0],
+		KeyL: ['д', 'Д', '∆', '∆', 0],
+		KeyM: ['ь', 'Ь', '~', '~', 0],
+		KeyN: ['т', 'Т', '™', '™', 0],
+		KeyO: ['щ', 'Щ', 'ў', 'Ў', 0],
+		KeyP: ['з', 'З', '‘', '’', 0],
+		KeyQ: ['й', 'Й', 'ј', 'Ј', 0],
+		KeyR: ['к', 'К', '®', '®', 0],
+		KeyS: ['ы', 'Ы', 'ы', 'Ы', 0],
+		KeyT: ['е', 'Е', '†', '†', 0],
+		KeyU: ['г', 'Г', 'ѓ', 'Ѓ', 0],
+		KeyV: ['м', 'М', 'µ', 'µ', 0],
+		KeyW: ['ц', 'Ц', 'џ', 'Џ', 0],
+		KeyX: ['ч', 'Ч', '≈', '≈', 0],
+		KeyY: ['н', 'Н', 'њ', 'Њ', 0],
+		KeyZ: ['я', 'Я', 'ђ', 'Ђ', 0],
+		Digit1: ['1', '!', '!', '|', 0],
+		Digit2: ['2', '"', '@', '"', 0],
+		Digit3: ['3', '№', '#', '£', 0],
+		Digit4: ['4', '%', '$', '€', 0],
+		Digit5: ['5', ':', '%', '∞', 0],
+		Digit6: ['6', ',', '^', '¬', 0],
+		Digit7: ['7', '.', '&', '¶', 0],
+		Digit8: ['8', ';', '*', '√', 0],
+		Digit9: ['9', '(', '{', '\'', 0],
+		Digit0: ['0', ')', '}', '`', 0],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', ' ', ' ', 0],
+		Minus: ['-', '_', '–', '—', 0],
+		Equal: ['=', '+', '»', '«', 0],
+		BracketLeft: ['х', 'Х', '“', '”', 0],
+		BracketRight: ['ъ', 'Ъ', 'ъ', 'Ъ', 0],
+		Backslash: ['ё', 'Ё', 'ё', 'Ё', 0],
+		Semicolon: ['ж', 'Ж', '…', '…', 0],
+		Quote: ['э', 'Э', 'э', 'Э', 0],
+		Backquote: [']', '[', ']', '[', 0],
+		Comma: ['б', 'Б', '≤', '<', 0],
+		Period: ['ю', 'Ю', '≥', '>', 0],
+		Slash: ['/', '?', '“', '„', 0],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '/', '/', 0],
+		NumpadMultiply: ['*', '*', '*', '*', 0],
+		NumpadSubtract: ['-', '-', '-', '-', 0],
+		NumpadAdd: ['+', '+', '+', '+', 0],
+		NumpadEnter: [],
+		Numpad1: ['1', '1', '1', '1', 0],
+		Numpad2: ['2', '2', '2', '2', 0],
+		Numpad3: ['3', '3', '3', '3', 0],
+		Numpad4: ['4', '4', '4', '4', 0],
+		Numpad5: ['5', '5', '5', '5', 0],
+		Numpad6: ['6', '6', '6', '6', 0],
+		Numpad7: ['7', '7', '7', '7', 0],
+		Numpad8: ['8', '8', '8', '8', 0],
+		Numpad9: ['9', '9', '9', '9', 0],
+		Numpad0: ['0', '0', '0', '0', 0],
+		NumpadDecimal: [',', '.', ',', ',', 0],
+		IntlBackslash: ['>', '<', '§', '±', 0],
+		ContextMenu: [],
+		NumpadEqual: ['=', '=', '=', '=', 0],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: ['', '=', '', '', 0],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/ru.linux.ts

@@ -0,0 +1,187 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { model: 'pc104', layout: 'ru', variant: ',', options: '', rules: 'base' },
+	secondaryLayouts: [],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['ф', 'Ф', 'ф', 'Ф', 0],
+		KeyB: ['и', 'И', 'и', 'И', 0],
+		KeyC: ['с', 'С', 'с', 'С', 0],
+		KeyD: ['в', 'В', 'в', 'В', 0],
+		KeyE: ['у', 'У', 'у', 'У', 0],
+		KeyF: ['а', 'А', 'а', 'А', 0],
+		KeyG: ['п', 'П', 'п', 'П', 0],
+		KeyH: ['р', 'Р', 'р', 'Р', 0],
+		KeyI: ['ш', 'Ш', 'ш', 'Ш', 0],
+		KeyJ: ['о', 'О', 'о', 'О', 0],
+		KeyK: ['л', 'Л', 'л', 'Л', 0],
+		KeyL: ['д', 'Д', 'д', 'Д', 0],
+		KeyM: ['ь', 'Ь', 'ь', 'Ь', 0],
+		KeyN: ['т', 'Т', 'т', 'Т', 0],
+		KeyO: ['щ', 'Щ', 'щ', 'Щ', 0],
+		KeyP: ['з', 'З', 'з', 'З', 0],
+		KeyQ: ['й', 'Й', 'й', 'Й', 0],
+		KeyR: ['к', 'К', 'к', 'К', 0],
+		KeyS: ['ы', 'Ы', 'ы', 'Ы', 0],
+		KeyT: ['е', 'Е', 'е', 'Е', 0],
+		KeyU: ['г', 'Г', 'г', 'Г', 0],
+		KeyV: ['м', 'М', 'м', 'М', 0],
+		KeyW: ['ц', 'Ц', 'ц', 'Ц', 0],
+		KeyX: ['ч', 'Ч', 'ч', 'Ч', 0],
+		KeyY: ['н', 'Н', 'н', 'Н', 0],
+		KeyZ: ['я', 'Я', 'я', 'Я', 0],
+		Digit1: ['1', '!', '1', '!', 0],
+		Digit2: ['2', '"', '2', '"', 0],
+		Digit3: ['3', '№', '3', '№', 0],
+		Digit4: ['4', ';', '4', ';', 0],
+		Digit5: ['5', '%', '5', '%', 0],
+		Digit6: ['6', ':', '6', ':', 0],
+		Digit7: ['7', '?', '7', '?', 0],
+		Digit8: ['8', '*', '₽', '', 0],
+		Digit9: ['9', '(', '9', '(', 0],
+		Digit0: ['0', ')', '0', ')', 0],
+		Enter: ['\r', '\r', '\r', '\r', 0],
+		Escape: ['\u001b', '\u001b', '\u001b', '\u001b', 0],
+		Backspace: ['\b', '\b', '\b', '\b', 0],
+		Tab: ['\t', '', '\t', '', 0],
+		Space: [' ', ' ', ' ', ' ', 0],
+		Minus: ['-', '_', '-', '_', 0],
+		Equal: ['=', '+', '=', '+', 0],
+		BracketLeft: ['х', 'Х', 'х', 'Х', 0],
+		BracketRight: ['ъ', 'Ъ', 'ъ', 'Ъ', 0],
+		Backslash: ['\\', '/', '\\', '/', 0],
+		Semicolon: ['ж', 'Ж', 'ж', 'Ж', 0],
+		Quote: ['э', 'Э', 'э', 'Э', 0],
+		Backquote: ['ё', 'Ё', 'ё', 'Ё', 0],
+		Comma: ['б', 'Б', 'б', 'Б', 0],
+		Period: ['ю', 'Ю', 'ю', 'Ю', 0],
+		Slash: ['.', ',', '.', ',', 0],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: ['', '', '', '', 0],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: ['/', '/', '/', '/', 0],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: [],
+		NumpadMultiply: ['*', '*', '*', '*', 0],
+		NumpadSubtract: ['-', '-', '-', '-', 0],
+		NumpadAdd: ['+', '+', '+', '+', 0],
+		NumpadEnter: [],
+		Numpad1: ['', '1', '', '1', 0],
+		Numpad2: ['', '2', '', '2', 0],
+		Numpad3: ['', '3', '', '3', 0],
+		Numpad4: ['', '4', '', '4', 0],
+		Numpad5: ['', '5', '', '5', 0],
+		Numpad6: ['', '6', '', '6', 0],
+		Numpad7: ['', '7', '', '7', 0],
+		Numpad8: ['', '8', '', '8', 0],
+		Numpad9: ['', '9', '', '9', 0],
+		Numpad0: ['', '0', '', '0', 0],
+		NumpadDecimal: ['', ',', '', ',', 0],
+		IntlBackslash: ['/', '|', '|', '¦', 0],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: [],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Open: [],
+		Help: [],
+		Select: [],
+		Again: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		Find: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		Lang5: [],
+		NumpadParenLeft: [],
+		NumpadParenRight: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: ['\r', '\r', '\r', '\r', 0],
+		MetaRight: ['.', '.', '.', '.', 0],
+		BrightnessUp: [],
+		BrightnessDown: [],
+		MediaPlay: [],
+		MediaRecord: [],
+		MediaFastForward: [],
+		MediaRewind: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		SelectTask: [],
+		LaunchScreenSaver: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: [],
+		MailReply: [],
+		MailForward: [],
+		MailSend: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/ru.win.ts

@@ -0,0 +1,169 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { name: '00000419', id: '', text: 'Russian' },
+	secondaryLayouts: [],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['ф', 'Ф', '', '', 0, 'VK_A'],
+		KeyB: ['и', 'И', '', '', 0, 'VK_B'],
+		KeyC: ['с', 'С', '', '', 0, 'VK_C'],
+		KeyD: ['в', 'В', '', '', 0, 'VK_D'],
+		KeyE: ['у', 'У', '', '', 0, 'VK_E'],
+		KeyF: ['а', 'А', '', '', 0, 'VK_F'],
+		KeyG: ['п', 'П', '', '', 0, 'VK_G'],
+		KeyH: ['р', 'Р', '', '', 0, 'VK_H'],
+		KeyI: ['ш', 'Ш', '', '', 0, 'VK_I'],
+		KeyJ: ['о', 'О', '', '', 0, 'VK_J'],
+		KeyK: ['л', 'Л', '', '', 0, 'VK_K'],
+		KeyL: ['д', 'Д', '', '', 0, 'VK_L'],
+		KeyM: ['ь', 'Ь', '', '', 0, 'VK_M'],
+		KeyN: ['т', 'Т', '', '', 0, 'VK_N'],
+		KeyO: ['щ', 'Щ', '', '', 0, 'VK_O'],
+		KeyP: ['з', 'З', '', '', 0, 'VK_P'],
+		KeyQ: ['й', 'Й', '', '', 0, 'VK_Q'],
+		KeyR: ['к', 'К', '', '', 0, 'VK_R'],
+		KeyS: ['ы', 'Ы', '', '', 0, 'VK_S'],
+		KeyT: ['е', 'Е', '', '', 0, 'VK_T'],
+		KeyU: ['г', 'Г', '', '', 0, 'VK_U'],
+		KeyV: ['м', 'М', '', '', 0, 'VK_V'],
+		KeyW: ['ц', 'Ц', '', '', 0, 'VK_W'],
+		KeyX: ['ч', 'Ч', '', '', 0, 'VK_X'],
+		KeyY: ['н', 'Н', '', '', 0, 'VK_Y'],
+		KeyZ: ['я', 'Я', '', '', 0, 'VK_Z'],
+		Digit1: ['1', '!', '', '', 0, 'VK_1'],
+		Digit2: ['2', '"', '', '', 0, 'VK_2'],
+		Digit3: ['3', '№', '', '', 0, 'VK_3'],
+		Digit4: ['4', ';', '', '', 0, 'VK_4'],
+		Digit5: ['5', '%', '', '', 0, 'VK_5'],
+		Digit6: ['6', ':', '', '', 0, 'VK_6'],
+		Digit7: ['7', '?', '', '', 0, 'VK_7'],
+		Digit8: ['8', '*', '₽', '', 0, 'VK_8'],
+		Digit9: ['9', '(', '', '', 0, 'VK_9'],
+		Digit0: ['0', ')', '', '', 0, 'VK_0'],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', '', '', 0, 'VK_SPACE'],
+		Minus: ['-', '_', '', '', 0, 'VK_OEM_MINUS'],
+		Equal: ['=', '+', '', '', 0, 'VK_OEM_PLUS'],
+		BracketLeft: ['х', 'Х', '', '', 0, 'VK_OEM_4'],
+		BracketRight: ['ъ', 'Ъ', '', '', 0, 'VK_OEM_6'],
+		Backslash: ['\\', '/', '', '', 0, 'VK_OEM_5'],
+		Semicolon: ['ж', 'Ж', '', '', 0, 'VK_OEM_1'],
+		Quote: ['э', 'Э', '', '', 0, 'VK_OEM_7'],
+		Backquote: ['ё', 'Ё', '', '', 0, 'VK_OEM_3'],
+		Comma: ['б', 'Б', '', '', 0, 'VK_OEM_COMMA'],
+		Period: ['ю', 'Ю', '', '', 0, 'VK_OEM_PERIOD'],
+		Slash: ['.', ',', '', '', 0, 'VK_OEM_2'],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: [],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '', '', 0, 'VK_DIVIDE'],
+		NumpadMultiply: ['*', '*', '', '', 0, 'VK_MULTIPLY'],
+		NumpadSubtract: ['-', '-', '', '', 0, 'VK_SUBTRACT'],
+		NumpadAdd: ['+', '+', '', '', 0, 'VK_ADD'],
+		NumpadEnter: [],
+		Numpad1: [],
+		Numpad2: [],
+		Numpad3: [],
+		Numpad4: [],
+		Numpad5: [],
+		Numpad6: [],
+		Numpad7: [],
+		Numpad8: [],
+		Numpad9: [],
+		Numpad0: [],
+		NumpadDecimal: [],
+		IntlBackslash: ['\\', '/', '', '', 0, 'VK_OEM_102'],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: [],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Help: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/sv.darwin.ts

@@ -0,0 +1,132 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { id: 'com.apple.keylayout.Swedish-Pro', lang: 'sv', localizedName: 'Swedish - Pro' },
+	secondaryLayouts: [],
+	mapping: {
+		KeyA: ['a', 'A', '', '◊', 0],
+		KeyB: ['b', 'B', '›', '»', 0],
+		KeyC: ['c', 'C', 'ç', 'Ç', 0],
+		KeyD: ['d', 'D', '∂', '∆', 0],
+		KeyE: ['e', 'E', 'é', 'É', 0],
+		KeyF: ['f', 'F', 'ƒ', '∫', 0],
+		KeyG: ['g', 'G', '¸', '¯', 0],
+		KeyH: ['h', 'H', '˛', '˘', 0],
+		KeyI: ['i', 'I', 'ı', 'ˆ', 0],
+		KeyJ: ['j', 'J', '√', '¬', 0],
+		KeyK: ['k', 'K', 'ª', 'º', 0],
+		KeyL: ['l', 'L', 'fi', 'fl', 0],
+		KeyM: ['m', 'M', '’', '”', 0],
+		KeyN: ['n', 'N', '‘', '“', 0],
+		KeyO: ['o', 'O', 'œ', 'Œ', 0],
+		KeyP: ['p', 'P', 'π', '∏', 0],
+		KeyQ: ['q', 'Q', '•', '°', 0],
+		KeyR: ['r', 'R', '®', '√', 0],
+		KeyS: ['s', 'S', 'ß', '∑', 0],
+		KeyT: ['t', 'T', '†', '‡', 0],
+		KeyU: ['u', 'U', 'ü', 'Ü', 0],
+		KeyV: ['v', 'V', '‹', '«', 0],
+		KeyW: ['w', 'W', 'Ω', '˝', 0],
+		KeyX: ['x', 'X', '≈', 'ˇ', 0],
+		KeyY: ['y', 'Y', 'µ', '˜', 0],
+		KeyZ: ['z', 'Z', '÷', '⁄', 0],
+		Digit1: ['1', '!', '©', '¡', 0],
+		Digit2: ['2', '"', '@', '”', 0],
+		Digit3: ['3', '#', '£', '¥', 0],
+		Digit4: ['4', '€', '$', '¢', 0],
+		Digit5: ['5', '%', '∞', '‰', 0],
+		Digit6: ['6', '&', '§', '¶', 0],
+		Digit7: ['7', '/', '|', '\\', 0],
+		Digit8: ['8', '(', '[', '{', 0],
+		Digit9: ['9', ')', ']', '}', 0],
+		Digit0: ['0', '=', '≈', '≠', 0],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', ' ', ' ', 0],
+		Minus: ['+', '?', '±', '¿', 0],
+		Equal: ['´', '`', '´', '`', 3],
+		BracketLeft: ['å', 'Å', '˙', '˚', 0],
+		BracketRight: ['¨', '^', '~', '^', 7],
+		Backslash: ['\'', '*', '™', '’', 0],
+		Semicolon: ['ö', 'Ö', 'ø', 'Ø', 0],
+		Quote: ['ä', 'Ä', 'æ', 'Æ', 0],
+		Backquote: ['<', '>', '≤', '≥', 0],
+		Comma: [',', ';', '‚', '„', 0],
+		Period: ['.', ':', '…', '·', 0],
+		Slash: ['-', '_', '–', '—', 0],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '/', '/', 0],
+		NumpadMultiply: ['*', '*', '*', '*', 0],
+		NumpadSubtract: ['-', '-', '-', '-', 0],
+		NumpadAdd: ['+', '+', '+', '+', 0],
+		NumpadEnter: [],
+		Numpad1: ['1', '1', '1', '1', 0],
+		Numpad2: ['2', '2', '2', '2', 0],
+		Numpad3: ['3', '3', '3', '3', 0],
+		Numpad4: ['4', '4', '4', '4', 0],
+		Numpad5: ['5', '5', '5', '5', 0],
+		Numpad6: ['6', '6', '6', '6', 0],
+		Numpad7: ['7', '7', '7', '7', 0],
+		Numpad8: ['8', '8', '8', '8', 0],
+		Numpad9: ['9', '9', '9', '9', 0],
+		Numpad0: ['0', '0', '0', '0', 0],
+		NumpadDecimal: [',', '.', ',', '.', 0],
+		IntlBackslash: ['§', '°', '¶', '•', 0],
+		ContextMenu: [],
+		NumpadEqual: ['=', '=', '=', '=', 0],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: ['', '=', '', '=', 0],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/sv.win.ts

@@ -0,0 +1,171 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { name: '0000041D', id: '', text: 'Swedish' },
+	secondaryLayouts: [
+		{ name: '0000040B', id: '', text: 'Finnish' }
+	],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['a', 'A', '', '', 0, 'VK_A'],
+		KeyB: ['b', 'B', '', '', 0, 'VK_B'],
+		KeyC: ['c', 'C', '', '', 0, 'VK_C'],
+		KeyD: ['d', 'D', '', '', 0, 'VK_D'],
+		KeyE: ['e', 'E', '€', '', 0, 'VK_E'],
+		KeyF: ['f', 'F', '', '', 0, 'VK_F'],
+		KeyG: ['g', 'G', '', '', 0, 'VK_G'],
+		KeyH: ['h', 'H', '', '', 0, 'VK_H'],
+		KeyI: ['i', 'I', '', '', 0, 'VK_I'],
+		KeyJ: ['j', 'J', '', '', 0, 'VK_J'],
+		KeyK: ['k', 'K', '', '', 0, 'VK_K'],
+		KeyL: ['l', 'L', '', '', 0, 'VK_L'],
+		KeyM: ['m', 'M', 'µ', '', 0, 'VK_M'],
+		KeyN: ['n', 'N', '', '', 0, 'VK_N'],
+		KeyO: ['o', 'O', '', '', 0, 'VK_O'],
+		KeyP: ['p', 'P', '', '', 0, 'VK_P'],
+		KeyQ: ['q', 'Q', '', '', 0, 'VK_Q'],
+		KeyR: ['r', 'R', '', '', 0, 'VK_R'],
+		KeyS: ['s', 'S', '', '', 0, 'VK_S'],
+		KeyT: ['t', 'T', '', '', 0, 'VK_T'],
+		KeyU: ['u', 'U', '', '', 0, 'VK_U'],
+		KeyV: ['v', 'V', '', '', 0, 'VK_V'],
+		KeyW: ['w', 'W', '', '', 0, 'VK_W'],
+		KeyX: ['x', 'X', '', '', 0, 'VK_X'],
+		KeyY: ['y', 'Y', '', '', 0, 'VK_Y'],
+		KeyZ: ['z', 'Z', '', '', 0, 'VK_Z'],
+		Digit1: ['1', '!', '', '', 0, 'VK_1'],
+		Digit2: ['2', '"', '@', '', 0, 'VK_2'],
+		Digit3: ['3', '#', '£', '', 0, 'VK_3'],
+		Digit4: ['4', '¤', '$', '', 0, 'VK_4'],
+		Digit5: ['5', '%', '€', '', 0, 'VK_5'],
+		Digit6: ['6', '&', '', '', 0, 'VK_6'],
+		Digit7: ['7', '/', '{', '', 0, 'VK_7'],
+		Digit8: ['8', '(', '[', '', 0, 'VK_8'],
+		Digit9: ['9', ')', ']', '', 0, 'VK_9'],
+		Digit0: ['0', '=', '}', '', 0, 'VK_0'],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', '', '', 0, 'VK_SPACE'],
+		Minus: ['+', '?', '\\', '', 0, 'VK_OEM_PLUS'],
+		Equal: ['´', '`', '', '', 0, 'VK_OEM_4'],
+		BracketLeft: ['å', 'Å', '', '', 0, 'VK_OEM_6'],
+		BracketRight: ['¨', '^', '~', '', 0, 'VK_OEM_1'],
+		Backslash: ['\'', '*', '', '', 0, 'VK_OEM_2'],
+		Semicolon: ['ö', 'Ö', '', '', 0, 'VK_OEM_3'],
+		Quote: ['ä', 'Ä', '', '', 0, 'VK_OEM_7'],
+		Backquote: ['§', '½', '', '', 0, 'VK_OEM_5'],
+		Comma: [',', ';', '', '', 0, 'VK_OEM_COMMA'],
+		Period: ['.', ':', '', '', 0, 'VK_OEM_PERIOD'],
+		Slash: ['-', '_', '', '', 0, 'VK_OEM_MINUS'],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: [],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '', '', 0, 'VK_DIVIDE'],
+		NumpadMultiply: ['*', '*', '', '', 0, 'VK_MULTIPLY'],
+		NumpadSubtract: ['-', '-', '', '', 0, 'VK_SUBTRACT'],
+		NumpadAdd: ['+', '+', '', '', 0, 'VK_ADD'],
+		NumpadEnter: [],
+		Numpad1: [],
+		Numpad2: [],
+		Numpad3: [],
+		Numpad4: [],
+		Numpad5: [],
+		Numpad6: [],
+		Numpad7: [],
+		Numpad8: [],
+		Numpad9: [],
+		Numpad0: [],
+		NumpadDecimal: [],
+		IntlBackslash: ['<', '>', '|', '', 0, 'VK_OEM_102'],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: [],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Help: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/thai.win.ts

@@ -0,0 +1,168 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { name: '0000041E', id: '', text: 'Thai Kedmanee' },
+	secondaryLayouts: [],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['ฟ', 'ฤ', '', '', 0, 'VK_A'],
+		KeyB: ['ิ', 'ฺ', '', '', 0, 'VK_B'],
+		KeyC: ['แ', 'ฉ', '', '', 0, 'VK_C'],
+		KeyD: ['ก', 'ฏ', '', '', 0, 'VK_D'],
+		KeyE: ['ำ', 'ฎ', '', '', 0, 'VK_E'],
+		KeyF: ['ด', 'โ', '', '', 0, 'VK_F'],
+		KeyG: ['เ', 'ฌ', '', '', 0, 'VK_G'],
+		KeyH: ['้', '็', '', '', 0, 'VK_H'],
+		KeyI: ['ร', 'ณ', '', '', 0, 'VK_I'],
+		KeyJ: ['่', '๋', '', '', 0, 'VK_J'],
+		KeyK: ['า', 'ษ', '', '', 0, 'VK_K'],
+		KeyL: ['ส', 'ศ', '', '', 0, 'VK_L'],
+		KeyM: ['ท', '?', '', '', 0, 'VK_M'],
+		KeyN: ['ื', '์', '', '', 0, 'VK_N'],
+		KeyO: ['น', 'ฯ', '', '', 0, 'VK_O'],
+		KeyP: ['ย', 'ญ', '', '', 0, 'VK_P'],
+		KeyQ: ['ๆ', '๐', '', '', 0, 'VK_Q'],
+		KeyR: ['พ', 'ฑ', '', '', 0, 'VK_R'],
+		KeyS: ['ห', 'ฆ', '', '', 0, 'VK_S'],
+		KeyT: ['ะ', 'ธ', '', '', 0, 'VK_T'],
+		KeyU: ['ี', '๊', '', '', 0, 'VK_U'],
+		KeyV: ['อ', 'ฮ', '', '', 0, 'VK_V'],
+		KeyW: ['ไ', '"', '', '', 0, 'VK_W'],
+		KeyX: ['ป', ')', '', '', 0, 'VK_X'],
+		KeyY: ['ั', 'ํ', '', '', 0, 'VK_Y'],
+		KeyZ: ['ผ', '(', '', '', 0, 'VK_Z'],
+		Digit1: ['ๅ', '+', '', '', 0, 'VK_1'],
+		Digit2: ['/', '๑', '', '', 0, 'VK_2'],
+		Digit3: ['-', '๒', '', '', 0, 'VK_3'],
+		Digit4: ['ภ', '๓', '', '', 0, 'VK_4'],
+		Digit5: ['ถ', '๔', '', '', 0, 'VK_5'],
+		Digit6: ['ุ', 'ู', '', '', 0, 'VK_6'],
+		Digit7: ['ึ', '฿', '', '', 0, 'VK_7'],
+		Digit8: ['ค', '๕', '', '', 0, 'VK_8'],
+		Digit9: ['ต', '๖', '', '', 0, 'VK_9'],
+		Digit0: ['จ', '๗', '', '', 0, 'VK_0'],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', '', '', 0, 'VK_SPACE'],
+		Minus: ['ข', '๘', '', '', 0, 'VK_OEM_MINUS'],
+		Equal: ['ช', '๙', '', '', 0, 'VK_OEM_PLUS'],
+		BracketLeft: ['บ', 'ฐ', '', '', 0, 'VK_OEM_4'],
+		BracketRight: ['ล', ',', '', '', 0, 'VK_OEM_6'],
+		Backslash: ['ฃ', 'ฅ', '', '', 0, 'VK_OEM_5'],
+		Semicolon: ['ว', 'ซ', '', '', 0, 'VK_OEM_1'],
+		Quote: ['ง', '.', '', '', 0, 'VK_OEM_7'],
+		Backquote: ['_', '%', '', '', 0, 'VK_OEM_3'],
+		Comma: ['ม', 'ฒ', '', '', 0, 'VK_OEM_COMMA'],
+		Period: ['ใ', 'ฬ', '', '', 0, 'VK_OEM_PERIOD'],
+		Slash: ['ฝ', 'ฦ', '', '', 0, 'VK_OEM_2'],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: [],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '', '', 0, 'VK_DIVIDE'],
+		NumpadMultiply: ['*', '*', '', '', 0, 'VK_MULTIPLY'],
+		NumpadSubtract: ['-', '-', '', '', 0, 'VK_SUBTRACT'],
+		NumpadAdd: ['+', '+', '', '', 0, 'VK_ADD'],
+		NumpadEnter: [],
+		Numpad1: [],
+		Numpad2: [],
+		Numpad3: [],
+		Numpad4: [],
+		Numpad5: [],
+		Numpad6: [],
+		Numpad7: [],
+		Numpad8: [],
+		Numpad9: [],
+		Numpad0: [],
+		NumpadDecimal: [],
+		IntlBackslash: ['ฃ', 'ฅ', '', '', 0, 'VK_OEM_102'],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: [],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Help: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/tr.win.ts

@@ -0,0 +1,168 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { name: '0000041F', id: '', text: 'Turkish Q' },
+	secondaryLayouts: [],
+	mapping: {
+		Sleep: [],
+		WakeUp: [],
+		KeyA: ['a', 'A', 'æ', 'Æ', 0, 'VK_A'],
+		KeyB: ['b', 'B', '', '', 0, 'VK_B'],
+		KeyC: ['c', 'C', '', '', 0, 'VK_C'],
+		KeyD: ['d', 'D', '', '', 0, 'VK_D'],
+		KeyE: ['e', 'E', '€', '', 0, 'VK_E'],
+		KeyF: ['f', 'F', '', '', 0, 'VK_F'],
+		KeyG: ['g', 'G', '', '', 0, 'VK_G'],
+		KeyH: ['h', 'H', '', '', 0, 'VK_H'],
+		KeyI: ['ı', 'I', 'i', 'İ', 0, 'VK_I'],
+		KeyJ: ['j', 'J', '', '', 0, 'VK_J'],
+		KeyK: ['k', 'K', '', '', 0, 'VK_K'],
+		KeyL: ['l', 'L', '', '', 0, 'VK_L'],
+		KeyM: ['m', 'M', '', '', 0, 'VK_M'],
+		KeyN: ['n', 'N', '', '', 0, 'VK_N'],
+		KeyO: ['o', 'O', '', '', 0, 'VK_O'],
+		KeyP: ['p', 'P', '', '', 0, 'VK_P'],
+		KeyQ: ['q', 'Q', '@', '', 0, 'VK_Q'],
+		KeyR: ['r', 'R', '', '', 0, 'VK_R'],
+		KeyS: ['s', 'S', 'ß', '', 0, 'VK_S'],
+		KeyT: ['t', 'T', '₺', '', 0, 'VK_T'],
+		KeyU: ['u', 'U', '', '', 0, 'VK_U'],
+		KeyV: ['v', 'V', '', '', 0, 'VK_V'],
+		KeyW: ['w', 'W', '', '', 0, 'VK_W'],
+		KeyX: ['x', 'X', '', '', 0, 'VK_X'],
+		KeyY: ['y', 'Y', '', '', 0, 'VK_Y'],
+		KeyZ: ['z', 'Z', '', '', 0, 'VK_Z'],
+		Digit1: ['1', '!', '>', '', 0, 'VK_1'],
+		Digit2: ['2', '\'', '£', '', 0, 'VK_2'],
+		Digit3: ['3', '^', '#', '', 0, 'VK_3'],
+		Digit4: ['4', '+', '$', '', 0, 'VK_4'],
+		Digit5: ['5', '%', '½', '', 0, 'VK_5'],
+		Digit6: ['6', '&', '', '', 0, 'VK_6'],
+		Digit7: ['7', '/', '{', '', 0, 'VK_7'],
+		Digit8: ['8', '(', '[', '', 0, 'VK_8'],
+		Digit9: ['9', ')', ']', '', 0, 'VK_9'],
+		Digit0: ['0', '=', '}', '', 0, 'VK_0'],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', '', '', 0, 'VK_SPACE'],
+		Minus: ['*', '?', '\\', '', 0, 'VK_OEM_8'],
+		Equal: ['-', '_', '|', '', 0, 'VK_OEM_MINUS'],
+		BracketLeft: ['ğ', 'Ğ', '¨', '', 0, 'VK_OEM_4'],
+		BracketRight: ['ü', 'Ü', '~', '', 0, 'VK_OEM_6'],
+		Backslash: [',', ';', '`', '', 0, 'VK_OEM_COMMA'],
+		Semicolon: ['ş', 'Ş', '´', '', 0, 'VK_OEM_1'],
+		Quote: ['i', 'İ', '', '', 0, 'VK_OEM_7'],
+		Backquote: ['"', 'é', '<', '', 0, 'VK_OEM_3'],
+		Comma: ['ö', 'Ö', '', '', 0, 'VK_OEM_2'],
+		Period: ['ç', 'Ç', '', '', 0, 'VK_OEM_5'],
+		Slash: ['.', ':', '', '', 0, 'VK_OEM_PERIOD'],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		PrintScreen: [],
+		ScrollLock: [],
+		Pause: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '', '', 0, 'VK_DIVIDE'],
+		NumpadMultiply: ['*', '*', '', '', 0, 'VK_MULTIPLY'],
+		NumpadSubtract: ['-', '-', '', '', 0, 'VK_SUBTRACT'],
+		NumpadAdd: ['+', '+', '', '', 0, 'VK_ADD'],
+		NumpadEnter: [],
+		Numpad1: [],
+		Numpad2: [],
+		Numpad3: [],
+		Numpad4: [],
+		Numpad5: [],
+		Numpad6: [],
+		Numpad7: [],
+		Numpad8: [],
+		Numpad9: [],
+		Numpad0: [],
+		NumpadDecimal: [],
+		IntlBackslash: ['<', '>', '|', '', 0, 'VK_OEM_102'],
+		ContextMenu: [],
+		Power: [],
+		NumpadEqual: [],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		F21: [],
+		F22: [],
+		F23: [],
+		F24: [],
+		Help: [],
+		Undo: [],
+		Cut: [],
+		Copy: [],
+		Paste: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: [],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		Convert: [],
+		NonConvert: [],
+		Lang1: [],
+		Lang2: [],
+		Lang3: [],
+		Lang4: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: [],
+		MediaTrackNext: [],
+		MediaTrackPrevious: [],
+		MediaStop: [],
+		Eject: [],
+		MediaPlayPause: [],
+		MediaSelect: [],
+		LaunchMail: [],
+		LaunchApp2: [],
+		LaunchApp1: [],
+		BrowserSearch: [],
+		BrowserHome: [],
+		BrowserBack: [],
+		BrowserForward: [],
+		BrowserStop: [],
+		BrowserRefresh: [],
+		BrowserFavorites: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/zh-hans.darwin.ts

@@ -0,0 +1,131 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+	layout: { id: 'com.apple.inputmethod.SCIM.ITABC', lang: 'zh-Hans', localizedName: '搜狗拼音' },
+	secondaryLayouts: [],
+	mapping: {
+		KeyA: ['a', 'A', 'å', 'Å', 0],
+		KeyB: ['b', 'B', '∫', 'ı', 0],
+		KeyC: ['c', 'C', 'ç', 'Ç', 0],
+		KeyD: ['d', 'D', '∂', 'Î', 0],
+		KeyE: ['e', 'E', '´', '´', 4],
+		KeyF: ['f', 'F', 'ƒ', 'Ï', 0],
+		KeyG: ['g', 'G', '©', '˝', 0],
+		KeyH: ['h', 'H', '˙', 'Ó', 0],
+		KeyI: ['i', 'I', 'ˆ', 'ˆ', 4],
+		KeyJ: ['j', 'J', '∆', 'Ô', 0],
+		KeyK: ['k', 'K', '˚', '', 0],
+		KeyL: ['l', 'L', '¬', 'Ò', 0],
+		KeyM: ['m', 'M', 'µ', 'Â', 0],
+		KeyN: ['n', 'N', '˜', '˜', 4],
+		KeyO: ['o', 'O', 'ø', 'Ø', 0],
+		KeyP: ['p', 'P', 'π', '∏', 0],
+		KeyQ: ['q', 'Q', 'œ', 'Œ', 0],
+		KeyR: ['r', 'R', '®', '‰', 0],
+		KeyS: ['s', 'S', 'ß', 'Í', 0],
+		KeyT: ['t', 'T', '†', 'ˇ', 0],
+		KeyU: ['u', 'U', '¨', '¨', 4],
+		KeyV: ['v', 'V', '√', '◊', 0],
+		KeyW: ['w', 'W', '∑', '„', 0],
+		KeyX: ['x', 'X', '≈', '˛', 0],
+		KeyY: ['y', 'Y', '¥', 'Á', 0],
+		KeyZ: ['z', 'Z', 'Ω', '¸', 0],
+		Digit1: ['1', '！', '¡', '⁄', 0],
+		Digit2: ['2', '@', '™', '€', 0],
+		Digit3: ['3', '#', '£', '‹', 0],
+		Digit4: ['4', '¥', '¢', '›', 0],
+		Digit5: ['5', '%', '∞', 'fi', 0],
+		Digit6: ['6', '', '§', 'fl', 0],
+		Digit7: ['7', '&', '¶', '‡', 0],
+		Digit8: ['8', '*', '•', '°', 0],
+		Digit9: ['9', '（', 'ª', '·', 0],
+		Digit0: ['0', '）', 'º', '‚', 0],
+		Enter: [],
+		Escape: [],
+		Backspace: [],
+		Tab: [],
+		Space: [' ', ' ', ' ', ' ', 0],
+		Minus: ['-', '', '–', '—', 0],
+		Equal: ['=', '+', '≠', '±', 0],
+		BracketLeft: ['【', '「', '“', '”', 0],
+		BracketRight: ['】', '」', '‘', '’', 0],
+		Backslash: ['、', '|', '«', '»', 0],
+		Semicolon: ['；', '：', '…', 'Ú', 0],
+		Quote: ['\'', '"', 'æ', 'Æ', 0],
+		Backquote: ['·', '～', '`', '`', 4],
+		Comma: ['，', '《', '≤', '¯', 0],
+		Period: ['。', '》', '≥', '˘', 0],
+		Slash: ['/', '？', '÷', '¿', 0],
+		CapsLock: [],
+		F1: [],
+		F2: [],
+		F3: [],
+		F4: [],
+		F5: [],
+		F6: [],
+		F7: [],
+		F8: [],
+		F9: [],
+		F10: [],
+		F11: [],
+		F12: [],
+		Insert: [],
+		Home: [],
+		PageUp: [],
+		Delete: [],
+		End: [],
+		PageDown: [],
+		ArrowRight: [],
+		ArrowLeft: [],
+		ArrowDown: [],
+		ArrowUp: [],
+		NumLock: [],
+		NumpadDivide: ['/', '/', '/', '/', 0],
+		NumpadMultiply: ['*', '*', '*', '*', 0],
+		NumpadSubtract: ['-', '-', '-', '-', 0],
+		NumpadAdd: ['+', '+', '+', '+', 0],
+		NumpadEnter: [],
+		Numpad1: ['1', '1', '1', '1', 0],
+		Numpad2: ['2', '2', '2', '2', 0],
+		Numpad3: ['3', '3', '3', '3', 0],
+		Numpad4: ['4', '4', '4', '4', 0],
+		Numpad5: ['5', '5', '5', '5', 0],
+		Numpad6: ['6', '6', '6', '6', 0],
+		Numpad7: ['7', '7', '7', '7', 0],
+		Numpad8: ['8', '8', '8', '8', 0],
+		Numpad9: ['9', '9', '9', '9', 0],
+		Numpad0: ['0', '0', '0', '0', 0],
+		NumpadDecimal: ['.', '.', '.', '.', 0],
+		IntlBackslash: ['§', '±', '§', '±', 0],
+		ContextMenu: [],
+		NumpadEqual: ['=', '=', '=', '=', 0],
+		F13: [],
+		F14: [],
+		F15: [],
+		F16: [],
+		F17: [],
+		F18: [],
+		F19: [],
+		F20: [],
+		AudioVolumeMute: [],
+		AudioVolumeUp: ['', '=', '', '=', 0],
+		AudioVolumeDown: [],
+		NumpadComma: [],
+		IntlRo: [],
+		KanaMode: [],
+		IntlYen: [],
+		ControlLeft: [],
+		ShiftLeft: [],
+		AltLeft: [],
+		MetaLeft: [],
+		ControlRight: [],
+		ShiftRight: [],
+		AltRight: [],
+		MetaRight: []
+	}
+});

lib/vscode/src/vs/workbench/services/keybinding/browser/keymapService.ts

@@ -0,0 +1,638 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as nls from 'vs/nls';
+import { Emitter, Event } from 'vs/base/common/event';
+import { Disposable, MutableDisposable } from 'vs/base/common/lifecycle';
+import { IKeymapService, IKeyboardLayoutInfo, IKeyboardMapping, IWindowsKeyboardMapping, KeymapInfo, IRawMixedKeyboardMapping, getKeyboardLayoutId, IKeymapInfo } from 'vs/workbench/services/keybinding/common/keymapInfo';
+import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
+import { DispatchConfig } from 'vs/workbench/services/keybinding/common/dispatchConfig';
+import { IKeyboardMapper, CachedKeyboardMapper } from 'vs/workbench/services/keybinding/common/keyboardMapper';
+import { OS, OperatingSystem, isMacintosh, isWindows } from 'vs/base/common/platform';
+import { WindowsKeyboardMapper } from 'vs/workbench/services/keybinding/common/windowsKeyboardMapper';
+import { MacLinuxFallbackKeyboardMapper } from 'vs/workbench/services/keybinding/common/macLinuxFallbackKeyboardMapper';
+import { IKeyboardEvent } from 'vs/platform/keybinding/common/keybinding';
+import { IMacLinuxKeyboardMapping, MacLinuxKeyboardMapper } from 'vs/workbench/services/keybinding/common/macLinuxKeyboardMapper';
+import { StandardKeyboardEvent } from 'vs/base/browser/keyboardEvent';
+import { URI } from 'vs/base/common/uri';
+import { IFileService } from 'vs/platform/files/common/files';
+import { RunOnceScheduler } from 'vs/base/common/async';
+import { parse, getNodeType } from 'vs/base/common/json';
+import * as objects from 'vs/base/common/objects';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { Registry } from 'vs/platform/registry/common/platform';
+import { Extensions as ConfigExtensions, IConfigurationRegistry, IConfigurationNode } from 'vs/platform/configuration/common/configurationRegistry';
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
+import { INavigatorWithKeyboard } from 'vs/workbench/services/keybinding/browser/navigatorKeyboard';
+import { INotificationService } from 'vs/platform/notification/common/notification';
+import { ICommandService } from 'vs/platform/commands/common/commands';
+import { IStorageService } from 'vs/platform/storage/common/storage';
+
+export class BrowserKeyboardMapperFactoryBase {
+	// keyboard mapper
+	protected _initialized: boolean;
+	protected _keyboardMapper: IKeyboardMapper | null;
+	private readonly _onDidChangeKeyboardMapper = new Emitter<void>();
+	public readonly onDidChangeKeyboardMapper: Event<void> = this._onDidChangeKeyboardMapper.event;
+
+	// keymap infos
+	protected _keymapInfos: KeymapInfo[];
+	protected _mru: KeymapInfo[];
+	private _activeKeymapInfo: KeymapInfo | null;
+
+	get activeKeymap(): KeymapInfo | null {
+		return this._activeKeymapInfo;
+	}
+
+	get keymapInfos(): KeymapInfo[] {
+		return this._keymapInfos;
+	}
+
+	get activeKeyboardLayout(): IKeyboardLayoutInfo | null {
+		if (!this._initialized) {
+			return null;
+		}
+
+		return this._activeKeymapInfo && this._activeKeymapInfo.layout;
+	}
+
+	get activeKeyMapping(): IKeyboardMapping | null {
+		if (!this._initialized) {
+			return null;
+		}
+
+		return this._activeKeymapInfo && this._activeKeymapInfo.mapping;
+	}
+
+	get keyboardLayouts(): IKeyboardLayoutInfo[] {
+		return this._keymapInfos.map(keymapInfo => keymapInfo.layout);
+	}
+
+	protected constructor(
+		// private _notificationService: INotificationService,
+		// private _storageService: IStorageService,
+		// private _commandService: ICommandService
+	) {
+		this._keyboardMapper = null;
+		this._initialized = false;
+		this._keymapInfos = [];
+		this._mru = [];
+		this._activeKeymapInfo = null;
+
+		if ((<INavigatorWithKeyboard>navigator).keyboard && (<INavigatorWithKeyboard>navigator).keyboard.addEventListener) {
+			(<INavigatorWithKeyboard>navigator).keyboard.addEventListener!('layoutchange', () => {
+				// Update user keyboard map settings
+				this._getBrowserKeyMapping().then((mapping: IKeyboardMapping | null) => {
+					if (this.isKeyMappingActive(mapping)) {
+						return;
+					}
+
+					this.onKeyboardLayoutChanged();
+				});
+			});
+		}
+	}
+
+	registerKeyboardLayout(layout: KeymapInfo) {
+		this._keymapInfos.push(layout);
+		this._mru = this._keymapInfos;
+	}
+
+	removeKeyboardLayout(layout: KeymapInfo): void {
+		let index = this._mru.indexOf(layout);
+		this._mru.splice(index, 1);
+		index = this._keymapInfos.indexOf(layout);
+		this._keymapInfos.splice(index, 1);
+	}
+
+	getMatchedKeymapInfo(keyMapping: IKeyboardMapping | null): { result: KeymapInfo, score: number } | null {
+		if (!keyMapping) {
+			return null;
+		}
+
+		let usStandard = this.getUSStandardLayout();
+
+		if (usStandard) {
+			let maxScore = usStandard.getScore(keyMapping);
+			if (maxScore === 0) {
+				return {
+					result: usStandard,
+					score: 0
+				};
+			}
+
+			let result = usStandard;
+			for (let i = 0; i < this._mru.length; i++) {
+				let score = this._mru[i].getScore(keyMapping);
+				if (score > maxScore) {
+					if (score === 0) {
+						return {
+							result: this._mru[i],
+							score: 0
+						};
+					}
+
+					maxScore = score;
+					result = this._mru[i];
+				}
+			}
+
+			return {
+				result,
+				score: maxScore
+			};
+		}
+
+		for (let i = 0; i < this._mru.length; i++) {
+			if (this._mru[i].fuzzyEqual(keyMapping)) {
+				return {
+					result: this._mru[i],
+					score: 0
+				};
+			}
+		}
+
+		return null;
+	}
+
+	getUSStandardLayout() {
+		const usStandardLayouts = this._mru.filter(layout => layout.layout.isUSStandard);
+
+		if (usStandardLayouts.length) {
+			return usStandardLayouts[0];
+		}
+
+		return null;
+	}
+
+	isKeyMappingActive(keymap: IKeyboardMapping | null) {
+		return this._activeKeymapInfo && keymap && this._activeKeymapInfo.fuzzyEqual(keymap);
+	}
+
+	setUSKeyboardLayout() {
+		this._activeKeymapInfo = this.getUSStandardLayout();
+	}
+
+	setActiveKeyMapping(keymap: IKeyboardMapping | null) {
+		let keymapUpdated = false;
+		let matchedKeyboardLayout = this.getMatchedKeymapInfo(keymap);
+		if (matchedKeyboardLayout) {
+			// let score = matchedKeyboardLayout.score;
+
+			// Due to https://bugs.chromium.org/p/chromium/issues/detail?id=977609, any key after a dead key will generate a wrong mapping,
+			// we shoud avoid yielding the false error.
+			// if (keymap && score < 0) {
+			// const donotAskUpdateKey = 'missing.keyboardlayout.donotask';
+			// if (this._storageService.getBoolean(donotAskUpdateKey, StorageScope.GLOBAL)) {
+			// 	return;
+			// }
+
+			// // the keyboard layout doesn't actually match the key event or the keymap from chromium
+			// this._notificationService.prompt(
+			// 	Severity.Info,
+			// 	nls.localize('missing.keyboardlayout', 'Fail to find matching keyboard layout'),
+			// 	[{
+			// 		label: nls.localize('keyboardLayoutMissing.configure', "Configure"),
+			// 		run: () => this._commandService.executeCommand('workbench.action.openKeyboardLayoutPicker')
+			// 	}, {
+			// 		label: nls.localize('neverAgain', "Don't Show Again"),
+			// 		isSecondary: true,
+			// 		run: () => this._storageService.store(donotAskUpdateKey, true, StorageScope.GLOBAL)
+			// 	}]
+			// );
+
+			// console.warn('Active keymap/keyevent does not match current keyboard layout', JSON.stringify(keymap), this._activeKeymapInfo ? JSON.stringify(this._activeKeymapInfo.layout) : '');
+
+			// return;
+			// }
+
+			if (!this._activeKeymapInfo) {
+				this._activeKeymapInfo = matchedKeyboardLayout.result;
+				keymapUpdated = true;
+			} else if (keymap) {
+				if (matchedKeyboardLayout.result.getScore(keymap) > this._activeKeymapInfo.getScore(keymap)) {
+					this._activeKeymapInfo = matchedKeyboardLayout.result;
+					keymapUpdated = true;
+				}
+			}
+		}
+
+		if (!this._activeKeymapInfo) {
+			this._activeKeymapInfo = this.getUSStandardLayout();
+			keymapUpdated = true;
+		}
+
+		if (!this._activeKeymapInfo || !keymapUpdated) {
+			return;
+		}
+
+		const index = this._mru.indexOf(this._activeKeymapInfo);
+
+		this._mru.splice(index, 1);
+		this._mru.unshift(this._activeKeymapInfo);
+
+		this._setKeyboardData(this._activeKeymapInfo);
+	}
+
+	setActiveKeymapInfo(keymapInfo: KeymapInfo) {
+		this._activeKeymapInfo = keymapInfo;
+
+		const index = this._mru.indexOf(this._activeKeymapInfo);
+
+		if (index === 0) {
+			return;
+		}
+
+		this._mru.splice(index, 1);
+		this._mru.unshift(this._activeKeymapInfo);
+
+		this._setKeyboardData(this._activeKeymapInfo);
+	}
+
+	public onKeyboardLayoutChanged(): void {
+		this._updateKeyboardLayoutAsync(this._initialized);
+	}
+
+	private _updateKeyboardLayoutAsync(initialized: boolean, keyboardEvent?: IKeyboardEvent) {
+		if (!initialized) {
+			return;
+		}
+
+		this._getBrowserKeyMapping(keyboardEvent).then(keyMap => {
+			// might be false positive
+			if (this.isKeyMappingActive(keyMap)) {
+				return;
+			}
+			this.setActiveKeyMapping(keyMap);
+		});
+	}
+
+	public getKeyboardMapper(dispatchConfig: DispatchConfig): IKeyboardMapper {
+		if (!this._initialized) {
+			return new MacLinuxFallbackKeyboardMapper(OS);
+		}
+		if (dispatchConfig === DispatchConfig.KeyCode) {
+			// Forcefully set to use keyCode
+			return new MacLinuxFallbackKeyboardMapper(OS);
+		}
+		return this._keyboardMapper!;
+	}
+
+	public validateCurrentKeyboardMapping(keyboardEvent: IKeyboardEvent): void {
+		if (!this._initialized) {
+			return;
+		}
+
+		let isCurrentKeyboard = this._validateCurrentKeyboardMapping(keyboardEvent);
+
+		if (isCurrentKeyboard) {
+			return;
+		}
+
+		this._updateKeyboardLayoutAsync(true, keyboardEvent);
+	}
+
+	public setKeyboardLayout(layoutName: string) {
+		let matchedLayouts: KeymapInfo[] = this.keymapInfos.filter(keymapInfo => getKeyboardLayoutId(keymapInfo.layout) === layoutName);
+
+		if (matchedLayouts.length > 0) {
+			this.setActiveKeymapInfo(matchedLayouts[0]);
+		}
+	}
+
+	private _setKeyboardData(keymapInfo: KeymapInfo): void {
+		this._initialized = true;
+
+		this._keyboardMapper = new CachedKeyboardMapper(BrowserKeyboardMapperFactory._createKeyboardMapper(keymapInfo));
+		this._onDidChangeKeyboardMapper.fire();
+	}
+
+	private static _createKeyboardMapper(keymapInfo: KeymapInfo): IKeyboardMapper {
+		let rawMapping = keymapInfo.mapping;
+		const isUSStandard = !!keymapInfo.layout.isUSStandard;
+		if (OS === OperatingSystem.Windows) {
+			return new WindowsKeyboardMapper(isUSStandard, <IWindowsKeyboardMapping>rawMapping);
+		}
+		if (Object.keys(rawMapping).length === 0) {
+			// Looks like reading the mappings failed (most likely Mac + Japanese/Chinese keyboard layouts)
+			return new MacLinuxFallbackKeyboardMapper(OS);
+		}
+
+		return new MacLinuxKeyboardMapper(isUSStandard, <IMacLinuxKeyboardMapping>rawMapping, OS);
+	}
+
+	//#region Browser API
+	private _validateCurrentKeyboardMapping(keyboardEvent: IKeyboardEvent): boolean {
+		if (!this._initialized) {
+			return true;
+		}
+
+		const standardKeyboardEvent = keyboardEvent as StandardKeyboardEvent;
+		const currentKeymap = this._activeKeymapInfo;
+		if (!currentKeymap) {
+			return true;
+		}
+
+		if (standardKeyboardEvent.browserEvent.key === 'Dead' || standardKeyboardEvent.browserEvent.isComposing) {
+			return true;
+		}
+
+		const mapping = currentKeymap.mapping[standardKeyboardEvent.code];
+
+		if (!mapping) {
+			return false;
+		}
+
+		if (mapping.value === '') {
+			// The value is empty when the key is not a printable character, we skip validation.
+			if (keyboardEvent.ctrlKey || keyboardEvent.metaKey) {
+				setTimeout(() => {
+					this._getBrowserKeyMapping().then((keymap: IRawMixedKeyboardMapping | null) => {
+						if (this.isKeyMappingActive(keymap)) {
+							return;
+						}
+
+						this.onKeyboardLayoutChanged();
+					});
+				}, 350);
+			}
+			return true;
+		}
+
+		const expectedValue = standardKeyboardEvent.altKey && standardKeyboardEvent.shiftKey ? mapping.withShiftAltGr :
+			standardKeyboardEvent.altKey ? mapping.withAltGr :
+				standardKeyboardEvent.shiftKey ? mapping.withShift : mapping.value;
+
+		const isDead = (standardKeyboardEvent.altKey && standardKeyboardEvent.shiftKey && mapping.withShiftAltGrIsDeadKey) ||
+			(standardKeyboardEvent.altKey && mapping.withAltGrIsDeadKey) ||
+			(standardKeyboardEvent.shiftKey && mapping.withShiftIsDeadKey) ||
+			mapping.valueIsDeadKey;
+
+		if (isDead && standardKeyboardEvent.browserEvent.key !== 'Dead') {
+			return false;
+		}
+
+		// TODO, this assumption is wrong as `browserEvent.key` doesn't necessarily equal expectedValue from real keymap
+		if (!isDead && standardKeyboardEvent.browserEvent.key !== expectedValue) {
+			return false;
+		}
+
+		return true;
+	}
+
+	private async _getBrowserKeyMapping(keyboardEvent?: IKeyboardEvent): Promise<IRawMixedKeyboardMapping | null> {
+		if ((navigator as any).keyboard) {
+			try {
+				return (navigator as any).keyboard.getLayoutMap().then((e: any) => {
+					let ret: IKeyboardMapping = {};
+					for (let key of e) {
+						ret[key[0]] = {
+							'value': key[1],
+							'withShift': '',
+							'withAltGr': '',
+							'withShiftAltGr': ''
+						};
+					}
+
+					return ret;
+
+					// const matchedKeyboardLayout = this.getMatchedKeymapInfo(ret);
+
+					// if (matchedKeyboardLayout) {
+					// 	return matchedKeyboardLayout.result.mapping;
+					// }
+
+					// return null;
+				});
+			} catch {
+				// getLayoutMap can throw if invoked from a nested browsing context
+			}
+		} else if (keyboardEvent && !keyboardEvent.shiftKey && !keyboardEvent.altKey && !keyboardEvent.metaKey && !keyboardEvent.metaKey) {
+			let ret: IKeyboardMapping = {};
+			const standardKeyboardEvent = keyboardEvent as StandardKeyboardEvent;
+			ret[standardKeyboardEvent.browserEvent.code] = {
+				'value': standardKeyboardEvent.browserEvent.key,
+				'withShift': '',
+				'withAltGr': '',
+				'withShiftAltGr': ''
+			};
+
+			const matchedKeyboardLayout = this.getMatchedKeymapInfo(ret);
+
+			if (matchedKeyboardLayout) {
+				return ret;
+			}
+
+			return null;
+		}
+
+		return null;
+	}
+
+	//#endregion
+}
+
+export class BrowserKeyboardMapperFactory extends BrowserKeyboardMapperFactoryBase {
+	constructor(notificationService: INotificationService, storageService: IStorageService, commandService: ICommandService) {
+		// super(notificationService, storageService, commandService);
+		super();
+
+		const platform = isWindows ? 'win' : isMacintosh ? 'darwin' : 'linux';
+
+		import('vs/workbench/services/keybinding/browser/keyboardLayouts/layout.contribution.' + platform).then((m) => {
+			let keymapInfos: IKeymapInfo[] = m.KeyboardLayoutContribution.INSTANCE.layoutInfos;
+			this._keymapInfos.push(...keymapInfos.map(info => (new KeymapInfo(info.layout, info.secondaryLayouts, info.mapping, info.isUserKeyboardLayout))));
+			this._mru = this._keymapInfos;
+			this._initialized = true;
+			this.onKeyboardLayoutChanged();
+		});
+	}
+}
+
+class UserKeyboardLayout extends Disposable {
+
+	private readonly reloadConfigurationScheduler: RunOnceScheduler;
+	protected readonly _onDidChange: Emitter<void> = this._register(new Emitter<void>());
+	readonly onDidChange: Event<void> = this._onDidChange.event;
+
+	private _keyboardLayout: KeymapInfo | null;
+	get keyboardLayout(): KeymapInfo | null { return this._keyboardLayout; }
+
+	constructor(
+		private readonly keyboardLayoutResource: URI,
+		private readonly fileService: IFileService
+	) {
+		super();
+
+		this._keyboardLayout = null;
+
+		this.reloadConfigurationScheduler = this._register(new RunOnceScheduler(() => this.reload().then(changed => {
+			if (changed) {
+				this._onDidChange.fire();
+			}
+		}), 50));
+
+		this._register(Event.filter(this.fileService.onDidFilesChange, e => e.contains(this.keyboardLayoutResource))(() => this.reloadConfigurationScheduler.schedule()));
+	}
+
+	async initialize(): Promise<void> {
+		await this.reload();
+	}
+
+	private async reload(): Promise<boolean> {
+		const existing = this._keyboardLayout;
+		try {
+			const content = await this.fileService.readFile(this.keyboardLayoutResource);
+			const value = parse(content.value.toString());
+			if (getNodeType(value) === 'object') {
+				const layoutInfo = value.layout;
+				const mappings = value.rawMapping;
+				this._keyboardLayout = KeymapInfo.createKeyboardLayoutFromDebugInfo(layoutInfo, mappings, true);
+			} else {
+				this._keyboardLayout = null;
+			}
+		} catch (e) {
+			this._keyboardLayout = null;
+		}
+
+		return existing ? !objects.equals(existing, this._keyboardLayout) : true;
+	}
+
+}
+
+class BrowserKeymapService extends Disposable implements IKeymapService {
+	public _serviceBrand: undefined;
+
+	private readonly _onDidChangeKeyboardMapper = new Emitter<void>();
+	public readonly onDidChangeKeyboardMapper: Event<void> = this._onDidChangeKeyboardMapper.event;
+
+	private _userKeyboardLayout: UserKeyboardLayout;
+
+	private readonly layoutChangeListener = this._register(new MutableDisposable());
+	private readonly _factory: BrowserKeyboardMapperFactory;
+
+	constructor(
+		@IEnvironmentService environmentService: IEnvironmentService,
+		@IFileService fileService: IFileService,
+		@INotificationService notificationService: INotificationService,
+		@IStorageService storageService: IStorageService,
+		@ICommandService commandService: ICommandService,
+		@IConfigurationService private configurationService: IConfigurationService,
+	) {
+		super();
+		const keyboardConfig = configurationService.getValue<{ layout: string }>('keyboard');
+		const layout = keyboardConfig.layout;
+		this._factory = new BrowserKeyboardMapperFactory(notificationService, storageService, commandService);
+
+		this.registerKeyboardListener();
+
+		if (layout && layout !== 'autodetect') {
+			// set keyboard layout
+			this._factory.setKeyboardLayout(layout);
+		}
+
+		this._register(configurationService.onDidChangeConfiguration(e => {
+			if (e.affectedKeys.indexOf('keyboard.layout') >= 0) {
+				const keyboardConfig = configurationService.getValue<{ layout: string }>('keyboard');
+				const layout = keyboardConfig.layout;
+
+				if (layout === 'autodetect') {
+					this.registerKeyboardListener();
+					this._factory.onKeyboardLayoutChanged();
+				} else {
+					this._factory.setKeyboardLayout(layout);
+					this.layoutChangeListener.clear();
+				}
+			}
+		}));
+
+		this._userKeyboardLayout = new UserKeyboardLayout(environmentService.keyboardLayoutResource, fileService);
+		this._userKeyboardLayout.initialize().then(() => {
+			if (this._userKeyboardLayout.keyboardLayout) {
+				this._factory.registerKeyboardLayout(this._userKeyboardLayout.keyboardLayout);
+
+				this.setUserKeyboardLayoutIfMatched();
+			}
+		});
+
+		this._register(this._userKeyboardLayout.onDidChange(() => {
+			let userKeyboardLayouts = this._factory.keymapInfos.filter(layout => layout.isUserKeyboardLayout);
+
+			if (userKeyboardLayouts.length) {
+				if (this._userKeyboardLayout.keyboardLayout) {
+					userKeyboardLayouts[0].update(this._userKeyboardLayout.keyboardLayout);
+				} else {
+					this._factory.removeKeyboardLayout(userKeyboardLayouts[0]);
+				}
+			} else {
+				if (this._userKeyboardLayout.keyboardLayout) {
+					this._factory.registerKeyboardLayout(this._userKeyboardLayout.keyboardLayout);
+				}
+			}
+
+			this.setUserKeyboardLayoutIfMatched();
+		}));
+	}
+
+	setUserKeyboardLayoutIfMatched() {
+		const keyboardConfig = this.configurationService.getValue<{ layout: string }>('keyboard');
+		const layout = keyboardConfig.layout;
+
+		if (layout && this._userKeyboardLayout.keyboardLayout) {
+			if (getKeyboardLayoutId(this._userKeyboardLayout.keyboardLayout.layout) === layout && this._factory.activeKeymap) {
+
+				if (!this._userKeyboardLayout.keyboardLayout.equal(this._factory.activeKeymap)) {
+					this._factory.setActiveKeymapInfo(this._userKeyboardLayout.keyboardLayout);
+				}
+			}
+		}
+	}
+
+	registerKeyboardListener() {
+		this.layoutChangeListener.value = this._factory.onDidChangeKeyboardMapper(() => {
+			this._onDidChangeKeyboardMapper.fire();
+		});
+	}
+
+	getKeyboardMapper(dispatchConfig: DispatchConfig): IKeyboardMapper {
+		return this._factory.getKeyboardMapper(dispatchConfig);
+	}
+
+	public getCurrentKeyboardLayout(): IKeyboardLayoutInfo | null {
+		return this._factory.activeKeyboardLayout;
+	}
+
+	public getAllKeyboardLayouts(): IKeyboardLayoutInfo[] {
+		return this._factory.keyboardLayouts;
+	}
+
+	public getRawKeyboardMapping(): IKeyboardMapping | null {
+		return this._factory.activeKeyMapping;
+	}
+
+	public validateCurrentKeyboardMapping(keyboardEvent: IKeyboardEvent): void {
+		this._factory.validateCurrentKeyboardMapping(keyboardEvent);
+	}
+}
+
+registerSingleton(IKeymapService, BrowserKeymapService, true);
+
+// Configuration
+const configurationRegistry = Registry.as<IConfigurationRegistry>(ConfigExtensions.Configuration);
+const keyboardConfiguration: IConfigurationNode = {
+	'id': 'keyboard',
+	'order': 15,
+	'type': 'object',
+	'title': nls.localize('keyboardConfigurationTitle', "Keyboard"),
+	'properties': {
+		'keyboard.layout': {
+			'type': 'string',
+			'default': 'autodetect',
+			'description': nls.localize('keyboard.layout.config', "Control the keyboard layout used in web.")
+		}
+	}
+};
+
+configurationRegistry.registerConfiguration(keyboardConfiguration);

lib/vscode/src/vs/workbench/services/keybinding/browser/navigatorKeyboard.ts

@@ -0,0 +1,15 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+export interface IKeyboard {
+	getLayoutMap(): Promise<Object>;
+	lock(keyCodes?: string[]): Promise<void>;
+	unlock(): void;
+	addEventListener?(type: string, listener: () => void): void;
+
+}
+export type INavigatorWithKeyboard = Navigator & {
+	keyboard: IKeyboard
+};

lib/vscode/src/vs/workbench/services/keybinding/common/dispatchConfig.ts

@@ -0,0 +1,17 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
+
+export const enum DispatchConfig {
+	Code,
+	KeyCode
+}
+
+export function getDispatchConfig(configurationService: IConfigurationService): DispatchConfig {
+	const keyboard = configurationService.getValue('keyboard');
+	const r = (keyboard ? (<any>keyboard).dispatch : null);
+	return (r === 'keyCode' ? DispatchConfig.KeyCode : DispatchConfig.Code);
+}

lib/vscode/src/vs/workbench/services/keybinding/common/keybindingEditing.ts

@@ -0,0 +1,288 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { localize } from 'vs/nls';
+import { Queue } from 'vs/base/common/async';
+import * as json from 'vs/base/common/json';
+import * as objects from 'vs/base/common/objects';
+import { setProperty } from 'vs/base/common/jsonEdit';
+import { Edit } from 'vs/base/common/jsonFormatter';
+import { Disposable, IReference } from 'vs/base/common/lifecycle';
+import { isArray } from 'vs/base/common/types';
+import { URI } from 'vs/base/common/uri';
+import { EditOperation } from 'vs/editor/common/core/editOperation';
+import { Range } from 'vs/editor/common/core/range';
+import { Selection } from 'vs/editor/common/core/selection';
+import { ITextModel } from 'vs/editor/common/model';
+import { ITextModelService, IResolvedTextEditorModel } from 'vs/editor/common/services/resolverService';
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
+import { ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { IFileService } from 'vs/platform/files/common/files';
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { IUserFriendlyKeybinding } from 'vs/platform/keybinding/common/keybinding';
+import { ResolvedKeybindingItem } from 'vs/platform/keybinding/common/resolvedKeybindingItem';
+import { ITextFileService } from 'vs/workbench/services/textfile/common/textfiles';
+import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
+
+export const IKeybindingEditingService = createDecorator<IKeybindingEditingService>('keybindingEditingService');
+
+export interface IKeybindingEditingService {
+
+	readonly _serviceBrand: undefined;
+
+	editKeybinding(keybindingItem: ResolvedKeybindingItem, key: string, when: string | undefined): Promise<void>;
+
+	removeKeybinding(keybindingItem: ResolvedKeybindingItem): Promise<void>;
+
+	resetKeybinding(keybindingItem: ResolvedKeybindingItem): Promise<void>;
+}
+
+export class KeybindingsEditingService extends Disposable implements IKeybindingEditingService {
+
+	public _serviceBrand: undefined;
+	private queue: Queue<void>;
+
+	private resource: URI = this.environmentService.keybindingsResource;
+
+	constructor(
+		@ITextModelService private readonly textModelResolverService: ITextModelService,
+		@ITextFileService private readonly textFileService: ITextFileService,
+		@IFileService private readonly fileService: IFileService,
+		@IConfigurationService private readonly configurationService: IConfigurationService,
+		@IEnvironmentService private readonly environmentService: IEnvironmentService
+	) {
+		super();
+		this.queue = new Queue<void>();
+	}
+
+	editKeybinding(keybindingItem: ResolvedKeybindingItem, key: string, when: string | undefined): Promise<void> {
+		return this.queue.queue(() => this.doEditKeybinding(keybindingItem, key, when)); // queue up writes to prevent race conditions
+	}
+
+	resetKeybinding(keybindingItem: ResolvedKeybindingItem): Promise<void> {
+		return this.queue.queue(() => this.doResetKeybinding(keybindingItem)); // queue up writes to prevent race conditions
+	}
+
+	removeKeybinding(keybindingItem: ResolvedKeybindingItem): Promise<void> {
+		return this.queue.queue(() => this.doRemoveKeybinding(keybindingItem)); // queue up writes to prevent race conditions
+	}
+
+	private doEditKeybinding(keybindingItem: ResolvedKeybindingItem, key: string, when: string | undefined): Promise<void> {
+		return this.resolveAndValidate()
+			.then(reference => {
+				const model = reference.object.textEditorModel;
+				const userKeybindingEntries = <IUserFriendlyKeybinding[]>json.parse(model.getValue());
+				const userKeybindingEntryIndex = this.findUserKeybindingEntryIndex(keybindingItem, userKeybindingEntries);
+				this.updateKeybinding(keybindingItem, key, when, model, userKeybindingEntryIndex);
+				if (keybindingItem.isDefault && keybindingItem.resolvedKeybinding) {
+					this.removeDefaultKeybinding(keybindingItem, model);
+				}
+				return this.save().finally(() => reference.dispose());
+			});
+	}
+
+	private doRemoveKeybinding(keybindingItem: ResolvedKeybindingItem): Promise<void> {
+		return this.resolveAndValidate()
+			.then(reference => {
+				const model = reference.object.textEditorModel;
+				if (keybindingItem.isDefault) {
+					this.removeDefaultKeybinding(keybindingItem, model);
+				} else {
+					this.removeUserKeybinding(keybindingItem, model);
+				}
+				return this.save().finally(() => reference.dispose());
+			});
+	}
+
+	private doResetKeybinding(keybindingItem: ResolvedKeybindingItem): Promise<void> {
+		return this.resolveAndValidate()
+			.then(reference => {
+				const model = reference.object.textEditorModel;
+				if (!keybindingItem.isDefault) {
+					this.removeUserKeybinding(keybindingItem, model);
+					this.removeUnassignedDefaultKeybinding(keybindingItem, model);
+				}
+				return this.save().finally(() => reference.dispose());
+			});
+	}
+
+	private save(): Promise<any> {
+		return this.textFileService.save(this.resource);
+	}
+
+	private updateKeybinding(keybindingItem: ResolvedKeybindingItem, newKey: string, when: string | undefined, model: ITextModel, userKeybindingEntryIndex: number): void {
+		const { tabSize, insertSpaces } = model.getOptions();
+		const eol = model.getEOL();
+		if (userKeybindingEntryIndex !== -1) {
+			// Update the keybinding with new key
+			this.applyEditsToBuffer(setProperty(model.getValue(), [userKeybindingEntryIndex, 'key'], newKey, { tabSize, insertSpaces, eol })[0], model);
+			const edits = setProperty(model.getValue(), [userKeybindingEntryIndex, 'when'], when, { tabSize, insertSpaces, eol });
+			if (edits.length > 0) {
+				this.applyEditsToBuffer(edits[0], model);
+			}
+		} else {
+			// Add the new keybinding with new key
+			this.applyEditsToBuffer(setProperty(model.getValue(), [-1], this.asObject(newKey, keybindingItem.command, when, false), { tabSize, insertSpaces, eol })[0], model);
+		}
+	}
+
+	private removeUserKeybinding(keybindingItem: ResolvedKeybindingItem, model: ITextModel): void {
+		const { tabSize, insertSpaces } = model.getOptions();
+		const eol = model.getEOL();
+		const userKeybindingEntries = <IUserFriendlyKeybinding[]>json.parse(model.getValue());
+		const userKeybindingEntryIndex = this.findUserKeybindingEntryIndex(keybindingItem, userKeybindingEntries);
+		if (userKeybindingEntryIndex !== -1) {
+			this.applyEditsToBuffer(setProperty(model.getValue(), [userKeybindingEntryIndex], undefined, { tabSize, insertSpaces, eol })[0], model);
+		}
+	}
+
+	private removeDefaultKeybinding(keybindingItem: ResolvedKeybindingItem, model: ITextModel): void {
+		const { tabSize, insertSpaces } = model.getOptions();
+		const eol = model.getEOL();
+		const key = keybindingItem.resolvedKeybinding ? keybindingItem.resolvedKeybinding.getUserSettingsLabel() : null;
+		if (key) {
+			const entry: IUserFriendlyKeybinding = this.asObject(key, keybindingItem.command, keybindingItem.when ? keybindingItem.when.serialize() : undefined, true);
+			const userKeybindingEntries = <IUserFriendlyKeybinding[]>json.parse(model.getValue());
+			if (userKeybindingEntries.every(e => !this.areSame(e, entry))) {
+				this.applyEditsToBuffer(setProperty(model.getValue(), [-1], entry, { tabSize, insertSpaces, eol })[0], model);
+			}
+		}
+	}
+
+	private removeUnassignedDefaultKeybinding(keybindingItem: ResolvedKeybindingItem, model: ITextModel): void {
+		const { tabSize, insertSpaces } = model.getOptions();
+		const eol = model.getEOL();
+		const userKeybindingEntries = <IUserFriendlyKeybinding[]>json.parse(model.getValue());
+		const indices = this.findUnassignedDefaultKeybindingEntryIndex(keybindingItem, userKeybindingEntries).reverse();
+		for (const index of indices) {
+			this.applyEditsToBuffer(setProperty(model.getValue(), [index], undefined, { tabSize, insertSpaces, eol })[0], model);
+		}
+	}
+
+	private findUserKeybindingEntryIndex(keybindingItem: ResolvedKeybindingItem, userKeybindingEntries: IUserFriendlyKeybinding[]): number {
+		for (let index = 0; index < userKeybindingEntries.length; index++) {
+			const keybinding = userKeybindingEntries[index];
+			if (keybinding.command === keybindingItem.command) {
+				if (!keybinding.when && !keybindingItem.when) {
+					return index;
+				}
+				if (keybinding.when && keybindingItem.when) {
+					const contextKeyExpr = ContextKeyExpr.deserialize(keybinding.when);
+					if (contextKeyExpr && contextKeyExpr.serialize() === keybindingItem.when.serialize()) {
+						return index;
+					}
+				}
+			}
+		}
+		return -1;
+	}
+
+	private findUnassignedDefaultKeybindingEntryIndex(keybindingItem: ResolvedKeybindingItem, userKeybindingEntries: IUserFriendlyKeybinding[]): number[] {
+		const indices: number[] = [];
+		for (let index = 0; index < userKeybindingEntries.length; index++) {
+			if (userKeybindingEntries[index].command === `-${keybindingItem.command}`) {
+				indices.push(index);
+			}
+		}
+		return indices;
+	}
+
+	private asObject(key: string, command: string | null, when: string | undefined, negate: boolean): any {
+		const object: any = { key };
+		if (command) {
+			object['command'] = negate ? `-${command}` : command;
+		}
+		if (when) {
+			object['when'] = when;
+		}
+		return object;
+	}
+
+	private areSame(a: IUserFriendlyKeybinding, b: IUserFriendlyKeybinding): boolean {
+		if (a.command !== b.command) {
+			return false;
+		}
+		if (a.key !== b.key) {
+			return false;
+		}
+		const whenA = ContextKeyExpr.deserialize(a.when);
+		const whenB = ContextKeyExpr.deserialize(b.when);
+		if ((whenA && !whenB) || (!whenA && whenB)) {
+			return false;
+		}
+		if (whenA && whenB && !whenA.equals(whenB)) {
+			return false;
+		}
+		if (!objects.equals(a.args, b.args)) {
+			return false;
+		}
+		return true;
+	}
+
+	private applyEditsToBuffer(edit: Edit, model: ITextModel): void {
+		const startPosition = model.getPositionAt(edit.offset);
+		const endPosition = model.getPositionAt(edit.offset + edit.length);
+		const range = new Range(startPosition.lineNumber, startPosition.column, endPosition.lineNumber, endPosition.column);
+		let currentText = model.getValueInRange(range);
+		const editOperation = currentText ? EditOperation.replace(range, edit.content) : EditOperation.insert(startPosition, edit.content);
+		model.pushEditOperations([new Selection(startPosition.lineNumber, startPosition.column, startPosition.lineNumber, startPosition.column)], [editOperation], () => []);
+	}
+
+	private resolveModelReference(): Promise<IReference<IResolvedTextEditorModel>> {
+		return this.fileService.exists(this.resource)
+			.then(exists => {
+				const EOL = this.configurationService.getValue<{ eol: string }>('files', { overrideIdentifier: 'json' })['eol'];
+				const result: Promise<any> = exists ? Promise.resolve(null) : this.textFileService.write(this.resource, this.getEmptyContent(EOL), { encoding: 'utf8' });
+				return result.then(() => this.textModelResolverService.createModelReference(this.resource));
+			});
+	}
+
+	private resolveAndValidate(): Promise<IReference<IResolvedTextEditorModel>> {
+
+		// Target cannot be dirty if not writing into buffer
+		if (this.textFileService.isDirty(this.resource)) {
+			return Promise.reject(new Error(localize('errorKeybindingsFileDirty', "Unable to write because the keybindings configuration file is dirty. Please save it first and then try again.")));
+		}
+
+		return this.resolveModelReference()
+			.then(reference => {
+				const model = reference.object.textEditorModel;
+				const EOL = model.getEOL();
+				if (model.getValue()) {
+					const parsed = this.parse(model);
+					if (parsed.parseErrors.length) {
+						reference.dispose();
+						return Promise.reject<any>(new Error(localize('parseErrors', "Unable to write to the keybindings configuration file. Please open it to correct errors/warnings in the file and try again.")));
+					}
+					if (parsed.result) {
+						if (!isArray(parsed.result)) {
+							reference.dispose();
+							return Promise.reject<any>(new Error(localize('errorInvalidConfiguration', "Unable to write to the keybindings configuration file. It has an object which is not of type Array. Please open the file to clean up and try again.")));
+						}
+					} else {
+						const content = EOL + '[]';
+						this.applyEditsToBuffer({ content, length: content.length, offset: model.getValue().length }, model);
+					}
+				} else {
+					const content = this.getEmptyContent(EOL);
+					this.applyEditsToBuffer({ content, length: content.length, offset: 0 }, model);
+				}
+				return reference;
+			});
+	}
+
+	private parse(model: ITextModel): { result: IUserFriendlyKeybinding[], parseErrors: json.ParseError[] } {
+		const parseErrors: json.ParseError[] = [];
+		const result = json.parse(model.getValue(), parseErrors, { allowTrailingComma: true, allowEmptyContent: true });
+		return { result, parseErrors };
+	}
+
+	private getEmptyContent(EOL: string): string {
+		return '// ' + localize('emptyKeybindingsHeader', "Place your key bindings in this file to override the defaults") + EOL + '[]';
+	}
+}
+
+registerSingleton(IKeybindingEditingService, KeybindingsEditingService, true);

lib/vscode/src/vs/workbench/services/keybinding/common/keybindingIO.ts

@@ -0,0 +1,85 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { SimpleKeybinding } from 'vs/base/common/keyCodes';
+import { KeybindingParser } from 'vs/base/common/keybindingParser';
+import { ScanCodeBinding } from 'vs/base/common/scanCode';
+import { ContextKeyExpr, ContextKeyExpression } from 'vs/platform/contextkey/common/contextkey';
+import { IUserFriendlyKeybinding } from 'vs/platform/keybinding/common/keybinding';
+import { ResolvedKeybindingItem } from 'vs/platform/keybinding/common/resolvedKeybindingItem';
+
+export interface IUserKeybindingItem {
+	parts: (SimpleKeybinding | ScanCodeBinding)[];
+	command: string | null;
+	commandArgs?: any;
+	when: ContextKeyExpression | undefined;
+}
+
+export class KeybindingIO {
+
+	public static writeKeybindingItem(out: OutputBuilder, item: ResolvedKeybindingItem): void {
+		if (!item.resolvedKeybinding) {
+			return;
+		}
+		let quotedSerializedKeybinding = JSON.stringify(item.resolvedKeybinding.getUserSettingsLabel());
+		out.write(`{ "key": ${rightPaddedString(quotedSerializedKeybinding + ',', 25)} "command": `);
+
+		let quotedSerializedWhen = item.when ? JSON.stringify(item.when.serialize()) : '';
+		let 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(' }');
+	}
+
+	public static readUserKeybindingItem(input: IUserFriendlyKeybinding): IUserKeybindingItem {
+		const parts = (typeof input.key === 'string' ? KeybindingParser.parseUserBinding(input.key) : []);
+		const when = (typeof input.when === 'string' ? ContextKeyExpr.deserialize(input.when) : undefined);
+		const command = (typeof input.command === 'string' ? input.command : null);
+		const commandArgs = (typeof input.args !== 'undefined' ? input.args : undefined);
+		return {
+			parts: parts,
+			command: command,
+			commandArgs: commandArgs,
+			when: when
+		};
+	}
+}
+
+function rightPaddedString(str: string, minChars: number): string {
+	if (str.length < minChars) {
+		return str + (new Array(minChars - str.length).join(' '));
+	}
+	return str;
+}
+
+export class OutputBuilder {
+
+	private _lines: string[] = [];
+	private _currentLine: string = '';
+
+	write(str: string): void {
+		this._currentLine += str;
+	}
+
+	writeLine(str: string = ''): void {
+		this._lines.push(this._currentLine + str);
+		this._currentLine = '';
+	}
+
+	toString(): string {
+		this.writeLine();
+		return this._lines.join('\n');
+	}
+}

lib/vscode/src/vs/workbench/services/keybinding/common/keyboardMapper.ts

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Keybinding, ResolvedKeybinding, SimpleKeybinding } from 'vs/base/common/keyCodes';
+import { ScanCodeBinding } from 'vs/base/common/scanCode';
+import { IKeyboardEvent } from 'vs/platform/keybinding/common/keybinding';
+
+export interface IKeyboardMapper {
+	dumpDebugInfo(): string;
+	resolveKeybinding(keybinding: Keybinding): ResolvedKeybinding[];
+	resolveKeyboardEvent(keyboardEvent: IKeyboardEvent): ResolvedKeybinding;
+	resolveUserBinding(firstPart: (SimpleKeybinding | ScanCodeBinding)[]): ResolvedKeybinding[];
+}
+
+export class CachedKeyboardMapper implements IKeyboardMapper {
+
+	private _actual: IKeyboardMapper;
+	private _cache: Map<string, ResolvedKeybinding[]>;
+
+	constructor(actual: IKeyboardMapper) {
+		this._actual = actual;
+		this._cache = new Map<string, ResolvedKeybinding[]>();
+	}
+
+	public dumpDebugInfo(): string {
+		return this._actual.dumpDebugInfo();
+	}
+
+	public resolveKeybinding(keybinding: Keybinding): ResolvedKeybinding[] {
+		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;
+	}
+
+	public resolveKeyboardEvent(keyboardEvent: IKeyboardEvent): ResolvedKeybinding {
+		return this._actual.resolveKeyboardEvent(keyboardEvent);
+	}
+
+	public resolveUserBinding(parts: (SimpleKeybinding | ScanCodeBinding)[]): ResolvedKeybinding[] {
+		return this._actual.resolveUserBinding(parts);
+	}
+}

lib/vscode/src/vs/workbench/services/keybinding/common/keymapInfo.ts

@@ -0,0 +1,343 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Event } from 'vs/base/common/event';
+import { isWindows, isLinux } from 'vs/base/common/platform';
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { DispatchConfig } from 'vs/workbench/services/keybinding/common/dispatchConfig';
+import { IKeyboardMapper } from 'vs/workbench/services/keybinding/common/keyboardMapper';
+import { IKeyboardEvent } from 'vs/platform/keybinding/common/keybinding';
+
+
+export interface IWindowsKeyMapping {
+	vkey: string;
+	value: string;
+	withShift: string;
+	withAltGr: string;
+	withShiftAltGr: string;
+}
+export interface IWindowsKeyboardMapping {
+	[code: string]: IWindowsKeyMapping;
+}
+export interface ILinuxKeyMapping {
+	value: string;
+	withShift: string;
+	withAltGr: string;
+	withShiftAltGr: string;
+}
+export interface ILinuxKeyboardMapping {
+	[code: string]: ILinuxKeyMapping;
+}
+export interface IMacKeyMapping {
+	value: string;
+	withShift: string;
+	withAltGr: string;
+	withShiftAltGr: string;
+	valueIsDeadKey: boolean;
+	withShiftIsDeadKey: boolean;
+	withAltGrIsDeadKey: boolean;
+	withShiftAltGrIsDeadKey: boolean;
+}
+export interface IMacKeyboardMapping {
+	[code: string]: IMacKeyMapping;
+}
+
+export type IKeyboardMapping = IWindowsKeyboardMapping | ILinuxKeyboardMapping | IMacKeyboardMapping;
+
+/* __GDPR__FRAGMENT__
+	"IKeyboardLayoutInfo" : {
+		"name" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+		"id": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+		"text": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
+	}
+*/
+export interface IWindowsKeyboardLayoutInfo {
+	name: string;
+	id: string;
+	text: string;
+}
+
+/* __GDPR__FRAGMENT__
+	"IKeyboardLayoutInfo" : {
+		"model" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+		"layout": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+		"variant": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+		"options": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+		"rules": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
+	}
+*/
+export interface ILinuxKeyboardLayoutInfo {
+	model: string;
+	layout: string;
+	variant: string;
+	options: string;
+	rules: string;
+}
+
+/* __GDPR__FRAGMENT__
+	"IKeyboardLayoutInfo" : {
+		"id" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+		"lang": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+		"localizedName": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
+	}
+*/
+export interface IMacKeyboardLayoutInfo {
+	id: string;
+	lang: string;
+	localizedName?: string;
+}
+
+export type IKeyboardLayoutInfo = (IWindowsKeyboardLayoutInfo | ILinuxKeyboardLayoutInfo | IMacKeyboardLayoutInfo) & { isUserKeyboardLayout?: boolean; isUSStandard?: true };
+
+export const IKeymapService = createDecorator<IKeymapService>('keymapService');
+
+export interface IKeymapService {
+	readonly _serviceBrand: undefined;
+	onDidChangeKeyboardMapper: Event<void>;
+	getKeyboardMapper(dispatchConfig: DispatchConfig): IKeyboardMapper;
+	getCurrentKeyboardLayout(): IKeyboardLayoutInfo | null;
+	getAllKeyboardLayouts(): IKeyboardLayoutInfo[];
+	getRawKeyboardMapping(): IKeyboardMapping | null;
+	validateCurrentKeyboardMapping(keyboardEvent: IKeyboardEvent): void;
+}
+
+export function areKeyboardLayoutsEqual(a: IKeyboardLayoutInfo | null, b: IKeyboardLayoutInfo | null): boolean {
+	if (!a || !b) {
+		return false;
+	}
+
+	if ((<IWindowsKeyboardLayoutInfo>a).name && (<IWindowsKeyboardLayoutInfo>b).name && (<IWindowsKeyboardLayoutInfo>a).name === (<IWindowsKeyboardLayoutInfo>b).name) {
+		return true;
+	}
+
+	if ((<IMacKeyboardLayoutInfo>a).id && (<IMacKeyboardLayoutInfo>b).id && (<IMacKeyboardLayoutInfo>a).id === (<IMacKeyboardLayoutInfo>b).id) {
+		return true;
+	}
+
+	if ((<ILinuxKeyboardLayoutInfo>a).model &&
+		(<ILinuxKeyboardLayoutInfo>b).model &&
+		(<ILinuxKeyboardLayoutInfo>a).model === (<ILinuxKeyboardLayoutInfo>b).model &&
+		(<ILinuxKeyboardLayoutInfo>a).layout === (<ILinuxKeyboardLayoutInfo>b).layout
+	) {
+		return true;
+	}
+
+	return false;
+}
+
+export function parseKeyboardLayoutDescription(layout: IKeyboardLayoutInfo | null): { label: string, description: string } {
+	if (!layout) {
+		return { label: '', description: '' };
+	}
+
+	if ((<IWindowsKeyboardLayoutInfo>layout).name) {
+		// windows
+		let windowsLayout = <IWindowsKeyboardLayoutInfo>layout;
+		return {
+			label: windowsLayout.text,
+			description: ''
+		};
+	}
+
+	if ((<IMacKeyboardLayoutInfo>layout).id) {
+		let macLayout = <IMacKeyboardLayoutInfo>layout;
+		if (macLayout.localizedName) {
+			return {
+				label: macLayout.localizedName,
+				description: ''
+			};
+		}
+
+		if (/^com\.apple\.keylayout\./.test(macLayout.id)) {
+			return {
+				label: macLayout.id.replace(/^com\.apple\.keylayout\./, '').replace(/-/, ' '),
+				description: ''
+			};
+		}
+		if (/^.*inputmethod\./.test(macLayout.id)) {
+			return {
+				label: macLayout.id.replace(/^.*inputmethod\./, '').replace(/[-\.]/, ' '),
+				description: `Input Method (${macLayout.lang})`
+			};
+		}
+
+		return {
+			label: macLayout.lang,
+			description: ''
+		};
+	}
+
+	let linuxLayout = <ILinuxKeyboardLayoutInfo>layout;
+
+	return {
+		label: linuxLayout.layout,
+		description: ''
+	};
+}
+
+export function getKeyboardLayoutId(layout: IKeyboardLayoutInfo): string {
+	if ((<IWindowsKeyboardLayoutInfo>layout).name) {
+		return (<IWindowsKeyboardLayoutInfo>layout).name;
+	}
+
+	if ((<IMacKeyboardLayoutInfo>layout).id) {
+		return (<IMacKeyboardLayoutInfo>layout).id;
+	}
+
+	return (<ILinuxKeyboardLayoutInfo>layout).layout;
+}
+
+function deserializeMapping(serializedMapping: ISerializedMapping) {
+	let mapping = serializedMapping;
+
+	let ret: { [key: string]: any } = {};
+	for (let key in mapping) {
+		let result: (string | number)[] = mapping[key];
+		if (result.length) {
+			let value = result[0];
+			let withShift = result[1];
+			let withAltGr = result[2];
+			let withShiftAltGr = result[3];
+			let mask = Number(result[4]);
+			let 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
+			};
+		}
+	}
+
+	return ret;
+}
+
+export interface IRawMixedKeyboardMapping {
+	[key: string]: {
+		value: string,
+		withShift: string;
+		withAltGr: string;
+		withShiftAltGr: string;
+		valueIsDeadKey?: boolean;
+		withShiftIsDeadKey?: boolean;
+		withAltGrIsDeadKey?: boolean;
+		withShiftAltGrIsDeadKey?: boolean;
+
+	};
+}
+
+interface ISerializedMapping {
+	[key: string]: (string | number)[];
+}
+
+export interface IKeymapInfo {
+	layout: IKeyboardLayoutInfo;
+	secondaryLayouts: IKeyboardLayoutInfo[];
+	mapping: ISerializedMapping;
+	isUserKeyboardLayout?: boolean;
+}
+
+export class KeymapInfo {
+	mapping: IRawMixedKeyboardMapping;
+	isUserKeyboardLayout: boolean;
+
+	constructor(public layout: IKeyboardLayoutInfo, public secondaryLayouts: IKeyboardLayoutInfo[], keyboardMapping: ISerializedMapping, isUserKeyboardLayout?: boolean) {
+		this.mapping = deserializeMapping(keyboardMapping);
+		this.isUserKeyboardLayout = !!isUserKeyboardLayout;
+		this.layout.isUserKeyboardLayout = !!isUserKeyboardLayout;
+	}
+
+	static createKeyboardLayoutFromDebugInfo(layout: IKeyboardLayoutInfo, value: IRawMixedKeyboardMapping, isUserKeyboardLayout?: boolean): KeymapInfo {
+		let keyboardLayoutInfo = new KeymapInfo(layout, [], {}, true);
+		keyboardLayoutInfo.mapping = value;
+		return keyboardLayoutInfo;
+	}
+
+	update(other: KeymapInfo) {
+		this.layout = other.layout;
+		this.secondaryLayouts = other.secondaryLayouts;
+		this.mapping = other.mapping;
+		this.isUserKeyboardLayout = other.isUserKeyboardLayout;
+		this.layout.isUserKeyboardLayout = other.isUserKeyboardLayout;
+	}
+
+	getScore(other: IRawMixedKeyboardMapping): number {
+		let score = 0;
+		for (let key in other) {
+			if (isWindows && (key === 'Backslash' || key === 'KeyQ')) {
+				// keymap from Chromium is probably wrong.
+				continue;
+			}
+
+			if (isLinux && (key === 'Backspace' || key === 'Escape')) {
+				// native keymap doesn't align with keyboard event
+				continue;
+			}
+
+			let currentMapping = this.mapping[key];
+
+			if (currentMapping === undefined) {
+				score -= 1;
+			}
+
+			let otherMapping = other[key];
+
+			if (currentMapping && otherMapping && currentMapping.value !== otherMapping.value) {
+				score -= 1;
+			}
+		}
+
+		return score;
+	}
+
+	equal(other: KeymapInfo): boolean {
+		if (this.isUserKeyboardLayout !== other.isUserKeyboardLayout) {
+			return false;
+		}
+
+		if (getKeyboardLayoutId(this.layout) !== getKeyboardLayoutId(other.layout)) {
+			return false;
+		}
+
+		return this.fuzzyEqual(other.mapping);
+	}
+
+	fuzzyEqual(other: IRawMixedKeyboardMapping): boolean {
+		for (let key in other) {
+			if (isWindows && (key === 'Backslash' || key === 'KeyQ')) {
+				// keymap from Chromium is probably wrong.
+				continue;
+			}
+			if (this.mapping[key] === undefined) {
+				return false;
+			}
+
+			let currentMapping = this.mapping[key];
+			let otherMapping = other[key];
+
+			if (currentMapping.value !== otherMapping.value) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+}

lib/vscode/src/vs/workbench/services/keybinding/common/macLinuxFallbackKeyboardMapper.ts

@@ -0,0 +1,128 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ChordKeybinding, KeyCode, Keybinding, ResolvedKeybinding, SimpleKeybinding } from 'vs/base/common/keyCodes';
+import { OperatingSystem } from 'vs/base/common/platform';
+import { IMMUTABLE_CODE_TO_KEY_CODE, ScanCode, ScanCodeBinding } from 'vs/base/common/scanCode';
+import { IKeyboardEvent } from 'vs/platform/keybinding/common/keybinding';
+import { USLayoutResolvedKeybinding } from 'vs/platform/keybinding/common/usLayoutResolvedKeybinding';
+import { IKeyboardMapper } from 'vs/workbench/services/keybinding/common/keyboardMapper';
+import { removeElementsAfterNulls } from 'vs/platform/keybinding/common/resolvedKeybindingItem';
+
+/**
+ * A keyboard mapper to be used when reading the keymap from the OS fails.
+ */
+export class MacLinuxFallbackKeyboardMapper implements IKeyboardMapper {
+
+	/**
+	 * OS (can be Linux or Macintosh)
+	 */
+	private readonly _OS: OperatingSystem;
+
+	constructor(OS: OperatingSystem) {
+		this._OS = OS;
+	}
+
+	public dumpDebugInfo(): string {
+		return 'FallbackKeyboardMapper dispatching on keyCode';
+	}
+
+	public resolveKeybinding(keybinding: Keybinding): ResolvedKeybinding[] {
+		return [new USLayoutResolvedKeybinding(keybinding, this._OS)];
+	}
+
+	public resolveKeyboardEvent(keyboardEvent: IKeyboardEvent): ResolvedKeybinding {
+		let keybinding = new SimpleKeybinding(
+			keyboardEvent.ctrlKey,
+			keyboardEvent.shiftKey,
+			keyboardEvent.altKey,
+			keyboardEvent.metaKey,
+			keyboardEvent.keyCode
+		);
+		return new USLayoutResolvedKeybinding(keybinding.toChord(), this._OS);
+	}
+
+	private _scanCodeToKeyCode(scanCode: ScanCode): KeyCode {
+		const immutableKeyCode = IMMUTABLE_CODE_TO_KEY_CODE[scanCode];
+		if (immutableKeyCode !== -1) {
+			return immutableKeyCode;
+		}
+
+		switch (scanCode) {
+			case ScanCode.KeyA: return KeyCode.KEY_A;
+			case ScanCode.KeyB: return KeyCode.KEY_B;
+			case ScanCode.KeyC: return KeyCode.KEY_C;
+			case ScanCode.KeyD: return KeyCode.KEY_D;
+			case ScanCode.KeyE: return KeyCode.KEY_E;
+			case ScanCode.KeyF: return KeyCode.KEY_F;
+			case ScanCode.KeyG: return KeyCode.KEY_G;
+			case ScanCode.KeyH: return KeyCode.KEY_H;
+			case ScanCode.KeyI: return KeyCode.KEY_I;
+			case ScanCode.KeyJ: return KeyCode.KEY_J;
+			case ScanCode.KeyK: return KeyCode.KEY_K;
+			case ScanCode.KeyL: return KeyCode.KEY_L;
+			case ScanCode.KeyM: return KeyCode.KEY_M;
+			case ScanCode.KeyN: return KeyCode.KEY_N;
+			case ScanCode.KeyO: return KeyCode.KEY_O;
+			case ScanCode.KeyP: return KeyCode.KEY_P;
+			case ScanCode.KeyQ: return KeyCode.KEY_Q;
+			case ScanCode.KeyR: return KeyCode.KEY_R;
+			case ScanCode.KeyS: return KeyCode.KEY_S;
+			case ScanCode.KeyT: return KeyCode.KEY_T;
+			case ScanCode.KeyU: return KeyCode.KEY_U;
+			case ScanCode.KeyV: return KeyCode.KEY_V;
+			case ScanCode.KeyW: return KeyCode.KEY_W;
+			case ScanCode.KeyX: return KeyCode.KEY_X;
+			case ScanCode.KeyY: return KeyCode.KEY_Y;
+			case ScanCode.KeyZ: return KeyCode.KEY_Z;
+			case ScanCode.Digit1: return KeyCode.KEY_1;
+			case ScanCode.Digit2: return KeyCode.KEY_2;
+			case ScanCode.Digit3: return KeyCode.KEY_3;
+			case ScanCode.Digit4: return KeyCode.KEY_4;
+			case ScanCode.Digit5: return KeyCode.KEY_5;
+			case ScanCode.Digit6: return KeyCode.KEY_6;
+			case ScanCode.Digit7: return KeyCode.KEY_7;
+			case ScanCode.Digit8: return KeyCode.KEY_8;
+			case ScanCode.Digit9: return KeyCode.KEY_9;
+			case ScanCode.Digit0: return KeyCode.KEY_0;
+			case ScanCode.Minus: return KeyCode.US_MINUS;
+			case ScanCode.Equal: return KeyCode.US_EQUAL;
+			case ScanCode.BracketLeft: return KeyCode.US_OPEN_SQUARE_BRACKET;
+			case ScanCode.BracketRight: return KeyCode.US_CLOSE_SQUARE_BRACKET;
+			case ScanCode.Backslash: return KeyCode.US_BACKSLASH;
+			case ScanCode.IntlHash: return KeyCode.Unknown; // missing
+			case ScanCode.Semicolon: return KeyCode.US_SEMICOLON;
+			case ScanCode.Quote: return KeyCode.US_QUOTE;
+			case ScanCode.Backquote: return KeyCode.US_BACKTICK;
+			case ScanCode.Comma: return KeyCode.US_COMMA;
+			case ScanCode.Period: return KeyCode.US_DOT;
+			case ScanCode.Slash: return KeyCode.US_SLASH;
+			case ScanCode.IntlBackslash: return KeyCode.OEM_102;
+		}
+		return KeyCode.Unknown;
+	}
+
+	private _resolveSimpleUserBinding(binding: SimpleKeybinding | ScanCodeBinding | null): SimpleKeybinding | null {
+		if (!binding) {
+			return null;
+		}
+		if (binding instanceof SimpleKeybinding) {
+			return binding;
+		}
+		const keyCode = this._scanCodeToKeyCode(binding.scanCode);
+		if (keyCode === KeyCode.Unknown) {
+			return null;
+		}
+		return new SimpleKeybinding(binding.ctrlKey, binding.shiftKey, binding.altKey, binding.metaKey, keyCode);
+	}
+
+	public resolveUserBinding(input: (SimpleKeybinding | ScanCodeBinding)[]): ResolvedKeybinding[] {
+		const parts: SimpleKeybinding[] = removeElementsAfterNulls(input.map(keybinding => this._resolveSimpleUserBinding(keybinding)));
+		if (parts.length > 0) {
+			return [new USLayoutResolvedKeybinding(new ChordKeybinding(parts), this._OS)];
+		}
+		return [];
+	}
+}

lib/vscode/src/vs/workbench/services/keybinding/common/windowsKeyboardMapper.ts

@@ -0,0 +1,684 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { CharCode } from 'vs/base/common/charCode';
+import { KeyCode, KeyCodeUtils, Keybinding, ResolvedKeybinding, SimpleKeybinding } from 'vs/base/common/keyCodes';
+import { UILabelProvider } from 'vs/base/common/keybindingLabels';
+import { OperatingSystem } from 'vs/base/common/platform';
+import { IMMUTABLE_CODE_TO_KEY_CODE, ScanCode, ScanCodeBinding, ScanCodeUtils } from 'vs/base/common/scanCode';
+import { IKeyboardEvent } from 'vs/platform/keybinding/common/keybinding';
+import { IKeyboardMapper } from 'vs/workbench/services/keybinding/common/keyboardMapper';
+import { BaseResolvedKeybinding } from 'vs/platform/keybinding/common/baseResolvedKeybinding';
+import { removeElementsAfterNulls } from 'vs/platform/keybinding/common/resolvedKeybindingItem';
+
+export interface IWindowsKeyMapping {
+	vkey: string;
+	value: string;
+	withShift: string;
+	withAltGr: string;
+	withShiftAltGr: string;
+}
+
+function windowsKeyMappingEquals(a: IWindowsKeyMapping, b: IWindowsKeyMapping): boolean {
+	if (!a && !b) {
+		return true;
+	}
+	if (!a || !b) {
+		return false;
+	}
+	return (
+		a.vkey === b.vkey
+		&& a.value === b.value
+		&& a.withShift === b.withShift
+		&& a.withAltGr === b.withAltGr
+		&& a.withShiftAltGr === b.withShiftAltGr
+	);
+}
+
+export interface IWindowsKeyboardMapping {
+	[scanCode: string]: IWindowsKeyMapping;
+}
+
+export function windowsKeyboardMappingEquals(a: IWindowsKeyboardMapping | null, b: IWindowsKeyboardMapping | null): boolean {
+	if (!a && !b) {
+		return true;
+	}
+	if (!a || !b) {
+		return false;
+	}
+	for (let scanCode = 0; scanCode < ScanCode.MAX_VALUE; scanCode++) {
+		const strScanCode = ScanCodeUtils.toString(scanCode);
+		const aEntry = a[strScanCode];
+		const bEntry = b[strScanCode];
+		if (!windowsKeyMappingEquals(aEntry, bEntry)) {
+			return false;
+		}
+	}
+	return true;
+}
+
+
+const LOG = false;
+function log(str: string): void {
+	if (LOG) {
+		console.info(str);
+	}
+}
+
+const NATIVE_KEY_CODE_TO_KEY_CODE: { [nativeKeyCode: string]: KeyCode; } = _getNativeMap();
+
+export interface IScanCodeMapping {
+	scanCode: ScanCode;
+	keyCode: KeyCode;
+	value: string;
+	withShift: string;
+	withAltGr: string;
+	withShiftAltGr: string;
+}
+
+export class WindowsNativeResolvedKeybinding extends BaseResolvedKeybinding<SimpleKeybinding> {
+
+	private readonly _mapper: WindowsKeyboardMapper;
+
+	constructor(mapper: WindowsKeyboardMapper, parts: SimpleKeybinding[]) {
+		super(OperatingSystem.Windows, parts);
+		this._mapper = mapper;
+	}
+
+	protected _getLabel(keybinding: SimpleKeybinding): string | null {
+		if (keybinding.isDuplicateModifierCase()) {
+			return '';
+		}
+		return this._mapper.getUILabelForKeyCode(keybinding.keyCode);
+	}
+
+	private _getUSLabelForKeybinding(keybinding: SimpleKeybinding): string | null {
+		if (keybinding.isDuplicateModifierCase()) {
+			return '';
+		}
+		return KeyCodeUtils.toString(keybinding.keyCode);
+	}
+
+	public getUSLabel(): string | null {
+		return UILabelProvider.toLabel(this._os, this._parts, (keybinding) => this._getUSLabelForKeybinding(keybinding));
+	}
+
+	protected _getAriaLabel(keybinding: SimpleKeybinding): string | null {
+		if (keybinding.isDuplicateModifierCase()) {
+			return '';
+		}
+		return this._mapper.getAriaLabelForKeyCode(keybinding.keyCode);
+	}
+
+	private _keyCodeToElectronAccelerator(keyCode: KeyCode): string | null {
+		if (keyCode >= KeyCode.NUMPAD_0 && keyCode <= KeyCode.NUMPAD_DIVIDE) {
+			// Electron cannot handle numpad keys
+			return null;
+		}
+
+		switch (keyCode) {
+			case KeyCode.UpArrow:
+				return 'Up';
+			case KeyCode.DownArrow:
+				return 'Down';
+			case KeyCode.LeftArrow:
+				return 'Left';
+			case KeyCode.RightArrow:
+				return 'Right';
+		}
+
+		// electron menus always do the correct rendering on Windows
+		return KeyCodeUtils.toString(keyCode);
+	}
+
+	protected _getElectronAccelerator(keybinding: SimpleKeybinding): string | null {
+		if (keybinding.isDuplicateModifierCase()) {
+			return null;
+		}
+		return this._keyCodeToElectronAccelerator(keybinding.keyCode);
+	}
+
+	protected _getUserSettingsLabel(keybinding: SimpleKeybinding): string | null {
+		if (keybinding.isDuplicateModifierCase()) {
+			return '';
+		}
+		const result = this._mapper.getUserSettingsLabelForKeyCode(keybinding.keyCode);
+		return (result ? result.toLowerCase() : result);
+	}
+
+	protected _isWYSIWYG(keybinding: SimpleKeybinding): boolean {
+		return this.__isWYSIWYG(keybinding.keyCode);
+	}
+
+	private __isWYSIWYG(keyCode: KeyCode): boolean {
+		if (
+			keyCode === KeyCode.LeftArrow
+			|| keyCode === KeyCode.UpArrow
+			|| keyCode === KeyCode.RightArrow
+			|| keyCode === KeyCode.DownArrow
+		) {
+			return true;
+		}
+		const ariaLabel = this._mapper.getAriaLabelForKeyCode(keyCode);
+		const userSettingsLabel = this._mapper.getUserSettingsLabelForKeyCode(keyCode);
+		return (ariaLabel === userSettingsLabel);
+	}
+
+	protected _getDispatchPart(keybinding: SimpleKeybinding): string | null {
+		if (keybinding.isModifierKey()) {
+			return null;
+		}
+		let result = '';
+
+		if (keybinding.ctrlKey) {
+			result += 'ctrl+';
+		}
+		if (keybinding.shiftKey) {
+			result += 'shift+';
+		}
+		if (keybinding.altKey) {
+			result += 'alt+';
+		}
+		if (keybinding.metaKey) {
+			result += 'meta+';
+		}
+		result += KeyCodeUtils.toString(keybinding.keyCode);
+
+		return result;
+	}
+
+	private static getProducedCharCode(kb: ScanCodeBinding, mapping: IScanCodeMapping): string | null {
+		if (!mapping) {
+			return null;
+		}
+		if (kb.ctrlKey && kb.shiftKey && kb.altKey) {
+			return mapping.withShiftAltGr;
+		}
+		if (kb.ctrlKey && kb.altKey) {
+			return mapping.withAltGr;
+		}
+		if (kb.shiftKey) {
+			return mapping.withShift;
+		}
+		return mapping.value;
+	}
+
+	public static getProducedChar(kb: ScanCodeBinding, mapping: IScanCodeMapping): string {
+		const char = this.getProducedCharCode(kb, mapping);
+		if (char === null || char.length === 0) {
+			return ' --- ';
+		}
+		return '  ' + char + '  ';
+	}
+}
+
+export class WindowsKeyboardMapper implements IKeyboardMapper {
+
+	public readonly isUSStandard: boolean;
+	private readonly _codeInfo: IScanCodeMapping[];
+	private readonly _scanCodeToKeyCode: KeyCode[];
+	private readonly _keyCodeToLabel: Array<string | null> = [];
+	private readonly _keyCodeExists: boolean[];
+
+	constructor(isUSStandard: boolean, rawMappings: IWindowsKeyboardMapping) {
+		this.isUSStandard = isUSStandard;
+		this._scanCodeToKeyCode = [];
+		this._keyCodeToLabel = [];
+		this._keyCodeExists = [];
+		this._keyCodeToLabel[KeyCode.Unknown] = KeyCodeUtils.toString(KeyCode.Unknown);
+
+		for (let scanCode = ScanCode.None; scanCode < ScanCode.MAX_VALUE; scanCode++) {
+			const immutableKeyCode = IMMUTABLE_CODE_TO_KEY_CODE[scanCode];
+			if (immutableKeyCode !== -1) {
+				this._scanCodeToKeyCode[scanCode] = immutableKeyCode;
+				this._keyCodeToLabel[immutableKeyCode] = KeyCodeUtils.toString(immutableKeyCode);
+				this._keyCodeExists[immutableKeyCode] = true;
+			}
+		}
+
+		let producesLetter: boolean[] = [];
+		let producesLetters = false;
+
+		this._codeInfo = [];
+		for (let strCode in rawMappings) {
+			if (rawMappings.hasOwnProperty(strCode)) {
+				const scanCode = ScanCodeUtils.toEnum(strCode);
+				if (scanCode === ScanCode.None) {
+					log(`Unknown scanCode ${strCode} in mapping.`);
+					continue;
+				}
+				const rawMapping = rawMappings[strCode];
+
+				const immutableKeyCode = IMMUTABLE_CODE_TO_KEY_CODE[scanCode];
+				if (immutableKeyCode !== -1) {
+					const keyCode = NATIVE_KEY_CODE_TO_KEY_CODE[rawMapping.vkey] || KeyCode.Unknown;
+					if (keyCode === KeyCode.Unknown || immutableKeyCode === keyCode) {
+						continue;
+					}
+					if (scanCode !== ScanCode.NumpadComma) {
+						// Looks like ScanCode.NumpadComma doesn't always map to KeyCode.NUMPAD_SEPARATOR
+						// e.g. on POR - PTB
+						continue;
+					}
+				}
+
+				const value = rawMapping.value;
+				const withShift = rawMapping.withShift;
+				const withAltGr = rawMapping.withAltGr;
+				const withShiftAltGr = rawMapping.withShiftAltGr;
+				const keyCode = NATIVE_KEY_CODE_TO_KEY_CODE[rawMapping.vkey] || KeyCode.Unknown;
+
+				const mapping: IScanCodeMapping = {
+					scanCode: scanCode,
+					keyCode: keyCode,
+					value: value,
+					withShift: withShift,
+					withAltGr: withAltGr,
+					withShiftAltGr: withShiftAltGr,
+				};
+				this._codeInfo[scanCode] = mapping;
+				this._scanCodeToKeyCode[scanCode] = keyCode;
+
+				if (keyCode === KeyCode.Unknown) {
+					continue;
+				}
+				this._keyCodeExists[keyCode] = true;
+
+				if (value.length === 0) {
+					// This key does not produce strings
+					this._keyCodeToLabel[keyCode] = null;
+				}
+
+				else if (value.length > 1) {
+					// This key produces a letter representable with multiple UTF-16 code units.
+					this._keyCodeToLabel[keyCode] = value;
+				}
+
+				else {
+					const charCode = value.charCodeAt(0);
+
+					if (charCode >= CharCode.a && charCode <= CharCode.z) {
+						const upperCaseValue = CharCode.A + (charCode - CharCode.a);
+						producesLetter[upperCaseValue] = true;
+						producesLetters = true;
+						this._keyCodeToLabel[keyCode] = String.fromCharCode(CharCode.A + (charCode - CharCode.a));
+					}
+
+					else if (charCode >= CharCode.A && charCode <= CharCode.Z) {
+						producesLetter[charCode] = true;
+						producesLetters = true;
+						this._keyCodeToLabel[keyCode] = value;
+					}
+
+					else {
+						this._keyCodeToLabel[keyCode] = value;
+					}
+				}
+			}
+		}
+
+		// Handle keyboard layouts where latin characters are not produced e.g. Cyrillic
+		const _registerLetterIfMissing = (charCode: CharCode, keyCode: KeyCode): void => {
+			if (!producesLetter[charCode]) {
+				this._keyCodeToLabel[keyCode] = String.fromCharCode(charCode);
+			}
+		};
+		_registerLetterIfMissing(CharCode.A, KeyCode.KEY_A);
+		_registerLetterIfMissing(CharCode.B, KeyCode.KEY_B);
+		_registerLetterIfMissing(CharCode.C, KeyCode.KEY_C);
+		_registerLetterIfMissing(CharCode.D, KeyCode.KEY_D);
+		_registerLetterIfMissing(CharCode.E, KeyCode.KEY_E);
+		_registerLetterIfMissing(CharCode.F, KeyCode.KEY_F);
+		_registerLetterIfMissing(CharCode.G, KeyCode.KEY_G);
+		_registerLetterIfMissing(CharCode.H, KeyCode.KEY_H);
+		_registerLetterIfMissing(CharCode.I, KeyCode.KEY_I);
+		_registerLetterIfMissing(CharCode.J, KeyCode.KEY_J);
+		_registerLetterIfMissing(CharCode.K, KeyCode.KEY_K);
+		_registerLetterIfMissing(CharCode.L, KeyCode.KEY_L);
+		_registerLetterIfMissing(CharCode.M, KeyCode.KEY_M);
+		_registerLetterIfMissing(CharCode.N, KeyCode.KEY_N);
+		_registerLetterIfMissing(CharCode.O, KeyCode.KEY_O);
+		_registerLetterIfMissing(CharCode.P, KeyCode.KEY_P);
+		_registerLetterIfMissing(CharCode.Q, KeyCode.KEY_Q);
+		_registerLetterIfMissing(CharCode.R, KeyCode.KEY_R);
+		_registerLetterIfMissing(CharCode.S, KeyCode.KEY_S);
+		_registerLetterIfMissing(CharCode.T, KeyCode.KEY_T);
+		_registerLetterIfMissing(CharCode.U, KeyCode.KEY_U);
+		_registerLetterIfMissing(CharCode.V, KeyCode.KEY_V);
+		_registerLetterIfMissing(CharCode.W, KeyCode.KEY_W);
+		_registerLetterIfMissing(CharCode.X, KeyCode.KEY_X);
+		_registerLetterIfMissing(CharCode.Y, KeyCode.KEY_Y);
+		_registerLetterIfMissing(CharCode.Z, KeyCode.KEY_Z);
+
+		if (!producesLetters) {
+			// Since this keyboard layout produces no latin letters at all, most of the UI will use the
+			// US kb layout equivalent for UI labels, so also try to render other keys with the US labels
+			// for consistency...
+			const _registerLabel = (keyCode: KeyCode, charCode: CharCode): void => {
+				// const existingLabel = this._keyCodeToLabel[keyCode];
+				// const existingCharCode = (existingLabel ? existingLabel.charCodeAt(0) : CharCode.Null);
+				// if (existingCharCode < 32 || existingCharCode > 126) {
+				this._keyCodeToLabel[keyCode] = String.fromCharCode(charCode);
+				// }
+			};
+			_registerLabel(KeyCode.US_SEMICOLON, CharCode.Semicolon);
+			_registerLabel(KeyCode.US_EQUAL, CharCode.Equals);
+			_registerLabel(KeyCode.US_COMMA, CharCode.Comma);
+			_registerLabel(KeyCode.US_MINUS, CharCode.Dash);
+			_registerLabel(KeyCode.US_DOT, CharCode.Period);
+			_registerLabel(KeyCode.US_SLASH, CharCode.Slash);
+			_registerLabel(KeyCode.US_BACKTICK, CharCode.BackTick);
+			_registerLabel(KeyCode.US_OPEN_SQUARE_BRACKET, CharCode.OpenSquareBracket);
+			_registerLabel(KeyCode.US_BACKSLASH, CharCode.Backslash);
+			_registerLabel(KeyCode.US_CLOSE_SQUARE_BRACKET, CharCode.CloseSquareBracket);
+			_registerLabel(KeyCode.US_QUOTE, CharCode.SingleQuote);
+		}
+	}
+
+	public dumpDebugInfo(): string {
+		let result: string[] = [];
+
+		let immutableSamples = [
+			ScanCode.ArrowUp,
+			ScanCode.Numpad0
+		];
+
+		let cnt = 0;
+		result.push(`-----------------------------------------------------------------------------------------------------------------------------------------`);
+		for (let scanCode = ScanCode.None; scanCode < ScanCode.MAX_VALUE; 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 scanCodeBinding = new ScanCodeBinding(ctrlKey, shiftKey, altKey, false, scanCode);
+				const kb = this._resolveSimpleUserBinding(scanCodeBinding);
+				const strKeyCode = (kb ? KeyCodeUtils.toString(kb.keyCode) : null);
+				const resolvedKb = (kb ? new WindowsNativeResolvedKeybinding(this, [kb]) : null);
+
+				const outScanCode = `${ctrlKey ? 'Ctrl+' : ''}${shiftKey ? 'Shift+' : ''}${altKey ? 'Alt+' : ''}${strCode}`;
+				const ariaLabel = (resolvedKb ? resolvedKb.getAriaLabel() : null);
+				const outUILabel = (ariaLabel ? ariaLabel.replace(/Control\+/, 'Ctrl+') : null);
+				const outUserSettings = (resolvedKb ? resolvedKb.getUserSettingsLabel() : null);
+				const outKey = WindowsNativeResolvedKeybinding.getProducedChar(scanCodeBinding, mapping);
+				const 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');
+	}
+
+	private _leftPad(str: string | null, cnt: number): string {
+		if (str === null) {
+			str = 'null';
+		}
+		while (str.length < cnt) {
+			str = ' ' + str;
+		}
+		return str;
+	}
+
+	public getUILabelForKeyCode(keyCode: KeyCode): string {
+		return this._getLabelForKeyCode(keyCode);
+	}
+
+	public getAriaLabelForKeyCode(keyCode: KeyCode): string {
+		return this._getLabelForKeyCode(keyCode);
+	}
+
+	public getUserSettingsLabelForKeyCode(keyCode: KeyCode): string {
+		if (this.isUSStandard) {
+			return KeyCodeUtils.toUserSettingsUS(keyCode);
+		}
+		return KeyCodeUtils.toUserSettingsGeneral(keyCode);
+	}
+
+	private _getLabelForKeyCode(keyCode: KeyCode): string {
+		return this._keyCodeToLabel[keyCode] || KeyCodeUtils.toString(KeyCode.Unknown);
+	}
+
+	public resolveKeybinding(keybinding: Keybinding): WindowsNativeResolvedKeybinding[] {
+		const parts = keybinding.parts;
+		for (let i = 0, len = parts.length; i < len; i++) {
+			const part = parts[i];
+			if (!this._keyCodeExists[part.keyCode]) {
+				return [];
+			}
+		}
+		return [new WindowsNativeResolvedKeybinding(this, parts)];
+	}
+
+	public resolveKeyboardEvent(keyboardEvent: IKeyboardEvent): WindowsNativeResolvedKeybinding {
+		const keybinding = new SimpleKeybinding(keyboardEvent.ctrlKey, keyboardEvent.shiftKey, keyboardEvent.altKey, keyboardEvent.metaKey, keyboardEvent.keyCode);
+		return new WindowsNativeResolvedKeybinding(this, [keybinding]);
+	}
+
+	private _resolveSimpleUserBinding(binding: SimpleKeybinding | ScanCodeBinding | null): SimpleKeybinding | null {
+		if (!binding) {
+			return null;
+		}
+		if (binding instanceof SimpleKeybinding) {
+			if (!this._keyCodeExists[binding.keyCode]) {
+				return null;
+			}
+			return binding;
+		}
+		const keyCode = this._scanCodeToKeyCode[binding.scanCode] || KeyCode.Unknown;
+		if (keyCode === KeyCode.Unknown || !this._keyCodeExists[keyCode]) {
+			return null;
+		}
+		return new SimpleKeybinding(binding.ctrlKey, binding.shiftKey, binding.altKey, binding.metaKey, keyCode);
+	}
+
+	public resolveUserBinding(input: (SimpleKeybinding | ScanCodeBinding)[]): ResolvedKeybinding[] {
+		const parts: SimpleKeybinding[] = removeElementsAfterNulls(input.map(keybinding => this._resolveSimpleUserBinding(keybinding)));
+		if (parts.length > 0) {
+			return [new WindowsNativeResolvedKeybinding(this, parts)];
+		}
+		return [];
+	}
+}
+
+
+// See https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx
+// See https://github.com/microsoft/node-native-keymap/blob/master/deps/chromium/keyboard_codes_win.h
+function _getNativeMap() {
+	return {
+		VK_BACK: KeyCode.Backspace,
+		VK_TAB: KeyCode.Tab,
+		VK_CLEAR: KeyCode.Unknown, // MISSING
+		VK_RETURN: KeyCode.Enter,
+		VK_SHIFT: KeyCode.Shift,
+		VK_CONTROL: KeyCode.Ctrl,
+		VK_MENU: KeyCode.Alt,
+		VK_PAUSE: KeyCode.PauseBreak,
+		VK_CAPITAL: KeyCode.CapsLock,
+		VK_KANA: KeyCode.Unknown, // MISSING
+		VK_HANGUL: KeyCode.Unknown, // MISSING
+		VK_JUNJA: KeyCode.Unknown, // MISSING
+		VK_FINAL: KeyCode.Unknown, // MISSING
+		VK_HANJA: KeyCode.Unknown, // MISSING
+		VK_KANJI: KeyCode.Unknown, // MISSING
+		VK_ESCAPE: KeyCode.Escape,
+		VK_CONVERT: KeyCode.Unknown, // MISSING
+		VK_NONCONVERT: KeyCode.Unknown, // MISSING
+		VK_ACCEPT: KeyCode.Unknown, // MISSING
+		VK_MODECHANGE: KeyCode.Unknown, // MISSING
+		VK_SPACE: KeyCode.Space,
+		VK_PRIOR: KeyCode.PageUp,
+		VK_NEXT: KeyCode.PageDown,
+		VK_END: KeyCode.End,
+		VK_HOME: KeyCode.Home,
+		VK_LEFT: KeyCode.LeftArrow,
+		VK_UP: KeyCode.UpArrow,
+		VK_RIGHT: KeyCode.RightArrow,
+		VK_DOWN: KeyCode.DownArrow,
+		VK_SELECT: KeyCode.Unknown, // MISSING
+		VK_PRINT: KeyCode.Unknown, // MISSING
+		VK_EXECUTE: KeyCode.Unknown, // MISSING
+		VK_SNAPSHOT: KeyCode.Unknown, // MISSING
+		VK_INSERT: KeyCode.Insert,
+		VK_DELETE: KeyCode.Delete,
+		VK_HELP: KeyCode.Unknown, // MISSING
+
+		VK_0: KeyCode.KEY_0,
+		VK_1: KeyCode.KEY_1,
+		VK_2: KeyCode.KEY_2,
+		VK_3: KeyCode.KEY_3,
+		VK_4: KeyCode.KEY_4,
+		VK_5: KeyCode.KEY_5,
+		VK_6: KeyCode.KEY_6,
+		VK_7: KeyCode.KEY_7,
+		VK_8: KeyCode.KEY_8,
+		VK_9: KeyCode.KEY_9,
+		VK_A: KeyCode.KEY_A,
+		VK_B: KeyCode.KEY_B,
+		VK_C: KeyCode.KEY_C,
+		VK_D: KeyCode.KEY_D,
+		VK_E: KeyCode.KEY_E,
+		VK_F: KeyCode.KEY_F,
+		VK_G: KeyCode.KEY_G,
+		VK_H: KeyCode.KEY_H,
+		VK_I: KeyCode.KEY_I,
+		VK_J: KeyCode.KEY_J,
+		VK_K: KeyCode.KEY_K,
+		VK_L: KeyCode.KEY_L,
+		VK_M: KeyCode.KEY_M,
+		VK_N: KeyCode.KEY_N,
+		VK_O: KeyCode.KEY_O,
+		VK_P: KeyCode.KEY_P,
+		VK_Q: KeyCode.KEY_Q,
+		VK_R: KeyCode.KEY_R,
+		VK_S: KeyCode.KEY_S,
+		VK_T: KeyCode.KEY_T,
+		VK_U: KeyCode.KEY_U,
+		VK_V: KeyCode.KEY_V,
+		VK_W: KeyCode.KEY_W,
+		VK_X: KeyCode.KEY_X,
+		VK_Y: KeyCode.KEY_Y,
+		VK_Z: KeyCode.KEY_Z,
+
+		VK_LWIN: KeyCode.Meta,
+		VK_COMMAND: KeyCode.Meta,
+		VK_RWIN: KeyCode.Meta,
+		VK_APPS: KeyCode.Unknown, // MISSING
+		VK_SLEEP: KeyCode.Unknown, // MISSING
+		VK_NUMPAD0: KeyCode.NUMPAD_0,
+		VK_NUMPAD1: KeyCode.NUMPAD_1,
+		VK_NUMPAD2: KeyCode.NUMPAD_2,
+		VK_NUMPAD3: KeyCode.NUMPAD_3,
+		VK_NUMPAD4: KeyCode.NUMPAD_4,
+		VK_NUMPAD5: KeyCode.NUMPAD_5,
+		VK_NUMPAD6: KeyCode.NUMPAD_6,
+		VK_NUMPAD7: KeyCode.NUMPAD_7,
+		VK_NUMPAD8: KeyCode.NUMPAD_8,
+		VK_NUMPAD9: KeyCode.NUMPAD_9,
+		VK_MULTIPLY: KeyCode.NUMPAD_MULTIPLY,
+		VK_ADD: KeyCode.NUMPAD_ADD,
+		VK_SEPARATOR: KeyCode.NUMPAD_SEPARATOR,
+		VK_SUBTRACT: KeyCode.NUMPAD_SUBTRACT,
+		VK_DECIMAL: KeyCode.NUMPAD_DECIMAL,
+		VK_DIVIDE: KeyCode.NUMPAD_DIVIDE,
+		VK_F1: KeyCode.F1,
+		VK_F2: KeyCode.F2,
+		VK_F3: KeyCode.F3,
+		VK_F4: KeyCode.F4,
+		VK_F5: KeyCode.F5,
+		VK_F6: KeyCode.F6,
+		VK_F7: KeyCode.F7,
+		VK_F8: KeyCode.F8,
+		VK_F9: KeyCode.F9,
+		VK_F10: KeyCode.F10,
+		VK_F11: KeyCode.F11,
+		VK_F12: KeyCode.F12,
+		VK_F13: KeyCode.F13,
+		VK_F14: KeyCode.F14,
+		VK_F15: KeyCode.F15,
+		VK_F16: KeyCode.F16,
+		VK_F17: KeyCode.F17,
+		VK_F18: KeyCode.F18,
+		VK_F19: KeyCode.F19,
+		VK_F20: KeyCode.Unknown, // MISSING
+		VK_F21: KeyCode.Unknown, // MISSING
+		VK_F22: KeyCode.Unknown, // MISSING
+		VK_F23: KeyCode.Unknown, // MISSING
+		VK_F24: KeyCode.Unknown, // MISSING
+		VK_NUMLOCK: KeyCode.NumLock,
+		VK_SCROLL: KeyCode.ScrollLock,
+		VK_LSHIFT: KeyCode.Shift,
+		VK_RSHIFT: KeyCode.Shift,
+		VK_LCONTROL: KeyCode.Ctrl,
+		VK_RCONTROL: KeyCode.Ctrl,
+		VK_LMENU: KeyCode.Unknown, // MISSING
+		VK_RMENU: KeyCode.Unknown, // MISSING
+		VK_BROWSER_BACK: KeyCode.Unknown, // MISSING
+		VK_BROWSER_FORWARD: KeyCode.Unknown, // MISSING
+		VK_BROWSER_REFRESH: KeyCode.Unknown, // MISSING
+		VK_BROWSER_STOP: KeyCode.Unknown, // MISSING
+		VK_BROWSER_SEARCH: KeyCode.Unknown, // MISSING
+		VK_BROWSER_FAVORITES: KeyCode.Unknown, // MISSING
+		VK_BROWSER_HOME: KeyCode.Unknown, // MISSING
+		VK_VOLUME_MUTE: KeyCode.Unknown, // MISSING
+		VK_VOLUME_DOWN: KeyCode.Unknown, // MISSING
+		VK_VOLUME_UP: KeyCode.Unknown, // MISSING
+		VK_MEDIA_NEXT_TRACK: KeyCode.Unknown, // MISSING
+		VK_MEDIA_PREV_TRACK: KeyCode.Unknown, // MISSING
+		VK_MEDIA_STOP: KeyCode.Unknown, // MISSING
+		VK_MEDIA_PLAY_PAUSE: KeyCode.Unknown, // MISSING
+		VK_MEDIA_LAUNCH_MAIL: KeyCode.Unknown, // MISSING
+		VK_MEDIA_LAUNCH_MEDIA_SELECT: KeyCode.Unknown, // MISSING
+		VK_MEDIA_LAUNCH_APP1: KeyCode.Unknown, // MISSING
+		VK_MEDIA_LAUNCH_APP2: KeyCode.Unknown, // MISSING
+		VK_OEM_1: KeyCode.US_SEMICOLON,
+		VK_OEM_PLUS: KeyCode.US_EQUAL,
+		VK_OEM_COMMA: KeyCode.US_COMMA,
+		VK_OEM_MINUS: KeyCode.US_MINUS,
+		VK_OEM_PERIOD: KeyCode.US_DOT,
+		VK_OEM_2: KeyCode.US_SLASH,
+		VK_OEM_3: KeyCode.US_BACKTICK,
+		VK_ABNT_C1: KeyCode.ABNT_C1,
+		VK_ABNT_C2: KeyCode.ABNT_C2,
+		VK_OEM_4: KeyCode.US_OPEN_SQUARE_BRACKET,
+		VK_OEM_5: KeyCode.US_BACKSLASH,
+		VK_OEM_6: KeyCode.US_CLOSE_SQUARE_BRACKET,
+		VK_OEM_7: KeyCode.US_QUOTE,
+		VK_OEM_8: KeyCode.OEM_8,
+		VK_OEM_102: KeyCode.OEM_102,
+		VK_PROCESSKEY: KeyCode.Unknown, // MISSING
+		VK_PACKET: KeyCode.Unknown, // MISSING
+		VK_DBE_SBCSCHAR: KeyCode.Unknown, // MISSING
+		VK_DBE_DBCSCHAR: KeyCode.Unknown, // MISSING
+		VK_ATTN: KeyCode.Unknown, // MISSING
+		VK_CRSEL: KeyCode.Unknown, // MISSING
+		VK_EXSEL: KeyCode.Unknown, // MISSING
+		VK_EREOF: KeyCode.Unknown, // MISSING
+		VK_PLAY: KeyCode.Unknown, // MISSING
+		VK_ZOOM: KeyCode.Unknown, // MISSING
+		VK_NONAME: KeyCode.Unknown, // MISSING
+		VK_PA1: KeyCode.Unknown, // MISSING
+		VK_OEM_CLEAR: KeyCode.Unknown, // MISSING
+		VK_UNKNOWN: KeyCode.Unknown,
+	};
+}

lib/vscode/src/vs/workbench/services/keybinding/electron-browser/nativeKeymapService.ts

@@ -0,0 +1,174 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as nativeKeymap from 'native-keymap';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { IKeymapService, IKeyboardLayoutInfo, IKeyboardMapping } from 'vs/workbench/services/keybinding/common/keymapInfo';
+import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
+import { IKeyboardMapper, CachedKeyboardMapper } from 'vs/workbench/services/keybinding/common/keyboardMapper';
+import { Emitter, Event } from 'vs/base/common/event';
+import { DispatchConfig } from 'vs/workbench/services/keybinding/common/dispatchConfig';
+import { MacLinuxFallbackKeyboardMapper } from 'vs/workbench/services/keybinding/common/macLinuxFallbackKeyboardMapper';
+import { OS, OperatingSystem } from 'vs/base/common/platform';
+import { WindowsKeyboardMapper, windowsKeyboardMappingEquals } from 'vs/workbench/services/keybinding/common/windowsKeyboardMapper';
+import { MacLinuxKeyboardMapper, macLinuxKeyboardMappingEquals, IMacLinuxKeyboardMapping } from 'vs/workbench/services/keybinding/common/macLinuxKeyboardMapper';
+import { IKeyboardEvent } from 'vs/platform/keybinding/common/keybinding';
+import { ipcRenderer } from 'vs/base/parts/sandbox/electron-sandbox/globals';
+
+export class KeyboardMapperFactory {
+	public static readonly INSTANCE = new KeyboardMapperFactory();
+
+	private _layoutInfo: nativeKeymap.IKeyboardLayoutInfo | null;
+	private _rawMapping: nativeKeymap.IKeyboardMapping | null;
+	private _keyboardMapper: IKeyboardMapper | null;
+	private _initialized: boolean;
+
+	private readonly _onDidChangeKeyboardMapper = new Emitter<void>();
+	public readonly onDidChangeKeyboardMapper: Event<void> = this._onDidChangeKeyboardMapper.event;
+
+	private constructor() {
+		this._layoutInfo = null;
+		this._rawMapping = null;
+		this._keyboardMapper = null;
+		this._initialized = false;
+	}
+
+	public _onKeyboardLayoutChanged(): void {
+		if (this._initialized) {
+			this._setKeyboardData(nativeKeymap.getCurrentKeyboardLayout(), nativeKeymap.getKeyMap());
+		}
+	}
+
+	public getKeyboardMapper(dispatchConfig: DispatchConfig): IKeyboardMapper {
+		if (!this._initialized) {
+			this._setKeyboardData(nativeKeymap.getCurrentKeyboardLayout(), nativeKeymap.getKeyMap());
+		}
+		if (dispatchConfig === DispatchConfig.KeyCode) {
+			// Forcefully set to use keyCode
+			return new MacLinuxFallbackKeyboardMapper(OS);
+		}
+		return this._keyboardMapper!;
+	}
+
+	public getCurrentKeyboardLayout(): nativeKeymap.IKeyboardLayoutInfo | null {
+		if (!this._initialized) {
+			this._setKeyboardData(nativeKeymap.getCurrentKeyboardLayout(), nativeKeymap.getKeyMap());
+		}
+		return this._layoutInfo;
+	}
+
+	private static _isUSStandard(_kbInfo: nativeKeymap.IKeyboardLayoutInfo): boolean {
+		if (OS === OperatingSystem.Linux) {
+			const kbInfo = <nativeKeymap.ILinuxKeyboardLayoutInfo>_kbInfo;
+			return (kbInfo && (kbInfo.layout === 'us' || /^us,/.test(kbInfo.layout)));
+		}
+
+		if (OS === OperatingSystem.Macintosh) {
+			const kbInfo = <nativeKeymap.IMacKeyboardLayoutInfo>_kbInfo;
+			return (kbInfo && kbInfo.id === 'com.apple.keylayout.US');
+		}
+
+		if (OS === OperatingSystem.Windows) {
+			const kbInfo = <nativeKeymap.IWindowsKeyboardLayoutInfo>_kbInfo;
+			return (kbInfo && kbInfo.name === '00000409');
+		}
+
+		return false;
+	}
+
+	public getRawKeyboardMapping(): nativeKeymap.IKeyboardMapping | null {
+		if (!this._initialized) {
+			this._setKeyboardData(nativeKeymap.getCurrentKeyboardLayout(), nativeKeymap.getKeyMap());
+		}
+		return this._rawMapping;
+	}
+
+	private _setKeyboardData(layoutInfo: nativeKeymap.IKeyboardLayoutInfo, rawMapping: nativeKeymap.IKeyboardMapping): void {
+		this._layoutInfo = layoutInfo;
+
+		if (this._initialized && KeyboardMapperFactory._equals(this._rawMapping, rawMapping)) {
+			// nothing to do...
+			return;
+		}
+
+		this._initialized = true;
+		this._rawMapping = rawMapping;
+		this._keyboardMapper = new CachedKeyboardMapper(
+			KeyboardMapperFactory._createKeyboardMapper(this._layoutInfo, this._rawMapping)
+		);
+		this._onDidChangeKeyboardMapper.fire();
+	}
+
+	private static _createKeyboardMapper(layoutInfo: nativeKeymap.IKeyboardLayoutInfo, rawMapping: nativeKeymap.IKeyboardMapping): IKeyboardMapper {
+		const isUSStandard = KeyboardMapperFactory._isUSStandard(layoutInfo);
+		if (OS === OperatingSystem.Windows) {
+			return new WindowsKeyboardMapper(isUSStandard, <nativeKeymap.IWindowsKeyboardMapping>rawMapping);
+		}
+
+		if (Object.keys(rawMapping).length === 0) {
+			// Looks like reading the mappings failed (most likely Mac + Japanese/Chinese keyboard layouts)
+			return new MacLinuxFallbackKeyboardMapper(OS);
+		}
+
+		if (OS === OperatingSystem.Macintosh) {
+			const kbInfo = <nativeKeymap.IMacKeyboardLayoutInfo>layoutInfo;
+			if (kbInfo.id === 'com.apple.keylayout.DVORAK-QWERTYCMD') {
+				// Use keyCode based dispatching for DVORAK - QWERTY ⌘
+				return new MacLinuxFallbackKeyboardMapper(OS);
+			}
+		}
+
+		return new MacLinuxKeyboardMapper(isUSStandard, <IMacLinuxKeyboardMapping>rawMapping, OS);
+	}
+
+	private static _equals(a: nativeKeymap.IKeyboardMapping | null, b: nativeKeymap.IKeyboardMapping | null): boolean {
+		if (OS === OperatingSystem.Windows) {
+			return windowsKeyboardMappingEquals(<nativeKeymap.IWindowsKeyboardMapping>a, <nativeKeymap.IWindowsKeyboardMapping>b);
+		}
+
+		return macLinuxKeyboardMappingEquals(<IMacLinuxKeyboardMapping>a, <IMacLinuxKeyboardMapping>b);
+	}
+}
+
+class NativeKeymapService extends Disposable implements IKeymapService {
+	public _serviceBrand: undefined;
+
+	private readonly _onDidChangeKeyboardMapper = this._register(new Emitter<void>());
+	public readonly onDidChangeKeyboardMapper: Event<void> = this._onDidChangeKeyboardMapper.event;
+
+	constructor() {
+		super();
+
+		this._register(KeyboardMapperFactory.INSTANCE.onDidChangeKeyboardMapper(() => {
+			this._onDidChangeKeyboardMapper.fire();
+		}));
+
+		ipcRenderer.on('vscode:keyboardLayoutChanged', () => {
+			KeyboardMapperFactory.INSTANCE._onKeyboardLayoutChanged();
+		});
+	}
+
+	getKeyboardMapper(dispatchConfig: DispatchConfig): IKeyboardMapper {
+		return KeyboardMapperFactory.INSTANCE.getKeyboardMapper(dispatchConfig);
+	}
+
+	public getCurrentKeyboardLayout(): IKeyboardLayoutInfo | null {
+		return KeyboardMapperFactory.INSTANCE.getCurrentKeyboardLayout();
+	}
+
+	getAllKeyboardLayouts(): IKeyboardLayoutInfo[] {
+		return [];
+	}
+
+	public getRawKeyboardMapping(): IKeyboardMapping | null {
+		return KeyboardMapperFactory.INSTANCE.getRawKeyboardMapping();
+	}
+
+	public validateCurrentKeyboardMapping(keyboardEvent: IKeyboardEvent): void {
+		return;
+	}
+}
+
+registerSingleton(IKeymapService, NativeKeymapService, true);

lib/vscode/src/vs/workbench/services/keybinding/test/electron-browser/browserKeyboardMapper.test.ts

@@ -0,0 +1,150 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import * as assert from 'assert';
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/en.darwin'; // 15%
+import 'vs/workbench/services/keybinding/browser/keyboardLayouts/de.darwin';
+import { KeyboardLayoutContribution } from 'vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution';
+import { BrowserKeyboardMapperFactoryBase } from 'vs/workbench/services/keybinding/browser/keymapService';
+import { KeymapInfo, IKeymapInfo } from 'vs/workbench/services/keybinding/common/keymapInfo';
+import { TestInstantiationService } from 'vs/platform/instantiation/test/common/instantiationServiceMock';
+import { INotificationService } from 'vs/platform/notification/common/notification';
+import { ICommandService } from 'vs/platform/commands/common/commands';
+import { IStorageService } from 'vs/platform/storage/common/storage';
+import { TestNotificationService } from 'vs/platform/notification/test/common/testNotificationService';
+import { TestStorageService } from 'vs/workbench/test/common/workbenchTestServices';
+
+class TestKeyboardMapperFactory extends BrowserKeyboardMapperFactoryBase {
+	constructor(notificationService: INotificationService, storageService: IStorageService, commandService: ICommandService) {
+		// super(notificationService, storageService, commandService);
+		super();
+
+		const keymapInfos: IKeymapInfo[] = KeyboardLayoutContribution.INSTANCE.layoutInfos;
+		this._keymapInfos.push(...keymapInfos.map(info => (new KeymapInfo(info.layout, info.secondaryLayouts, info.mapping, info.isUserKeyboardLayout))));
+		this._mru = this._keymapInfos;
+		this._initialized = true;
+		this.onKeyboardLayoutChanged();
+		const usLayout = this.getUSStandardLayout();
+		if (usLayout) {
+			this.setActiveKeyMapping(usLayout.mapping);
+		}
+	}
+}
+
+suite('keyboard layout loader', () => {
+	let instantiationService: TestInstantiationService = new TestInstantiationService();
+	let notitifcationService = instantiationService.stub(INotificationService, new TestNotificationService());
+	let storageService = instantiationService.stub(IStorageService, new TestStorageService());
+
+	let commandService = instantiationService.stub(ICommandService, {});
+	let instance = new TestKeyboardMapperFactory(notitifcationService, storageService, commandService);
+
+	test('load default US keyboard layout', () => {
+		assert.notEqual(instance.activeKeyboardLayout, null);
+	});
+
+	test('isKeyMappingActive', () => {
+		instance.setUSKeyboardLayout();
+		assert.equal(instance.isKeyMappingActive({
+			KeyA: {
+				value: 'a',
+				valueIsDeadKey: false,
+				withShift: 'A',
+				withShiftIsDeadKey: false,
+				withAltGr: 'å',
+				withAltGrIsDeadKey: false,
+				withShiftAltGr: 'Å',
+				withShiftAltGrIsDeadKey: false
+			}
+		}), true);
+
+		assert.equal(instance.isKeyMappingActive({
+			KeyA: {
+				value: 'a',
+				valueIsDeadKey: false,
+				withShift: 'A',
+				withShiftIsDeadKey: false,
+				withAltGr: 'å',
+				withAltGrIsDeadKey: false,
+				withShiftAltGr: 'Å',
+				withShiftAltGrIsDeadKey: false
+			},
+			KeyZ: {
+				value: 'z',
+				valueIsDeadKey: false,
+				withShift: 'Z',
+				withShiftIsDeadKey: false,
+				withAltGr: 'Ω',
+				withAltGrIsDeadKey: false,
+				withShiftAltGr: '¸',
+				withShiftAltGrIsDeadKey: false
+			}
+		}), true);
+
+		assert.equal(instance.isKeyMappingActive({
+			KeyZ: {
+				value: 'y',
+				valueIsDeadKey: false,
+				withShift: 'Y',
+				withShiftIsDeadKey: false,
+				withAltGr: '¥',
+				withAltGrIsDeadKey: false,
+				withShiftAltGr: 'Ÿ',
+				withShiftAltGrIsDeadKey: false
+			},
+		}), false);
+
+	});
+
+	test('Switch keymapping', () => {
+		instance.setActiveKeyMapping({
+			KeyZ: {
+				value: 'y',
+				valueIsDeadKey: false,
+				withShift: 'Y',
+				withShiftIsDeadKey: false,
+				withAltGr: '¥',
+				withAltGrIsDeadKey: false,
+				withShiftAltGr: 'Ÿ',
+				withShiftAltGrIsDeadKey: false
+			}
+		});
+		assert.equal(!!instance.activeKeyboardLayout!.isUSStandard, false);
+		assert.equal(instance.isKeyMappingActive({
+			KeyZ: {
+				value: 'y',
+				valueIsDeadKey: false,
+				withShift: 'Y',
+				withShiftIsDeadKey: false,
+				withAltGr: '¥',
+				withAltGrIsDeadKey: false,
+				withShiftAltGr: 'Ÿ',
+				withShiftAltGrIsDeadKey: false
+			},
+		}), true);
+
+		instance.setUSKeyboardLayout();
+		assert.equal(instance.activeKeyboardLayout!.isUSStandard, true);
+	});
+
+	test('Switch keyboard layout info', () => {
+		instance.setKeyboardLayout('com.apple.keylayout.German');
+		assert.equal(!!instance.activeKeyboardLayout!.isUSStandard, false);
+		assert.equal(instance.isKeyMappingActive({
+			KeyZ: {
+				value: 'y',
+				valueIsDeadKey: false,
+				withShift: 'Y',
+				withShiftIsDeadKey: false,
+				withAltGr: '¥',
+				withAltGrIsDeadKey: false,
+				withShiftAltGr: 'Ÿ',
+				withShiftAltGrIsDeadKey: false
+			},
+		}), true);
+
+		instance.setUSKeyboardLayout();
+		assert.equal(instance.activeKeyboardLayout!.isUSStandard, true);
+	});
+});

lib/vscode/src/vs/workbench/services/keybinding/test/electron-browser/keybindingEditing.test.ts

@@ -0,0 +1,318 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'vs/base/common/path';
+import * as json from 'vs/base/common/json';
+import { ChordKeybinding, KeyCode, SimpleKeybinding } from 'vs/base/common/keyCodes';
+import { OS } from 'vs/base/common/platform';
+import * as uuid from 'vs/base/common/uuid';
+import { mkdirp, rimraf, RimRafMode } from 'vs/base/node/pfs';
+import { IModeService } from 'vs/editor/common/services/modeService';
+import { ModeServiceImpl } from 'vs/editor/common/services/modeServiceImpl';
+import { IModelService } from 'vs/editor/common/services/modelService';
+import { ModelServiceImpl } from 'vs/editor/common/services/modelServiceImpl';
+import { ITextModelService } from 'vs/editor/common/services/resolverService';
+import { ITextResourcePropertiesService } from 'vs/editor/common/services/textResourceConfigurationService';
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
+import { ContextKeyExpr, IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { IFileService } from 'vs/platform/files/common/files';
+import { TestInstantiationService } from 'vs/platform/instantiation/test/common/instantiationServiceMock';
+import { IUserFriendlyKeybinding } from 'vs/platform/keybinding/common/keybinding';
+import { ResolvedKeybindingItem } from 'vs/platform/keybinding/common/resolvedKeybindingItem';
+import { USLayoutResolvedKeybinding } from 'vs/platform/keybinding/common/usLayoutResolvedKeybinding';
+import { MockContextKeyService } from 'vs/platform/keybinding/test/common/mockKeybindingService';
+import { ILifecycleService } from 'vs/workbench/services/lifecycle/common/lifecycle';
+import { ILogService, NullLogService } from 'vs/platform/log/common/log';
+import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
+import { NullTelemetryService } from 'vs/platform/telemetry/common/telemetryUtils';
+import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace';
+import { IBackupFileService } from 'vs/workbench/services/backup/common/backup';
+import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
+import { IEditorGroupsService } from 'vs/workbench/services/editor/common/editorGroupsService';
+import { KeybindingsEditingService } from 'vs/workbench/services/keybinding/common/keybindingEditing';
+import { ITextFileService } from 'vs/workbench/services/textfile/common/textfiles';
+import { TextModelResolverService } from 'vs/workbench/services/textmodelResolver/common/textModelResolverService';
+import { TestBackupFileService, TestEditorGroupsService, TestEditorService, TestLifecycleService, TestPathService, TestProductService } from 'vs/workbench/test/browser/workbenchTestServices';
+import { FileService } from 'vs/platform/files/common/fileService';
+import { Schemas } from 'vs/base/common/network';
+import { DiskFileSystemProvider } from 'vs/platform/files/node/diskFileSystemProvider';
+import { URI } from 'vs/base/common/uri';
+import { FileUserDataProvider } from 'vs/workbench/services/userData/common/fileUserDataProvider';
+import { NativeWorkbenchEnvironmentService } from 'vs/workbench/services/environment/electron-browser/environmentService';
+import { TestConfigurationService } from 'vs/platform/configuration/test/common/testConfigurationService';
+import { IWorkingCopyService } from 'vs/workbench/services/workingCopy/common/workingCopyService';
+import { TestWorkbenchConfiguration, TestTextFileService } from 'vs/workbench/test/electron-browser/workbenchTestServices';
+import { ILabelService } from 'vs/platform/label/common/label';
+import { LabelService } from 'vs/workbench/services/label/common/labelService';
+import { IFilesConfigurationService, FilesConfigurationService } from 'vs/workbench/services/filesConfiguration/common/filesConfigurationService';
+import { WorkingCopyFileService, IWorkingCopyFileService } from 'vs/workbench/services/workingCopy/common/workingCopyFileService';
+import { IUndoRedoService } from 'vs/platform/undoRedo/common/undoRedo';
+import { UndoRedoService } from 'vs/platform/undoRedo/common/undoRedoService';
+import { TestTextResourcePropertiesService, TestContextService, TestWorkingCopyService } from 'vs/workbench/test/common/workbenchTestServices';
+import { IThemeService } from 'vs/platform/theme/common/themeService';
+import { TestThemeService } from 'vs/platform/theme/test/common/testThemeService';
+import { IPathService } from 'vs/workbench/services/path/common/pathService';
+import { IUriIdentityService } from 'vs/workbench/services/uriIdentity/common/uriIdentity';
+import { UriIdentityService } from 'vs/workbench/services/uriIdentity/common/uriIdentityService';
+
+class TestWorkbenchEnvironmentService extends NativeWorkbenchEnvironmentService {
+
+	constructor(private _appSettingsHome: URI) {
+		super(TestWorkbenchConfiguration, TestProductService);
+	}
+
+	get appSettingsHome() { return this._appSettingsHome; }
+}
+
+interface Modifiers {
+	metaKey?: boolean;
+	ctrlKey?: boolean;
+	altKey?: boolean;
+	shiftKey?: boolean;
+}
+
+suite('KeybindingsEditing', () => {
+
+	let instantiationService: TestInstantiationService;
+	let testObject: KeybindingsEditingService;
+	let testDir: string;
+	let keybindingsFile: string;
+
+	setup(() => {
+		return setUpWorkspace().then(() => {
+			keybindingsFile = path.join(testDir, 'keybindings.json');
+
+			instantiationService = new TestInstantiationService();
+
+			const environmentService = new TestWorkbenchEnvironmentService(URI.file(testDir));
+
+			const configService = new TestConfigurationService();
+			configService.setUserConfiguration('files', { 'eol': '\n' });
+
+			instantiationService.stub(IEnvironmentService, environmentService);
+			instantiationService.stub(IPathService, new TestPathService());
+			instantiationService.stub(IConfigurationService, configService);
+			instantiationService.stub(IWorkspaceContextService, new TestContextService());
+			const lifecycleService = new TestLifecycleService();
+			instantiationService.stub(ILifecycleService, lifecycleService);
+			instantiationService.stub(IContextKeyService, <IContextKeyService>instantiationService.createInstance(MockContextKeyService));
+			instantiationService.stub(IEditorGroupsService, new TestEditorGroupsService());
+			instantiationService.stub(IEditorService, new TestEditorService());
+			instantiationService.stub(IWorkingCopyService, new TestWorkingCopyService());
+			instantiationService.stub(ITelemetryService, NullTelemetryService);
+			instantiationService.stub(IModeService, ModeServiceImpl);
+			instantiationService.stub(ILogService, new NullLogService());
+			instantiationService.stub(ILabelService, instantiationService.createInstance(LabelService));
+			instantiationService.stub(IFilesConfigurationService, instantiationService.createInstance(FilesConfigurationService));
+			instantiationService.stub(ITextResourcePropertiesService, new TestTextResourcePropertiesService(instantiationService.get(IConfigurationService)));
+			instantiationService.stub(IUndoRedoService, instantiationService.createInstance(UndoRedoService));
+			instantiationService.stub(IThemeService, new TestThemeService());
+			instantiationService.stub(IModelService, instantiationService.createInstance(ModelServiceImpl));
+			const fileService = new FileService(new NullLogService());
+			const diskFileSystemProvider = new DiskFileSystemProvider(new NullLogService());
+			fileService.registerProvider(Schemas.file, diskFileSystemProvider);
+			fileService.registerProvider(Schemas.userData, new FileUserDataProvider(environmentService.appSettingsHome, undefined, diskFileSystemProvider, environmentService, new NullLogService()));
+			instantiationService.stub(IFileService, fileService);
+			instantiationService.stub(IUriIdentityService, new UriIdentityService(fileService));
+			instantiationService.stub(IWorkingCopyService, new TestWorkingCopyService());
+			instantiationService.stub(IWorkingCopyFileService, instantiationService.createInstance(WorkingCopyFileService));
+			instantiationService.stub(ITextFileService, instantiationService.createInstance(TestTextFileService));
+			instantiationService.stub(ITextModelService, <ITextModelService>instantiationService.createInstance(TextModelResolverService));
+			instantiationService.stub(IBackupFileService, new TestBackupFileService());
+
+			testObject = instantiationService.createInstance(KeybindingsEditingService);
+		});
+	});
+
+	async function setUpWorkspace(): Promise<void> {
+		testDir = path.join(os.tmpdir(), 'vsctests', uuid.generateUuid());
+		return await mkdirp(testDir, 493);
+	}
+
+	teardown(() => {
+		return new Promise<void>((c) => {
+			if (testDir) {
+				rimraf(testDir, RimRafMode.MOVE).then(c, c);
+			} else {
+				c(undefined);
+			}
+		}).then(() => testDir = null!);
+	});
+
+	test('errors cases - parse errors', () => {
+		fs.writeFileSync(keybindingsFile, ',,,,,,,,,,,,,,');
+		return testObject.editKeybinding(aResolvedKeybindingItem({ firstPart: { keyCode: KeyCode.Escape } }), 'alt+c', undefined)
+			.then(() => assert.fail('Should fail with parse errors'),
+				error => assert.equal(error.message, 'Unable to write to the keybindings configuration file. Please open it to correct errors/warnings in the file and try again.'));
+	});
+
+	test('errors cases - parse errors 2', () => {
+		fs.writeFileSync(keybindingsFile, '[{"key": }]');
+		return testObject.editKeybinding(aResolvedKeybindingItem({ firstPart: { keyCode: KeyCode.Escape } }), 'alt+c', undefined)
+			.then(() => assert.fail('Should fail with parse errors'),
+				error => assert.equal(error.message, 'Unable to write to the keybindings configuration file. Please open it to correct errors/warnings in the file and try again.'));
+	});
+
+	test('errors cases - dirty', () => {
+		instantiationService.stub(ITextFileService, 'isDirty', true);
+		return testObject.editKeybinding(aResolvedKeybindingItem({ firstPart: { keyCode: KeyCode.Escape } }), 'alt+c', undefined)
+			.then(() => assert.fail('Should fail with dirty error'),
+				error => assert.equal(error.message, 'Unable to write because the keybindings configuration file is dirty. Please save it first and then try again.'));
+	});
+
+	test('errors cases - did not find an array', () => {
+		fs.writeFileSync(keybindingsFile, '{"key": "alt+c", "command": "hello"}');
+		return testObject.editKeybinding(aResolvedKeybindingItem({ firstPart: { keyCode: KeyCode.Escape } }), 'alt+c', undefined)
+			.then(() => assert.fail('Should fail with dirty error'),
+				error => assert.equal(error.message, 'Unable to write to the keybindings configuration file. It has an object which is not of type Array. Please open the file to clean up and try again.'));
+	});
+
+	test('edit a default keybinding to an empty file', () => {
+		fs.writeFileSync(keybindingsFile, '');
+		const expected: IUserFriendlyKeybinding[] = [{ key: 'alt+c', command: 'a' }, { key: 'escape', command: '-a' }];
+		return testObject.editKeybinding(aResolvedKeybindingItem({ firstPart: { keyCode: KeyCode.Escape }, command: 'a' }), 'alt+c', undefined)
+			.then(() => assert.deepEqual(getUserKeybindings(), expected));
+	});
+
+	test('edit a default keybinding to an empty array', () => {
+		writeToKeybindingsFile();
+		const expected: IUserFriendlyKeybinding[] = [{ key: 'alt+c', command: 'a' }, { key: 'escape', command: '-a' }];
+		return testObject.editKeybinding(aResolvedKeybindingItem({ firstPart: { keyCode: KeyCode.Escape }, command: 'a' }), 'alt+c', undefined)
+			.then(() => assert.deepEqual(getUserKeybindings(), expected));
+	});
+
+	test('edit a default keybinding in an existing array', () => {
+		writeToKeybindingsFile({ command: 'b', key: 'shift+c' });
+		const expected: IUserFriendlyKeybinding[] = [{ key: 'shift+c', command: 'b' }, { key: 'alt+c', command: 'a' }, { key: 'escape', command: '-a' }];
+		return testObject.editKeybinding(aResolvedKeybindingItem({ firstPart: { keyCode: KeyCode.Escape }, command: 'a' }), 'alt+c', undefined)
+			.then(() => assert.deepEqual(getUserKeybindings(), expected));
+	});
+
+	test('add a new default keybinding', () => {
+		const expected: IUserFriendlyKeybinding[] = [{ key: 'alt+c', command: 'a' }];
+		return testObject.editKeybinding(aResolvedKeybindingItem({ command: 'a' }), 'alt+c', undefined)
+			.then(() => assert.deepEqual(getUserKeybindings(), expected));
+	});
+
+	test('edit an user keybinding', () => {
+		writeToKeybindingsFile({ key: 'escape', command: 'b' });
+		const expected: IUserFriendlyKeybinding[] = [{ key: 'alt+c', command: 'b' }];
+		return testObject.editKeybinding(aResolvedKeybindingItem({ firstPart: { keyCode: KeyCode.Escape }, command: 'b', isDefault: false }), 'alt+c', undefined)
+			.then(() => assert.deepEqual(getUserKeybindings(), expected));
+	});
+
+	test('edit an user keybinding with more than one element', () => {
+		writeToKeybindingsFile({ key: 'escape', command: 'b' }, { key: 'alt+shift+g', command: 'c' });
+		const expected: IUserFriendlyKeybinding[] = [{ key: 'alt+c', command: 'b' }, { key: 'alt+shift+g', command: 'c' }];
+		return testObject.editKeybinding(aResolvedKeybindingItem({ firstPart: { keyCode: KeyCode.Escape }, command: 'b', isDefault: false }), 'alt+c', undefined)
+			.then(() => assert.deepEqual(getUserKeybindings(), expected));
+	});
+
+	test('remove a default keybinding', () => {
+		const expected: IUserFriendlyKeybinding[] = [{ key: 'alt+c', command: '-a' }];
+		return testObject.removeKeybinding(aResolvedKeybindingItem({ command: 'a', firstPart: { keyCode: KeyCode.KEY_C, modifiers: { altKey: true } } }))
+			.then(() => assert.deepEqual(getUserKeybindings(), expected));
+	});
+
+	test('remove a default keybinding should not ad duplicate entries', async () => {
+		const expected: IUserFriendlyKeybinding[] = [{ key: 'alt+c', command: '-a' }];
+		await testObject.removeKeybinding(aResolvedKeybindingItem({ command: 'a', firstPart: { keyCode: KeyCode.KEY_C, modifiers: { altKey: true } } }));
+		await testObject.removeKeybinding(aResolvedKeybindingItem({ command: 'a', firstPart: { keyCode: KeyCode.KEY_C, modifiers: { altKey: true } } }));
+		await testObject.removeKeybinding(aResolvedKeybindingItem({ command: 'a', firstPart: { keyCode: KeyCode.KEY_C, modifiers: { altKey: true } } }));
+		await testObject.removeKeybinding(aResolvedKeybindingItem({ command: 'a', firstPart: { keyCode: KeyCode.KEY_C, modifiers: { altKey: true } } }));
+		await testObject.removeKeybinding(aResolvedKeybindingItem({ command: 'a', firstPart: { keyCode: KeyCode.KEY_C, modifiers: { altKey: true } } }));
+		assert.deepEqual(getUserKeybindings(), expected);
+	});
+
+	test('remove a user keybinding', () => {
+		writeToKeybindingsFile({ key: 'alt+c', command: 'b' });
+		return testObject.removeKeybinding(aResolvedKeybindingItem({ command: 'b', firstPart: { keyCode: KeyCode.KEY_C, modifiers: { altKey: true } }, isDefault: false }))
+			.then(() => assert.deepEqual(getUserKeybindings(), []));
+	});
+
+	test('reset an edited keybinding', () => {
+		writeToKeybindingsFile({ key: 'alt+c', command: 'b' });
+		return testObject.resetKeybinding(aResolvedKeybindingItem({ command: 'b', firstPart: { keyCode: KeyCode.KEY_C, modifiers: { altKey: true } }, isDefault: false }))
+			.then(() => assert.deepEqual(getUserKeybindings(), []));
+	});
+
+	test('reset a removed keybinding', () => {
+		writeToKeybindingsFile({ key: 'alt+c', command: '-b' });
+		return testObject.resetKeybinding(aResolvedKeybindingItem({ command: 'b', isDefault: false }))
+			.then(() => assert.deepEqual(getUserKeybindings(), []));
+	});
+
+	test('reset multiple removed keybindings', () => {
+		writeToKeybindingsFile({ key: 'alt+c', command: '-b' });
+		writeToKeybindingsFile({ key: 'alt+shift+c', command: '-b' });
+		writeToKeybindingsFile({ key: 'escape', command: '-b' });
+		return testObject.resetKeybinding(aResolvedKeybindingItem({ command: 'b', isDefault: false }))
+			.then(() => assert.deepEqual(getUserKeybindings(), []));
+	});
+
+	test('add a new keybinding to unassigned keybinding', () => {
+		writeToKeybindingsFile({ key: 'alt+c', command: '-a' });
+		const expected: IUserFriendlyKeybinding[] = [{ key: 'alt+c', command: '-a' }, { key: 'shift+alt+c', command: 'a' }];
+		return testObject.editKeybinding(aResolvedKeybindingItem({ command: 'a', isDefault: false }), 'shift+alt+c', undefined)
+			.then(() => assert.deepEqual(getUserKeybindings(), expected));
+	});
+
+	test('add when expression', () => {
+		writeToKeybindingsFile({ key: 'alt+c', command: '-a' });
+		const expected: IUserFriendlyKeybinding[] = [{ key: 'alt+c', command: '-a' }, { key: 'shift+alt+c', command: 'a', when: 'editorTextFocus' }];
+		return testObject.editKeybinding(aResolvedKeybindingItem({ command: 'a', isDefault: false }), 'shift+alt+c', 'editorTextFocus')
+			.then(() => assert.deepEqual(getUserKeybindings(), expected));
+	});
+
+	test('update command and when expression', () => {
+		writeToKeybindingsFile({ key: 'alt+c', command: '-a', when: 'editorTextFocus && !editorReadonly' });
+		const expected: IUserFriendlyKeybinding[] = [{ key: 'alt+c', command: '-a', when: 'editorTextFocus && !editorReadonly' }, { key: 'shift+alt+c', command: 'a', when: 'editorTextFocus' }];
+		return testObject.editKeybinding(aResolvedKeybindingItem({ command: 'a', isDefault: false }), 'shift+alt+c', 'editorTextFocus')
+			.then(() => assert.deepEqual(getUserKeybindings(), expected));
+	});
+
+	test('update when expression', () => {
+		writeToKeybindingsFile({ key: 'alt+c', command: '-a', when: 'editorTextFocus && !editorReadonly' }, { key: 'shift+alt+c', command: 'a', when: 'editorTextFocus && !editorReadonly' });
+		const expected: IUserFriendlyKeybinding[] = [{ key: 'alt+c', command: '-a', when: 'editorTextFocus && !editorReadonly' }, { key: 'shift+alt+c', command: 'a', when: 'editorTextFocus' }];
+		return testObject.editKeybinding(aResolvedKeybindingItem({ command: 'a', isDefault: false, when: 'editorTextFocus && !editorReadonly' }), 'shift+alt+c', 'editorTextFocus')
+			.then(() => assert.deepEqual(getUserKeybindings(), expected));
+	});
+
+	test('remove when expression', () => {
+		writeToKeybindingsFile({ key: 'alt+c', command: '-a', when: 'editorTextFocus && !editorReadonly' });
+		const expected: IUserFriendlyKeybinding[] = [{ key: 'alt+c', command: '-a', when: 'editorTextFocus && !editorReadonly' }, { key: 'shift+alt+c', command: 'a' }];
+		return testObject.editKeybinding(aResolvedKeybindingItem({ command: 'a', isDefault: false }), 'shift+alt+c', undefined)
+			.then(() => assert.deepEqual(getUserKeybindings(), expected));
+	});
+
+	function writeToKeybindingsFile(...keybindings: IUserFriendlyKeybinding[]) {
+		fs.writeFileSync(keybindingsFile, JSON.stringify(keybindings || []));
+	}
+
+	function getUserKeybindings(): IUserFriendlyKeybinding[] {
+		return json.parse(fs.readFileSync(keybindingsFile).toString('utf8'));
+	}
+
+	function aResolvedKeybindingItem({ command, when, isDefault, firstPart, chordPart }: { command?: string, when?: string, isDefault?: boolean, firstPart?: { keyCode: KeyCode, modifiers?: Modifiers }, chordPart?: { keyCode: KeyCode, modifiers?: Modifiers } }): ResolvedKeybindingItem {
+		const aSimpleKeybinding = function (part: { keyCode: KeyCode, modifiers?: Modifiers }): SimpleKeybinding {
+			const { ctrlKey, shiftKey, altKey, metaKey } = part.modifiers || { ctrlKey: false, shiftKey: false, altKey: false, metaKey: false };
+			return new SimpleKeybinding(ctrlKey!, shiftKey!, altKey!, metaKey!, part.keyCode);
+		};
+		let parts: SimpleKeybinding[] = [];
+		if (firstPart) {
+			parts.push(aSimpleKeybinding(firstPart));
+			if (chordPart) {
+				parts.push(aSimpleKeybinding(chordPart));
+			}
+		}
+		const keybinding = parts.length > 0 ? new USLayoutResolvedKeybinding(new ChordKeybinding(parts), OS) : undefined;
+		return new ResolvedKeybindingItem(keybinding, command || 'some command', null, when ? ContextKeyExpr.deserialize(when) : undefined, isDefault === undefined ? true : isDefault, null);
+	}
+
+});

lib/vscode/src/vs/workbench/services/keybinding/test/electron-browser/keybindingIO.test.ts

@@ -0,0 +1,160 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import * as assert from 'assert';
+import { KeyChord, KeyCode, KeyMod, SimpleKeybinding, createKeybinding } from 'vs/base/common/keyCodes';
+import { KeybindingParser } from 'vs/base/common/keybindingParser';
+import { OperatingSystem } from 'vs/base/common/platform';
+import { ScanCode, ScanCodeBinding } from 'vs/base/common/scanCode';
+import { IUserFriendlyKeybinding } from 'vs/platform/keybinding/common/keybinding';
+import { USLayoutResolvedKeybinding } from 'vs/platform/keybinding/common/usLayoutResolvedKeybinding';
+import { KeybindingIO } from 'vs/workbench/services/keybinding/common/keybindingIO';
+
+suite('keybindingIO', () => {
+
+	test('serialize/deserialize', () => {
+
+		function testOneSerialization(keybinding: number, expected: string, msg: string, OS: OperatingSystem): void {
+			let usLayoutResolvedKeybinding = new USLayoutResolvedKeybinding(createKeybinding(keybinding, OS)!, OS);
+			let actualSerialized = usLayoutResolvedKeybinding.getUserSettingsLabel();
+			assert.equal(actualSerialized, expected, expected + ' - ' + msg);
+		}
+		function testSerialization(keybinding: number, expectedWin: string, expectedMac: string, expectedLinux: string): void {
+			testOneSerialization(keybinding, expectedWin, 'win', OperatingSystem.Windows);
+			testOneSerialization(keybinding, expectedMac, 'mac', OperatingSystem.Macintosh);
+			testOneSerialization(keybinding, expectedLinux, 'linux', OperatingSystem.Linux);
+		}
+
+		function testOneDeserialization(keybinding: string, _expected: number, msg: string, OS: OperatingSystem): void {
+			let actualDeserialized = KeybindingParser.parseKeybinding(keybinding, OS);
+			let expected = createKeybinding(_expected, OS);
+			assert.deepEqual(actualDeserialized, expected, keybinding + ' - ' + msg);
+		}
+		function testDeserialization(inWin: string, inMac: string, inLinux: string, expected: number): void {
+			testOneDeserialization(inWin, expected, 'win', OperatingSystem.Windows);
+			testOneDeserialization(inMac, expected, 'mac', OperatingSystem.Macintosh);
+			testOneDeserialization(inLinux, expected, 'linux', OperatingSystem.Linux);
+		}
+
+		function testRoundtrip(keybinding: number, expectedWin: string, expectedMac: string, expectedLinux: string): void {
+			testSerialization(keybinding, expectedWin, expectedMac, expectedLinux);
+			testDeserialization(expectedWin, expectedMac, expectedLinux, keybinding);
+		}
+
+		testRoundtrip(KeyCode.KEY_0, '0', '0', '0');
+		testRoundtrip(KeyCode.KEY_A, 'a', 'a', 'a');
+		testRoundtrip(KeyCode.UpArrow, 'up', 'up', 'up');
+		testRoundtrip(KeyCode.RightArrow, 'right', 'right', 'right');
+		testRoundtrip(KeyCode.DownArrow, 'down', 'down', 'down');
+		testRoundtrip(KeyCode.LeftArrow, 'left', 'left', 'left');
+
+		// one modifier
+		testRoundtrip(KeyMod.Alt | KeyCode.KEY_A, 'alt+a', 'alt+a', 'alt+a');
+		testRoundtrip(KeyMod.CtrlCmd | KeyCode.KEY_A, 'ctrl+a', 'cmd+a', 'ctrl+a');
+		testRoundtrip(KeyMod.Shift | KeyCode.KEY_A, 'shift+a', 'shift+a', 'shift+a');
+		testRoundtrip(KeyMod.WinCtrl | KeyCode.KEY_A, 'win+a', 'ctrl+a', 'meta+a');
+
+		// two modifiers
+		testRoundtrip(KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.KEY_A, 'ctrl+alt+a', 'alt+cmd+a', 'ctrl+alt+a');
+		testRoundtrip(KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.KEY_A, 'ctrl+shift+a', 'shift+cmd+a', 'ctrl+shift+a');
+		testRoundtrip(KeyMod.CtrlCmd | KeyMod.WinCtrl | KeyCode.KEY_A, 'ctrl+win+a', 'ctrl+cmd+a', 'ctrl+meta+a');
+		testRoundtrip(KeyMod.Shift | KeyMod.Alt | KeyCode.KEY_A, 'shift+alt+a', 'shift+alt+a', 'shift+alt+a');
+		testRoundtrip(KeyMod.Shift | KeyMod.WinCtrl | KeyCode.KEY_A, 'shift+win+a', 'ctrl+shift+a', 'shift+meta+a');
+		testRoundtrip(KeyMod.Alt | KeyMod.WinCtrl | KeyCode.KEY_A, 'alt+win+a', 'ctrl+alt+a', 'alt+meta+a');
+
+		// three modifiers
+		testRoundtrip(KeyMod.CtrlCmd | KeyMod.Shift | KeyMod.Alt | KeyCode.KEY_A, 'ctrl+shift+alt+a', 'shift+alt+cmd+a', 'ctrl+shift+alt+a');
+		testRoundtrip(KeyMod.CtrlCmd | KeyMod.Shift | KeyMod.WinCtrl | KeyCode.KEY_A, 'ctrl+shift+win+a', 'ctrl+shift+cmd+a', 'ctrl+shift+meta+a');
+		testRoundtrip(KeyMod.Shift | KeyMod.Alt | KeyMod.WinCtrl | KeyCode.KEY_A, 'shift+alt+win+a', 'ctrl+shift+alt+a', 'shift+alt+meta+a');
+
+		// all modifiers
+		testRoundtrip(KeyMod.CtrlCmd | KeyMod.Shift | KeyMod.Alt | KeyMod.WinCtrl | KeyCode.KEY_A, 'ctrl+shift+alt+win+a', 'ctrl+shift+alt+cmd+a', 'ctrl+shift+alt+meta+a');
+
+		// chords
+		testRoundtrip(KeyChord(KeyMod.CtrlCmd | KeyCode.KEY_A, KeyMod.CtrlCmd | KeyCode.KEY_A), 'ctrl+a ctrl+a', 'cmd+a cmd+a', 'ctrl+a ctrl+a');
+		testRoundtrip(KeyChord(KeyMod.CtrlCmd | KeyCode.UpArrow, KeyMod.CtrlCmd | KeyCode.UpArrow), 'ctrl+up ctrl+up', 'cmd+up cmd+up', 'ctrl+up ctrl+up');
+
+		// OEM keys
+		testRoundtrip(KeyCode.US_SEMICOLON, ';', ';', ';');
+		testRoundtrip(KeyCode.US_EQUAL, '=', '=', '=');
+		testRoundtrip(KeyCode.US_COMMA, ',', ',', ',');
+		testRoundtrip(KeyCode.US_MINUS, '-', '-', '-');
+		testRoundtrip(KeyCode.US_DOT, '.', '.', '.');
+		testRoundtrip(KeyCode.US_SLASH, '/', '/', '/');
+		testRoundtrip(KeyCode.US_BACKTICK, '`', '`', '`');
+		testRoundtrip(KeyCode.ABNT_C1, 'abnt_c1', 'abnt_c1', 'abnt_c1');
+		testRoundtrip(KeyCode.ABNT_C2, 'abnt_c2', 'abnt_c2', 'abnt_c2');
+		testRoundtrip(KeyCode.US_OPEN_SQUARE_BRACKET, '[', '[', '[');
+		testRoundtrip(KeyCode.US_BACKSLASH, '\\', '\\', '\\');
+		testRoundtrip(KeyCode.US_CLOSE_SQUARE_BRACKET, ']', ']', ']');
+		testRoundtrip(KeyCode.US_QUOTE, '\'', '\'', '\'');
+		testRoundtrip(KeyCode.OEM_8, 'oem_8', 'oem_8', 'oem_8');
+		testRoundtrip(KeyCode.OEM_102, 'oem_102', 'oem_102', 'oem_102');
+
+		// OEM aliases
+		testDeserialization('OEM_1', 'OEM_1', 'OEM_1', KeyCode.US_SEMICOLON);
+		testDeserialization('OEM_PLUS', 'OEM_PLUS', 'OEM_PLUS', KeyCode.US_EQUAL);
+		testDeserialization('OEM_COMMA', 'OEM_COMMA', 'OEM_COMMA', KeyCode.US_COMMA);
+		testDeserialization('OEM_MINUS', 'OEM_MINUS', 'OEM_MINUS', KeyCode.US_MINUS);
+		testDeserialization('OEM_PERIOD', 'OEM_PERIOD', 'OEM_PERIOD', KeyCode.US_DOT);
+		testDeserialization('OEM_2', 'OEM_2', 'OEM_2', KeyCode.US_SLASH);
+		testDeserialization('OEM_3', 'OEM_3', 'OEM_3', KeyCode.US_BACKTICK);
+		testDeserialization('ABNT_C1', 'ABNT_C1', 'ABNT_C1', KeyCode.ABNT_C1);
+		testDeserialization('ABNT_C2', 'ABNT_C2', 'ABNT_C2', KeyCode.ABNT_C2);
+		testDeserialization('OEM_4', 'OEM_4', 'OEM_4', KeyCode.US_OPEN_SQUARE_BRACKET);
+		testDeserialization('OEM_5', 'OEM_5', 'OEM_5', KeyCode.US_BACKSLASH);
+		testDeserialization('OEM_6', 'OEM_6', 'OEM_6', KeyCode.US_CLOSE_SQUARE_BRACKET);
+		testDeserialization('OEM_7', 'OEM_7', 'OEM_7', KeyCode.US_QUOTE);
+		testDeserialization('OEM_8', 'OEM_8', 'OEM_8', KeyCode.OEM_8);
+		testDeserialization('OEM_102', 'OEM_102', 'OEM_102', KeyCode.OEM_102);
+
+		// accepts '-' as separator
+		testDeserialization('ctrl-shift-alt-win-a', 'ctrl-shift-alt-cmd-a', 'ctrl-shift-alt-meta-a', KeyMod.CtrlCmd | KeyMod.Shift | KeyMod.Alt | KeyMod.WinCtrl | KeyCode.KEY_A);
+
+		// various input mistakes
+		testDeserialization(' ctrl-shift-alt-win-A ', ' shift-alt-cmd-Ctrl-A ', ' ctrl-shift-alt-META-A ', KeyMod.CtrlCmd | KeyMod.Shift | KeyMod.Alt | KeyMod.WinCtrl | KeyCode.KEY_A);
+	});
+
+	test('deserialize scan codes', () => {
+		assert.deepEqual(
+			KeybindingParser.parseUserBinding('ctrl+shift+[comma] ctrl+/'),
+			[new ScanCodeBinding(true, true, false, false, ScanCode.Comma), new SimpleKeybinding(true, false, false, false, KeyCode.US_SLASH)]
+		);
+	});
+
+	test('issue #10452 - invalid command', () => {
+		let strJSON = `[{ "key": "ctrl+k ctrl+f", "command": ["firstcommand", "seccondcommand"] }]`;
+		let userKeybinding = <IUserFriendlyKeybinding>JSON.parse(strJSON)[0];
+		let keybindingItem = KeybindingIO.readUserKeybindingItem(userKeybinding);
+		assert.equal(keybindingItem.command, null);
+	});
+
+	test('issue #10452 - invalid when', () => {
+		let strJSON = `[{ "key": "ctrl+k ctrl+f", "command": "firstcommand", "when": [] }]`;
+		let userKeybinding = <IUserFriendlyKeybinding>JSON.parse(strJSON)[0];
+		let keybindingItem = KeybindingIO.readUserKeybindingItem(userKeybinding);
+		assert.equal(keybindingItem.when, null);
+	});
+
+	test('issue #10452 - invalid key', () => {
+		let strJSON = `[{ "key": [], "command": "firstcommand" }]`;
+		let userKeybinding = <IUserFriendlyKeybinding>JSON.parse(strJSON)[0];
+		let keybindingItem = KeybindingIO.readUserKeybindingItem(userKeybinding);
+		assert.deepEqual(keybindingItem.parts, []);
+	});
+
+	test('issue #10452 - invalid key 2', () => {
+		let strJSON = `[{ "key": "", "command": "firstcommand" }]`;
+		let userKeybinding = <IUserFriendlyKeybinding>JSON.parse(strJSON)[0];
+		let keybindingItem = KeybindingIO.readUserKeybindingItem(userKeybinding);
+		assert.deepEqual(keybindingItem.parts, []);
+	});
+
+	test('test commands args', () => {
+		let strJSON = `[{ "key": "ctrl+k ctrl+f", "command": "firstcommand", "when": [], "args": { "text": "theText" } }]`;
+		let userKeybinding = <IUserFriendlyKeybinding>JSON.parse(strJSON)[0];
+		let keybindingItem = KeybindingIO.readUserKeybindingItem(userKeybinding);
+		assert.equal(keybindingItem.commandArgs.text, 'theText');
+	});
+});

lib/vscode/src/vs/workbench/services/keybinding/test/electron-browser/keyboardMapperTestUtils.ts

@@ -0,0 +1,77 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import * as path from 'vs/base/common/path';
+import { getPathFromAmdModule } from 'vs/base/common/amd';
+import { Keybinding, ResolvedKeybinding, SimpleKeybinding } from 'vs/base/common/keyCodes';
+import { ScanCodeBinding } from 'vs/base/common/scanCode';
+import { readFile, writeFile } from 'vs/base/node/pfs';
+import { IKeyboardEvent } from 'vs/platform/keybinding/common/keybinding';
+import { IKeyboardMapper } from 'vs/workbench/services/keybinding/common/keyboardMapper';
+
+export interface IResolvedKeybinding {
+	label: string | null;
+	ariaLabel: string | null;
+	electronAccelerator: string | null;
+	userSettingsLabel: string | null;
+	isWYSIWYG: boolean;
+	isChord: boolean;
+	dispatchParts: (string | null)[];
+}
+
+function toIResolvedKeybinding(kb: ResolvedKeybinding): IResolvedKeybinding {
+	return {
+		label: kb.getLabel(),
+		ariaLabel: kb.getAriaLabel(),
+		electronAccelerator: kb.getElectronAccelerator(),
+		userSettingsLabel: kb.getUserSettingsLabel(),
+		isWYSIWYG: kb.isWYSIWYG(),
+		isChord: kb.isChord(),
+		dispatchParts: kb.getDispatchParts(),
+	};
+}
+
+export function assertResolveKeybinding(mapper: IKeyboardMapper, keybinding: Keybinding | null, expected: IResolvedKeybinding[]): void {
+	let actual: IResolvedKeybinding[] = mapper.resolveKeybinding(keybinding!).map(toIResolvedKeybinding);
+	assert.deepEqual(actual, expected);
+}
+
+export function assertResolveKeyboardEvent(mapper: IKeyboardMapper, keyboardEvent: IKeyboardEvent, expected: IResolvedKeybinding): void {
+	let actual = toIResolvedKeybinding(mapper.resolveKeyboardEvent(keyboardEvent));
+	assert.deepEqual(actual, expected);
+}
+
+export function assertResolveUserBinding(mapper: IKeyboardMapper, parts: (SimpleKeybinding | ScanCodeBinding)[], expected: IResolvedKeybinding[]): void {
+	let actual: IResolvedKeybinding[] = mapper.resolveUserBinding(parts).map(toIResolvedKeybinding);
+	assert.deepEqual(actual, expected);
+}
+
+export function readRawMapping<T>(file: string): Promise<T> {
+	return readFile(getPathFromAmdModule(require, `vs/workbench/services/keybinding/test/electron-browser/${file}.js`)).then((buff) => {
+		let contents = buff.toString();
+		let func = new Function('define', contents);
+		let rawMappings: T | null = null;
+		func(function (value: T) {
+			rawMappings = value;
+		});
+		return rawMappings!;
+	});
+}
+
+export function assertMapping(writeFileIfDifferent: boolean, mapper: IKeyboardMapper, file: string): Promise<void> {
+	const filePath = path.normalize(getPathFromAmdModule(require, `vs/workbench/services/keybinding/test/electron-browser/${file}`));
+
+	return readFile(filePath).then((buff) => {
+		let expected = buff.toString();
+		const actual = mapper.dumpDebugInfo();
+		if (actual !== expected && writeFileIfDifferent) {
+			const destPath = filePath.replace(/vscode[\/\\]out[\/\\]vs/, 'vscode/src/vs');
+			writeFile(destPath, actual);
+		}
+
+		assert.deepEqual(actual.split(/\r\n|\n/), expected.split(/\r\n|\n/));
+	});
+}

lib/vscode/src/vs/workbench/services/keybinding/test/electron-browser/linux_de_ch.js

@@ -0,0 +1,491 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+define({
+	Sleep: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	WakeUp: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	KeyA: {
+		value: 'a',
+		withShift: 'A',
+		withAltGr: 'æ',
+		withShiftAltGr: 'Æ'
+	},
+	KeyB: {
+		value: 'b',
+		withShift: 'B',
+		withAltGr: '”',
+		withShiftAltGr: '’'
+	},
+	KeyC: {
+		value: 'c',
+		withShift: 'C',
+		withAltGr: '¢',
+		withShiftAltGr: '©'
+	},
+	KeyD: {
+		value: 'd',
+		withShift: 'D',
+		withAltGr: 'ð',
+		withShiftAltGr: 'Ð'
+	},
+	KeyE: {
+		value: 'e',
+		withShift: 'E',
+		withAltGr: '€',
+		withShiftAltGr: 'E'
+	},
+	KeyF: {
+		value: 'f',
+		withShift: 'F',
+		withAltGr: 'đ',
+		withShiftAltGr: 'ª'
+	},
+	KeyG: {
+		value: 'g',
+		withShift: 'G',
+		withAltGr: 'ŋ',
+		withShiftAltGr: 'Ŋ'
+	},
+	KeyH: {
+		value: 'h',
+		withShift: 'H',
+		withAltGr: 'ħ',
+		withShiftAltGr: 'Ħ'
+	},
+	KeyI: {
+		value: 'i',
+		withShift: 'I',
+		withAltGr: '→',
+		withShiftAltGr: 'ı'
+	},
+	KeyJ: {
+		value: 'j',
+		withShift: 'J',
+		withAltGr: '̉',
+		withShiftAltGr: '̛'
+	},
+	KeyK: {
+		value: 'k',
+		withShift: 'K',
+		withAltGr: 'ĸ',
+		withShiftAltGr: '&'
+	},
+	KeyL: {
+		value: 'l',
+		withShift: 'L',
+		withAltGr: 'ł',
+		withShiftAltGr: 'Ł'
+	},
+	KeyM: {
+		value: 'm',
+		withShift: 'M',
+		withAltGr: 'µ',
+		withShiftAltGr: 'º'
+	},
+	KeyN: {
+		value: 'n',
+		withShift: 'N',
+		withAltGr: 'n',
+		withShiftAltGr: 'N'
+	},
+	KeyO: {
+		value: 'o',
+		withShift: 'O',
+		withAltGr: 'œ',
+		withShiftAltGr: 'Œ'
+	},
+	KeyP: {
+		value: 'p',
+		withShift: 'P',
+		withAltGr: 'þ',
+		withShiftAltGr: 'Þ'
+	},
+	KeyQ: {
+		value: 'q',
+		withShift: 'Q',
+		withAltGr: '@',
+		withShiftAltGr: 'Ω'
+	},
+	KeyR: {
+		value: 'r',
+		withShift: 'R',
+		withAltGr: '¶',
+		withShiftAltGr: '®'
+	},
+	KeyS: {
+		value: 's',
+		withShift: 'S',
+		withAltGr: 'ß',
+		withShiftAltGr: '§'
+	},
+	KeyT: {
+		value: 't',
+		withShift: 'T',
+		withAltGr: 'ŧ',
+		withShiftAltGr: 'Ŧ'
+	},
+	KeyU: {
+		value: 'u',
+		withShift: 'U',
+		withAltGr: '↓',
+		withShiftAltGr: '↑'
+	},
+	KeyV: {
+		value: 'v',
+		withShift: 'V',
+		withAltGr: '“',
+		withShiftAltGr: '‘'
+	},
+	KeyW: {
+		value: 'w',
+		withShift: 'W',
+		withAltGr: 'ł',
+		withShiftAltGr: 'Ł'
+	},
+	KeyX: {
+		value: 'x',
+		withShift: 'X',
+		withAltGr: '»',
+		withShiftAltGr: '>'
+	},
+	KeyY: {
+		value: 'z',
+		withShift: 'Z',
+		withAltGr: '←',
+		withShiftAltGr: '¥'
+	},
+	KeyZ: {
+		value: 'y',
+		withShift: 'Y',
+		withAltGr: '«',
+		withShiftAltGr: '<'
+	},
+	Digit1: {
+		value: '1',
+		withShift: '+',
+		withAltGr: '|',
+		withShiftAltGr: '¡'
+	},
+	Digit2: {
+		value: '2',
+		withShift: '"',
+		withAltGr: '@',
+		withShiftAltGr: '⅛'
+	},
+	Digit3: {
+		value: '3',
+		withShift: '*',
+		withAltGr: '#',
+		withShiftAltGr: '£'
+	},
+	Digit4: {
+		value: '4',
+		withShift: 'ç',
+		withAltGr: '¼',
+		withShiftAltGr: '$'
+	},
+	Digit5: {
+		value: '5',
+		withShift: '%',
+		withAltGr: '½',
+		withShiftAltGr: '⅜'
+	},
+	Digit6: {
+		value: '6',
+		withShift: '&',
+		withAltGr: '¬',
+		withShiftAltGr: '⅝'
+	},
+	Digit7: {
+		value: '7',
+		withShift: '/',
+		withAltGr: '|',
+		withShiftAltGr: '⅞'
+	},
+	Digit8: {
+		value: '8',
+		withShift: '(',
+		withAltGr: '¢',
+		withShiftAltGr: '™'
+	},
+	Digit9: {
+		value: '9',
+		withShift: ')',
+		withAltGr: ']',
+		withShiftAltGr: '±'
+	},
+	Digit0: {
+		value: '0',
+		withShift: '=',
+		withAltGr: '}',
+		withShiftAltGr: '°'
+	},
+	Enter: {
+		value: '\r',
+		withShift: '\r',
+		withAltGr: '\r',
+		withShiftAltGr: '\r'
+	},
+	Escape: {
+		value: '\u001b',
+		withShift: '\u001b',
+		withAltGr: '\u001b',
+		withShiftAltGr: '\u001b'
+	},
+	Backspace: {
+		value: '\b',
+		withShift: '\b',
+		withAltGr: '\b',
+		withShiftAltGr: '\b'
+	},
+	Tab: {
+		value: '\t',
+		withShift: '',
+		withAltGr: '\t',
+		withShiftAltGr: ''
+	},
+	Space: {
+		value: ' ',
+		withShift: ' ',
+		withAltGr: ' ',
+		withShiftAltGr: ' '
+	},
+	Minus: {
+		value: '\'',
+		withShift: '?',
+		withAltGr: '́',
+		withShiftAltGr: '¿'
+	},
+	Equal: {
+		value: '̂',
+		withShift: '̀',
+		withAltGr: '̃',
+		withShiftAltGr: '̨'
+	},
+	BracketLeft: {
+		value: 'ü',
+		withShift: 'è',
+		withAltGr: '[',
+		withShiftAltGr: '̊'
+	},
+	BracketRight: {
+		value: '̈',
+		withShift: '!',
+		withAltGr: ']',
+		withShiftAltGr: '̄'
+	},
+	Backslash: {
+		value: '$',
+		withShift: '£',
+		withAltGr: '}',
+		withShiftAltGr: '̆'
+	},
+	Semicolon: {
+		value: 'ö',
+		withShift: 'é',
+		withAltGr: '́',
+		withShiftAltGr: '̋'
+	},
+	Quote: {
+		value: 'ä',
+		withShift: 'à',
+		withAltGr: '{',
+		withShiftAltGr: '̌'
+	},
+	Backquote: {
+		value: '§',
+		withShift: '°',
+		withAltGr: '¬',
+		withShiftAltGr: '¬'
+	},
+	Comma: {
+		value: ',',
+		withShift: ';',
+		withAltGr: '─',
+		withShiftAltGr: '×'
+	},
+	Period: {
+		value: '.',
+		withShift: ':',
+		withAltGr: '·',
+		withShiftAltGr: '÷'
+	},
+	Slash: {
+		value: '-',
+		withShift: '_',
+		withAltGr: '̣',
+		withShiftAltGr: '̇'
+	},
+	CapsLock: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F1: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F2: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F3: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F4: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F5: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F6: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F7: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F8: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F9: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F10: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F11: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F12: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	PrintScreen: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	ScrollLock: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Pause: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Insert: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Home: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	PageUp: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Delete: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	End: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	PageDown: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	ArrowRight: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	ArrowLeft: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	ArrowDown: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	ArrowUp: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	NumLock: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	NumpadDivide: {
+		value: '/',
+		withShift: '/',
+		withAltGr: '/',
+		withShiftAltGr: '/'
+	},
+	NumpadMultiply: {
+		value: '*',
+		withShift: '*',
+		withAltGr: '*',
+		withShiftAltGr: '*'
+	},
+	NumpadSubtract: {
+		value: '-',
+		withShift: '-',
+		withAltGr: '-',
+		withShiftAltGr: '-'
+	},
+	NumpadAdd: {
+		value: '+',
+		withShift: '+',
+		withAltGr: '+',
+		withShiftAltGr: '+'
+	},
+	NumpadEnter: {
+		value: '\r',
+		withShift: '\r',
+		withAltGr: '\r',
+		withShiftAltGr: '\r'
+	},
+	Numpad1: { value: '', withShift: '1', withAltGr: '', withShiftAltGr: '1' },
+	Numpad2: { value: '', withShift: '2', withAltGr: '', withShiftAltGr: '2' },
+	Numpad3: { value: '', withShift: '3', withAltGr: '', withShiftAltGr: '3' },
+	Numpad4: { value: '', withShift: '4', withAltGr: '', withShiftAltGr: '4' },
+	Numpad5: { value: '', withShift: '5', withAltGr: '', withShiftAltGr: '5' },
+	Numpad6: { value: '', withShift: '6', withAltGr: '', withShiftAltGr: '6' },
+	Numpad7: { value: '', withShift: '7', withAltGr: '', withShiftAltGr: '7' },
+	Numpad8: { value: '', withShift: '8', withAltGr: '', withShiftAltGr: '8' },
+	Numpad9: { value: '', withShift: '9', withAltGr: '', withShiftAltGr: '9' },
+	Numpad0: { value: '', withShift: '0', withAltGr: '', withShiftAltGr: '0' },
+	NumpadDecimal: { value: '', withShift: '.', withAltGr: '', withShiftAltGr: '.' },
+	IntlBackslash: {
+		value: '<',
+		withShift: '>',
+		withAltGr: '\\',
+		withShiftAltGr: '¦'
+	},
+	ContextMenu: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Power: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	NumpadEqual: {
+		value: '=',
+		withShift: '=',
+		withAltGr: '=',
+		withShiftAltGr: '='
+	},
+	F13: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F14: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F15: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F16: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F17: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F18: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F19: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F20: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F21: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F22: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F23: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F24: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Open: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Help: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Select: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Again: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Undo: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Cut: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Copy: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Paste: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Find: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	AudioVolumeMute: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	AudioVolumeUp: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	AudioVolumeDown: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	NumpadComma: {
+		value: '.',
+		withShift: '.',
+		withAltGr: '.',
+		withShiftAltGr: '.'
+	},
+	IntlRo: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	KanaMode: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	IntlYen: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Convert: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	NonConvert: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Lang1: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Lang2: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Lang3: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Lang4: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Lang5: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	NumpadParenLeft: {
+		value: '(',
+		withShift: '(',
+		withAltGr: '(',
+		withShiftAltGr: '('
+	},
+	NumpadParenRight: {
+		value: ')',
+		withShift: ')',
+		withAltGr: ')',
+		withShiftAltGr: ')'
+	},
+	ControlLeft: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	ShiftLeft: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	AltLeft: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MetaLeft: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	ControlRight: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	ShiftRight: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	AltRight: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MetaRight: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	BrightnessUp: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	BrightnessDown: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MediaPlay: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MediaRecord: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MediaFastForward: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MediaRewind: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MediaTrackNext: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MediaTrackPrevious: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MediaStop: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Eject: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MediaPlayPause: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MediaSelect: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	LaunchMail: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	LaunchApp2: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	LaunchApp1: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	SelectTask: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	LaunchScreenSaver: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	BrowserSearch: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	BrowserHome: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	BrowserBack: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	BrowserForward: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	BrowserStop: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	BrowserRefresh: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	BrowserFavorites: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MailReply: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MailForward: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MailSend: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' }
+});

lib/vscode/src/vs/workbench/services/keybinding/test/electron-browser/linux_de_ch.txt

@@ -0,0 +1,529 @@
+isUSStandard: false
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyA |   a   |                         A |     |                         A |                              a |                         A |                         [KeyA] |         |
+|                      Ctrl+KeyA |   a   |                    Ctrl+A |     |                    Ctrl+A |                         ctrl+a |                    Ctrl+A |                    ctrl+[KeyA] |         |
+|                     Shift+KeyA |   A   |                   Shift+A |     |                   Shift+A |                        shift+a |                   Shift+A |                   shift+[KeyA] |         |
+|                Ctrl+Shift+KeyA |   A   |              Ctrl+Shift+A |     |              Ctrl+Shift+A |                   ctrl+shift+a |              Ctrl+Shift+A |              ctrl+shift+[KeyA] |         |
+|                       Alt+KeyA |   a   |                     Alt+A |     |                     Alt+A |                          alt+a |                     Alt+A |                     alt+[KeyA] |         |
+|                  Ctrl+Alt+KeyA |   æ   |                Ctrl+Alt+A |     |                Ctrl+Alt+A |                     ctrl+alt+a |                Ctrl+Alt+A |                ctrl+alt+[KeyA] |         |
+|                 Shift+Alt+KeyA |   A   |               Shift+Alt+A |     |               Shift+Alt+A |                    shift+alt+a |               Shift+Alt+A |               shift+alt+[KeyA] |         |
+|            Ctrl+Shift+Alt+KeyA |   Æ   |          Ctrl+Shift+Alt+A |     |          Ctrl+Shift+Alt+A |               ctrl+shift+alt+a |          Ctrl+Shift+Alt+A |          ctrl+shift+alt+[KeyA] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyB |   b   |                         B |     |                         B |                              b |                         B |                         [KeyB] |         |
+|                      Ctrl+KeyB |   b   |                    Ctrl+B |     |                    Ctrl+B |                         ctrl+b |                    Ctrl+B |                    ctrl+[KeyB] |         |
+|                     Shift+KeyB |   B   |                   Shift+B |     |                   Shift+B |                        shift+b |                   Shift+B |                   shift+[KeyB] |         |
+|                Ctrl+Shift+KeyB |   B   |              Ctrl+Shift+B |     |              Ctrl+Shift+B |                   ctrl+shift+b |              Ctrl+Shift+B |              ctrl+shift+[KeyB] |         |
+|                       Alt+KeyB |   b   |                     Alt+B |     |                     Alt+B |                          alt+b |                     Alt+B |                     alt+[KeyB] |         |
+|                  Ctrl+Alt+KeyB |   ”   |                Ctrl+Alt+B |     |                Ctrl+Alt+B |                     ctrl+alt+b |                Ctrl+Alt+B |                ctrl+alt+[KeyB] |         |
+|                 Shift+Alt+KeyB |   B   |               Shift+Alt+B |     |               Shift+Alt+B |                    shift+alt+b |               Shift+Alt+B |               shift+alt+[KeyB] |         |
+|            Ctrl+Shift+Alt+KeyB |   ’   |          Ctrl+Shift+Alt+B |     |          Ctrl+Shift+Alt+B |               ctrl+shift+alt+b |          Ctrl+Shift+Alt+B |          ctrl+shift+alt+[KeyB] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyC |   c   |                         C |     |                         C |                              c |                         C |                         [KeyC] |         |
+|                      Ctrl+KeyC |   c   |                    Ctrl+C |     |                    Ctrl+C |                         ctrl+c |                    Ctrl+C |                    ctrl+[KeyC] |         |
+|                     Shift+KeyC |   C   |                   Shift+C |     |                   Shift+C |                        shift+c |                   Shift+C |                   shift+[KeyC] |         |
+|                Ctrl+Shift+KeyC |   C   |              Ctrl+Shift+C |     |              Ctrl+Shift+C |                   ctrl+shift+c |              Ctrl+Shift+C |              ctrl+shift+[KeyC] |         |
+|                       Alt+KeyC |   c   |                     Alt+C |     |                     Alt+C |                          alt+c |                     Alt+C |                     alt+[KeyC] |         |
+|                  Ctrl+Alt+KeyC |   ¢   |                Ctrl+Alt+C |     |                Ctrl+Alt+C |                     ctrl+alt+c |                Ctrl+Alt+C |                ctrl+alt+[KeyC] |         |
+|                 Shift+Alt+KeyC |   C   |               Shift+Alt+C |     |               Shift+Alt+C |                    shift+alt+c |               Shift+Alt+C |               shift+alt+[KeyC] |         |
+|            Ctrl+Shift+Alt+KeyC |   ©   |          Ctrl+Shift+Alt+C |     |          Ctrl+Shift+Alt+C |               ctrl+shift+alt+c |          Ctrl+Shift+Alt+C |          ctrl+shift+alt+[KeyC] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyD |   d   |                         D |     |                         D |                              d |                         D |                         [KeyD] |         |
+|                      Ctrl+KeyD |   d   |                    Ctrl+D |     |                    Ctrl+D |                         ctrl+d |                    Ctrl+D |                    ctrl+[KeyD] |         |
+|                     Shift+KeyD |   D   |                   Shift+D |     |                   Shift+D |                        shift+d |                   Shift+D |                   shift+[KeyD] |         |
+|                Ctrl+Shift+KeyD |   D   |              Ctrl+Shift+D |     |              Ctrl+Shift+D |                   ctrl+shift+d |              Ctrl+Shift+D |              ctrl+shift+[KeyD] |         |
+|                       Alt+KeyD |   d   |                     Alt+D |     |                     Alt+D |                          alt+d |                     Alt+D |                     alt+[KeyD] |         |
+|                  Ctrl+Alt+KeyD |   ð   |                Ctrl+Alt+D |     |                Ctrl+Alt+D |                     ctrl+alt+d |                Ctrl+Alt+D |                ctrl+alt+[KeyD] |         |
+|                 Shift+Alt+KeyD |   D   |               Shift+Alt+D |     |               Shift+Alt+D |                    shift+alt+d |               Shift+Alt+D |               shift+alt+[KeyD] |         |
+|            Ctrl+Shift+Alt+KeyD |   Ð   |          Ctrl+Shift+Alt+D |     |          Ctrl+Shift+Alt+D |               ctrl+shift+alt+d |          Ctrl+Shift+Alt+D |          ctrl+shift+alt+[KeyD] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyE |   e   |                         E |     |                         E |                              e |                         E |                         [KeyE] |         |
+|                      Ctrl+KeyE |   e   |                    Ctrl+E |     |                    Ctrl+E |                         ctrl+e |                    Ctrl+E |                    ctrl+[KeyE] |         |
+|                     Shift+KeyE |   E   |                   Shift+E |     |                   Shift+E |                        shift+e |                   Shift+E |                   shift+[KeyE] |         |
+|                Ctrl+Shift+KeyE |   E   |              Ctrl+Shift+E |     |              Ctrl+Shift+E |                   ctrl+shift+e |              Ctrl+Shift+E |              ctrl+shift+[KeyE] |         |
+|                       Alt+KeyE |   e   |                     Alt+E |     |                     Alt+E |                          alt+e |                     Alt+E |                     alt+[KeyE] |         |
+|                  Ctrl+Alt+KeyE |   €   |                Ctrl+Alt+E |     |                Ctrl+Alt+E |                     ctrl+alt+e |                Ctrl+Alt+E |                ctrl+alt+[KeyE] |         |
+|                 Shift+Alt+KeyE |   E   |               Shift+Alt+E |     |               Shift+Alt+E |                    shift+alt+e |               Shift+Alt+E |               shift+alt+[KeyE] |         |
+|            Ctrl+Shift+Alt+KeyE |   E   |          Ctrl+Shift+Alt+E |     |          Ctrl+Shift+Alt+E |               ctrl+shift+alt+e |          Ctrl+Shift+Alt+E |          ctrl+shift+alt+[KeyE] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyF |   f   |                         F |     |                         F |                              f |                         F |                         [KeyF] |         |
+|                      Ctrl+KeyF |   f   |                    Ctrl+F |     |                    Ctrl+F |                         ctrl+f |                    Ctrl+F |                    ctrl+[KeyF] |         |
+|                     Shift+KeyF |   F   |                   Shift+F |     |                   Shift+F |                        shift+f |                   Shift+F |                   shift+[KeyF] |         |
+|                Ctrl+Shift+KeyF |   F   |              Ctrl+Shift+F |     |              Ctrl+Shift+F |                   ctrl+shift+f |              Ctrl+Shift+F |              ctrl+shift+[KeyF] |         |
+|                       Alt+KeyF |   f   |                     Alt+F |     |                     Alt+F |                          alt+f |                     Alt+F |                     alt+[KeyF] |         |
+|                  Ctrl+Alt+KeyF |   đ   |                Ctrl+Alt+F |     |                Ctrl+Alt+F |                     ctrl+alt+f |                Ctrl+Alt+F |                ctrl+alt+[KeyF] |         |
+|                 Shift+Alt+KeyF |   F   |               Shift+Alt+F |     |               Shift+Alt+F |                    shift+alt+f |               Shift+Alt+F |               shift+alt+[KeyF] |         |
+|            Ctrl+Shift+Alt+KeyF |   ª   |          Ctrl+Shift+Alt+F |     |          Ctrl+Shift+Alt+F |               ctrl+shift+alt+f |          Ctrl+Shift+Alt+F |          ctrl+shift+alt+[KeyF] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyG |   g   |                         G |     |                         G |                              g |                         G |                         [KeyG] |         |
+|                      Ctrl+KeyG |   g   |                    Ctrl+G |     |                    Ctrl+G |                         ctrl+g |                    Ctrl+G |                    ctrl+[KeyG] |         |
+|                     Shift+KeyG |   G   |                   Shift+G |     |                   Shift+G |                        shift+g |                   Shift+G |                   shift+[KeyG] |         |
+|                Ctrl+Shift+KeyG |   G   |              Ctrl+Shift+G |     |              Ctrl+Shift+G |                   ctrl+shift+g |              Ctrl+Shift+G |              ctrl+shift+[KeyG] |         |
+|                       Alt+KeyG |   g   |                     Alt+G |     |                     Alt+G |                          alt+g |                     Alt+G |                     alt+[KeyG] |         |
+|                  Ctrl+Alt+KeyG |   ŋ   |                Ctrl+Alt+G |     |                Ctrl+Alt+G |                     ctrl+alt+g |                Ctrl+Alt+G |                ctrl+alt+[KeyG] |         |
+|                 Shift+Alt+KeyG |   G   |               Shift+Alt+G |     |               Shift+Alt+G |                    shift+alt+g |               Shift+Alt+G |               shift+alt+[KeyG] |         |
+|            Ctrl+Shift+Alt+KeyG |   Ŋ   |          Ctrl+Shift+Alt+G |     |          Ctrl+Shift+Alt+G |               ctrl+shift+alt+g |          Ctrl+Shift+Alt+G |          ctrl+shift+alt+[KeyG] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyH |   h   |                         H |     |                         H |                              h |                         H |                         [KeyH] |         |
+|                      Ctrl+KeyH |   h   |                    Ctrl+H |     |                    Ctrl+H |                         ctrl+h |                    Ctrl+H |                    ctrl+[KeyH] |         |
+|                     Shift+KeyH |   H   |                   Shift+H |     |                   Shift+H |                        shift+h |                   Shift+H |                   shift+[KeyH] |         |
+|                Ctrl+Shift+KeyH |   H   |              Ctrl+Shift+H |     |              Ctrl+Shift+H |                   ctrl+shift+h |              Ctrl+Shift+H |              ctrl+shift+[KeyH] |         |
+|                       Alt+KeyH |   h   |                     Alt+H |     |                     Alt+H |                          alt+h |                     Alt+H |                     alt+[KeyH] |         |
+|                  Ctrl+Alt+KeyH |   ħ   |                Ctrl+Alt+H |     |                Ctrl+Alt+H |                     ctrl+alt+h |                Ctrl+Alt+H |                ctrl+alt+[KeyH] |         |
+|                 Shift+Alt+KeyH |   H   |               Shift+Alt+H |     |               Shift+Alt+H |                    shift+alt+h |               Shift+Alt+H |               shift+alt+[KeyH] |         |
+|            Ctrl+Shift+Alt+KeyH |   Ħ   |          Ctrl+Shift+Alt+H |     |          Ctrl+Shift+Alt+H |               ctrl+shift+alt+h |          Ctrl+Shift+Alt+H |          ctrl+shift+alt+[KeyH] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyI |   i   |                         I |     |                         I |                              i |                         I |                         [KeyI] |         |
+|                      Ctrl+KeyI |   i   |                    Ctrl+I |     |                    Ctrl+I |                         ctrl+i |                    Ctrl+I |                    ctrl+[KeyI] |         |
+|                     Shift+KeyI |   I   |                   Shift+I |     |                   Shift+I |                        shift+i |                   Shift+I |                   shift+[KeyI] |         |
+|                Ctrl+Shift+KeyI |   I   |              Ctrl+Shift+I |     |              Ctrl+Shift+I |                   ctrl+shift+i |              Ctrl+Shift+I |              ctrl+shift+[KeyI] |         |
+|                       Alt+KeyI |   i   |                     Alt+I |     |                     Alt+I |                          alt+i |                     Alt+I |                     alt+[KeyI] |         |
+|                  Ctrl+Alt+KeyI |   →   |                Ctrl+Alt+I |     |                Ctrl+Alt+I |                     ctrl+alt+i |                Ctrl+Alt+I |                ctrl+alt+[KeyI] |         |
+|                 Shift+Alt+KeyI |   I   |               Shift+Alt+I |     |               Shift+Alt+I |                    shift+alt+i |               Shift+Alt+I |               shift+alt+[KeyI] |         |
+|            Ctrl+Shift+Alt+KeyI |   ı   |          Ctrl+Shift+Alt+I |     |          Ctrl+Shift+Alt+I |               ctrl+shift+alt+i |          Ctrl+Shift+Alt+I |          ctrl+shift+alt+[KeyI] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyJ |   j   |                         J |     |                         J |                              j |                         J |                         [KeyJ] |         |
+|                      Ctrl+KeyJ |   j   |                    Ctrl+J |     |                    Ctrl+J |                         ctrl+j |                    Ctrl+J |                    ctrl+[KeyJ] |         |
+|                     Shift+KeyJ |   J   |                   Shift+J |     |                   Shift+J |                        shift+j |                   Shift+J |                   shift+[KeyJ] |         |
+|                Ctrl+Shift+KeyJ |   J   |              Ctrl+Shift+J |     |              Ctrl+Shift+J |                   ctrl+shift+j |              Ctrl+Shift+J |              ctrl+shift+[KeyJ] |         |
+|                       Alt+KeyJ |   j   |                     Alt+J |     |                     Alt+J |                          alt+j |                     Alt+J |                     alt+[KeyJ] |         |
+|                  Ctrl+Alt+KeyJ | U+309 |                Ctrl+Alt+J |     |                Ctrl+Alt+J |                     ctrl+alt+j |                Ctrl+Alt+J |                ctrl+alt+[KeyJ] |         |
+|                 Shift+Alt+KeyJ |   J   |               Shift+Alt+J |     |               Shift+Alt+J |                    shift+alt+j |               Shift+Alt+J |               shift+alt+[KeyJ] |         |
+|            Ctrl+Shift+Alt+KeyJ | U+31b |          Ctrl+Shift+Alt+J |     |          Ctrl+Shift+Alt+J |               ctrl+shift+alt+j |          Ctrl+Shift+Alt+J |          ctrl+shift+alt+[KeyJ] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyK |   k   |                         K |     |                         K |                              k |                         K |                         [KeyK] |         |
+|                      Ctrl+KeyK |   k   |                    Ctrl+K |     |                    Ctrl+K |                         ctrl+k |                    Ctrl+K |                    ctrl+[KeyK] |         |
+|                     Shift+KeyK |   K   |                   Shift+K |     |                   Shift+K |                        shift+k |                   Shift+K |                   shift+[KeyK] |         |
+|                Ctrl+Shift+KeyK |   K   |              Ctrl+Shift+K |     |              Ctrl+Shift+K |                   ctrl+shift+k |              Ctrl+Shift+K |              ctrl+shift+[KeyK] |         |
+|                       Alt+KeyK |   k   |                     Alt+K |     |                     Alt+K |                          alt+k |                     Alt+K |                     alt+[KeyK] |         |
+|                  Ctrl+Alt+KeyK |   ĸ   |                Ctrl+Alt+K |     |                Ctrl+Alt+K |                     ctrl+alt+k |                Ctrl+Alt+K |                ctrl+alt+[KeyK] |         |
+|                 Shift+Alt+KeyK |   K   |               Shift+Alt+K |     |               Shift+Alt+K |                    shift+alt+k |               Shift+Alt+K |               shift+alt+[KeyK] |         |
+|            Ctrl+Shift+Alt+KeyK |   &   |          Ctrl+Shift+Alt+K |     |          Ctrl+Shift+Alt+K |               ctrl+shift+alt+k |          Ctrl+Shift+Alt+K |          ctrl+shift+alt+[KeyK] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyL |   l   |                         L |     |                         L |                              l |                         L |                         [KeyL] |         |
+|                      Ctrl+KeyL |   l   |                    Ctrl+L |     |                    Ctrl+L |                         ctrl+l |                    Ctrl+L |                    ctrl+[KeyL] |         |
+|                     Shift+KeyL |   L   |                   Shift+L |     |                   Shift+L |                        shift+l |                   Shift+L |                   shift+[KeyL] |         |
+|                Ctrl+Shift+KeyL |   L   |              Ctrl+Shift+L |     |              Ctrl+Shift+L |                   ctrl+shift+l |              Ctrl+Shift+L |              ctrl+shift+[KeyL] |         |
+|                       Alt+KeyL |   l   |                     Alt+L |     |                     Alt+L |                          alt+l |                     Alt+L |                     alt+[KeyL] |         |
+|                  Ctrl+Alt+KeyL |   ł   |                Ctrl+Alt+L |     |                Ctrl+Alt+L |                     ctrl+alt+l |                Ctrl+Alt+L |                ctrl+alt+[KeyL] |         |
+|                 Shift+Alt+KeyL |   L   |               Shift+Alt+L |     |               Shift+Alt+L |                    shift+alt+l |               Shift+Alt+L |               shift+alt+[KeyL] |         |
+|            Ctrl+Shift+Alt+KeyL |   Ł   |          Ctrl+Shift+Alt+L |     |          Ctrl+Shift+Alt+L |               ctrl+shift+alt+l |          Ctrl+Shift+Alt+L |          ctrl+shift+alt+[KeyL] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyM |   m   |                         M |     |                         M |                              m |                         M |                         [KeyM] |         |
+|                      Ctrl+KeyM |   m   |                    Ctrl+M |     |                    Ctrl+M |                         ctrl+m |                    Ctrl+M |                    ctrl+[KeyM] |         |
+|                     Shift+KeyM |   M   |                   Shift+M |     |                   Shift+M |                        shift+m |                   Shift+M |                   shift+[KeyM] |         |
+|                Ctrl+Shift+KeyM |   M   |              Ctrl+Shift+M |     |              Ctrl+Shift+M |                   ctrl+shift+m |              Ctrl+Shift+M |              ctrl+shift+[KeyM] |         |
+|                       Alt+KeyM |   m   |                     Alt+M |     |                     Alt+M |                          alt+m |                     Alt+M |                     alt+[KeyM] |         |
+|                  Ctrl+Alt+KeyM |   µ   |                Ctrl+Alt+M |     |                Ctrl+Alt+M |                     ctrl+alt+m |                Ctrl+Alt+M |                ctrl+alt+[KeyM] |         |
+|                 Shift+Alt+KeyM |   M   |               Shift+Alt+M |     |               Shift+Alt+M |                    shift+alt+m |               Shift+Alt+M |               shift+alt+[KeyM] |         |
+|            Ctrl+Shift+Alt+KeyM |   º   |          Ctrl+Shift+Alt+M |     |          Ctrl+Shift+Alt+M |               ctrl+shift+alt+m |          Ctrl+Shift+Alt+M |          ctrl+shift+alt+[KeyM] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyN |   n   |                         N |     |                         N |                              n |                         N |                         [KeyN] |         |
+|                      Ctrl+KeyN |   n   |                    Ctrl+N |     |                    Ctrl+N |                         ctrl+n |                    Ctrl+N |                    ctrl+[KeyN] |         |
+|                     Shift+KeyN |   N   |                   Shift+N |     |                   Shift+N |                        shift+n |                   Shift+N |                   shift+[KeyN] |         |
+|                Ctrl+Shift+KeyN |   N   |              Ctrl+Shift+N |     |              Ctrl+Shift+N |                   ctrl+shift+n |              Ctrl+Shift+N |              ctrl+shift+[KeyN] |         |
+|                       Alt+KeyN |   n   |                     Alt+N |     |                     Alt+N |                          alt+n |                     Alt+N |                     alt+[KeyN] |         |
+|                  Ctrl+Alt+KeyN |   n   |                Ctrl+Alt+N |     |                Ctrl+Alt+N |                     ctrl+alt+n |                Ctrl+Alt+N |                ctrl+alt+[KeyN] |         |
+|                 Shift+Alt+KeyN |   N   |               Shift+Alt+N |     |               Shift+Alt+N |                    shift+alt+n |               Shift+Alt+N |               shift+alt+[KeyN] |         |
+|            Ctrl+Shift+Alt+KeyN |   N   |          Ctrl+Shift+Alt+N |     |          Ctrl+Shift+Alt+N |               ctrl+shift+alt+n |          Ctrl+Shift+Alt+N |          ctrl+shift+alt+[KeyN] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyO |   o   |                         O |     |                         O |                              o |                         O |                         [KeyO] |         |
+|                      Ctrl+KeyO |   o   |                    Ctrl+O |     |                    Ctrl+O |                         ctrl+o |                    Ctrl+O |                    ctrl+[KeyO] |         |
+|                     Shift+KeyO |   O   |                   Shift+O |     |                   Shift+O |                        shift+o |                   Shift+O |                   shift+[KeyO] |         |
+|                Ctrl+Shift+KeyO |   O   |              Ctrl+Shift+O |     |              Ctrl+Shift+O |                   ctrl+shift+o |              Ctrl+Shift+O |              ctrl+shift+[KeyO] |         |
+|                       Alt+KeyO |   o   |                     Alt+O |     |                     Alt+O |                          alt+o |                     Alt+O |                     alt+[KeyO] |         |
+|                  Ctrl+Alt+KeyO |   œ   |                Ctrl+Alt+O |     |                Ctrl+Alt+O |                     ctrl+alt+o |                Ctrl+Alt+O |                ctrl+alt+[KeyO] |         |
+|                 Shift+Alt+KeyO |   O   |               Shift+Alt+O |     |               Shift+Alt+O |                    shift+alt+o |               Shift+Alt+O |               shift+alt+[KeyO] |         |
+|            Ctrl+Shift+Alt+KeyO |   Π  |          Ctrl+Shift+Alt+O |     |          Ctrl+Shift+Alt+O |               ctrl+shift+alt+o |          Ctrl+Shift+Alt+O |          ctrl+shift+alt+[KeyO] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyP |   p   |                         P |     |                         P |                              p |                         P |                         [KeyP] |         |
+|                      Ctrl+KeyP |   p   |                    Ctrl+P |     |                    Ctrl+P |                         ctrl+p |                    Ctrl+P |                    ctrl+[KeyP] |         |
+|                     Shift+KeyP |   P   |                   Shift+P |     |                   Shift+P |                        shift+p |                   Shift+P |                   shift+[KeyP] |         |
+|                Ctrl+Shift+KeyP |   P   |              Ctrl+Shift+P |     |              Ctrl+Shift+P |                   ctrl+shift+p |              Ctrl+Shift+P |              ctrl+shift+[KeyP] |         |
+|                       Alt+KeyP |   p   |                     Alt+P |     |                     Alt+P |                          alt+p |                     Alt+P |                     alt+[KeyP] |         |
+|                  Ctrl+Alt+KeyP |   þ   |                Ctrl+Alt+P |     |                Ctrl+Alt+P |                     ctrl+alt+p |                Ctrl+Alt+P |                ctrl+alt+[KeyP] |         |
+|                 Shift+Alt+KeyP |   P   |               Shift+Alt+P |     |               Shift+Alt+P |                    shift+alt+p |               Shift+Alt+P |               shift+alt+[KeyP] |         |
+|            Ctrl+Shift+Alt+KeyP |   Þ   |          Ctrl+Shift+Alt+P |     |          Ctrl+Shift+Alt+P |               ctrl+shift+alt+p |          Ctrl+Shift+Alt+P |          ctrl+shift+alt+[KeyP] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyQ |   q   |                         Q |     |                         Q |                              q |                         Q |                         [KeyQ] |         |
+|                      Ctrl+KeyQ |   q   |                    Ctrl+Q |     |                    Ctrl+Q |                         ctrl+q |                    Ctrl+Q |                    ctrl+[KeyQ] |         |
+|                     Shift+KeyQ |   Q   |                   Shift+Q |     |                   Shift+Q |                        shift+q |                   Shift+Q |                   shift+[KeyQ] |         |
+|                Ctrl+Shift+KeyQ |   Q   |              Ctrl+Shift+Q |     |              Ctrl+Shift+Q |                   ctrl+shift+q |              Ctrl+Shift+Q |              ctrl+shift+[KeyQ] |         |
+|                       Alt+KeyQ |   q   |                     Alt+Q |     |                     Alt+Q |                          alt+q |                     Alt+Q |                     alt+[KeyQ] |         |
+|                  Ctrl+Alt+KeyQ |   @   |                Ctrl+Alt+Q |     |                Ctrl+Alt+Q |                     ctrl+alt+q |                Ctrl+Alt+Q |                ctrl+alt+[KeyQ] |         |
+|                 Shift+Alt+KeyQ |   Q   |               Shift+Alt+Q |     |               Shift+Alt+Q |                    shift+alt+q |               Shift+Alt+Q |               shift+alt+[KeyQ] |         |
+|            Ctrl+Shift+Alt+KeyQ |   Ω   |          Ctrl+Shift+Alt+Q |     |          Ctrl+Shift+Alt+Q |               ctrl+shift+alt+q |          Ctrl+Shift+Alt+Q |          ctrl+shift+alt+[KeyQ] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyR |   r   |                         R |     |                         R |                              r |                         R |                         [KeyR] |         |
+|                      Ctrl+KeyR |   r   |                    Ctrl+R |     |                    Ctrl+R |                         ctrl+r |                    Ctrl+R |                    ctrl+[KeyR] |         |
+|                     Shift+KeyR |   R   |                   Shift+R |     |                   Shift+R |                        shift+r |                   Shift+R |                   shift+[KeyR] |         |
+|                Ctrl+Shift+KeyR |   R   |              Ctrl+Shift+R |     |              Ctrl+Shift+R |                   ctrl+shift+r |              Ctrl+Shift+R |              ctrl+shift+[KeyR] |         |
+|                       Alt+KeyR |   r   |                     Alt+R |     |                     Alt+R |                          alt+r |                     Alt+R |                     alt+[KeyR] |         |
+|                  Ctrl+Alt+KeyR |   ¶   |                Ctrl+Alt+R |     |                Ctrl+Alt+R |                     ctrl+alt+r |                Ctrl+Alt+R |                ctrl+alt+[KeyR] |         |
+|                 Shift+Alt+KeyR |   R   |               Shift+Alt+R |     |               Shift+Alt+R |                    shift+alt+r |               Shift+Alt+R |               shift+alt+[KeyR] |         |
+|            Ctrl+Shift+Alt+KeyR |   ®   |          Ctrl+Shift+Alt+R |     |          Ctrl+Shift+Alt+R |               ctrl+shift+alt+r |          Ctrl+Shift+Alt+R |          ctrl+shift+alt+[KeyR] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyS |   s   |                         S |     |                         S |                              s |                         S |                         [KeyS] |         |
+|                      Ctrl+KeyS |   s   |                    Ctrl+S |     |                    Ctrl+S |                         ctrl+s |                    Ctrl+S |                    ctrl+[KeyS] |         |
+|                     Shift+KeyS |   S   |                   Shift+S |     |                   Shift+S |                        shift+s |                   Shift+S |                   shift+[KeyS] |         |
+|                Ctrl+Shift+KeyS |   S   |              Ctrl+Shift+S |     |              Ctrl+Shift+S |                   ctrl+shift+s |              Ctrl+Shift+S |              ctrl+shift+[KeyS] |         |
+|                       Alt+KeyS |   s   |                     Alt+S |     |                     Alt+S |                          alt+s |                     Alt+S |                     alt+[KeyS] |         |
+|                  Ctrl+Alt+KeyS |   ß   |                Ctrl+Alt+S |     |                Ctrl+Alt+S |                     ctrl+alt+s |                Ctrl+Alt+S |                ctrl+alt+[KeyS] |         |
+|                 Shift+Alt+KeyS |   S   |               Shift+Alt+S |     |               Shift+Alt+S |                    shift+alt+s |               Shift+Alt+S |               shift+alt+[KeyS] |         |
+|            Ctrl+Shift+Alt+KeyS |   §   |          Ctrl+Shift+Alt+S |     |          Ctrl+Shift+Alt+S |               ctrl+shift+alt+s |          Ctrl+Shift+Alt+S |          ctrl+shift+alt+[KeyS] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyT |   t   |                         T |     |                         T |                              t |                         T |                         [KeyT] |         |
+|                      Ctrl+KeyT |   t   |                    Ctrl+T |     |                    Ctrl+T |                         ctrl+t |                    Ctrl+T |                    ctrl+[KeyT] |         |
+|                     Shift+KeyT |   T   |                   Shift+T |     |                   Shift+T |                        shift+t |                   Shift+T |                   shift+[KeyT] |         |
+|                Ctrl+Shift+KeyT |   T   |              Ctrl+Shift+T |     |              Ctrl+Shift+T |                   ctrl+shift+t |              Ctrl+Shift+T |              ctrl+shift+[KeyT] |         |
+|                       Alt+KeyT |   t   |                     Alt+T |     |                     Alt+T |                          alt+t |                     Alt+T |                     alt+[KeyT] |         |
+|                  Ctrl+Alt+KeyT |   ŧ   |                Ctrl+Alt+T |     |                Ctrl+Alt+T |                     ctrl+alt+t |                Ctrl+Alt+T |                ctrl+alt+[KeyT] |         |
+|                 Shift+Alt+KeyT |   T   |               Shift+Alt+T |     |               Shift+Alt+T |                    shift+alt+t |               Shift+Alt+T |               shift+alt+[KeyT] |         |
+|            Ctrl+Shift+Alt+KeyT |   Ŧ   |          Ctrl+Shift+Alt+T |     |          Ctrl+Shift+Alt+T |               ctrl+shift+alt+t |          Ctrl+Shift+Alt+T |          ctrl+shift+alt+[KeyT] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyU |   u   |                         U |     |                         U |                              u |                         U |                         [KeyU] |         |
+|                      Ctrl+KeyU |   u   |                    Ctrl+U |     |                    Ctrl+U |                         ctrl+u |                    Ctrl+U |                    ctrl+[KeyU] |         |
+|                     Shift+KeyU |   U   |                   Shift+U |     |                   Shift+U |                        shift+u |                   Shift+U |                   shift+[KeyU] |         |
+|                Ctrl+Shift+KeyU |   U   |              Ctrl+Shift+U |     |              Ctrl+Shift+U |                   ctrl+shift+u |              Ctrl+Shift+U |              ctrl+shift+[KeyU] |         |
+|                       Alt+KeyU |   u   |                     Alt+U |     |                     Alt+U |                          alt+u |                     Alt+U |                     alt+[KeyU] |         |
+|                  Ctrl+Alt+KeyU |   ↓   |                Ctrl+Alt+U |     |                Ctrl+Alt+U |                     ctrl+alt+u |                Ctrl+Alt+U |                ctrl+alt+[KeyU] |         |
+|                 Shift+Alt+KeyU |   U   |               Shift+Alt+U |     |               Shift+Alt+U |                    shift+alt+u |               Shift+Alt+U |               shift+alt+[KeyU] |         |
+|            Ctrl+Shift+Alt+KeyU |   ↑   |          Ctrl+Shift+Alt+U |     |          Ctrl+Shift+Alt+U |               ctrl+shift+alt+u |          Ctrl+Shift+Alt+U |          ctrl+shift+alt+[KeyU] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyV |   v   |                         V |     |                         V |                              v |                         V |                         [KeyV] |         |
+|                      Ctrl+KeyV |   v   |                    Ctrl+V |     |                    Ctrl+V |                         ctrl+v |                    Ctrl+V |                    ctrl+[KeyV] |         |
+|                     Shift+KeyV |   V   |                   Shift+V |     |                   Shift+V |                        shift+v |                   Shift+V |                   shift+[KeyV] |         |
+|                Ctrl+Shift+KeyV |   V   |              Ctrl+Shift+V |     |              Ctrl+Shift+V |                   ctrl+shift+v |              Ctrl+Shift+V |              ctrl+shift+[KeyV] |         |
+|                       Alt+KeyV |   v   |                     Alt+V |     |                     Alt+V |                          alt+v |                     Alt+V |                     alt+[KeyV] |         |
+|                  Ctrl+Alt+KeyV |   “   |                Ctrl+Alt+V |     |                Ctrl+Alt+V |                     ctrl+alt+v |                Ctrl+Alt+V |                ctrl+alt+[KeyV] |         |
+|                 Shift+Alt+KeyV |   V   |               Shift+Alt+V |     |               Shift+Alt+V |                    shift+alt+v |               Shift+Alt+V |               shift+alt+[KeyV] |         |
+|            Ctrl+Shift+Alt+KeyV |   ‘   |          Ctrl+Shift+Alt+V |     |          Ctrl+Shift+Alt+V |               ctrl+shift+alt+v |          Ctrl+Shift+Alt+V |          ctrl+shift+alt+[KeyV] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyW |   w   |                         W |     |                         W |                              w |                         W |                         [KeyW] |         |
+|                      Ctrl+KeyW |   w   |                    Ctrl+W |     |                    Ctrl+W |                         ctrl+w |                    Ctrl+W |                    ctrl+[KeyW] |         |
+|                     Shift+KeyW |   W   |                   Shift+W |     |                   Shift+W |                        shift+w |                   Shift+W |                   shift+[KeyW] |         |
+|                Ctrl+Shift+KeyW |   W   |              Ctrl+Shift+W |     |              Ctrl+Shift+W |                   ctrl+shift+w |              Ctrl+Shift+W |              ctrl+shift+[KeyW] |         |
+|                       Alt+KeyW |   w   |                     Alt+W |     |                     Alt+W |                          alt+w |                     Alt+W |                     alt+[KeyW] |         |
+|                  Ctrl+Alt+KeyW |   ł   |                Ctrl+Alt+W |     |                Ctrl+Alt+W |                     ctrl+alt+w |                Ctrl+Alt+W |                ctrl+alt+[KeyW] |         |
+|                 Shift+Alt+KeyW |   W   |               Shift+Alt+W |     |               Shift+Alt+W |                    shift+alt+w |               Shift+Alt+W |               shift+alt+[KeyW] |         |
+|            Ctrl+Shift+Alt+KeyW |   Ł   |          Ctrl+Shift+Alt+W |     |          Ctrl+Shift+Alt+W |               ctrl+shift+alt+w |          Ctrl+Shift+Alt+W |          ctrl+shift+alt+[KeyW] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyX |   x   |                         X |     |                         X |                              x |                         X |                         [KeyX] |         |
+|                      Ctrl+KeyX |   x   |                    Ctrl+X |     |                    Ctrl+X |                         ctrl+x |                    Ctrl+X |                    ctrl+[KeyX] |         |
+|                     Shift+KeyX |   X   |                   Shift+X |     |                   Shift+X |                        shift+x |                   Shift+X |                   shift+[KeyX] |         |
+|                Ctrl+Shift+KeyX |   X   |              Ctrl+Shift+X |     |              Ctrl+Shift+X |                   ctrl+shift+x |              Ctrl+Shift+X |              ctrl+shift+[KeyX] |         |
+|                       Alt+KeyX |   x   |                     Alt+X |     |                     Alt+X |                          alt+x |                     Alt+X |                     alt+[KeyX] |         |
+|                  Ctrl+Alt+KeyX |   »   |                Ctrl+Alt+X |     |                Ctrl+Alt+X |                     ctrl+alt+x |                Ctrl+Alt+X |                ctrl+alt+[KeyX] |         |
+|                 Shift+Alt+KeyX |   X   |               Shift+Alt+X |     |               Shift+Alt+X |                    shift+alt+x |               Shift+Alt+X |               shift+alt+[KeyX] |         |
+|            Ctrl+Shift+Alt+KeyX |   >   |          Ctrl+Shift+Alt+X |     |          Ctrl+Shift+Alt+X |               ctrl+shift+alt+x |          Ctrl+Shift+Alt+X |          ctrl+shift+alt+[KeyX] |         |
+|                                |       |                   Shift+. |   1 |                           |                                |                           |                                |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyY |   z   |                         Z |     |                         Z |                              z |                         Z |                         [KeyY] |         |
+|                      Ctrl+KeyY |   z   |                    Ctrl+Z |     |                    Ctrl+Z |                         ctrl+z |                    Ctrl+Z |                    ctrl+[KeyY] |         |
+|                     Shift+KeyY |   Z   |                   Shift+Z |     |                   Shift+Z |                        shift+z |                   Shift+Z |                   shift+[KeyY] |         |
+|                Ctrl+Shift+KeyY |   Z   |              Ctrl+Shift+Z |     |              Ctrl+Shift+Z |                   ctrl+shift+z |              Ctrl+Shift+Z |              ctrl+shift+[KeyY] |         |
+|                       Alt+KeyY |   z   |                     Alt+Z |     |                     Alt+Z |                          alt+z |                     Alt+Z |                     alt+[KeyY] |         |
+|                  Ctrl+Alt+KeyY |   ←   |                Ctrl+Alt+Z |     |                Ctrl+Alt+Z |                     ctrl+alt+z |                Ctrl+Alt+Z |                ctrl+alt+[KeyY] |         |
+|                 Shift+Alt+KeyY |   Z   |               Shift+Alt+Z |     |               Shift+Alt+Z |                    shift+alt+z |               Shift+Alt+Z |               shift+alt+[KeyY] |         |
+|            Ctrl+Shift+Alt+KeyY |   ¥   |          Ctrl+Shift+Alt+Z |     |          Ctrl+Shift+Alt+Z |               ctrl+shift+alt+z |          Ctrl+Shift+Alt+Z |          ctrl+shift+alt+[KeyY] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyZ |   y   |                         Y |     |                         Y |                              y |                         Y |                         [KeyZ] |         |
+|                      Ctrl+KeyZ |   y   |                    Ctrl+Y |     |                    Ctrl+Y |                         ctrl+y |                    Ctrl+Y |                    ctrl+[KeyZ] |         |
+|                     Shift+KeyZ |   Y   |                   Shift+Y |     |                   Shift+Y |                        shift+y |                   Shift+Y |                   shift+[KeyZ] |         |
+|                Ctrl+Shift+KeyZ |   Y   |              Ctrl+Shift+Y |     |              Ctrl+Shift+Y |                   ctrl+shift+y |              Ctrl+Shift+Y |              ctrl+shift+[KeyZ] |         |
+|                       Alt+KeyZ |   y   |                     Alt+Y |     |                     Alt+Y |                          alt+y |                     Alt+Y |                     alt+[KeyZ] |         |
+|                  Ctrl+Alt+KeyZ |   «   |                Ctrl+Alt+Y |     |                Ctrl+Alt+Y |                     ctrl+alt+y |                Ctrl+Alt+Y |                ctrl+alt+[KeyZ] |         |
+|                 Shift+Alt+KeyZ |   Y   |               Shift+Alt+Y |     |               Shift+Alt+Y |                    shift+alt+y |               Shift+Alt+Y |               shift+alt+[KeyZ] |         |
+|            Ctrl+Shift+Alt+KeyZ |   <   |          Ctrl+Shift+Alt+Y |     |          Ctrl+Shift+Alt+Y |               ctrl+shift+alt+y |          Ctrl+Shift+Alt+Y |          ctrl+shift+alt+[KeyZ] |         |
+|                                |       |                   Shift+, |   1 |                           |                                |                           |                                |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit1 |   1   |                         1 |     |                         1 |                              1 |                         1 |                       [Digit1] |         |
+|                    Ctrl+Digit1 |   1   |                    Ctrl+1 |     |                    Ctrl+1 |                         ctrl+1 |                    Ctrl+1 |                  ctrl+[Digit1] |         |
+|                   Shift+Digit1 |   +   |                   Shift+1 |     |                   Shift+1 |                        shift+1 |                   Shift+1 |                 shift+[Digit1] |         |
+|                                |       |                   Shift+= |     |                           |                                |                           |                                |         |
+|              Ctrl+Shift+Digit1 |   +   |              Ctrl+Shift+1 |     |              Ctrl+Shift+1 |                   ctrl+shift+1 |              Ctrl+Shift+1 |            ctrl+shift+[Digit1] |         |
+|                                |       |              Ctrl+Shift+= |     |                           |                                |                           |                                |         |
+|                     Alt+Digit1 |   1   |                     Alt+1 |     |                     Alt+1 |                          alt+1 |                     Alt+1 |                   alt+[Digit1] |         |
+|                Ctrl+Alt+Digit1 |   |   |                Ctrl+Alt+1 |     |                Ctrl+Alt+1 |                     ctrl+alt+1 |                Ctrl+Alt+1 |              ctrl+alt+[Digit1] |         |
+|                                |       |                   Shift+\ |   1 |                           |                                |                           |                                |         |
+|               Shift+Alt+Digit1 |   +   |               Shift+Alt+1 |     |               Shift+Alt+1 |                    shift+alt+1 |               Shift+Alt+1 |             shift+alt+[Digit1] |         |
+|                                |       |               Shift+Alt+= |     |                           |                                |                           |                                |         |
+|          Ctrl+Shift+Alt+Digit1 |   ¡   |          Ctrl+Shift+Alt+1 |     |          Ctrl+Shift+Alt+1 |               ctrl+shift+alt+1 |          Ctrl+Shift+Alt+1 |        ctrl+shift+alt+[Digit1] |         |
+|                                |       |          Ctrl+Shift+Alt+= |     |                           |                                |                           |                                |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit2 |   2   |                         2 |     |                         2 |                              2 |                         2 |                       [Digit2] |         |
+|                    Ctrl+Digit2 |   2   |                    Ctrl+2 |     |                    Ctrl+2 |                         ctrl+2 |                    Ctrl+2 |                  ctrl+[Digit2] |         |
+|                   Shift+Digit2 |   "   |                   Shift+2 |     |                   Shift+2 |                        shift+2 |                   Shift+2 |                 shift+[Digit2] |         |
+|                                |       |                   Shift+' |     |                           |                                |                           |                                |         |
+|              Ctrl+Shift+Digit2 |   "   |              Ctrl+Shift+2 |     |              Ctrl+Shift+2 |                   ctrl+shift+2 |              Ctrl+Shift+2 |            ctrl+shift+[Digit2] |         |
+|                                |       |              Ctrl+Shift+' |     |                           |                                |                           |                                |         |
+|                     Alt+Digit2 |   2   |                     Alt+2 |     |                     Alt+2 |                          alt+2 |                     Alt+2 |                   alt+[Digit2] |         |
+|                Ctrl+Alt+Digit2 |   @   |                Ctrl+Alt+2 |     |                Ctrl+Alt+2 |                     ctrl+alt+2 |                Ctrl+Alt+2 |              ctrl+alt+[Digit2] |         |
+|               Shift+Alt+Digit2 |   "   |               Shift+Alt+2 |     |               Shift+Alt+2 |                    shift+alt+2 |               Shift+Alt+2 |             shift+alt+[Digit2] |         |
+|                                |       |               Shift+Alt+' |     |                           |                                |                           |                                |         |
+|          Ctrl+Shift+Alt+Digit2 |   ⅛   |          Ctrl+Shift+Alt+2 |     |          Ctrl+Shift+Alt+2 |               ctrl+shift+alt+2 |          Ctrl+Shift+Alt+2 |        ctrl+shift+alt+[Digit2] |         |
+|                                |       |          Ctrl+Shift+Alt+' |     |                           |                                |                           |                                |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit3 |   3   |                         3 |     |                         3 |                              3 |                         3 |                       [Digit3] |         |
+|                    Ctrl+Digit3 |   3   |                    Ctrl+3 |     |                    Ctrl+3 |                         ctrl+3 |                    Ctrl+3 |                  ctrl+[Digit3] |         |
+|                   Shift+Digit3 |   *   |                   Shift+3 |     |                   Shift+3 |                        shift+3 |                   Shift+3 |                 shift+[Digit3] |         |
+|              Ctrl+Shift+Digit3 |   *   |              Ctrl+Shift+3 |     |              Ctrl+Shift+3 |                   ctrl+shift+3 |              Ctrl+Shift+3 |            ctrl+shift+[Digit3] |         |
+|                     Alt+Digit3 |   3   |                     Alt+3 |     |                     Alt+3 |                          alt+3 |                     Alt+3 |                   alt+[Digit3] |         |
+|                Ctrl+Alt+Digit3 |   #   |                Ctrl+Alt+3 |     |                Ctrl+Alt+3 |                     ctrl+alt+3 |                Ctrl+Alt+3 |              ctrl+alt+[Digit3] |         |
+|               Shift+Alt+Digit3 |   *   |               Shift+Alt+3 |     |               Shift+Alt+3 |                    shift+alt+3 |               Shift+Alt+3 |             shift+alt+[Digit3] |         |
+|          Ctrl+Shift+Alt+Digit3 |   £   |          Ctrl+Shift+Alt+3 |     |          Ctrl+Shift+Alt+3 |               ctrl+shift+alt+3 |          Ctrl+Shift+Alt+3 |        ctrl+shift+alt+[Digit3] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit4 |   4   |                         4 |     |                         4 |                              4 |                         4 |                       [Digit4] |         |
+|                    Ctrl+Digit4 |   4   |                    Ctrl+4 |     |                    Ctrl+4 |                         ctrl+4 |                    Ctrl+4 |                  ctrl+[Digit4] |         |
+|                   Shift+Digit4 |   ç   |                   Shift+4 |     |                   Shift+4 |                        shift+4 |                   Shift+4 |                 shift+[Digit4] |         |
+|              Ctrl+Shift+Digit4 |   ç   |              Ctrl+Shift+4 |     |              Ctrl+Shift+4 |                   ctrl+shift+4 |              Ctrl+Shift+4 |            ctrl+shift+[Digit4] |         |
+|                     Alt+Digit4 |   4   |                     Alt+4 |     |                     Alt+4 |                          alt+4 |                     Alt+4 |                   alt+[Digit4] |         |
+|                Ctrl+Alt+Digit4 |   ¼   |                Ctrl+Alt+4 |     |                Ctrl+Alt+4 |                     ctrl+alt+4 |                Ctrl+Alt+4 |              ctrl+alt+[Digit4] |         |
+|               Shift+Alt+Digit4 |   ç   |               Shift+Alt+4 |     |               Shift+Alt+4 |                    shift+alt+4 |               Shift+Alt+4 |             shift+alt+[Digit4] |         |
+|          Ctrl+Shift+Alt+Digit4 |   $   |          Ctrl+Shift+Alt+4 |     |          Ctrl+Shift+Alt+4 |               ctrl+shift+alt+4 |          Ctrl+Shift+Alt+4 |        ctrl+shift+alt+[Digit4] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit5 |   5   |                         5 |     |                         5 |                              5 |                         5 |                       [Digit5] |         |
+|                    Ctrl+Digit5 |   5   |                    Ctrl+5 |     |                    Ctrl+5 |                         ctrl+5 |                    Ctrl+5 |                  ctrl+[Digit5] |         |
+|                   Shift+Digit5 |   %   |                   Shift+5 |     |                   Shift+5 |                        shift+5 |                   Shift+5 |                 shift+[Digit5] |         |
+|              Ctrl+Shift+Digit5 |   %   |              Ctrl+Shift+5 |     |              Ctrl+Shift+5 |                   ctrl+shift+5 |              Ctrl+Shift+5 |            ctrl+shift+[Digit5] |         |
+|                     Alt+Digit5 |   5   |                     Alt+5 |     |                     Alt+5 |                          alt+5 |                     Alt+5 |                   alt+[Digit5] |         |
+|                Ctrl+Alt+Digit5 |   ½   |                Ctrl+Alt+5 |     |                Ctrl+Alt+5 |                     ctrl+alt+5 |                Ctrl+Alt+5 |              ctrl+alt+[Digit5] |         |
+|               Shift+Alt+Digit5 |   %   |               Shift+Alt+5 |     |               Shift+Alt+5 |                    shift+alt+5 |               Shift+Alt+5 |             shift+alt+[Digit5] |         |
+|          Ctrl+Shift+Alt+Digit5 |   ⅜   |          Ctrl+Shift+Alt+5 |     |          Ctrl+Shift+Alt+5 |               ctrl+shift+alt+5 |          Ctrl+Shift+Alt+5 |        ctrl+shift+alt+[Digit5] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit6 |   6   |                         6 |     |                         6 |                              6 |                         6 |                       [Digit6] |         |
+|                    Ctrl+Digit6 |   6   |                    Ctrl+6 |     |                    Ctrl+6 |                         ctrl+6 |                    Ctrl+6 |                  ctrl+[Digit6] |         |
+|                   Shift+Digit6 |   &   |                   Shift+6 |     |                   Shift+6 |                        shift+6 |                   Shift+6 |                 shift+[Digit6] |         |
+|              Ctrl+Shift+Digit6 |   &   |              Ctrl+Shift+6 |     |              Ctrl+Shift+6 |                   ctrl+shift+6 |              Ctrl+Shift+6 |            ctrl+shift+[Digit6] |         |
+|                     Alt+Digit6 |   6   |                     Alt+6 |     |                     Alt+6 |                          alt+6 |                     Alt+6 |                   alt+[Digit6] |         |
+|                Ctrl+Alt+Digit6 |   ¬   |                Ctrl+Alt+6 |     |                Ctrl+Alt+6 |                     ctrl+alt+6 |                Ctrl+Alt+6 |              ctrl+alt+[Digit6] |         |
+|               Shift+Alt+Digit6 |   &   |               Shift+Alt+6 |     |               Shift+Alt+6 |                    shift+alt+6 |               Shift+Alt+6 |             shift+alt+[Digit6] |         |
+|          Ctrl+Shift+Alt+Digit6 |   ⅝   |          Ctrl+Shift+Alt+6 |     |          Ctrl+Shift+Alt+6 |               ctrl+shift+alt+6 |          Ctrl+Shift+Alt+6 |        ctrl+shift+alt+[Digit6] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit7 |   7   |                         7 |     |                         7 |                              7 |                         7 |                       [Digit7] |         |
+|                    Ctrl+Digit7 |   7   |                    Ctrl+7 |     |                    Ctrl+7 |                         ctrl+7 |                    Ctrl+7 |                  ctrl+[Digit7] |         |
+|                   Shift+Digit7 |   /   |                   Shift+7 |     |                   Shift+7 |                        shift+7 |                   Shift+7 |                 shift+[Digit7] |         |
+|                                |       |                         / |     |                           |                                |                           |                                |         |
+|              Ctrl+Shift+Digit7 |   /   |              Ctrl+Shift+7 |     |              Ctrl+Shift+7 |                   ctrl+shift+7 |              Ctrl+Shift+7 |            ctrl+shift+[Digit7] |         |
+|                                |       |                    Ctrl+/ |     |                           |                                |                           |                                |         |
+|                     Alt+Digit7 |   7   |                     Alt+7 |     |                     Alt+7 |                          alt+7 |                     Alt+7 |                   alt+[Digit7] |         |
+|                Ctrl+Alt+Digit7 |   |   |                Ctrl+Alt+7 |     |                Ctrl+Alt+7 |                     ctrl+alt+7 |                Ctrl+Alt+7 |              ctrl+alt+[Digit7] |         |
+|                                |       |                   Shift+\ |   2 |                           |                                |                           |                                |         |
+|               Shift+Alt+Digit7 |   /   |               Shift+Alt+7 |     |               Shift+Alt+7 |                    shift+alt+7 |               Shift+Alt+7 |             shift+alt+[Digit7] |         |
+|                                |       |                     Alt+/ |     |                           |                                |                           |                                |         |
+|          Ctrl+Shift+Alt+Digit7 |   ⅞   |          Ctrl+Shift+Alt+7 |     |          Ctrl+Shift+Alt+7 |               ctrl+shift+alt+7 |          Ctrl+Shift+Alt+7 |        ctrl+shift+alt+[Digit7] |         |
+|                                |       |                Ctrl+Alt+/ |     |                           |                                |                           |                                |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit8 |   8   |                         8 |     |                         8 |                              8 |                         8 |                       [Digit8] |         |
+|                    Ctrl+Digit8 |   8   |                    Ctrl+8 |     |                    Ctrl+8 |                         ctrl+8 |                    Ctrl+8 |                  ctrl+[Digit8] |         |
+|                   Shift+Digit8 |   (   |                   Shift+8 |     |                   Shift+8 |                        shift+8 |                   Shift+8 |                 shift+[Digit8] |         |
+|              Ctrl+Shift+Digit8 |   (   |              Ctrl+Shift+8 |     |              Ctrl+Shift+8 |                   ctrl+shift+8 |              Ctrl+Shift+8 |            ctrl+shift+[Digit8] |         |
+|                     Alt+Digit8 |   8   |                     Alt+8 |     |                     Alt+8 |                          alt+8 |                     Alt+8 |                   alt+[Digit8] |         |
+|                Ctrl+Alt+Digit8 |   ¢   |                Ctrl+Alt+8 |     |                Ctrl+Alt+8 |                     ctrl+alt+8 |                Ctrl+Alt+8 |              ctrl+alt+[Digit8] |         |
+|               Shift+Alt+Digit8 |   (   |               Shift+Alt+8 |     |               Shift+Alt+8 |                    shift+alt+8 |               Shift+Alt+8 |             shift+alt+[Digit8] |         |
+|          Ctrl+Shift+Alt+Digit8 |   ™   |          Ctrl+Shift+Alt+8 |     |          Ctrl+Shift+Alt+8 |               ctrl+shift+alt+8 |          Ctrl+Shift+Alt+8 |        ctrl+shift+alt+[Digit8] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit9 |   9   |                         9 |     |                         9 |                              9 |                         9 |                       [Digit9] |         |
+|                    Ctrl+Digit9 |   9   |                    Ctrl+9 |     |                    Ctrl+9 |                         ctrl+9 |                    Ctrl+9 |                  ctrl+[Digit9] |         |
+|                   Shift+Digit9 |   )   |                   Shift+9 |     |                   Shift+9 |                        shift+9 |                   Shift+9 |                 shift+[Digit9] |         |
+|              Ctrl+Shift+Digit9 |   )   |              Ctrl+Shift+9 |     |              Ctrl+Shift+9 |                   ctrl+shift+9 |              Ctrl+Shift+9 |            ctrl+shift+[Digit9] |         |
+|                     Alt+Digit9 |   9   |                     Alt+9 |     |                     Alt+9 |                          alt+9 |                     Alt+9 |                   alt+[Digit9] |         |
+|                Ctrl+Alt+Digit9 |   ]   |                Ctrl+Alt+9 |     |                Ctrl+Alt+9 |                     ctrl+alt+9 |                Ctrl+Alt+9 |              ctrl+alt+[Digit9] |         |
+|                                |       |                         ] |   1 |                           |                                |                           |                                |         |
+|               Shift+Alt+Digit9 |   )   |               Shift+Alt+9 |     |               Shift+Alt+9 |                    shift+alt+9 |               Shift+Alt+9 |             shift+alt+[Digit9] |         |
+|          Ctrl+Shift+Alt+Digit9 |   ±   |          Ctrl+Shift+Alt+9 |     |          Ctrl+Shift+Alt+9 |               ctrl+shift+alt+9 |          Ctrl+Shift+Alt+9 |        ctrl+shift+alt+[Digit9] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit0 |   0   |                         0 |     |                         0 |                              0 |                         0 |                       [Digit0] |         |
+|                    Ctrl+Digit0 |   0   |                    Ctrl+0 |     |                    Ctrl+0 |                         ctrl+0 |                    Ctrl+0 |                  ctrl+[Digit0] |         |
+|                   Shift+Digit0 |   =   |                   Shift+0 |     |                   Shift+0 |                        shift+0 |                   Shift+0 |                 shift+[Digit0] |         |
+|                                |       |                         = |     |                           |                                |                           |                                |         |
+|              Ctrl+Shift+Digit0 |   =   |              Ctrl+Shift+0 |     |              Ctrl+Shift+0 |                   ctrl+shift+0 |              Ctrl+Shift+0 |            ctrl+shift+[Digit0] |         |
+|                                |       |                    Ctrl+= |     |                           |                                |                           |                                |         |
+|                     Alt+Digit0 |   0   |                     Alt+0 |     |                     Alt+0 |                          alt+0 |                     Alt+0 |                   alt+[Digit0] |         |
+|                Ctrl+Alt+Digit0 |   }   |                Ctrl+Alt+0 |     |                Ctrl+Alt+0 |                     ctrl+alt+0 |                Ctrl+Alt+0 |              ctrl+alt+[Digit0] |         |
+|                                |       |                   Shift+] |   1 |                           |                                |                           |                                |         |
+|               Shift+Alt+Digit0 |   =   |               Shift+Alt+0 |     |               Shift+Alt+0 |                    shift+alt+0 |               Shift+Alt+0 |             shift+alt+[Digit0] |         |
+|                                |       |                     Alt+= |     |                           |                                |                           |                                |         |
+|          Ctrl+Shift+Alt+Digit0 |   °   |          Ctrl+Shift+Alt+0 |     |          Ctrl+Shift+Alt+0 |               ctrl+shift+alt+0 |          Ctrl+Shift+Alt+0 |        ctrl+shift+alt+[Digit0] |         |
+|                                |       |                Ctrl+Alt+= |     |                           |                                |                           |                                |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Minus |   '   |                         ' |     |                         ' |                        [Minus] |                      null |                        [Minus] |    NO   |
+|                     Ctrl+Minus |   '   |                    Ctrl+' |     |                    Ctrl+' |                   ctrl+[Minus] |                      null |                   ctrl+[Minus] |    NO   |
+|                    Shift+Minus |   ?   |                   Shift+/ |     |                   Shift+' |                  shift+[Minus] |                      null |                  shift+[Minus] |    NO   |
+|               Ctrl+Shift+Minus |   ?   |              Ctrl+Shift+/ |     |              Ctrl+Shift+' |             ctrl+shift+[Minus] |                      null |             ctrl+shift+[Minus] |    NO   |
+|                      Alt+Minus |   '   |                     Alt+' |     |                     Alt+' |                    alt+[Minus] |                      null |                    alt+[Minus] |    NO   |
+|                 Ctrl+Alt+Minus |   ´   |                Ctrl+Alt+' |     |                Ctrl+Alt+' |               ctrl+alt+[Minus] |                      null |               ctrl+alt+[Minus] |    NO   |
+|                Shift+Alt+Minus |   ?   |               Shift+Alt+/ |     |               Shift+Alt+' |              shift+alt+[Minus] |                      null |              shift+alt+[Minus] |    NO   |
+|           Ctrl+Shift+Alt+Minus |   ¿   |          Ctrl+Shift+Alt+/ |     |          Ctrl+Shift+Alt+' |         ctrl+shift+alt+[Minus] |                      null |         ctrl+shift+alt+[Minus] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Equal |   ^   |                           |     |                         ^ |                        [Equal] |                      null |                        [Equal] |    NO   |
+|                     Ctrl+Equal |   ^   |                           |     |                    Ctrl+^ |                   ctrl+[Equal] |                      null |                   ctrl+[Equal] |    NO   |
+|                    Shift+Equal |   `   |                         ` |     |                   Shift+^ |                  shift+[Equal] |                      null |                  shift+[Equal] |    NO   |
+|               Ctrl+Shift+Equal |   `   |                    Ctrl+` |     |              Ctrl+Shift+^ |             ctrl+shift+[Equal] |                      null |             ctrl+shift+[Equal] |    NO   |
+|                      Alt+Equal |   ^   |                           |     |                     Alt+^ |                    alt+[Equal] |                      null |                    alt+[Equal] |    NO   |
+|                 Ctrl+Alt+Equal |   ˜   |                           |     |                Ctrl+Alt+^ |               ctrl+alt+[Equal] |                      null |               ctrl+alt+[Equal] |    NO   |
+|                Shift+Alt+Equal |   `   |                     Alt+` |     |               Shift+Alt+^ |              shift+alt+[Equal] |                      null |              shift+alt+[Equal] |    NO   |
+|           Ctrl+Shift+Alt+Equal | U+328 |                Ctrl+Alt+` |     |          Ctrl+Shift+Alt+^ |         ctrl+shift+alt+[Equal] |                      null |         ctrl+shift+alt+[Equal] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                    BracketLeft |   ü   |                           |     |                         ü |                  [BracketLeft] |                      null |                  [BracketLeft] |    NO   |
+|               Ctrl+BracketLeft |   ü   |                           |     |                    Ctrl+ü |             ctrl+[BracketLeft] |                      null |             ctrl+[BracketLeft] |    NO   |
+|              Shift+BracketLeft |   è   |                           |     |                   Shift+ü |            shift+[BracketLeft] |                      null |            shift+[BracketLeft] |    NO   |
+|         Ctrl+Shift+BracketLeft |   è   |                           |     |              Ctrl+Shift+ü |       ctrl+shift+[BracketLeft] |                      null |       ctrl+shift+[BracketLeft] |    NO   |
+|                Alt+BracketLeft |   ü   |                           |     |                     Alt+ü |              alt+[BracketLeft] |                      null |              alt+[BracketLeft] |    NO   |
+|           Ctrl+Alt+BracketLeft |   [   |                         [ |     |                Ctrl+Alt+ü |         ctrl+alt+[BracketLeft] |                      null |         ctrl+alt+[BracketLeft] |    NO   |
+|          Shift+Alt+BracketLeft |   è   |                           |     |               Shift+Alt+ü |        shift+alt+[BracketLeft] |                      null |        shift+alt+[BracketLeft] |    NO   |
+|     Ctrl+Shift+Alt+BracketLeft |   ˚   |                           |     |          Ctrl+Shift+Alt+ü |   ctrl+shift+alt+[BracketLeft] |                      null |   ctrl+shift+alt+[BracketLeft] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                   BracketRight |   ¨   |                           |     |                         ¨ |                 [BracketRight] |                      null |                 [BracketRight] |    NO   |
+|              Ctrl+BracketRight |   ¨   |                           |     |                    Ctrl+¨ |            ctrl+[BracketRight] |                      null |            ctrl+[BracketRight] |    NO   |
+|             Shift+BracketRight |   !   |                           |     |                   Shift+¨ |           shift+[BracketRight] |                      null |           shift+[BracketRight] |    NO   |
+|        Ctrl+Shift+BracketRight |   !   |                           |     |              Ctrl+Shift+¨ |      ctrl+shift+[BracketRight] |                      null |      ctrl+shift+[BracketRight] |    NO   |
+|               Alt+BracketRight |   ¨   |                           |     |                     Alt+¨ |             alt+[BracketRight] |                      null |             alt+[BracketRight] |    NO   |
+|          Ctrl+Alt+BracketRight |   ]   |                         ] |   2 |                Ctrl+Alt+¨ |        ctrl+alt+[BracketRight] |                      null |        ctrl+alt+[BracketRight] |    NO   |
+|         Shift+Alt+BracketRight |   !   |                           |     |               Shift+Alt+¨ |       shift+alt+[BracketRight] |                      null |       shift+alt+[BracketRight] |    NO   |
+|    Ctrl+Shift+Alt+BracketRight |   ¯   |                           |     |          Ctrl+Shift+Alt+¨ |  ctrl+shift+alt+[BracketRight] |                      null |  ctrl+shift+alt+[BracketRight] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                      Backslash |   $   |                           |     |                         $ |                    [Backslash] |                      null |                    [Backslash] |    NO   |
+|                 Ctrl+Backslash |   $   |                           |     |                    Ctrl+$ |               ctrl+[Backslash] |                      null |               ctrl+[Backslash] |    NO   |
+|                Shift+Backslash |   £   |                           |     |                   Shift+$ |              shift+[Backslash] |                      null |              shift+[Backslash] |    NO   |
+|           Ctrl+Shift+Backslash |   £   |                           |     |              Ctrl+Shift+$ |         ctrl+shift+[Backslash] |                      null |         ctrl+shift+[Backslash] |    NO   |
+|                  Alt+Backslash |   $   |                           |     |                     Alt+$ |                alt+[Backslash] |                      null |                alt+[Backslash] |    NO   |
+|             Ctrl+Alt+Backslash |   }   |                   Shift+] |   2 |                Ctrl+Alt+$ |           ctrl+alt+[Backslash] |                      null |           ctrl+alt+[Backslash] |    NO   |
+|            Shift+Alt+Backslash |   £   |                           |     |               Shift+Alt+$ |          shift+alt+[Backslash] |                      null |          shift+alt+[Backslash] |    NO   |
+|       Ctrl+Shift+Alt+Backslash |   ˘   |                           |     |          Ctrl+Shift+Alt+$ |     ctrl+shift+alt+[Backslash] |                      null |     ctrl+shift+alt+[Backslash] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                       IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|                  Ctrl+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|                 Shift+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|            Ctrl+Shift+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|                   Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|              Ctrl+Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|             Shift+Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|        Ctrl+Shift+Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                      Semicolon |   ö   |                           |     |                         ö |                    [Semicolon] |                      null |                    [Semicolon] |    NO   |
+|                 Ctrl+Semicolon |   ö   |                           |     |                    Ctrl+ö |               ctrl+[Semicolon] |                      null |               ctrl+[Semicolon] |    NO   |
+|                Shift+Semicolon |   é   |                           |     |                   Shift+ö |              shift+[Semicolon] |                      null |              shift+[Semicolon] |    NO   |
+|           Ctrl+Shift+Semicolon |   é   |                           |     |              Ctrl+Shift+ö |         ctrl+shift+[Semicolon] |                      null |         ctrl+shift+[Semicolon] |    NO   |
+|                  Alt+Semicolon |   ö   |                           |     |                     Alt+ö |                alt+[Semicolon] |                      null |                alt+[Semicolon] |    NO   |
+|             Ctrl+Alt+Semicolon |   ´   |                           |     |                Ctrl+Alt+ö |           ctrl+alt+[Semicolon] |                      null |           ctrl+alt+[Semicolon] |    NO   |
+|            Shift+Alt+Semicolon |   é   |                           |     |               Shift+Alt+ö |          shift+alt+[Semicolon] |                      null |          shift+alt+[Semicolon] |    NO   |
+|       Ctrl+Shift+Alt+Semicolon |   ˝   |                           |     |          Ctrl+Shift+Alt+ö |     ctrl+shift+alt+[Semicolon] |                      null |     ctrl+shift+alt+[Semicolon] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Quote |   ä   |                           |     |                         ä |                        [Quote] |                      null |                        [Quote] |    NO   |
+|                     Ctrl+Quote |   ä   |                           |     |                    Ctrl+ä |                   ctrl+[Quote] |                      null |                   ctrl+[Quote] |    NO   |
+|                    Shift+Quote |   à   |                           |     |                   Shift+ä |                  shift+[Quote] |                      null |                  shift+[Quote] |    NO   |
+|               Ctrl+Shift+Quote |   à   |                           |     |              Ctrl+Shift+ä |             ctrl+shift+[Quote] |                      null |             ctrl+shift+[Quote] |    NO   |
+|                      Alt+Quote |   ä   |                           |     |                     Alt+ä |                    alt+[Quote] |                      null |                    alt+[Quote] |    NO   |
+|                 Ctrl+Alt+Quote |   {   |                   Shift+[ |     |                Ctrl+Alt+ä |               ctrl+alt+[Quote] |                      null |               ctrl+alt+[Quote] |    NO   |
+|                Shift+Alt+Quote |   à   |                           |     |               Shift+Alt+ä |              shift+alt+[Quote] |                      null |              shift+alt+[Quote] |    NO   |
+|           Ctrl+Shift+Alt+Quote | U+30c |                           |     |          Ctrl+Shift+Alt+ä |         ctrl+shift+alt+[Quote] |                      null |         ctrl+shift+alt+[Quote] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                      Backquote |   §   |                           |     |                         § |                    [Backquote] |                      null |                    [Backquote] |    NO   |
+|                 Ctrl+Backquote |   §   |                           |     |                    Ctrl+§ |               ctrl+[Backquote] |                      null |               ctrl+[Backquote] |    NO   |
+|                Shift+Backquote |   °   |                           |     |                   Shift+§ |              shift+[Backquote] |                      null |              shift+[Backquote] |    NO   |
+|           Ctrl+Shift+Backquote |   °   |                           |     |              Ctrl+Shift+§ |         ctrl+shift+[Backquote] |                      null |         ctrl+shift+[Backquote] |    NO   |
+|                  Alt+Backquote |   §   |                           |     |                     Alt+§ |                alt+[Backquote] |                      null |                alt+[Backquote] |    NO   |
+|             Ctrl+Alt+Backquote |   ¬   |                           |     |                Ctrl+Alt+§ |           ctrl+alt+[Backquote] |                      null |           ctrl+alt+[Backquote] |    NO   |
+|            Shift+Alt+Backquote |   °   |                           |     |               Shift+Alt+§ |          shift+alt+[Backquote] |                      null |          shift+alt+[Backquote] |    NO   |
+|       Ctrl+Shift+Alt+Backquote |   ¬   |                           |     |          Ctrl+Shift+Alt+§ |     ctrl+shift+alt+[Backquote] |                      null |     ctrl+shift+alt+[Backquote] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Comma |   ,   |                         , |     |                         , |                        [Comma] |                      null |                        [Comma] |    NO   |
+|                     Ctrl+Comma |   ,   |                    Ctrl+, |     |                    Ctrl+, |                   ctrl+[Comma] |                      null |                   ctrl+[Comma] |    NO   |
+|                    Shift+Comma |   ;   |                         ; |     |                   Shift+, |                  shift+[Comma] |                      null |                  shift+[Comma] |    NO   |
+|               Ctrl+Shift+Comma |   ;   |                    Ctrl+; |     |              Ctrl+Shift+, |             ctrl+shift+[Comma] |                      null |             ctrl+shift+[Comma] |    NO   |
+|                      Alt+Comma |   ,   |                     Alt+, |     |                     Alt+, |                    alt+[Comma] |                      null |                    alt+[Comma] |    NO   |
+|                 Ctrl+Alt+Comma |   ─   |                Ctrl+Alt+, |     |                Ctrl+Alt+, |               ctrl+alt+[Comma] |                      null |               ctrl+alt+[Comma] |    NO   |
+|                Shift+Alt+Comma |   ;   |                     Alt+; |     |               Shift+Alt+, |              shift+alt+[Comma] |                      null |              shift+alt+[Comma] |    NO   |
+|           Ctrl+Shift+Alt+Comma |   ×   |                Ctrl+Alt+; |     |          Ctrl+Shift+Alt+, |         ctrl+shift+alt+[Comma] |                      null |         ctrl+shift+alt+[Comma] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Period |   .   |                         . |     |                         . |                       [Period] |                      null |                       [Period] |    NO   |
+|                    Ctrl+Period |   .   |                    Ctrl+. |     |                    Ctrl+. |                  ctrl+[Period] |                      null |                  ctrl+[Period] |    NO   |
+|                   Shift+Period |   :   |                   Shift+; |     |                   Shift+. |                 shift+[Period] |                      null |                 shift+[Period] |    NO   |
+|              Ctrl+Shift+Period |   :   |              Ctrl+Shift+; |     |              Ctrl+Shift+. |            ctrl+shift+[Period] |                      null |            ctrl+shift+[Period] |    NO   |
+|                     Alt+Period |   .   |                     Alt+. |     |                     Alt+. |                   alt+[Period] |                      null |                   alt+[Period] |    NO   |
+|                Ctrl+Alt+Period |   ·   |                Ctrl+Alt+. |     |                Ctrl+Alt+. |              ctrl+alt+[Period] |                      null |              ctrl+alt+[Period] |    NO   |
+|               Shift+Alt+Period |   :   |               Shift+Alt+; |     |               Shift+Alt+. |             shift+alt+[Period] |                      null |             shift+alt+[Period] |    NO   |
+|          Ctrl+Shift+Alt+Period |   ÷   |          Ctrl+Shift+Alt+; |     |          Ctrl+Shift+Alt+. |        ctrl+shift+alt+[Period] |                      null |        ctrl+shift+alt+[Period] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Slash |   -   |                         - |     |                         - |                              - |                      null |                        [Slash] |         |
+|                     Ctrl+Slash |   -   |                    Ctrl+- |     |                    Ctrl+- |                         ctrl+- |                      null |                   ctrl+[Slash] |         |
+|                    Shift+Slash |   _   |                   Shift+- |     |                   Shift+- |                        shift+- |                      null |                  shift+[Slash] |         |
+|               Ctrl+Shift+Slash |   _   |              Ctrl+Shift+- |     |              Ctrl+Shift+- |                   ctrl+shift+- |                      null |             ctrl+shift+[Slash] |         |
+|                      Alt+Slash |   -   |                     Alt+- |     |                     Alt+- |                          alt+- |                      null |                    alt+[Slash] |         |
+|                 Ctrl+Alt+Slash | U+323 |                Ctrl+Alt+- |     |                Ctrl+Alt+- |                     ctrl+alt+- |                      null |               ctrl+alt+[Slash] |         |
+|                Shift+Alt+Slash |   _   |               Shift+Alt+- |     |               Shift+Alt+- |                    shift+alt+- |                      null |              shift+alt+[Slash] |         |
+|           Ctrl+Shift+Alt+Slash |   ˙   |          Ctrl+Shift+Alt+- |     |          Ctrl+Shift+Alt+- |               ctrl+shift+alt+- |                      null |         ctrl+shift+alt+[Slash] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                        ArrowUp |  ---  |                   UpArrow |     |                   UpArrow |                             up |                        Up |                      [ArrowUp] |         |
+|                   Ctrl+ArrowUp |  ---  |              Ctrl+UpArrow |     |              Ctrl+UpArrow |                        ctrl+up |                   Ctrl+Up |                 ctrl+[ArrowUp] |         |
+|                  Shift+ArrowUp |  ---  |             Shift+UpArrow |     |             Shift+UpArrow |                       shift+up |                  Shift+Up |                shift+[ArrowUp] |         |
+|             Ctrl+Shift+ArrowUp |  ---  |        Ctrl+Shift+UpArrow |     |        Ctrl+Shift+UpArrow |                  ctrl+shift+up |             Ctrl+Shift+Up |           ctrl+shift+[ArrowUp] |         |
+|                    Alt+ArrowUp |  ---  |               Alt+UpArrow |     |               Alt+UpArrow |                         alt+up |                    Alt+Up |                  alt+[ArrowUp] |         |
+|               Ctrl+Alt+ArrowUp |  ---  |          Ctrl+Alt+UpArrow |     |          Ctrl+Alt+UpArrow |                    ctrl+alt+up |               Ctrl+Alt+Up |             ctrl+alt+[ArrowUp] |         |
+|              Shift+Alt+ArrowUp |  ---  |         Shift+Alt+UpArrow |     |         Shift+Alt+UpArrow |                   shift+alt+up |              Shift+Alt+Up |            shift+alt+[ArrowUp] |         |
+|         Ctrl+Shift+Alt+ArrowUp |  ---  |    Ctrl+Shift+Alt+UpArrow |     |    Ctrl+Shift+Alt+UpArrow |              ctrl+shift+alt+up |         Ctrl+Shift+Alt+Up |       ctrl+shift+alt+[ArrowUp] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                        Numpad0 |  ---  |                   NumPad0 |     |                   NumPad0 |                        numpad0 |                      null |                      [Numpad0] |         |
+|                   Ctrl+Numpad0 |  ---  |              Ctrl+NumPad0 |     |              Ctrl+NumPad0 |                   ctrl+numpad0 |                      null |                 ctrl+[Numpad0] |         |
+|                  Shift+Numpad0 |  ---  |             Shift+NumPad0 |     |             Shift+NumPad0 |                  shift+numpad0 |                      null |                shift+[Numpad0] |         |
+|             Ctrl+Shift+Numpad0 |  ---  |        Ctrl+Shift+NumPad0 |     |        Ctrl+Shift+NumPad0 |             ctrl+shift+numpad0 |                      null |           ctrl+shift+[Numpad0] |         |
+|                    Alt+Numpad0 |  ---  |               Alt+NumPad0 |     |               Alt+NumPad0 |                    alt+numpad0 |                      null |                  alt+[Numpad0] |         |
+|               Ctrl+Alt+Numpad0 |  ---  |          Ctrl+Alt+NumPad0 |     |          Ctrl+Alt+NumPad0 |               ctrl+alt+numpad0 |                      null |             ctrl+alt+[Numpad0] |         |
+|              Shift+Alt+Numpad0 |  ---  |         Shift+Alt+NumPad0 |     |         Shift+Alt+NumPad0 |              shift+alt+numpad0 |                      null |            shift+alt+[Numpad0] |         |
+|         Ctrl+Shift+Alt+Numpad0 |  ---  |    Ctrl+Shift+Alt+NumPad0 |     |    Ctrl+Shift+Alt+NumPad0 |         ctrl+shift+alt+numpad0 |                      null |       ctrl+shift+alt+[Numpad0] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                  IntlBackslash |   <   |                   Shift+, |   2 |                         < |                [IntlBackslash] |                      null |                [IntlBackslash] |    NO   |
+|             Ctrl+IntlBackslash |   <   |              Ctrl+Shift+, |     |                    Ctrl+< |           ctrl+[IntlBackslash] |                      null |           ctrl+[IntlBackslash] |    NO   |
+|            Shift+IntlBackslash |   >   |                   Shift+. |   2 |                   Shift+< |          shift+[IntlBackslash] |                      null |          shift+[IntlBackslash] |    NO   |
+|       Ctrl+Shift+IntlBackslash |   >   |              Ctrl+Shift+. |     |              Ctrl+Shift+< |     ctrl+shift+[IntlBackslash] |                      null |     ctrl+shift+[IntlBackslash] |    NO   |
+|              Alt+IntlBackslash |   <   |               Shift+Alt+, |     |                     Alt+< |            alt+[IntlBackslash] |                      null |            alt+[IntlBackslash] |    NO   |
+|         Ctrl+Alt+IntlBackslash |   \   |                         \ |     |                Ctrl+Alt+< |       ctrl+alt+[IntlBackslash] |                      null |       ctrl+alt+[IntlBackslash] |    NO   |
+|        Shift+Alt+IntlBackslash |   >   |               Shift+Alt+. |     |               Shift+Alt+< |      shift+alt+[IntlBackslash] |                      null |      shift+alt+[IntlBackslash] |    NO   |
+|   Ctrl+Shift+Alt+IntlBackslash |   ¦   |          Ctrl+Shift+Alt+. |     |          Ctrl+Shift+Alt+< | ctrl+shift+alt+[IntlBackslash] |                      null | ctrl+shift+alt+[IntlBackslash] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         IntlRo |  ---  |                           |     |                      null |                       [IntlRo] |                      null |                       [IntlRo] |    NO   |
+|                    Ctrl+IntlRo |  ---  |                           |     |                      null |                  ctrl+[IntlRo] |                      null |                  ctrl+[IntlRo] |    NO   |
+|                   Shift+IntlRo |  ---  |                           |     |                      null |                 shift+[IntlRo] |                      null |                 shift+[IntlRo] |    NO   |
+|              Ctrl+Shift+IntlRo |  ---  |                           |     |                      null |            ctrl+shift+[IntlRo] |                      null |            ctrl+shift+[IntlRo] |    NO   |
+|                     Alt+IntlRo |  ---  |                           |     |                      null |                   alt+[IntlRo] |                      null |                   alt+[IntlRo] |    NO   |
+|                Ctrl+Alt+IntlRo |  ---  |                           |     |                      null |              ctrl+alt+[IntlRo] |                      null |              ctrl+alt+[IntlRo] |    NO   |
+|               Shift+Alt+IntlRo |  ---  |                           |     |                      null |             shift+alt+[IntlRo] |                      null |             shift+alt+[IntlRo] |    NO   |
+|          Ctrl+Shift+Alt+IntlRo |  ---  |                           |     |                      null |        ctrl+shift+alt+[IntlRo] |                      null |        ctrl+shift+alt+[IntlRo] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                        IntlYen |  ---  |                           |     |                      null |                      [IntlYen] |                      null |                      [IntlYen] |    NO   |
+|                   Ctrl+IntlYen |  ---  |                           |     |                      null |                 ctrl+[IntlYen] |                      null |                 ctrl+[IntlYen] |    NO   |
+|                  Shift+IntlYen |  ---  |                           |     |                      null |                shift+[IntlYen] |                      null |                shift+[IntlYen] |    NO   |
+|             Ctrl+Shift+IntlYen |  ---  |                           |     |                      null |           ctrl+shift+[IntlYen] |                      null |           ctrl+shift+[IntlYen] |    NO   |
+|                    Alt+IntlYen |  ---  |                           |     |                      null |                  alt+[IntlYen] |                      null |                  alt+[IntlYen] |    NO   |
+|               Ctrl+Alt+IntlYen |  ---  |                           |     |                      null |             ctrl+alt+[IntlYen] |                      null |             ctrl+alt+[IntlYen] |    NO   |
+|              Shift+Alt+IntlYen |  ---  |                           |     |                      null |            shift+alt+[IntlYen] |                      null |            shift+alt+[IntlYen] |    NO   |
+|         Ctrl+Shift+Alt+IntlYen |  ---  |                           |     |                      null |       ctrl+shift+alt+[IntlYen] |                      null |       ctrl+shift+alt+[IntlYen] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

lib/vscode/src/vs/workbench/services/keybinding/test/electron-browser/linux_en_uk.txt

@@ -0,0 +1,517 @@
+isUSStandard: false
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyA |   a   |                         A |     |                         A |                              a |                         A |                         [KeyA] |         |
+|                      Ctrl+KeyA |   a   |                    Ctrl+A |     |                    Ctrl+A |                         ctrl+a |                    Ctrl+A |                    ctrl+[KeyA] |         |
+|                     Shift+KeyA |   A   |                   Shift+A |     |                   Shift+A |                        shift+a |                   Shift+A |                   shift+[KeyA] |         |
+|                Ctrl+Shift+KeyA |   A   |              Ctrl+Shift+A |     |              Ctrl+Shift+A |                   ctrl+shift+a |              Ctrl+Shift+A |              ctrl+shift+[KeyA] |         |
+|                       Alt+KeyA |   a   |                     Alt+A |     |                     Alt+A |                          alt+a |                     Alt+A |                     alt+[KeyA] |         |
+|                  Ctrl+Alt+KeyA |   æ   |                Ctrl+Alt+A |     |                Ctrl+Alt+A |                     ctrl+alt+a |                Ctrl+Alt+A |                ctrl+alt+[KeyA] |         |
+|                 Shift+Alt+KeyA |   A   |               Shift+Alt+A |     |               Shift+Alt+A |                    shift+alt+a |               Shift+Alt+A |               shift+alt+[KeyA] |         |
+|            Ctrl+Shift+Alt+KeyA |   Æ   |          Ctrl+Shift+Alt+A |     |          Ctrl+Shift+Alt+A |               ctrl+shift+alt+a |          Ctrl+Shift+Alt+A |          ctrl+shift+alt+[KeyA] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyB |   b   |                         B |     |                         B |                              b |                         B |                         [KeyB] |         |
+|                      Ctrl+KeyB |   b   |                    Ctrl+B |     |                    Ctrl+B |                         ctrl+b |                    Ctrl+B |                    ctrl+[KeyB] |         |
+|                     Shift+KeyB |   B   |                   Shift+B |     |                   Shift+B |                        shift+b |                   Shift+B |                   shift+[KeyB] |         |
+|                Ctrl+Shift+KeyB |   B   |              Ctrl+Shift+B |     |              Ctrl+Shift+B |                   ctrl+shift+b |              Ctrl+Shift+B |              ctrl+shift+[KeyB] |         |
+|                       Alt+KeyB |   b   |                     Alt+B |     |                     Alt+B |                          alt+b |                     Alt+B |                     alt+[KeyB] |         |
+|                  Ctrl+Alt+KeyB |   ”   |                Ctrl+Alt+B |     |                Ctrl+Alt+B |                     ctrl+alt+b |                Ctrl+Alt+B |                ctrl+alt+[KeyB] |         |
+|                 Shift+Alt+KeyB |   B   |               Shift+Alt+B |     |               Shift+Alt+B |                    shift+alt+b |               Shift+Alt+B |               shift+alt+[KeyB] |         |
+|            Ctrl+Shift+Alt+KeyB |   ’   |          Ctrl+Shift+Alt+B |     |          Ctrl+Shift+Alt+B |               ctrl+shift+alt+b |          Ctrl+Shift+Alt+B |          ctrl+shift+alt+[KeyB] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyC |   c   |                         C |     |                         C |                              c |                         C |                         [KeyC] |         |
+|                      Ctrl+KeyC |   c   |                    Ctrl+C |     |                    Ctrl+C |                         ctrl+c |                    Ctrl+C |                    ctrl+[KeyC] |         |
+|                     Shift+KeyC |   C   |                   Shift+C |     |                   Shift+C |                        shift+c |                   Shift+C |                   shift+[KeyC] |         |
+|                Ctrl+Shift+KeyC |   C   |              Ctrl+Shift+C |     |              Ctrl+Shift+C |                   ctrl+shift+c |              Ctrl+Shift+C |              ctrl+shift+[KeyC] |         |
+|                       Alt+KeyC |   c   |                     Alt+C |     |                     Alt+C |                          alt+c |                     Alt+C |                     alt+[KeyC] |         |
+|                  Ctrl+Alt+KeyC |   ¢   |                Ctrl+Alt+C |     |                Ctrl+Alt+C |                     ctrl+alt+c |                Ctrl+Alt+C |                ctrl+alt+[KeyC] |         |
+|                 Shift+Alt+KeyC |   C   |               Shift+Alt+C |     |               Shift+Alt+C |                    shift+alt+c |               Shift+Alt+C |               shift+alt+[KeyC] |         |
+|            Ctrl+Shift+Alt+KeyC |   ©   |          Ctrl+Shift+Alt+C |     |          Ctrl+Shift+Alt+C |               ctrl+shift+alt+c |          Ctrl+Shift+Alt+C |          ctrl+shift+alt+[KeyC] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyD |   d   |                         D |     |                         D |                              d |                         D |                         [KeyD] |         |
+|                      Ctrl+KeyD |   d   |                    Ctrl+D |     |                    Ctrl+D |                         ctrl+d |                    Ctrl+D |                    ctrl+[KeyD] |         |
+|                     Shift+KeyD |   D   |                   Shift+D |     |                   Shift+D |                        shift+d |                   Shift+D |                   shift+[KeyD] |         |
+|                Ctrl+Shift+KeyD |   D   |              Ctrl+Shift+D |     |              Ctrl+Shift+D |                   ctrl+shift+d |              Ctrl+Shift+D |              ctrl+shift+[KeyD] |         |
+|                       Alt+KeyD |   d   |                     Alt+D |     |                     Alt+D |                          alt+d |                     Alt+D |                     alt+[KeyD] |         |
+|                  Ctrl+Alt+KeyD |   ð   |                Ctrl+Alt+D |     |                Ctrl+Alt+D |                     ctrl+alt+d |                Ctrl+Alt+D |                ctrl+alt+[KeyD] |         |
+|                 Shift+Alt+KeyD |   D   |               Shift+Alt+D |     |               Shift+Alt+D |                    shift+alt+d |               Shift+Alt+D |               shift+alt+[KeyD] |         |
+|            Ctrl+Shift+Alt+KeyD |   Ð   |          Ctrl+Shift+Alt+D |     |          Ctrl+Shift+Alt+D |               ctrl+shift+alt+d |          Ctrl+Shift+Alt+D |          ctrl+shift+alt+[KeyD] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyE |   e   |                         E |     |                         E |                              e |                         E |                         [KeyE] |         |
+|                      Ctrl+KeyE |   e   |                    Ctrl+E |     |                    Ctrl+E |                         ctrl+e |                    Ctrl+E |                    ctrl+[KeyE] |         |
+|                     Shift+KeyE |   E   |                   Shift+E |     |                   Shift+E |                        shift+e |                   Shift+E |                   shift+[KeyE] |         |
+|                Ctrl+Shift+KeyE |   E   |              Ctrl+Shift+E |     |              Ctrl+Shift+E |                   ctrl+shift+e |              Ctrl+Shift+E |              ctrl+shift+[KeyE] |         |
+|                       Alt+KeyE |   e   |                     Alt+E |     |                     Alt+E |                          alt+e |                     Alt+E |                     alt+[KeyE] |         |
+|                  Ctrl+Alt+KeyE |   e   |                Ctrl+Alt+E |     |                Ctrl+Alt+E |                     ctrl+alt+e |                Ctrl+Alt+E |                ctrl+alt+[KeyE] |         |
+|                 Shift+Alt+KeyE |   E   |               Shift+Alt+E |     |               Shift+Alt+E |                    shift+alt+e |               Shift+Alt+E |               shift+alt+[KeyE] |         |
+|            Ctrl+Shift+Alt+KeyE |   E   |          Ctrl+Shift+Alt+E |     |          Ctrl+Shift+Alt+E |               ctrl+shift+alt+e |          Ctrl+Shift+Alt+E |          ctrl+shift+alt+[KeyE] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyF |   f   |                         F |     |                         F |                              f |                         F |                         [KeyF] |         |
+|                      Ctrl+KeyF |   f   |                    Ctrl+F |     |                    Ctrl+F |                         ctrl+f |                    Ctrl+F |                    ctrl+[KeyF] |         |
+|                     Shift+KeyF |   F   |                   Shift+F |     |                   Shift+F |                        shift+f |                   Shift+F |                   shift+[KeyF] |         |
+|                Ctrl+Shift+KeyF |   F   |              Ctrl+Shift+F |     |              Ctrl+Shift+F |                   ctrl+shift+f |              Ctrl+Shift+F |              ctrl+shift+[KeyF] |         |
+|                       Alt+KeyF |   f   |                     Alt+F |     |                     Alt+F |                          alt+f |                     Alt+F |                     alt+[KeyF] |         |
+|                  Ctrl+Alt+KeyF |   đ   |                Ctrl+Alt+F |     |                Ctrl+Alt+F |                     ctrl+alt+f |                Ctrl+Alt+F |                ctrl+alt+[KeyF] |         |
+|                 Shift+Alt+KeyF |   F   |               Shift+Alt+F |     |               Shift+Alt+F |                    shift+alt+f |               Shift+Alt+F |               shift+alt+[KeyF] |         |
+|            Ctrl+Shift+Alt+KeyF |   ª   |          Ctrl+Shift+Alt+F |     |          Ctrl+Shift+Alt+F |               ctrl+shift+alt+f |          Ctrl+Shift+Alt+F |          ctrl+shift+alt+[KeyF] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyG |   g   |                         G |     |                         G |                              g |                         G |                         [KeyG] |         |
+|                      Ctrl+KeyG |   g   |                    Ctrl+G |     |                    Ctrl+G |                         ctrl+g |                    Ctrl+G |                    ctrl+[KeyG] |         |
+|                     Shift+KeyG |   G   |                   Shift+G |     |                   Shift+G |                        shift+g |                   Shift+G |                   shift+[KeyG] |         |
+|                Ctrl+Shift+KeyG |   G   |              Ctrl+Shift+G |     |              Ctrl+Shift+G |                   ctrl+shift+g |              Ctrl+Shift+G |              ctrl+shift+[KeyG] |         |
+|                       Alt+KeyG |   g   |                     Alt+G |     |                     Alt+G |                          alt+g |                     Alt+G |                     alt+[KeyG] |         |
+|                  Ctrl+Alt+KeyG |   ŋ   |                Ctrl+Alt+G |     |                Ctrl+Alt+G |                     ctrl+alt+g |                Ctrl+Alt+G |                ctrl+alt+[KeyG] |         |
+|                 Shift+Alt+KeyG |   G   |               Shift+Alt+G |     |               Shift+Alt+G |                    shift+alt+g |               Shift+Alt+G |               shift+alt+[KeyG] |         |
+|            Ctrl+Shift+Alt+KeyG |   Ŋ   |          Ctrl+Shift+Alt+G |     |          Ctrl+Shift+Alt+G |               ctrl+shift+alt+g |          Ctrl+Shift+Alt+G |          ctrl+shift+alt+[KeyG] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyH |   h   |                         H |     |                         H |                              h |                         H |                         [KeyH] |         |
+|                      Ctrl+KeyH |   h   |                    Ctrl+H |     |                    Ctrl+H |                         ctrl+h |                    Ctrl+H |                    ctrl+[KeyH] |         |
+|                     Shift+KeyH |   H   |                   Shift+H |     |                   Shift+H |                        shift+h |                   Shift+H |                   shift+[KeyH] |         |
+|                Ctrl+Shift+KeyH |   H   |              Ctrl+Shift+H |     |              Ctrl+Shift+H |                   ctrl+shift+h |              Ctrl+Shift+H |              ctrl+shift+[KeyH] |         |
+|                       Alt+KeyH |   h   |                     Alt+H |     |                     Alt+H |                          alt+h |                     Alt+H |                     alt+[KeyH] |         |
+|                  Ctrl+Alt+KeyH |   ħ   |                Ctrl+Alt+H |     |                Ctrl+Alt+H |                     ctrl+alt+h |                Ctrl+Alt+H |                ctrl+alt+[KeyH] |         |
+|                 Shift+Alt+KeyH |   H   |               Shift+Alt+H |     |               Shift+Alt+H |                    shift+alt+h |               Shift+Alt+H |               shift+alt+[KeyH] |         |
+|            Ctrl+Shift+Alt+KeyH |   Ħ   |          Ctrl+Shift+Alt+H |     |          Ctrl+Shift+Alt+H |               ctrl+shift+alt+h |          Ctrl+Shift+Alt+H |          ctrl+shift+alt+[KeyH] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyI |   i   |                         I |     |                         I |                              i |                         I |                         [KeyI] |         |
+|                      Ctrl+KeyI |   i   |                    Ctrl+I |     |                    Ctrl+I |                         ctrl+i |                    Ctrl+I |                    ctrl+[KeyI] |         |
+|                     Shift+KeyI |   I   |                   Shift+I |     |                   Shift+I |                        shift+i |                   Shift+I |                   shift+[KeyI] |         |
+|                Ctrl+Shift+KeyI |   I   |              Ctrl+Shift+I |     |              Ctrl+Shift+I |                   ctrl+shift+i |              Ctrl+Shift+I |              ctrl+shift+[KeyI] |         |
+|                       Alt+KeyI |   i   |                     Alt+I |     |                     Alt+I |                          alt+i |                     Alt+I |                     alt+[KeyI] |         |
+|                  Ctrl+Alt+KeyI |   →   |                Ctrl+Alt+I |     |                Ctrl+Alt+I |                     ctrl+alt+i |                Ctrl+Alt+I |                ctrl+alt+[KeyI] |         |
+|                 Shift+Alt+KeyI |   I   |               Shift+Alt+I |     |               Shift+Alt+I |                    shift+alt+i |               Shift+Alt+I |               shift+alt+[KeyI] |         |
+|            Ctrl+Shift+Alt+KeyI |   ı   |          Ctrl+Shift+Alt+I |     |          Ctrl+Shift+Alt+I |               ctrl+shift+alt+i |          Ctrl+Shift+Alt+I |          ctrl+shift+alt+[KeyI] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyJ |   j   |                         J |     |                         J |                              j |                         J |                         [KeyJ] |         |
+|                      Ctrl+KeyJ |   j   |                    Ctrl+J |     |                    Ctrl+J |                         ctrl+j |                    Ctrl+J |                    ctrl+[KeyJ] |         |
+|                     Shift+KeyJ |   J   |                   Shift+J |     |                   Shift+J |                        shift+j |                   Shift+J |                   shift+[KeyJ] |         |
+|                Ctrl+Shift+KeyJ |   J   |              Ctrl+Shift+J |     |              Ctrl+Shift+J |                   ctrl+shift+j |              Ctrl+Shift+J |              ctrl+shift+[KeyJ] |         |
+|                       Alt+KeyJ |   j   |                     Alt+J |     |                     Alt+J |                          alt+j |                     Alt+J |                     alt+[KeyJ] |         |
+|                  Ctrl+Alt+KeyJ | U+309 |                Ctrl+Alt+J |     |                Ctrl+Alt+J |                     ctrl+alt+j |                Ctrl+Alt+J |                ctrl+alt+[KeyJ] |         |
+|                 Shift+Alt+KeyJ |   J   |               Shift+Alt+J |     |               Shift+Alt+J |                    shift+alt+j |               Shift+Alt+J |               shift+alt+[KeyJ] |         |
+|            Ctrl+Shift+Alt+KeyJ | U+31b |          Ctrl+Shift+Alt+J |     |          Ctrl+Shift+Alt+J |               ctrl+shift+alt+j |          Ctrl+Shift+Alt+J |          ctrl+shift+alt+[KeyJ] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyK |   k   |                         K |     |                         K |                              k |                         K |                         [KeyK] |         |
+|                      Ctrl+KeyK |   k   |                    Ctrl+K |     |                    Ctrl+K |                         ctrl+k |                    Ctrl+K |                    ctrl+[KeyK] |         |
+|                     Shift+KeyK |   K   |                   Shift+K |     |                   Shift+K |                        shift+k |                   Shift+K |                   shift+[KeyK] |         |
+|                Ctrl+Shift+KeyK |   K   |              Ctrl+Shift+K |     |              Ctrl+Shift+K |                   ctrl+shift+k |              Ctrl+Shift+K |              ctrl+shift+[KeyK] |         |
+|                       Alt+KeyK |   k   |                     Alt+K |     |                     Alt+K |                          alt+k |                     Alt+K |                     alt+[KeyK] |         |
+|                  Ctrl+Alt+KeyK |   ĸ   |                Ctrl+Alt+K |     |                Ctrl+Alt+K |                     ctrl+alt+k |                Ctrl+Alt+K |                ctrl+alt+[KeyK] |         |
+|                 Shift+Alt+KeyK |   K   |               Shift+Alt+K |     |               Shift+Alt+K |                    shift+alt+k |               Shift+Alt+K |               shift+alt+[KeyK] |         |
+|            Ctrl+Shift+Alt+KeyK |   &   |          Ctrl+Shift+Alt+K |     |          Ctrl+Shift+Alt+K |               ctrl+shift+alt+k |          Ctrl+Shift+Alt+K |          ctrl+shift+alt+[KeyK] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyL |   l   |                         L |     |                         L |                              l |                         L |                         [KeyL] |         |
+|                      Ctrl+KeyL |   l   |                    Ctrl+L |     |                    Ctrl+L |                         ctrl+l |                    Ctrl+L |                    ctrl+[KeyL] |         |
+|                     Shift+KeyL |   L   |                   Shift+L |     |                   Shift+L |                        shift+l |                   Shift+L |                   shift+[KeyL] |         |
+|                Ctrl+Shift+KeyL |   L   |              Ctrl+Shift+L |     |              Ctrl+Shift+L |                   ctrl+shift+l |              Ctrl+Shift+L |              ctrl+shift+[KeyL] |         |
+|                       Alt+KeyL |   l   |                     Alt+L |     |                     Alt+L |                          alt+l |                     Alt+L |                     alt+[KeyL] |         |
+|                  Ctrl+Alt+KeyL |   ł   |                Ctrl+Alt+L |     |                Ctrl+Alt+L |                     ctrl+alt+l |                Ctrl+Alt+L |                ctrl+alt+[KeyL] |         |
+|                 Shift+Alt+KeyL |   L   |               Shift+Alt+L |     |               Shift+Alt+L |                    shift+alt+l |               Shift+Alt+L |               shift+alt+[KeyL] |         |
+|            Ctrl+Shift+Alt+KeyL |   Ł   |          Ctrl+Shift+Alt+L |     |          Ctrl+Shift+Alt+L |               ctrl+shift+alt+l |          Ctrl+Shift+Alt+L |          ctrl+shift+alt+[KeyL] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyM |   m   |                         M |     |                         M |                              m |                         M |                         [KeyM] |         |
+|                      Ctrl+KeyM |   m   |                    Ctrl+M |     |                    Ctrl+M |                         ctrl+m |                    Ctrl+M |                    ctrl+[KeyM] |         |
+|                     Shift+KeyM |   M   |                   Shift+M |     |                   Shift+M |                        shift+m |                   Shift+M |                   shift+[KeyM] |         |
+|                Ctrl+Shift+KeyM |   M   |              Ctrl+Shift+M |     |              Ctrl+Shift+M |                   ctrl+shift+m |              Ctrl+Shift+M |              ctrl+shift+[KeyM] |         |
+|                       Alt+KeyM |   m   |                     Alt+M |     |                     Alt+M |                          alt+m |                     Alt+M |                     alt+[KeyM] |         |
+|                  Ctrl+Alt+KeyM |   µ   |                Ctrl+Alt+M |     |                Ctrl+Alt+M |                     ctrl+alt+m |                Ctrl+Alt+M |                ctrl+alt+[KeyM] |         |
+|                 Shift+Alt+KeyM |   M   |               Shift+Alt+M |     |               Shift+Alt+M |                    shift+alt+m |               Shift+Alt+M |               shift+alt+[KeyM] |         |
+|            Ctrl+Shift+Alt+KeyM |   º   |          Ctrl+Shift+Alt+M |     |          Ctrl+Shift+Alt+M |               ctrl+shift+alt+m |          Ctrl+Shift+Alt+M |          ctrl+shift+alt+[KeyM] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyN |   n   |                         N |     |                         N |                              n |                         N |                         [KeyN] |         |
+|                      Ctrl+KeyN |   n   |                    Ctrl+N |     |                    Ctrl+N |                         ctrl+n |                    Ctrl+N |                    ctrl+[KeyN] |         |
+|                     Shift+KeyN |   N   |                   Shift+N |     |                   Shift+N |                        shift+n |                   Shift+N |                   shift+[KeyN] |         |
+|                Ctrl+Shift+KeyN |   N   |              Ctrl+Shift+N |     |              Ctrl+Shift+N |                   ctrl+shift+n |              Ctrl+Shift+N |              ctrl+shift+[KeyN] |         |
+|                       Alt+KeyN |   n   |                     Alt+N |     |                     Alt+N |                          alt+n |                     Alt+N |                     alt+[KeyN] |         |
+|                  Ctrl+Alt+KeyN |   n   |                Ctrl+Alt+N |     |                Ctrl+Alt+N |                     ctrl+alt+n |                Ctrl+Alt+N |                ctrl+alt+[KeyN] |         |
+|                 Shift+Alt+KeyN |   N   |               Shift+Alt+N |     |               Shift+Alt+N |                    shift+alt+n |               Shift+Alt+N |               shift+alt+[KeyN] |         |
+|            Ctrl+Shift+Alt+KeyN |   N   |          Ctrl+Shift+Alt+N |     |          Ctrl+Shift+Alt+N |               ctrl+shift+alt+n |          Ctrl+Shift+Alt+N |          ctrl+shift+alt+[KeyN] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyO |   o   |                         O |     |                         O |                              o |                         O |                         [KeyO] |         |
+|                      Ctrl+KeyO |   o   |                    Ctrl+O |     |                    Ctrl+O |                         ctrl+o |                    Ctrl+O |                    ctrl+[KeyO] |         |
+|                     Shift+KeyO |   O   |                   Shift+O |     |                   Shift+O |                        shift+o |                   Shift+O |                   shift+[KeyO] |         |
+|                Ctrl+Shift+KeyO |   O   |              Ctrl+Shift+O |     |              Ctrl+Shift+O |                   ctrl+shift+o |              Ctrl+Shift+O |              ctrl+shift+[KeyO] |         |
+|                       Alt+KeyO |   o   |                     Alt+O |     |                     Alt+O |                          alt+o |                     Alt+O |                     alt+[KeyO] |         |
+|                  Ctrl+Alt+KeyO |   ø   |                Ctrl+Alt+O |     |                Ctrl+Alt+O |                     ctrl+alt+o |                Ctrl+Alt+O |                ctrl+alt+[KeyO] |         |
+|                 Shift+Alt+KeyO |   O   |               Shift+Alt+O |     |               Shift+Alt+O |                    shift+alt+o |               Shift+Alt+O |               shift+alt+[KeyO] |         |
+|            Ctrl+Shift+Alt+KeyO |   Ø   |          Ctrl+Shift+Alt+O |     |          Ctrl+Shift+Alt+O |               ctrl+shift+alt+o |          Ctrl+Shift+Alt+O |          ctrl+shift+alt+[KeyO] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyP |   p   |                         P |     |                         P |                              p |                         P |                         [KeyP] |         |
+|                      Ctrl+KeyP |   p   |                    Ctrl+P |     |                    Ctrl+P |                         ctrl+p |                    Ctrl+P |                    ctrl+[KeyP] |         |
+|                     Shift+KeyP |   P   |                   Shift+P |     |                   Shift+P |                        shift+p |                   Shift+P |                   shift+[KeyP] |         |
+|                Ctrl+Shift+KeyP |   P   |              Ctrl+Shift+P |     |              Ctrl+Shift+P |                   ctrl+shift+p |              Ctrl+Shift+P |              ctrl+shift+[KeyP] |         |
+|                       Alt+KeyP |   p   |                     Alt+P |     |                     Alt+P |                          alt+p |                     Alt+P |                     alt+[KeyP] |         |
+|                  Ctrl+Alt+KeyP |   þ   |                Ctrl+Alt+P |     |                Ctrl+Alt+P |                     ctrl+alt+p |                Ctrl+Alt+P |                ctrl+alt+[KeyP] |         |
+|                 Shift+Alt+KeyP |   P   |               Shift+Alt+P |     |               Shift+Alt+P |                    shift+alt+p |               Shift+Alt+P |               shift+alt+[KeyP] |         |
+|            Ctrl+Shift+Alt+KeyP |   Þ   |          Ctrl+Shift+Alt+P |     |          Ctrl+Shift+Alt+P |               ctrl+shift+alt+p |          Ctrl+Shift+Alt+P |          ctrl+shift+alt+[KeyP] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyQ |   q   |                         Q |     |                         Q |                              q |                         Q |                         [KeyQ] |         |
+|                      Ctrl+KeyQ |   q   |                    Ctrl+Q |     |                    Ctrl+Q |                         ctrl+q |                    Ctrl+Q |                    ctrl+[KeyQ] |         |
+|                     Shift+KeyQ |   Q   |                   Shift+Q |     |                   Shift+Q |                        shift+q |                   Shift+Q |                   shift+[KeyQ] |         |
+|                Ctrl+Shift+KeyQ |   Q   |              Ctrl+Shift+Q |     |              Ctrl+Shift+Q |                   ctrl+shift+q |              Ctrl+Shift+Q |              ctrl+shift+[KeyQ] |         |
+|                       Alt+KeyQ |   q   |                     Alt+Q |     |                     Alt+Q |                          alt+q |                     Alt+Q |                     alt+[KeyQ] |         |
+|                  Ctrl+Alt+KeyQ |   @   |                Ctrl+Alt+Q |     |                Ctrl+Alt+Q |                     ctrl+alt+q |                Ctrl+Alt+Q |                ctrl+alt+[KeyQ] |         |
+|                 Shift+Alt+KeyQ |   Q   |               Shift+Alt+Q |     |               Shift+Alt+Q |                    shift+alt+q |               Shift+Alt+Q |               shift+alt+[KeyQ] |         |
+|            Ctrl+Shift+Alt+KeyQ |   Ω   |          Ctrl+Shift+Alt+Q |     |          Ctrl+Shift+Alt+Q |               ctrl+shift+alt+q |          Ctrl+Shift+Alt+Q |          ctrl+shift+alt+[KeyQ] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyR |   r   |                         R |     |                         R |                              r |                         R |                         [KeyR] |         |
+|                      Ctrl+KeyR |   r   |                    Ctrl+R |     |                    Ctrl+R |                         ctrl+r |                    Ctrl+R |                    ctrl+[KeyR] |         |
+|                     Shift+KeyR |   R   |                   Shift+R |     |                   Shift+R |                        shift+r |                   Shift+R |                   shift+[KeyR] |         |
+|                Ctrl+Shift+KeyR |   R   |              Ctrl+Shift+R |     |              Ctrl+Shift+R |                   ctrl+shift+r |              Ctrl+Shift+R |              ctrl+shift+[KeyR] |         |
+|                       Alt+KeyR |   r   |                     Alt+R |     |                     Alt+R |                          alt+r |                     Alt+R |                     alt+[KeyR] |         |
+|                  Ctrl+Alt+KeyR |   ¶   |                Ctrl+Alt+R |     |                Ctrl+Alt+R |                     ctrl+alt+r |                Ctrl+Alt+R |                ctrl+alt+[KeyR] |         |
+|                 Shift+Alt+KeyR |   R   |               Shift+Alt+R |     |               Shift+Alt+R |                    shift+alt+r |               Shift+Alt+R |               shift+alt+[KeyR] |         |
+|            Ctrl+Shift+Alt+KeyR |   ®   |          Ctrl+Shift+Alt+R |     |          Ctrl+Shift+Alt+R |               ctrl+shift+alt+r |          Ctrl+Shift+Alt+R |          ctrl+shift+alt+[KeyR] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyS |   s   |                         S |     |                         S |                              s |                         S |                         [KeyS] |         |
+|                      Ctrl+KeyS |   s   |                    Ctrl+S |     |                    Ctrl+S |                         ctrl+s |                    Ctrl+S |                    ctrl+[KeyS] |         |
+|                     Shift+KeyS |   S   |                   Shift+S |     |                   Shift+S |                        shift+s |                   Shift+S |                   shift+[KeyS] |         |
+|                Ctrl+Shift+KeyS |   S   |              Ctrl+Shift+S |     |              Ctrl+Shift+S |                   ctrl+shift+s |              Ctrl+Shift+S |              ctrl+shift+[KeyS] |         |
+|                       Alt+KeyS |   s   |                     Alt+S |     |                     Alt+S |                          alt+s |                     Alt+S |                     alt+[KeyS] |         |
+|                  Ctrl+Alt+KeyS |   ß   |                Ctrl+Alt+S |     |                Ctrl+Alt+S |                     ctrl+alt+s |                Ctrl+Alt+S |                ctrl+alt+[KeyS] |         |
+|                 Shift+Alt+KeyS |   S   |               Shift+Alt+S |     |               Shift+Alt+S |                    shift+alt+s |               Shift+Alt+S |               shift+alt+[KeyS] |         |
+|            Ctrl+Shift+Alt+KeyS |   §   |          Ctrl+Shift+Alt+S |     |          Ctrl+Shift+Alt+S |               ctrl+shift+alt+s |          Ctrl+Shift+Alt+S |          ctrl+shift+alt+[KeyS] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyT |   t   |                         T |     |                         T |                              t |                         T |                         [KeyT] |         |
+|                      Ctrl+KeyT |   t   |                    Ctrl+T |     |                    Ctrl+T |                         ctrl+t |                    Ctrl+T |                    ctrl+[KeyT] |         |
+|                     Shift+KeyT |   T   |                   Shift+T |     |                   Shift+T |                        shift+t |                   Shift+T |                   shift+[KeyT] |         |
+|                Ctrl+Shift+KeyT |   T   |              Ctrl+Shift+T |     |              Ctrl+Shift+T |                   ctrl+shift+t |              Ctrl+Shift+T |              ctrl+shift+[KeyT] |         |
+|                       Alt+KeyT |   t   |                     Alt+T |     |                     Alt+T |                          alt+t |                     Alt+T |                     alt+[KeyT] |         |
+|                  Ctrl+Alt+KeyT |   ŧ   |                Ctrl+Alt+T |     |                Ctrl+Alt+T |                     ctrl+alt+t |                Ctrl+Alt+T |                ctrl+alt+[KeyT] |         |
+|                 Shift+Alt+KeyT |   T   |               Shift+Alt+T |     |               Shift+Alt+T |                    shift+alt+t |               Shift+Alt+T |               shift+alt+[KeyT] |         |
+|            Ctrl+Shift+Alt+KeyT |   Ŧ   |          Ctrl+Shift+Alt+T |     |          Ctrl+Shift+Alt+T |               ctrl+shift+alt+t |          Ctrl+Shift+Alt+T |          ctrl+shift+alt+[KeyT] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyU |   u   |                         U |     |                         U |                              u |                         U |                         [KeyU] |         |
+|                      Ctrl+KeyU |   u   |                    Ctrl+U |     |                    Ctrl+U |                         ctrl+u |                    Ctrl+U |                    ctrl+[KeyU] |         |
+|                     Shift+KeyU |   U   |                   Shift+U |     |                   Shift+U |                        shift+u |                   Shift+U |                   shift+[KeyU] |         |
+|                Ctrl+Shift+KeyU |   U   |              Ctrl+Shift+U |     |              Ctrl+Shift+U |                   ctrl+shift+u |              Ctrl+Shift+U |              ctrl+shift+[KeyU] |         |
+|                       Alt+KeyU |   u   |                     Alt+U |     |                     Alt+U |                          alt+u |                     Alt+U |                     alt+[KeyU] |         |
+|                  Ctrl+Alt+KeyU |   ↓   |                Ctrl+Alt+U |     |                Ctrl+Alt+U |                     ctrl+alt+u |                Ctrl+Alt+U |                ctrl+alt+[KeyU] |         |
+|                 Shift+Alt+KeyU |   U   |               Shift+Alt+U |     |               Shift+Alt+U |                    shift+alt+u |               Shift+Alt+U |               shift+alt+[KeyU] |         |
+|            Ctrl+Shift+Alt+KeyU |   ↑   |          Ctrl+Shift+Alt+U |     |          Ctrl+Shift+Alt+U |               ctrl+shift+alt+u |          Ctrl+Shift+Alt+U |          ctrl+shift+alt+[KeyU] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyV |   v   |                         V |     |                         V |                              v |                         V |                         [KeyV] |         |
+|                      Ctrl+KeyV |   v   |                    Ctrl+V |     |                    Ctrl+V |                         ctrl+v |                    Ctrl+V |                    ctrl+[KeyV] |         |
+|                     Shift+KeyV |   V   |                   Shift+V |     |                   Shift+V |                        shift+v |                   Shift+V |                   shift+[KeyV] |         |
+|                Ctrl+Shift+KeyV |   V   |              Ctrl+Shift+V |     |              Ctrl+Shift+V |                   ctrl+shift+v |              Ctrl+Shift+V |              ctrl+shift+[KeyV] |         |
+|                       Alt+KeyV |   v   |                     Alt+V |     |                     Alt+V |                          alt+v |                     Alt+V |                     alt+[KeyV] |         |
+|                  Ctrl+Alt+KeyV |   “   |                Ctrl+Alt+V |     |                Ctrl+Alt+V |                     ctrl+alt+v |                Ctrl+Alt+V |                ctrl+alt+[KeyV] |         |
+|                 Shift+Alt+KeyV |   V   |               Shift+Alt+V |     |               Shift+Alt+V |                    shift+alt+v |               Shift+Alt+V |               shift+alt+[KeyV] |         |
+|            Ctrl+Shift+Alt+KeyV |   ‘   |          Ctrl+Shift+Alt+V |     |          Ctrl+Shift+Alt+V |               ctrl+shift+alt+v |          Ctrl+Shift+Alt+V |          ctrl+shift+alt+[KeyV] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyW |   w   |                         W |     |                         W |                              w |                         W |                         [KeyW] |         |
+|                      Ctrl+KeyW |   w   |                    Ctrl+W |     |                    Ctrl+W |                         ctrl+w |                    Ctrl+W |                    ctrl+[KeyW] |         |
+|                     Shift+KeyW |   W   |                   Shift+W |     |                   Shift+W |                        shift+w |                   Shift+W |                   shift+[KeyW] |         |
+|                Ctrl+Shift+KeyW |   W   |              Ctrl+Shift+W |     |              Ctrl+Shift+W |                   ctrl+shift+w |              Ctrl+Shift+W |              ctrl+shift+[KeyW] |         |
+|                       Alt+KeyW |   w   |                     Alt+W |     |                     Alt+W |                          alt+w |                     Alt+W |                     alt+[KeyW] |         |
+|                  Ctrl+Alt+KeyW |   ł   |                Ctrl+Alt+W |     |                Ctrl+Alt+W |                     ctrl+alt+w |                Ctrl+Alt+W |                ctrl+alt+[KeyW] |         |
+|                 Shift+Alt+KeyW |   W   |               Shift+Alt+W |     |               Shift+Alt+W |                    shift+alt+w |               Shift+Alt+W |               shift+alt+[KeyW] |         |
+|            Ctrl+Shift+Alt+KeyW |   Ł   |          Ctrl+Shift+Alt+W |     |          Ctrl+Shift+Alt+W |               ctrl+shift+alt+w |          Ctrl+Shift+Alt+W |          ctrl+shift+alt+[KeyW] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyX |   x   |                         X |     |                         X |                              x |                         X |                         [KeyX] |         |
+|                      Ctrl+KeyX |   x   |                    Ctrl+X |     |                    Ctrl+X |                         ctrl+x |                    Ctrl+X |                    ctrl+[KeyX] |         |
+|                     Shift+KeyX |   X   |                   Shift+X |     |                   Shift+X |                        shift+x |                   Shift+X |                   shift+[KeyX] |         |
+|                Ctrl+Shift+KeyX |   X   |              Ctrl+Shift+X |     |              Ctrl+Shift+X |                   ctrl+shift+x |              Ctrl+Shift+X |              ctrl+shift+[KeyX] |         |
+|                       Alt+KeyX |   x   |                     Alt+X |     |                     Alt+X |                          alt+x |                     Alt+X |                     alt+[KeyX] |         |
+|                  Ctrl+Alt+KeyX |   »   |                Ctrl+Alt+X |     |                Ctrl+Alt+X |                     ctrl+alt+x |                Ctrl+Alt+X |                ctrl+alt+[KeyX] |         |
+|                 Shift+Alt+KeyX |   X   |               Shift+Alt+X |     |               Shift+Alt+X |                    shift+alt+x |               Shift+Alt+X |               shift+alt+[KeyX] |         |
+|            Ctrl+Shift+Alt+KeyX |   >   |          Ctrl+Shift+Alt+X |     |          Ctrl+Shift+Alt+X |               ctrl+shift+alt+x |          Ctrl+Shift+Alt+X |          ctrl+shift+alt+[KeyX] |         |
+|                                |       |                   Shift+. |   2 |                           |                                |                           |                                |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyY |   y   |                         Y |     |                         Y |                              y |                         Y |                         [KeyY] |         |
+|                      Ctrl+KeyY |   y   |                    Ctrl+Y |     |                    Ctrl+Y |                         ctrl+y |                    Ctrl+Y |                    ctrl+[KeyY] |         |
+|                     Shift+KeyY |   Y   |                   Shift+Y |     |                   Shift+Y |                        shift+y |                   Shift+Y |                   shift+[KeyY] |         |
+|                Ctrl+Shift+KeyY |   Y   |              Ctrl+Shift+Y |     |              Ctrl+Shift+Y |                   ctrl+shift+y |              Ctrl+Shift+Y |              ctrl+shift+[KeyY] |         |
+|                       Alt+KeyY |   y   |                     Alt+Y |     |                     Alt+Y |                          alt+y |                     Alt+Y |                     alt+[KeyY] |         |
+|                  Ctrl+Alt+KeyY |   ←   |                Ctrl+Alt+Y |     |                Ctrl+Alt+Y |                     ctrl+alt+y |                Ctrl+Alt+Y |                ctrl+alt+[KeyY] |         |
+|                 Shift+Alt+KeyY |   Y   |               Shift+Alt+Y |     |               Shift+Alt+Y |                    shift+alt+y |               Shift+Alt+Y |               shift+alt+[KeyY] |         |
+|            Ctrl+Shift+Alt+KeyY |   ¥   |          Ctrl+Shift+Alt+Y |     |          Ctrl+Shift+Alt+Y |               ctrl+shift+alt+y |          Ctrl+Shift+Alt+Y |          ctrl+shift+alt+[KeyY] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyZ |   z   |                         Z |     |                         Z |                              z |                         Z |                         [KeyZ] |         |
+|                      Ctrl+KeyZ |   z   |                    Ctrl+Z |     |                    Ctrl+Z |                         ctrl+z |                    Ctrl+Z |                    ctrl+[KeyZ] |         |
+|                     Shift+KeyZ |   Z   |                   Shift+Z |     |                   Shift+Z |                        shift+z |                   Shift+Z |                   shift+[KeyZ] |         |
+|                Ctrl+Shift+KeyZ |   Z   |              Ctrl+Shift+Z |     |              Ctrl+Shift+Z |                   ctrl+shift+z |              Ctrl+Shift+Z |              ctrl+shift+[KeyZ] |         |
+|                       Alt+KeyZ |   z   |                     Alt+Z |     |                     Alt+Z |                          alt+z |                     Alt+Z |                     alt+[KeyZ] |         |
+|                  Ctrl+Alt+KeyZ |   «   |                Ctrl+Alt+Z |     |                Ctrl+Alt+Z |                     ctrl+alt+z |                Ctrl+Alt+Z |                ctrl+alt+[KeyZ] |         |
+|                 Shift+Alt+KeyZ |   Z   |               Shift+Alt+Z |     |               Shift+Alt+Z |                    shift+alt+z |               Shift+Alt+Z |               shift+alt+[KeyZ] |         |
+|            Ctrl+Shift+Alt+KeyZ |   <   |          Ctrl+Shift+Alt+Z |     |          Ctrl+Shift+Alt+Z |               ctrl+shift+alt+z |          Ctrl+Shift+Alt+Z |          ctrl+shift+alt+[KeyZ] |         |
+|                                |       |                   Shift+, |   2 |                           |                                |                           |                                |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit1 |   1   |                         1 |     |                         1 |                              1 |                         1 |                       [Digit1] |         |
+|                    Ctrl+Digit1 |   1   |                    Ctrl+1 |     |                    Ctrl+1 |                         ctrl+1 |                    Ctrl+1 |                  ctrl+[Digit1] |         |
+|                   Shift+Digit1 |   !   |                   Shift+1 |     |                   Shift+1 |                        shift+1 |                   Shift+1 |                 shift+[Digit1] |         |
+|              Ctrl+Shift+Digit1 |   !   |              Ctrl+Shift+1 |     |              Ctrl+Shift+1 |                   ctrl+shift+1 |              Ctrl+Shift+1 |            ctrl+shift+[Digit1] |         |
+|                     Alt+Digit1 |   1   |                     Alt+1 |     |                     Alt+1 |                          alt+1 |                     Alt+1 |                   alt+[Digit1] |         |
+|                Ctrl+Alt+Digit1 |   ¹   |                Ctrl+Alt+1 |     |                Ctrl+Alt+1 |                     ctrl+alt+1 |                Ctrl+Alt+1 |              ctrl+alt+[Digit1] |         |
+|               Shift+Alt+Digit1 |   !   |               Shift+Alt+1 |     |               Shift+Alt+1 |                    shift+alt+1 |               Shift+Alt+1 |             shift+alt+[Digit1] |         |
+|          Ctrl+Shift+Alt+Digit1 |   ¡   |          Ctrl+Shift+Alt+1 |     |          Ctrl+Shift+Alt+1 |               ctrl+shift+alt+1 |          Ctrl+Shift+Alt+1 |        ctrl+shift+alt+[Digit1] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit2 |   2   |                         2 |     |                         2 |                              2 |                         2 |                       [Digit2] |         |
+|                    Ctrl+Digit2 |   2   |                    Ctrl+2 |     |                    Ctrl+2 |                         ctrl+2 |                    Ctrl+2 |                  ctrl+[Digit2] |         |
+|                   Shift+Digit2 |   "   |                   Shift+2 |     |                   Shift+2 |                        shift+2 |                   Shift+2 |                 shift+[Digit2] |         |
+|                                |       |                   Shift+' |   2 |                           |                                |                           |                                |         |
+|              Ctrl+Shift+Digit2 |   "   |              Ctrl+Shift+2 |     |              Ctrl+Shift+2 |                   ctrl+shift+2 |              Ctrl+Shift+2 |            ctrl+shift+[Digit2] |         |
+|                                |       |              Ctrl+Shift+' |   2 |                           |                                |                           |                                |         |
+|                     Alt+Digit2 |   2   |                     Alt+2 |     |                     Alt+2 |                          alt+2 |                     Alt+2 |                   alt+[Digit2] |         |
+|                Ctrl+Alt+Digit2 |   ²   |                Ctrl+Alt+2 |     |                Ctrl+Alt+2 |                     ctrl+alt+2 |                Ctrl+Alt+2 |              ctrl+alt+[Digit2] |         |
+|               Shift+Alt+Digit2 |   "   |               Shift+Alt+2 |     |               Shift+Alt+2 |                    shift+alt+2 |               Shift+Alt+2 |             shift+alt+[Digit2] |         |
+|                                |       |               Shift+Alt+' |   2 |                           |                                |                           |                                |         |
+|          Ctrl+Shift+Alt+Digit2 |   ⅛   |          Ctrl+Shift+Alt+2 |     |          Ctrl+Shift+Alt+2 |               ctrl+shift+alt+2 |          Ctrl+Shift+Alt+2 |        ctrl+shift+alt+[Digit2] |         |
+|                                |       |          Ctrl+Shift+Alt+' |   2 |                           |                                |                           |                                |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit3 |   3   |                         3 |     |                         3 |                              3 |                         3 |                       [Digit3] |         |
+|                    Ctrl+Digit3 |   3   |                    Ctrl+3 |     |                    Ctrl+3 |                         ctrl+3 |                    Ctrl+3 |                  ctrl+[Digit3] |         |
+|                   Shift+Digit3 |   £   |                   Shift+3 |     |                   Shift+3 |                        shift+3 |                   Shift+3 |                 shift+[Digit3] |         |
+|              Ctrl+Shift+Digit3 |   £   |              Ctrl+Shift+3 |     |              Ctrl+Shift+3 |                   ctrl+shift+3 |              Ctrl+Shift+3 |            ctrl+shift+[Digit3] |         |
+|                     Alt+Digit3 |   3   |                     Alt+3 |     |                     Alt+3 |                          alt+3 |                     Alt+3 |                   alt+[Digit3] |         |
+|                Ctrl+Alt+Digit3 |   ³   |                Ctrl+Alt+3 |     |                Ctrl+Alt+3 |                     ctrl+alt+3 |                Ctrl+Alt+3 |              ctrl+alt+[Digit3] |         |
+|               Shift+Alt+Digit3 |   £   |               Shift+Alt+3 |     |               Shift+Alt+3 |                    shift+alt+3 |               Shift+Alt+3 |             shift+alt+[Digit3] |         |
+|          Ctrl+Shift+Alt+Digit3 |   £   |          Ctrl+Shift+Alt+3 |     |          Ctrl+Shift+Alt+3 |               ctrl+shift+alt+3 |          Ctrl+Shift+Alt+3 |        ctrl+shift+alt+[Digit3] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit4 |   4   |                         4 |     |                         4 |                              4 |                         4 |                       [Digit4] |         |
+|                    Ctrl+Digit4 |   4   |                    Ctrl+4 |     |                    Ctrl+4 |                         ctrl+4 |                    Ctrl+4 |                  ctrl+[Digit4] |         |
+|                   Shift+Digit4 |   $   |                   Shift+4 |     |                   Shift+4 |                        shift+4 |                   Shift+4 |                 shift+[Digit4] |         |
+|              Ctrl+Shift+Digit4 |   $   |              Ctrl+Shift+4 |     |              Ctrl+Shift+4 |                   ctrl+shift+4 |              Ctrl+Shift+4 |            ctrl+shift+[Digit4] |         |
+|                     Alt+Digit4 |   4   |                     Alt+4 |     |                     Alt+4 |                          alt+4 |                     Alt+4 |                   alt+[Digit4] |         |
+|                Ctrl+Alt+Digit4 |   €   |                Ctrl+Alt+4 |     |                Ctrl+Alt+4 |                     ctrl+alt+4 |                Ctrl+Alt+4 |              ctrl+alt+[Digit4] |         |
+|               Shift+Alt+Digit4 |   $   |               Shift+Alt+4 |     |               Shift+Alt+4 |                    shift+alt+4 |               Shift+Alt+4 |             shift+alt+[Digit4] |         |
+|          Ctrl+Shift+Alt+Digit4 |   ¼   |          Ctrl+Shift+Alt+4 |     |          Ctrl+Shift+Alt+4 |               ctrl+shift+alt+4 |          Ctrl+Shift+Alt+4 |        ctrl+shift+alt+[Digit4] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit5 |   5   |                         5 |     |                         5 |                              5 |                         5 |                       [Digit5] |         |
+|                    Ctrl+Digit5 |   5   |                    Ctrl+5 |     |                    Ctrl+5 |                         ctrl+5 |                    Ctrl+5 |                  ctrl+[Digit5] |         |
+|                   Shift+Digit5 |   %   |                   Shift+5 |     |                   Shift+5 |                        shift+5 |                   Shift+5 |                 shift+[Digit5] |         |
+|              Ctrl+Shift+Digit5 |   %   |              Ctrl+Shift+5 |     |              Ctrl+Shift+5 |                   ctrl+shift+5 |              Ctrl+Shift+5 |            ctrl+shift+[Digit5] |         |
+|                     Alt+Digit5 |   5   |                     Alt+5 |     |                     Alt+5 |                          alt+5 |                     Alt+5 |                   alt+[Digit5] |         |
+|                Ctrl+Alt+Digit5 |   ½   |                Ctrl+Alt+5 |     |                Ctrl+Alt+5 |                     ctrl+alt+5 |                Ctrl+Alt+5 |              ctrl+alt+[Digit5] |         |
+|               Shift+Alt+Digit5 |   %   |               Shift+Alt+5 |     |               Shift+Alt+5 |                    shift+alt+5 |               Shift+Alt+5 |             shift+alt+[Digit5] |         |
+|          Ctrl+Shift+Alt+Digit5 |   ⅜   |          Ctrl+Shift+Alt+5 |     |          Ctrl+Shift+Alt+5 |               ctrl+shift+alt+5 |          Ctrl+Shift+Alt+5 |        ctrl+shift+alt+[Digit5] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit6 |   6   |                         6 |     |                         6 |                              6 |                         6 |                       [Digit6] |         |
+|                    Ctrl+Digit6 |   6   |                    Ctrl+6 |     |                    Ctrl+6 |                         ctrl+6 |                    Ctrl+6 |                  ctrl+[Digit6] |         |
+|                   Shift+Digit6 |   ^   |                   Shift+6 |     |                   Shift+6 |                        shift+6 |                   Shift+6 |                 shift+[Digit6] |         |
+|              Ctrl+Shift+Digit6 |   ^   |              Ctrl+Shift+6 |     |              Ctrl+Shift+6 |                   ctrl+shift+6 |              Ctrl+Shift+6 |            ctrl+shift+[Digit6] |         |
+|                     Alt+Digit6 |   6   |                     Alt+6 |     |                     Alt+6 |                          alt+6 |                     Alt+6 |                   alt+[Digit6] |         |
+|                Ctrl+Alt+Digit6 |   ¾   |                Ctrl+Alt+6 |     |                Ctrl+Alt+6 |                     ctrl+alt+6 |                Ctrl+Alt+6 |              ctrl+alt+[Digit6] |         |
+|               Shift+Alt+Digit6 |   ^   |               Shift+Alt+6 |     |               Shift+Alt+6 |                    shift+alt+6 |               Shift+Alt+6 |             shift+alt+[Digit6] |         |
+|          Ctrl+Shift+Alt+Digit6 |   ⅝   |          Ctrl+Shift+Alt+6 |     |          Ctrl+Shift+Alt+6 |               ctrl+shift+alt+6 |          Ctrl+Shift+Alt+6 |        ctrl+shift+alt+[Digit6] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit7 |   7   |                         7 |     |                         7 |                              7 |                         7 |                       [Digit7] |         |
+|                    Ctrl+Digit7 |   7   |                    Ctrl+7 |     |                    Ctrl+7 |                         ctrl+7 |                    Ctrl+7 |                  ctrl+[Digit7] |         |
+|                   Shift+Digit7 |   &   |                   Shift+7 |     |                   Shift+7 |                        shift+7 |                   Shift+7 |                 shift+[Digit7] |         |
+|              Ctrl+Shift+Digit7 |   &   |              Ctrl+Shift+7 |     |              Ctrl+Shift+7 |                   ctrl+shift+7 |              Ctrl+Shift+7 |            ctrl+shift+[Digit7] |         |
+|                     Alt+Digit7 |   7   |                     Alt+7 |     |                     Alt+7 |                          alt+7 |                     Alt+7 |                   alt+[Digit7] |         |
+|                Ctrl+Alt+Digit7 |   {   |                Ctrl+Alt+7 |     |                Ctrl+Alt+7 |                     ctrl+alt+7 |                Ctrl+Alt+7 |              ctrl+alt+[Digit7] |         |
+|                                |       |                   Shift+[ |   2 |                           |                                |                           |                                |         |
+|               Shift+Alt+Digit7 |   &   |               Shift+Alt+7 |     |               Shift+Alt+7 |                    shift+alt+7 |               Shift+Alt+7 |             shift+alt+[Digit7] |         |
+|          Ctrl+Shift+Alt+Digit7 |   ⅞   |          Ctrl+Shift+Alt+7 |     |          Ctrl+Shift+Alt+7 |               ctrl+shift+alt+7 |          Ctrl+Shift+Alt+7 |        ctrl+shift+alt+[Digit7] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit8 |   8   |                         8 |     |                         8 |                              8 |                         8 |                       [Digit8] |         |
+|                    Ctrl+Digit8 |   8   |                    Ctrl+8 |     |                    Ctrl+8 |                         ctrl+8 |                    Ctrl+8 |                  ctrl+[Digit8] |         |
+|                   Shift+Digit8 |   *   |                   Shift+8 |     |                   Shift+8 |                        shift+8 |                   Shift+8 |                 shift+[Digit8] |         |
+|              Ctrl+Shift+Digit8 |   *   |              Ctrl+Shift+8 |     |              Ctrl+Shift+8 |                   ctrl+shift+8 |              Ctrl+Shift+8 |            ctrl+shift+[Digit8] |         |
+|                     Alt+Digit8 |   8   |                     Alt+8 |     |                     Alt+8 |                          alt+8 |                     Alt+8 |                   alt+[Digit8] |         |
+|                Ctrl+Alt+Digit8 |   [   |                Ctrl+Alt+8 |     |                Ctrl+Alt+8 |                     ctrl+alt+8 |                Ctrl+Alt+8 |              ctrl+alt+[Digit8] |         |
+|                                |       |                         [ |   2 |                           |                                |                           |                                |         |
+|               Shift+Alt+Digit8 |   *   |               Shift+Alt+8 |     |               Shift+Alt+8 |                    shift+alt+8 |               Shift+Alt+8 |             shift+alt+[Digit8] |         |
+|          Ctrl+Shift+Alt+Digit8 |   ™   |          Ctrl+Shift+Alt+8 |     |          Ctrl+Shift+Alt+8 |               ctrl+shift+alt+8 |          Ctrl+Shift+Alt+8 |        ctrl+shift+alt+[Digit8] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit9 |   9   |                         9 |     |                         9 |                              9 |                         9 |                       [Digit9] |         |
+|                    Ctrl+Digit9 |   9   |                    Ctrl+9 |     |                    Ctrl+9 |                         ctrl+9 |                    Ctrl+9 |                  ctrl+[Digit9] |         |
+|                   Shift+Digit9 |   (   |                   Shift+9 |     |                   Shift+9 |                        shift+9 |                   Shift+9 |                 shift+[Digit9] |         |
+|              Ctrl+Shift+Digit9 |   (   |              Ctrl+Shift+9 |     |              Ctrl+Shift+9 |                   ctrl+shift+9 |              Ctrl+Shift+9 |            ctrl+shift+[Digit9] |         |
+|                     Alt+Digit9 |   9   |                     Alt+9 |     |                     Alt+9 |                          alt+9 |                     Alt+9 |                   alt+[Digit9] |         |
+|                Ctrl+Alt+Digit9 |   ]   |                Ctrl+Alt+9 |     |                Ctrl+Alt+9 |                     ctrl+alt+9 |                Ctrl+Alt+9 |              ctrl+alt+[Digit9] |         |
+|                                |       |                         ] |   2 |                           |                                |                           |                                |         |
+|               Shift+Alt+Digit9 |   (   |               Shift+Alt+9 |     |               Shift+Alt+9 |                    shift+alt+9 |               Shift+Alt+9 |             shift+alt+[Digit9] |         |
+|          Ctrl+Shift+Alt+Digit9 |   ±   |          Ctrl+Shift+Alt+9 |     |          Ctrl+Shift+Alt+9 |               ctrl+shift+alt+9 |          Ctrl+Shift+Alt+9 |        ctrl+shift+alt+[Digit9] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit0 |   0   |                         0 |     |                         0 |                              0 |                         0 |                       [Digit0] |         |
+|                    Ctrl+Digit0 |   0   |                    Ctrl+0 |     |                    Ctrl+0 |                         ctrl+0 |                    Ctrl+0 |                  ctrl+[Digit0] |         |
+|                   Shift+Digit0 |   )   |                   Shift+0 |     |                   Shift+0 |                        shift+0 |                   Shift+0 |                 shift+[Digit0] |         |
+|              Ctrl+Shift+Digit0 |   )   |              Ctrl+Shift+0 |     |              Ctrl+Shift+0 |                   ctrl+shift+0 |              Ctrl+Shift+0 |            ctrl+shift+[Digit0] |         |
+|                     Alt+Digit0 |   0   |                     Alt+0 |     |                     Alt+0 |                          alt+0 |                     Alt+0 |                   alt+[Digit0] |         |
+|                Ctrl+Alt+Digit0 |   }   |                Ctrl+Alt+0 |     |                Ctrl+Alt+0 |                     ctrl+alt+0 |                Ctrl+Alt+0 |              ctrl+alt+[Digit0] |         |
+|                                |       |                   Shift+] |   2 |                           |                                |                           |                                |         |
+|               Shift+Alt+Digit0 |   )   |               Shift+Alt+0 |     |               Shift+Alt+0 |                    shift+alt+0 |               Shift+Alt+0 |             shift+alt+[Digit0] |         |
+|          Ctrl+Shift+Alt+Digit0 |   °   |          Ctrl+Shift+Alt+0 |     |          Ctrl+Shift+Alt+0 |               ctrl+shift+alt+0 |          Ctrl+Shift+Alt+0 |        ctrl+shift+alt+[Digit0] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Minus |   -   |                         - |     |                         - |                              - |                      null |                        [Minus] |         |
+|                     Ctrl+Minus |   -   |                    Ctrl+- |     |                    Ctrl+- |                         ctrl+- |                      null |                   ctrl+[Minus] |         |
+|                    Shift+Minus |   _   |                   Shift+- |     |                   Shift+- |                        shift+- |                      null |                  shift+[Minus] |         |
+|               Ctrl+Shift+Minus |   _   |              Ctrl+Shift+- |     |              Ctrl+Shift+- |                   ctrl+shift+- |                      null |             ctrl+shift+[Minus] |         |
+|                      Alt+Minus |   -   |                     Alt+- |     |                     Alt+- |                          alt+- |                      null |                    alt+[Minus] |         |
+|                 Ctrl+Alt+Minus |   \   |                         \ |   1 |                Ctrl+Alt+- |               ctrl+alt+[Minus] |                      null |               ctrl+alt+[Minus] |    NO   |
+|                Shift+Alt+Minus |   _   |               Shift+Alt+- |     |               Shift+Alt+- |                    shift+alt+- |                      null |              shift+alt+[Minus] |         |
+|           Ctrl+Shift+Alt+Minus |   ¿   |          Ctrl+Shift+Alt+- |     |          Ctrl+Shift+Alt+- |               ctrl+shift+alt+- |                      null |         ctrl+shift+alt+[Minus] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Equal |   =   |                         = |     |                         = |                              = |                      null |                        [Equal] |         |
+|                     Ctrl+Equal |   =   |                    Ctrl+= |     |                    Ctrl+= |                         ctrl+= |                      null |                   ctrl+[Equal] |         |
+|                    Shift+Equal |   +   |                   Shift+= |     |                   Shift+= |                        shift+= |                      null |                  shift+[Equal] |         |
+|               Ctrl+Shift+Equal |   +   |              Ctrl+Shift+= |     |              Ctrl+Shift+= |                   ctrl+shift+= |                      null |             ctrl+shift+[Equal] |         |
+|                      Alt+Equal |   =   |                     Alt+= |     |                     Alt+= |                          alt+= |                      null |                    alt+[Equal] |         |
+|                 Ctrl+Alt+Equal | U+327 |                Ctrl+Alt+= |     |                Ctrl+Alt+= |                     ctrl+alt+= |                      null |               ctrl+alt+[Equal] |         |
+|                Shift+Alt+Equal |   +   |               Shift+Alt+= |     |               Shift+Alt+= |                    shift+alt+= |                      null |              shift+alt+[Equal] |         |
+|           Ctrl+Shift+Alt+Equal | U+328 |          Ctrl+Shift+Alt+= |     |          Ctrl+Shift+Alt+= |               ctrl+shift+alt+= |                      null |         ctrl+shift+alt+[Equal] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                    BracketLeft |   [   |                         [ |   1 |                         [ |                              [ |                      null |                  [BracketLeft] |         |
+|               Ctrl+BracketLeft |   [   |                    Ctrl+[ |     |                    Ctrl+[ |                         ctrl+[ |                      null |             ctrl+[BracketLeft] |         |
+|              Shift+BracketLeft |   {   |                   Shift+[ |   1 |                   Shift+[ |                        shift+[ |                      null |            shift+[BracketLeft] |         |
+|         Ctrl+Shift+BracketLeft |   {   |              Ctrl+Shift+[ |     |              Ctrl+Shift+[ |                   ctrl+shift+[ |                      null |       ctrl+shift+[BracketLeft] |         |
+|                Alt+BracketLeft |   [   |                     Alt+[ |     |                     Alt+[ |                          alt+[ |                      null |              alt+[BracketLeft] |         |
+|           Ctrl+Alt+BracketLeft |   ¨   |                Ctrl+Alt+[ |     |                Ctrl+Alt+[ |                     ctrl+alt+[ |                      null |         ctrl+alt+[BracketLeft] |         |
+|          Shift+Alt+BracketLeft |   {   |               Shift+Alt+[ |     |               Shift+Alt+[ |                    shift+alt+[ |                      null |        shift+alt+[BracketLeft] |         |
+|     Ctrl+Shift+Alt+BracketLeft |   ˚   |          Ctrl+Shift+Alt+[ |     |          Ctrl+Shift+Alt+[ |               ctrl+shift+alt+[ |                      null |   ctrl+shift+alt+[BracketLeft] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                   BracketRight |   ]   |                         ] |   1 |                         ] |                              ] |                      null |                 [BracketRight] |         |
+|              Ctrl+BracketRight |   ]   |                    Ctrl+] |     |                    Ctrl+] |                         ctrl+] |                      null |            ctrl+[BracketRight] |         |
+|             Shift+BracketRight |   }   |                   Shift+] |   1 |                   Shift+] |                        shift+] |                      null |           shift+[BracketRight] |         |
+|        Ctrl+Shift+BracketRight |   }   |              Ctrl+Shift+] |     |              Ctrl+Shift+] |                   ctrl+shift+] |                      null |      ctrl+shift+[BracketRight] |         |
+|               Alt+BracketRight |   ]   |                     Alt+] |     |                     Alt+] |                          alt+] |                      null |             alt+[BracketRight] |         |
+|          Ctrl+Alt+BracketRight |   ˜   |                Ctrl+Alt+] |     |                Ctrl+Alt+] |                     ctrl+alt+] |                      null |        ctrl+alt+[BracketRight] |         |
+|         Shift+Alt+BracketRight |   }   |               Shift+Alt+] |     |               Shift+Alt+] |                    shift+alt+] |                      null |       shift+alt+[BracketRight] |         |
+|    Ctrl+Shift+Alt+BracketRight |   ¯   |          Ctrl+Shift+Alt+] |     |          Ctrl+Shift+Alt+] |               ctrl+shift+alt+] |                      null |  ctrl+shift+alt+[BracketRight] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                      Backslash |   #   |                           |     |                         # |                    [Backslash] |                      null |                    [Backslash] |    NO   |
+|                 Ctrl+Backslash |   #   |                           |     |                    Ctrl+# |               ctrl+[Backslash] |                      null |               ctrl+[Backslash] |    NO   |
+|                Shift+Backslash |   ~   |                   Shift+` |   2 |                   Shift+# |              shift+[Backslash] |                      null |              shift+[Backslash] |    NO   |
+|           Ctrl+Shift+Backslash |   ~   |              Ctrl+Shift+` |   2 |              Ctrl+Shift+# |         ctrl+shift+[Backslash] |                      null |         ctrl+shift+[Backslash] |    NO   |
+|                  Alt+Backslash |   #   |                           |     |                     Alt+# |                alt+[Backslash] |                      null |                alt+[Backslash] |    NO   |
+|             Ctrl+Alt+Backslash |   `   |                         ` |   2 |                Ctrl+Alt+# |           ctrl+alt+[Backslash] |                      null |           ctrl+alt+[Backslash] |    NO   |
+|            Shift+Alt+Backslash |   ~   |               Shift+Alt+` |   2 |               Shift+Alt+# |          shift+alt+[Backslash] |                      null |          shift+alt+[Backslash] |    NO   |
+|       Ctrl+Shift+Alt+Backslash |   ˘   |          Ctrl+Shift+Alt+` |   2 |          Ctrl+Shift+Alt+# |     ctrl+shift+alt+[Backslash] |                      null |     ctrl+shift+alt+[Backslash] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                       IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|                  Ctrl+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|                 Shift+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|            Ctrl+Shift+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|                   Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|              Ctrl+Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|             Shift+Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|        Ctrl+Shift+Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                      Semicolon |   ;   |                         ; |     |                         ; |                              ; |                      null |                    [Semicolon] |         |
+|                 Ctrl+Semicolon |   ;   |                    Ctrl+; |     |                    Ctrl+; |                         ctrl+; |                      null |               ctrl+[Semicolon] |         |
+|                Shift+Semicolon |   :   |                   Shift+; |     |                   Shift+; |                        shift+; |                      null |              shift+[Semicolon] |         |
+|           Ctrl+Shift+Semicolon |   :   |              Ctrl+Shift+; |     |              Ctrl+Shift+; |                   ctrl+shift+; |                      null |         ctrl+shift+[Semicolon] |         |
+|                  Alt+Semicolon |   ;   |                     Alt+; |     |                     Alt+; |                          alt+; |                      null |                alt+[Semicolon] |         |
+|             Ctrl+Alt+Semicolon |   ´   |                Ctrl+Alt+; |     |                Ctrl+Alt+; |                     ctrl+alt+; |                      null |           ctrl+alt+[Semicolon] |         |
+|            Shift+Alt+Semicolon |   :   |               Shift+Alt+; |     |               Shift+Alt+; |                    shift+alt+; |                      null |          shift+alt+[Semicolon] |         |
+|       Ctrl+Shift+Alt+Semicolon |   ˝   |          Ctrl+Shift+Alt+; |     |          Ctrl+Shift+Alt+; |               ctrl+shift+alt+; |                      null |     ctrl+shift+alt+[Semicolon] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Quote |   '   |                         ' |     |                         ' |                              ' |                         ' |                        [Quote] |         |
+|                     Ctrl+Quote |   '   |                    Ctrl+' |     |                    Ctrl+' |                         ctrl+' |                    Ctrl+' |                   ctrl+[Quote] |         |
+|                    Shift+Quote |   @   |                   Shift+' |   1 |                   Shift+' |                        shift+' |                   Shift+' |                  shift+[Quote] |         |
+|               Ctrl+Shift+Quote |   @   |              Ctrl+Shift+' |   1 |              Ctrl+Shift+' |                   ctrl+shift+' |              Ctrl+Shift+' |             ctrl+shift+[Quote] |         |
+|                      Alt+Quote |   '   |                     Alt+' |     |                     Alt+' |                          alt+' |                     Alt+' |                    alt+[Quote] |         |
+|                 Ctrl+Alt+Quote |   ^   |                Ctrl+Alt+' |     |                Ctrl+Alt+' |                     ctrl+alt+' |                Ctrl+Alt+' |               ctrl+alt+[Quote] |         |
+|                Shift+Alt+Quote |   @   |               Shift+Alt+' |   1 |               Shift+Alt+' |                    shift+alt+' |               Shift+Alt+' |              shift+alt+[Quote] |         |
+|           Ctrl+Shift+Alt+Quote | U+30c |          Ctrl+Shift+Alt+' |   1 |          Ctrl+Shift+Alt+' |               ctrl+shift+alt+' |          Ctrl+Shift+Alt+' |         ctrl+shift+alt+[Quote] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                      Backquote |   `   |                         ` |   1 |                         ` |                              ` |                      null |                    [Backquote] |         |
+|                 Ctrl+Backquote |   `   |                    Ctrl+` |     |                    Ctrl+` |                         ctrl+` |                      null |               ctrl+[Backquote] |         |
+|                Shift+Backquote |   ¬   |                   Shift+` |   1 |                   Shift+` |                        shift+` |                      null |              shift+[Backquote] |         |
+|           Ctrl+Shift+Backquote |   ¬   |              Ctrl+Shift+` |   1 |              Ctrl+Shift+` |                   ctrl+shift+` |                      null |         ctrl+shift+[Backquote] |         |
+|                  Alt+Backquote |   `   |                     Alt+` |     |                     Alt+` |                          alt+` |                      null |                alt+[Backquote] |         |
+|             Ctrl+Alt+Backquote |   |   |                   Shift+\ |   1 |                Ctrl+Alt+` |           ctrl+alt+[Backquote] |                      null |           ctrl+alt+[Backquote] |    NO   |
+|            Shift+Alt+Backquote |   ¬   |               Shift+Alt+` |   1 |               Shift+Alt+` |                    shift+alt+` |                      null |          shift+alt+[Backquote] |         |
+|       Ctrl+Shift+Alt+Backquote |   |   |          Ctrl+Shift+Alt+` |   1 |          Ctrl+Shift+Alt+` |               ctrl+shift+alt+` |                      null |     ctrl+shift+alt+[Backquote] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Comma |   ,   |                         , |     |                         , |                              , |                      null |                        [Comma] |         |
+|                     Ctrl+Comma |   ,   |                    Ctrl+, |     |                    Ctrl+, |                         ctrl+, |                      null |                   ctrl+[Comma] |         |
+|                    Shift+Comma |   <   |                   Shift+, |   1 |                   Shift+, |                        shift+, |                      null |                  shift+[Comma] |         |
+|               Ctrl+Shift+Comma |   <   |              Ctrl+Shift+, |     |              Ctrl+Shift+, |                   ctrl+shift+, |                      null |             ctrl+shift+[Comma] |         |
+|                      Alt+Comma |   ,   |                     Alt+, |     |                     Alt+, |                          alt+, |                      null |                    alt+[Comma] |         |
+|                 Ctrl+Alt+Comma |   ─   |                Ctrl+Alt+, |     |                Ctrl+Alt+, |                     ctrl+alt+, |                      null |               ctrl+alt+[Comma] |         |
+|                Shift+Alt+Comma |   <   |               Shift+Alt+, |     |               Shift+Alt+, |                    shift+alt+, |                      null |              shift+alt+[Comma] |         |
+|           Ctrl+Shift+Alt+Comma |   ×   |          Ctrl+Shift+Alt+, |     |          Ctrl+Shift+Alt+, |               ctrl+shift+alt+, |                      null |         ctrl+shift+alt+[Comma] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Period |   .   |                         . |     |                         . |                              . |                      null |                       [Period] |         |
+|                    Ctrl+Period |   .   |                    Ctrl+. |     |                    Ctrl+. |                         ctrl+. |                      null |                  ctrl+[Period] |         |
+|                   Shift+Period |   >   |                   Shift+. |   1 |                   Shift+. |                        shift+. |                      null |                 shift+[Period] |         |
+|              Ctrl+Shift+Period |   >   |              Ctrl+Shift+. |     |              Ctrl+Shift+. |                   ctrl+shift+. |                      null |            ctrl+shift+[Period] |         |
+|                     Alt+Period |   .   |                     Alt+. |     |                     Alt+. |                          alt+. |                      null |                   alt+[Period] |         |
+|                Ctrl+Alt+Period |   ·   |                Ctrl+Alt+. |     |                Ctrl+Alt+. |                     ctrl+alt+. |                      null |              ctrl+alt+[Period] |         |
+|               Shift+Alt+Period |   >   |               Shift+Alt+. |     |               Shift+Alt+. |                    shift+alt+. |                      null |             shift+alt+[Period] |         |
+|          Ctrl+Shift+Alt+Period |   ÷   |          Ctrl+Shift+Alt+. |     |          Ctrl+Shift+Alt+. |               ctrl+shift+alt+. |                      null |        ctrl+shift+alt+[Period] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Slash |   /   |                         / |     |                         / |                              / |                      null |                        [Slash] |         |
+|                     Ctrl+Slash |   /   |                    Ctrl+/ |     |                    Ctrl+/ |                         ctrl+/ |                      null |                   ctrl+[Slash] |         |
+|                    Shift+Slash |   ?   |                   Shift+/ |     |                   Shift+/ |                        shift+/ |                      null |                  shift+[Slash] |         |
+|               Ctrl+Shift+Slash |   ?   |              Ctrl+Shift+/ |     |              Ctrl+Shift+/ |                   ctrl+shift+/ |                      null |             ctrl+shift+[Slash] |         |
+|                      Alt+Slash |   /   |                     Alt+/ |     |                     Alt+/ |                          alt+/ |                      null |                    alt+[Slash] |         |
+|                 Ctrl+Alt+Slash | U+323 |                Ctrl+Alt+/ |     |                Ctrl+Alt+/ |                     ctrl+alt+/ |                      null |               ctrl+alt+[Slash] |         |
+|                Shift+Alt+Slash |   ?   |               Shift+Alt+/ |     |               Shift+Alt+/ |                    shift+alt+/ |                      null |              shift+alt+[Slash] |         |
+|           Ctrl+Shift+Alt+Slash |   ˙   |          Ctrl+Shift+Alt+/ |     |          Ctrl+Shift+Alt+/ |               ctrl+shift+alt+/ |                      null |         ctrl+shift+alt+[Slash] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                        ArrowUp |  ---  |                   UpArrow |     |                   UpArrow |                             up |                        Up |                      [ArrowUp] |         |
+|                   Ctrl+ArrowUp |  ---  |              Ctrl+UpArrow |     |              Ctrl+UpArrow |                        ctrl+up |                   Ctrl+Up |                 ctrl+[ArrowUp] |         |
+|                  Shift+ArrowUp |  ---  |             Shift+UpArrow |     |             Shift+UpArrow |                       shift+up |                  Shift+Up |                shift+[ArrowUp] |         |
+|             Ctrl+Shift+ArrowUp |  ---  |        Ctrl+Shift+UpArrow |     |        Ctrl+Shift+UpArrow |                  ctrl+shift+up |             Ctrl+Shift+Up |           ctrl+shift+[ArrowUp] |         |
+|                    Alt+ArrowUp |  ---  |               Alt+UpArrow |     |               Alt+UpArrow |                         alt+up |                    Alt+Up |                  alt+[ArrowUp] |         |
+|               Ctrl+Alt+ArrowUp |  ---  |          Ctrl+Alt+UpArrow |     |          Ctrl+Alt+UpArrow |                    ctrl+alt+up |               Ctrl+Alt+Up |             ctrl+alt+[ArrowUp] |         |
+|              Shift+Alt+ArrowUp |  ---  |         Shift+Alt+UpArrow |     |         Shift+Alt+UpArrow |                   shift+alt+up |              Shift+Alt+Up |            shift+alt+[ArrowUp] |         |
+|         Ctrl+Shift+Alt+ArrowUp |  ---  |    Ctrl+Shift+Alt+UpArrow |     |    Ctrl+Shift+Alt+UpArrow |              ctrl+shift+alt+up |         Ctrl+Shift+Alt+Up |       ctrl+shift+alt+[ArrowUp] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                        Numpad0 |  ---  |                   NumPad0 |     |                   NumPad0 |                        numpad0 |                      null |                      [Numpad0] |         |
+|                   Ctrl+Numpad0 |  ---  |              Ctrl+NumPad0 |     |              Ctrl+NumPad0 |                   ctrl+numpad0 |                      null |                 ctrl+[Numpad0] |         |
+|                  Shift+Numpad0 |  ---  |             Shift+NumPad0 |     |             Shift+NumPad0 |                  shift+numpad0 |                      null |                shift+[Numpad0] |         |
+|             Ctrl+Shift+Numpad0 |  ---  |        Ctrl+Shift+NumPad0 |     |        Ctrl+Shift+NumPad0 |             ctrl+shift+numpad0 |                      null |           ctrl+shift+[Numpad0] |         |
+|                    Alt+Numpad0 |  ---  |               Alt+NumPad0 |     |               Alt+NumPad0 |                    alt+numpad0 |                      null |                  alt+[Numpad0] |         |
+|               Ctrl+Alt+Numpad0 |  ---  |          Ctrl+Alt+NumPad0 |     |          Ctrl+Alt+NumPad0 |               ctrl+alt+numpad0 |                      null |             ctrl+alt+[Numpad0] |         |
+|              Shift+Alt+Numpad0 |  ---  |         Shift+Alt+NumPad0 |     |         Shift+Alt+NumPad0 |              shift+alt+numpad0 |                      null |            shift+alt+[Numpad0] |         |
+|         Ctrl+Shift+Alt+Numpad0 |  ---  |    Ctrl+Shift+Alt+NumPad0 |     |    Ctrl+Shift+Alt+NumPad0 |         ctrl+shift+alt+numpad0 |                      null |       ctrl+shift+alt+[Numpad0] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                  IntlBackslash |   \   |                         \ |   2 |                         \ |                              \ |                      null |                [IntlBackslash] |         |
+|             Ctrl+IntlBackslash |   \   |                    Ctrl+\ |     |                    Ctrl+\ |                         ctrl+\ |                      null |           ctrl+[IntlBackslash] |         |
+|            Shift+IntlBackslash |   |   |                   Shift+\ |   2 |                   Shift+\ |                        shift+\ |                      null |          shift+[IntlBackslash] |         |
+|       Ctrl+Shift+IntlBackslash |   |   |              Ctrl+Shift+\ |     |              Ctrl+Shift+\ |                   ctrl+shift+\ |                      null |     ctrl+shift+[IntlBackslash] |         |
+|              Alt+IntlBackslash |   \   |                     Alt+\ |     |                     Alt+\ |                          alt+\ |                      null |            alt+[IntlBackslash] |         |
+|         Ctrl+Alt+IntlBackslash |   |   |                Ctrl+Alt+\ |     |                Ctrl+Alt+\ |                     ctrl+alt+\ |                      null |       ctrl+alt+[IntlBackslash] |         |
+|        Shift+Alt+IntlBackslash |   |   |               Shift+Alt+\ |     |               Shift+Alt+\ |                    shift+alt+\ |                      null |      shift+alt+[IntlBackslash] |         |
+|   Ctrl+Shift+Alt+IntlBackslash |   ¦   |          Ctrl+Shift+Alt+\ |     |          Ctrl+Shift+Alt+\ |               ctrl+shift+alt+\ |                      null | ctrl+shift+alt+[IntlBackslash] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         IntlRo |  ---  |                           |     |                      null |                       [IntlRo] |                      null |                       [IntlRo] |    NO   |
+|                    Ctrl+IntlRo |  ---  |                           |     |                      null |                  ctrl+[IntlRo] |                      null |                  ctrl+[IntlRo] |    NO   |
+|                   Shift+IntlRo |  ---  |                           |     |                      null |                 shift+[IntlRo] |                      null |                 shift+[IntlRo] |    NO   |
+|              Ctrl+Shift+IntlRo |  ---  |                           |     |                      null |            ctrl+shift+[IntlRo] |                      null |            ctrl+shift+[IntlRo] |    NO   |
+|                     Alt+IntlRo |  ---  |                           |     |                      null |                   alt+[IntlRo] |                      null |                   alt+[IntlRo] |    NO   |
+|                Ctrl+Alt+IntlRo |  ---  |                           |     |                      null |              ctrl+alt+[IntlRo] |                      null |              ctrl+alt+[IntlRo] |    NO   |
+|               Shift+Alt+IntlRo |  ---  |                           |     |                      null |             shift+alt+[IntlRo] |                      null |             shift+alt+[IntlRo] |    NO   |
+|          Ctrl+Shift+Alt+IntlRo |  ---  |                           |     |                      null |        ctrl+shift+alt+[IntlRo] |                      null |        ctrl+shift+alt+[IntlRo] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                        IntlYen |  ---  |                           |     |                      null |                      [IntlYen] |                      null |                      [IntlYen] |    NO   |
+|                   Ctrl+IntlYen |  ---  |                           |     |                      null |                 ctrl+[IntlYen] |                      null |                 ctrl+[IntlYen] |    NO   |
+|                  Shift+IntlYen |  ---  |                           |     |                      null |                shift+[IntlYen] |                      null |                shift+[IntlYen] |    NO   |
+|             Ctrl+Shift+IntlYen |  ---  |                           |     |                      null |           ctrl+shift+[IntlYen] |                      null |           ctrl+shift+[IntlYen] |    NO   |
+|                    Alt+IntlYen |  ---  |                           |     |                      null |                  alt+[IntlYen] |                      null |                  alt+[IntlYen] |    NO   |
+|               Ctrl+Alt+IntlYen |  ---  |                           |     |                      null |             ctrl+alt+[IntlYen] |                      null |             ctrl+alt+[IntlYen] |    NO   |
+|              Shift+Alt+IntlYen |  ---  |                           |     |                      null |            shift+alt+[IntlYen] |                      null |            shift+alt+[IntlYen] |    NO   |
+|         Ctrl+Shift+Alt+IntlYen |  ---  |                           |     |                      null |       ctrl+shift+alt+[IntlYen] |                      null |       ctrl+shift+alt+[IntlYen] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

lib/vscode/src/vs/workbench/services/keybinding/test/electron-browser/linux_en_us.js

@@ -0,0 +1,497 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+define({
+	Sleep: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	WakeUp: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	KeyA: {
+		value: 'a',
+		withShift: 'A',
+		withAltGr: 'a',
+		withShiftAltGr: 'A'
+	},
+	KeyB: {
+		value: 'b',
+		withShift: 'B',
+		withAltGr: 'b',
+		withShiftAltGr: 'B'
+	},
+	KeyC: {
+		value: 'c',
+		withShift: 'C',
+		withAltGr: 'c',
+		withShiftAltGr: 'C'
+	},
+	KeyD: {
+		value: 'd',
+		withShift: 'D',
+		withAltGr: 'd',
+		withShiftAltGr: 'D'
+	},
+	KeyE: {
+		value: 'e',
+		withShift: 'E',
+		withAltGr: 'e',
+		withShiftAltGr: 'E'
+	},
+	KeyF: {
+		value: 'f',
+		withShift: 'F',
+		withAltGr: 'f',
+		withShiftAltGr: 'F'
+	},
+	KeyG: {
+		value: 'g',
+		withShift: 'G',
+		withAltGr: 'g',
+		withShiftAltGr: 'G'
+	},
+	KeyH: {
+		value: 'h',
+		withShift: 'H',
+		withAltGr: 'h',
+		withShiftAltGr: 'H'
+	},
+	KeyI: {
+		value: 'i',
+		withShift: 'I',
+		withAltGr: 'i',
+		withShiftAltGr: 'I'
+	},
+	KeyJ: {
+		value: 'j',
+		withShift: 'J',
+		withAltGr: 'j',
+		withShiftAltGr: 'J'
+	},
+	KeyK: {
+		value: 'k',
+		withShift: 'K',
+		withAltGr: 'k',
+		withShiftAltGr: 'K'
+	},
+	KeyL: {
+		value: 'l',
+		withShift: 'L',
+		withAltGr: 'l',
+		withShiftAltGr: 'L'
+	},
+	KeyM: {
+		value: 'm',
+		withShift: 'M',
+		withAltGr: 'm',
+		withShiftAltGr: 'M'
+	},
+	KeyN: {
+		value: 'n',
+		withShift: 'N',
+		withAltGr: 'n',
+		withShiftAltGr: 'N'
+	},
+	KeyO: {
+		value: 'o',
+		withShift: 'O',
+		withAltGr: 'o',
+		withShiftAltGr: 'O'
+	},
+	KeyP: {
+		value: 'p',
+		withShift: 'P',
+		withAltGr: 'p',
+		withShiftAltGr: 'P'
+	},
+	KeyQ: {
+		value: 'q',
+		withShift: 'Q',
+		withAltGr: 'q',
+		withShiftAltGr: 'Q'
+	},
+	KeyR: {
+		value: 'r',
+		withShift: 'R',
+		withAltGr: 'r',
+		withShiftAltGr: 'R'
+	},
+	KeyS: {
+		value: 's',
+		withShift: 'S',
+		withAltGr: 's',
+		withShiftAltGr: 'S'
+	},
+	KeyT: {
+		value: 't',
+		withShift: 'T',
+		withAltGr: 't',
+		withShiftAltGr: 'T'
+	},
+	KeyU: {
+		value: 'u',
+		withShift: 'U',
+		withAltGr: 'u',
+		withShiftAltGr: 'U'
+	},
+	KeyV: {
+		value: 'v',
+		withShift: 'V',
+		withAltGr: 'v',
+		withShiftAltGr: 'V'
+	},
+	KeyW: {
+		value: 'w',
+		withShift: 'W',
+		withAltGr: 'w',
+		withShiftAltGr: 'W'
+	},
+	KeyX: {
+		value: 'x',
+		withShift: 'X',
+		withAltGr: 'x',
+		withShiftAltGr: 'X'
+	},
+	KeyY: {
+		value: 'y',
+		withShift: 'Y',
+		withAltGr: 'y',
+		withShiftAltGr: 'Y'
+	},
+	KeyZ: {
+		value: 'z',
+		withShift: 'Z',
+		withAltGr: 'z',
+		withShiftAltGr: 'Z'
+	},
+	Digit1: {
+		value: '1',
+		withShift: '!',
+		withAltGr: '1',
+		withShiftAltGr: '!'
+	},
+	Digit2: {
+		value: '2',
+		withShift: '@',
+		withAltGr: '2',
+		withShiftAltGr: '@'
+	},
+	Digit3: {
+		value: '3',
+		withShift: '#',
+		withAltGr: '3',
+		withShiftAltGr: '#'
+	},
+	Digit4: {
+		value: '4',
+		withShift: '$',
+		withAltGr: '4',
+		withShiftAltGr: '$'
+	},
+	Digit5: {
+		value: '5',
+		withShift: '%',
+		withAltGr: '5',
+		withShiftAltGr: '%'
+	},
+	Digit6: {
+		value: '6',
+		withShift: '^',
+		withAltGr: '6',
+		withShiftAltGr: '^'
+	},
+	Digit7: {
+		value: '7',
+		withShift: '&',
+		withAltGr: '7',
+		withShiftAltGr: '&'
+	},
+	Digit8: {
+		value: '8',
+		withShift: '*',
+		withAltGr: '8',
+		withShiftAltGr: '*'
+	},
+	Digit9: {
+		value: '9',
+		withShift: '(',
+		withAltGr: '9',
+		withShiftAltGr: '('
+	},
+	Digit0: {
+		value: '0',
+		withShift: ')',
+		withAltGr: '0',
+		withShiftAltGr: ')'
+	},
+	Enter: {
+		value: '\r',
+		withShift: '\r',
+		withAltGr: '\r',
+		withShiftAltGr: '\r'
+	},
+	Escape: {
+		value: '\u001b',
+		withShift: '\u001b',
+		withAltGr: '\u001b',
+		withShiftAltGr: '\u001b'
+	},
+	Backspace: {
+		value: '\b',
+		withShift: '\b',
+		withAltGr: '\b',
+		withShiftAltGr: '\b'
+	},
+	Tab: {
+		value: '\t',
+		withShift: '',
+		withAltGr: '\t',
+		withShiftAltGr: ''
+	},
+	Space: {
+		value: ' ',
+		withShift: ' ',
+		withAltGr: ' ',
+		withShiftAltGr: ' '
+	},
+	Minus: {
+		value: '-',
+		withShift: '_',
+		withAltGr: '-',
+		withShiftAltGr: '_'
+	},
+	Equal: {
+		value: '=',
+		withShift: '+',
+		withAltGr: '=',
+		withShiftAltGr: '+'
+	},
+	BracketLeft: {
+		value: '[',
+		withShift: '{',
+		withAltGr: '[',
+		withShiftAltGr: '{'
+	},
+	BracketRight: {
+		value: ']',
+		withShift: '}',
+		withAltGr: ']',
+		withShiftAltGr: '}'
+	},
+	Backslash: {
+		value: '\\',
+		withShift: '|',
+		withAltGr: '\\',
+		withShiftAltGr: '|'
+	},
+	Semicolon: {
+		value: ';',
+		withShift: ':',
+		withAltGr: ';',
+		withShiftAltGr: ':'
+	},
+	Quote: {
+		value: '\'',
+		withShift: '"',
+		withAltGr: '\'',
+		withShiftAltGr: '"'
+	},
+	Backquote: {
+		value: '`',
+		withShift: '~',
+		withAltGr: '`',
+		withShiftAltGr: '~'
+	},
+	Comma: {
+		value: ',',
+		withShift: '<',
+		withAltGr: ',',
+		withShiftAltGr: '<'
+	},
+	Period: {
+		value: '.',
+		withShift: '>',
+		withAltGr: '.',
+		withShiftAltGr: '>'
+	},
+	Slash: {
+		value: '/',
+		withShift: '?',
+		withAltGr: '/',
+		withShiftAltGr: '?'
+	},
+	CapsLock: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F1: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F2: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F3: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F4: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F5: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F6: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F7: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F8: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F9: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F10: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F11: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F12: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	PrintScreen: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	ScrollLock: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Pause: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Insert: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Home: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	PageUp: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Delete: {
+		value: '',
+		withShift: '',
+		withAltGr: '',
+		withShiftAltGr: ''
+	},
+	End: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	PageDown: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	ArrowRight: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	ArrowLeft: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	ArrowDown: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	ArrowUp: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	NumLock: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	NumpadDivide: {
+		value: '/',
+		withShift: '/',
+		withAltGr: '/',
+		withShiftAltGr: '/'
+	},
+	NumpadMultiply: {
+		value: '*',
+		withShift: '*',
+		withAltGr: '*',
+		withShiftAltGr: '*'
+	},
+	NumpadSubtract: {
+		value: '-',
+		withShift: '-',
+		withAltGr: '-',
+		withShiftAltGr: '-'
+	},
+	NumpadAdd: {
+		value: '+',
+		withShift: '+',
+		withAltGr: '+',
+		withShiftAltGr: '+'
+	},
+	NumpadEnter: {
+		value: '\r',
+		withShift: '\r',
+		withAltGr: '\r',
+		withShiftAltGr: '\r'
+	},
+	Numpad1: { value: '', withShift: '1', withAltGr: '', withShiftAltGr: '1' },
+	Numpad2: { value: '', withShift: '2', withAltGr: '', withShiftAltGr: '2' },
+	Numpad3: { value: '', withShift: '3', withAltGr: '', withShiftAltGr: '3' },
+	Numpad4: { value: '', withShift: '4', withAltGr: '', withShiftAltGr: '4' },
+	Numpad5: { value: '', withShift: '5', withAltGr: '', withShiftAltGr: '5' },
+	Numpad6: { value: '', withShift: '6', withAltGr: '', withShiftAltGr: '6' },
+	Numpad7: { value: '', withShift: '7', withAltGr: '', withShiftAltGr: '7' },
+	Numpad8: { value: '', withShift: '8', withAltGr: '', withShiftAltGr: '8' },
+	Numpad9: { value: '', withShift: '9', withAltGr: '', withShiftAltGr: '9' },
+	Numpad0: { value: '', withShift: '0', withAltGr: '', withShiftAltGr: '0' },
+	NumpadDecimal: { value: '', withShift: '.', withAltGr: '', withShiftAltGr: '.' },
+	IntlBackslash: {
+		value: '<',
+		withShift: '>',
+		withAltGr: '|',
+		withShiftAltGr: '¦'
+	},
+	ContextMenu: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Power: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	NumpadEqual: {
+		value: '=',
+		withShift: '=',
+		withAltGr: '=',
+		withShiftAltGr: '='
+	},
+	F13: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F14: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F15: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F16: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F17: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F18: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F19: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F20: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F21: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F22: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F23: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	F24: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Open: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Help: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Select: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Again: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Undo: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Cut: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Copy: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Paste: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Find: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	AudioVolumeMute: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	AudioVolumeUp: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	AudioVolumeDown: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	NumpadComma: {
+		value: '.',
+		withShift: '.',
+		withAltGr: '.',
+		withShiftAltGr: '.'
+	},
+	IntlRo: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	KanaMode: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	IntlYen: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Convert: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	NonConvert: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Lang1: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Lang2: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Lang3: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Lang4: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Lang5: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	NumpadParenLeft: {
+		value: '(',
+		withShift: '(',
+		withAltGr: '(',
+		withShiftAltGr: '('
+	},
+	NumpadParenRight: {
+		value: ')',
+		withShift: ')',
+		withAltGr: ')',
+		withShiftAltGr: ')'
+	},
+	ControlLeft: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	ShiftLeft: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	AltLeft: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MetaLeft: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	ControlRight: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	ShiftRight: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	AltRight: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MetaRight: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	BrightnessUp: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	BrightnessDown: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MediaPlay: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MediaRecord: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MediaFastForward: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MediaRewind: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MediaTrackNext: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MediaTrackPrevious: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MediaStop: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	Eject: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MediaPlayPause: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MediaSelect: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	LaunchMail: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	LaunchApp2: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	LaunchApp1: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	SelectTask: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	LaunchScreenSaver: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	BrowserSearch: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	BrowserHome: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	BrowserBack: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	BrowserForward: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	BrowserStop: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	BrowserRefresh: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	BrowserFavorites: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MailReply: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MailForward: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' },
+	MailSend: { value: '', withShift: '', withAltGr: '', withShiftAltGr: '' }
+
+});

lib/vscode/src/vs/workbench/services/keybinding/test/electron-browser/linux_en_us.txt

@@ -0,0 +1,507 @@
+isUSStandard: true
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyA |   a   |                         A |     |                         A |                              a |                         A |                         [KeyA] |         |
+|                      Ctrl+KeyA |   a   |                    Ctrl+A |     |                    Ctrl+A |                         ctrl+a |                    Ctrl+A |                    ctrl+[KeyA] |         |
+|                     Shift+KeyA |   A   |                   Shift+A |     |                   Shift+A |                        shift+a |                   Shift+A |                   shift+[KeyA] |         |
+|                Ctrl+Shift+KeyA |   A   |              Ctrl+Shift+A |     |              Ctrl+Shift+A |                   ctrl+shift+a |              Ctrl+Shift+A |              ctrl+shift+[KeyA] |         |
+|                       Alt+KeyA |   a   |                     Alt+A |     |                     Alt+A |                          alt+a |                     Alt+A |                     alt+[KeyA] |         |
+|                  Ctrl+Alt+KeyA |   a   |                Ctrl+Alt+A |     |                Ctrl+Alt+A |                     ctrl+alt+a |                Ctrl+Alt+A |                ctrl+alt+[KeyA] |         |
+|                 Shift+Alt+KeyA |   A   |               Shift+Alt+A |     |               Shift+Alt+A |                    shift+alt+a |               Shift+Alt+A |               shift+alt+[KeyA] |         |
+|            Ctrl+Shift+Alt+KeyA |   A   |          Ctrl+Shift+Alt+A |     |          Ctrl+Shift+Alt+A |               ctrl+shift+alt+a |          Ctrl+Shift+Alt+A |          ctrl+shift+alt+[KeyA] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyB |   b   |                         B |     |                         B |                              b |                         B |                         [KeyB] |         |
+|                      Ctrl+KeyB |   b   |                    Ctrl+B |     |                    Ctrl+B |                         ctrl+b |                    Ctrl+B |                    ctrl+[KeyB] |         |
+|                     Shift+KeyB |   B   |                   Shift+B |     |                   Shift+B |                        shift+b |                   Shift+B |                   shift+[KeyB] |         |
+|                Ctrl+Shift+KeyB |   B   |              Ctrl+Shift+B |     |              Ctrl+Shift+B |                   ctrl+shift+b |              Ctrl+Shift+B |              ctrl+shift+[KeyB] |         |
+|                       Alt+KeyB |   b   |                     Alt+B |     |                     Alt+B |                          alt+b |                     Alt+B |                     alt+[KeyB] |         |
+|                  Ctrl+Alt+KeyB |   b   |                Ctrl+Alt+B |     |                Ctrl+Alt+B |                     ctrl+alt+b |                Ctrl+Alt+B |                ctrl+alt+[KeyB] |         |
+|                 Shift+Alt+KeyB |   B   |               Shift+Alt+B |     |               Shift+Alt+B |                    shift+alt+b |               Shift+Alt+B |               shift+alt+[KeyB] |         |
+|            Ctrl+Shift+Alt+KeyB |   B   |          Ctrl+Shift+Alt+B |     |          Ctrl+Shift+Alt+B |               ctrl+shift+alt+b |          Ctrl+Shift+Alt+B |          ctrl+shift+alt+[KeyB] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyC |   c   |                         C |     |                         C |                              c |                         C |                         [KeyC] |         |
+|                      Ctrl+KeyC |   c   |                    Ctrl+C |     |                    Ctrl+C |                         ctrl+c |                    Ctrl+C |                    ctrl+[KeyC] |         |
+|                     Shift+KeyC |   C   |                   Shift+C |     |                   Shift+C |                        shift+c |                   Shift+C |                   shift+[KeyC] |         |
+|                Ctrl+Shift+KeyC |   C   |              Ctrl+Shift+C |     |              Ctrl+Shift+C |                   ctrl+shift+c |              Ctrl+Shift+C |              ctrl+shift+[KeyC] |         |
+|                       Alt+KeyC |   c   |                     Alt+C |     |                     Alt+C |                          alt+c |                     Alt+C |                     alt+[KeyC] |         |
+|                  Ctrl+Alt+KeyC |   c   |                Ctrl+Alt+C |     |                Ctrl+Alt+C |                     ctrl+alt+c |                Ctrl+Alt+C |                ctrl+alt+[KeyC] |         |
+|                 Shift+Alt+KeyC |   C   |               Shift+Alt+C |     |               Shift+Alt+C |                    shift+alt+c |               Shift+Alt+C |               shift+alt+[KeyC] |         |
+|            Ctrl+Shift+Alt+KeyC |   C   |          Ctrl+Shift+Alt+C |     |          Ctrl+Shift+Alt+C |               ctrl+shift+alt+c |          Ctrl+Shift+Alt+C |          ctrl+shift+alt+[KeyC] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyD |   d   |                         D |     |                         D |                              d |                         D |                         [KeyD] |         |
+|                      Ctrl+KeyD |   d   |                    Ctrl+D |     |                    Ctrl+D |                         ctrl+d |                    Ctrl+D |                    ctrl+[KeyD] |         |
+|                     Shift+KeyD |   D   |                   Shift+D |     |                   Shift+D |                        shift+d |                   Shift+D |                   shift+[KeyD] |         |
+|                Ctrl+Shift+KeyD |   D   |              Ctrl+Shift+D |     |              Ctrl+Shift+D |                   ctrl+shift+d |              Ctrl+Shift+D |              ctrl+shift+[KeyD] |         |
+|                       Alt+KeyD |   d   |                     Alt+D |     |                     Alt+D |                          alt+d |                     Alt+D |                     alt+[KeyD] |         |
+|                  Ctrl+Alt+KeyD |   d   |                Ctrl+Alt+D |     |                Ctrl+Alt+D |                     ctrl+alt+d |                Ctrl+Alt+D |                ctrl+alt+[KeyD] |         |
+|                 Shift+Alt+KeyD |   D   |               Shift+Alt+D |     |               Shift+Alt+D |                    shift+alt+d |               Shift+Alt+D |               shift+alt+[KeyD] |         |
+|            Ctrl+Shift+Alt+KeyD |   D   |          Ctrl+Shift+Alt+D |     |          Ctrl+Shift+Alt+D |               ctrl+shift+alt+d |          Ctrl+Shift+Alt+D |          ctrl+shift+alt+[KeyD] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyE |   e   |                         E |     |                         E |                              e |                         E |                         [KeyE] |         |
+|                      Ctrl+KeyE |   e   |                    Ctrl+E |     |                    Ctrl+E |                         ctrl+e |                    Ctrl+E |                    ctrl+[KeyE] |         |
+|                     Shift+KeyE |   E   |                   Shift+E |     |                   Shift+E |                        shift+e |                   Shift+E |                   shift+[KeyE] |         |
+|                Ctrl+Shift+KeyE |   E   |              Ctrl+Shift+E |     |              Ctrl+Shift+E |                   ctrl+shift+e |              Ctrl+Shift+E |              ctrl+shift+[KeyE] |         |
+|                       Alt+KeyE |   e   |                     Alt+E |     |                     Alt+E |                          alt+e |                     Alt+E |                     alt+[KeyE] |         |
+|                  Ctrl+Alt+KeyE |   e   |                Ctrl+Alt+E |     |                Ctrl+Alt+E |                     ctrl+alt+e |                Ctrl+Alt+E |                ctrl+alt+[KeyE] |         |
+|                 Shift+Alt+KeyE |   E   |               Shift+Alt+E |     |               Shift+Alt+E |                    shift+alt+e |               Shift+Alt+E |               shift+alt+[KeyE] |         |
+|            Ctrl+Shift+Alt+KeyE |   E   |          Ctrl+Shift+Alt+E |     |          Ctrl+Shift+Alt+E |               ctrl+shift+alt+e |          Ctrl+Shift+Alt+E |          ctrl+shift+alt+[KeyE] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyF |   f   |                         F |     |                         F |                              f |                         F |                         [KeyF] |         |
+|                      Ctrl+KeyF |   f   |                    Ctrl+F |     |                    Ctrl+F |                         ctrl+f |                    Ctrl+F |                    ctrl+[KeyF] |         |
+|                     Shift+KeyF |   F   |                   Shift+F |     |                   Shift+F |                        shift+f |                   Shift+F |                   shift+[KeyF] |         |
+|                Ctrl+Shift+KeyF |   F   |              Ctrl+Shift+F |     |              Ctrl+Shift+F |                   ctrl+shift+f |              Ctrl+Shift+F |              ctrl+shift+[KeyF] |         |
+|                       Alt+KeyF |   f   |                     Alt+F |     |                     Alt+F |                          alt+f |                     Alt+F |                     alt+[KeyF] |         |
+|                  Ctrl+Alt+KeyF |   f   |                Ctrl+Alt+F |     |                Ctrl+Alt+F |                     ctrl+alt+f |                Ctrl+Alt+F |                ctrl+alt+[KeyF] |         |
+|                 Shift+Alt+KeyF |   F   |               Shift+Alt+F |     |               Shift+Alt+F |                    shift+alt+f |               Shift+Alt+F |               shift+alt+[KeyF] |         |
+|            Ctrl+Shift+Alt+KeyF |   F   |          Ctrl+Shift+Alt+F |     |          Ctrl+Shift+Alt+F |               ctrl+shift+alt+f |          Ctrl+Shift+Alt+F |          ctrl+shift+alt+[KeyF] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyG |   g   |                         G |     |                         G |                              g |                         G |                         [KeyG] |         |
+|                      Ctrl+KeyG |   g   |                    Ctrl+G |     |                    Ctrl+G |                         ctrl+g |                    Ctrl+G |                    ctrl+[KeyG] |         |
+|                     Shift+KeyG |   G   |                   Shift+G |     |                   Shift+G |                        shift+g |                   Shift+G |                   shift+[KeyG] |         |
+|                Ctrl+Shift+KeyG |   G   |              Ctrl+Shift+G |     |              Ctrl+Shift+G |                   ctrl+shift+g |              Ctrl+Shift+G |              ctrl+shift+[KeyG] |         |
+|                       Alt+KeyG |   g   |                     Alt+G |     |                     Alt+G |                          alt+g |                     Alt+G |                     alt+[KeyG] |         |
+|                  Ctrl+Alt+KeyG |   g   |                Ctrl+Alt+G |     |                Ctrl+Alt+G |                     ctrl+alt+g |                Ctrl+Alt+G |                ctrl+alt+[KeyG] |         |
+|                 Shift+Alt+KeyG |   G   |               Shift+Alt+G |     |               Shift+Alt+G |                    shift+alt+g |               Shift+Alt+G |               shift+alt+[KeyG] |         |
+|            Ctrl+Shift+Alt+KeyG |   G   |          Ctrl+Shift+Alt+G |     |          Ctrl+Shift+Alt+G |               ctrl+shift+alt+g |          Ctrl+Shift+Alt+G |          ctrl+shift+alt+[KeyG] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyH |   h   |                         H |     |                         H |                              h |                         H |                         [KeyH] |         |
+|                      Ctrl+KeyH |   h   |                    Ctrl+H |     |                    Ctrl+H |                         ctrl+h |                    Ctrl+H |                    ctrl+[KeyH] |         |
+|                     Shift+KeyH |   H   |                   Shift+H |     |                   Shift+H |                        shift+h |                   Shift+H |                   shift+[KeyH] |         |
+|                Ctrl+Shift+KeyH |   H   |              Ctrl+Shift+H |     |              Ctrl+Shift+H |                   ctrl+shift+h |              Ctrl+Shift+H |              ctrl+shift+[KeyH] |         |
+|                       Alt+KeyH |   h   |                     Alt+H |     |                     Alt+H |                          alt+h |                     Alt+H |                     alt+[KeyH] |         |
+|                  Ctrl+Alt+KeyH |   h   |                Ctrl+Alt+H |     |                Ctrl+Alt+H |                     ctrl+alt+h |                Ctrl+Alt+H |                ctrl+alt+[KeyH] |         |
+|                 Shift+Alt+KeyH |   H   |               Shift+Alt+H |     |               Shift+Alt+H |                    shift+alt+h |               Shift+Alt+H |               shift+alt+[KeyH] |         |
+|            Ctrl+Shift+Alt+KeyH |   H   |          Ctrl+Shift+Alt+H |     |          Ctrl+Shift+Alt+H |               ctrl+shift+alt+h |          Ctrl+Shift+Alt+H |          ctrl+shift+alt+[KeyH] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyI |   i   |                         I |     |                         I |                              i |                         I |                         [KeyI] |         |
+|                      Ctrl+KeyI |   i   |                    Ctrl+I |     |                    Ctrl+I |                         ctrl+i |                    Ctrl+I |                    ctrl+[KeyI] |         |
+|                     Shift+KeyI |   I   |                   Shift+I |     |                   Shift+I |                        shift+i |                   Shift+I |                   shift+[KeyI] |         |
+|                Ctrl+Shift+KeyI |   I   |              Ctrl+Shift+I |     |              Ctrl+Shift+I |                   ctrl+shift+i |              Ctrl+Shift+I |              ctrl+shift+[KeyI] |         |
+|                       Alt+KeyI |   i   |                     Alt+I |     |                     Alt+I |                          alt+i |                     Alt+I |                     alt+[KeyI] |         |
+|                  Ctrl+Alt+KeyI |   i   |                Ctrl+Alt+I |     |                Ctrl+Alt+I |                     ctrl+alt+i |                Ctrl+Alt+I |                ctrl+alt+[KeyI] |         |
+|                 Shift+Alt+KeyI |   I   |               Shift+Alt+I |     |               Shift+Alt+I |                    shift+alt+i |               Shift+Alt+I |               shift+alt+[KeyI] |         |
+|            Ctrl+Shift+Alt+KeyI |   I   |          Ctrl+Shift+Alt+I |     |          Ctrl+Shift+Alt+I |               ctrl+shift+alt+i |          Ctrl+Shift+Alt+I |          ctrl+shift+alt+[KeyI] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyJ |   j   |                         J |     |                         J |                              j |                         J |                         [KeyJ] |         |
+|                      Ctrl+KeyJ |   j   |                    Ctrl+J |     |                    Ctrl+J |                         ctrl+j |                    Ctrl+J |                    ctrl+[KeyJ] |         |
+|                     Shift+KeyJ |   J   |                   Shift+J |     |                   Shift+J |                        shift+j |                   Shift+J |                   shift+[KeyJ] |         |
+|                Ctrl+Shift+KeyJ |   J   |              Ctrl+Shift+J |     |              Ctrl+Shift+J |                   ctrl+shift+j |              Ctrl+Shift+J |              ctrl+shift+[KeyJ] |         |
+|                       Alt+KeyJ |   j   |                     Alt+J |     |                     Alt+J |                          alt+j |                     Alt+J |                     alt+[KeyJ] |         |
+|                  Ctrl+Alt+KeyJ |   j   |                Ctrl+Alt+J |     |                Ctrl+Alt+J |                     ctrl+alt+j |                Ctrl+Alt+J |                ctrl+alt+[KeyJ] |         |
+|                 Shift+Alt+KeyJ |   J   |               Shift+Alt+J |     |               Shift+Alt+J |                    shift+alt+j |               Shift+Alt+J |               shift+alt+[KeyJ] |         |
+|            Ctrl+Shift+Alt+KeyJ |   J   |          Ctrl+Shift+Alt+J |     |          Ctrl+Shift+Alt+J |               ctrl+shift+alt+j |          Ctrl+Shift+Alt+J |          ctrl+shift+alt+[KeyJ] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyK |   k   |                         K |     |                         K |                              k |                         K |                         [KeyK] |         |
+|                      Ctrl+KeyK |   k   |                    Ctrl+K |     |                    Ctrl+K |                         ctrl+k |                    Ctrl+K |                    ctrl+[KeyK] |         |
+|                     Shift+KeyK |   K   |                   Shift+K |     |                   Shift+K |                        shift+k |                   Shift+K |                   shift+[KeyK] |         |
+|                Ctrl+Shift+KeyK |   K   |              Ctrl+Shift+K |     |              Ctrl+Shift+K |                   ctrl+shift+k |              Ctrl+Shift+K |              ctrl+shift+[KeyK] |         |
+|                       Alt+KeyK |   k   |                     Alt+K |     |                     Alt+K |                          alt+k |                     Alt+K |                     alt+[KeyK] |         |
+|                  Ctrl+Alt+KeyK |   k   |                Ctrl+Alt+K |     |                Ctrl+Alt+K |                     ctrl+alt+k |                Ctrl+Alt+K |                ctrl+alt+[KeyK] |         |
+|                 Shift+Alt+KeyK |   K   |               Shift+Alt+K |     |               Shift+Alt+K |                    shift+alt+k |               Shift+Alt+K |               shift+alt+[KeyK] |         |
+|            Ctrl+Shift+Alt+KeyK |   K   |          Ctrl+Shift+Alt+K |     |          Ctrl+Shift+Alt+K |               ctrl+shift+alt+k |          Ctrl+Shift+Alt+K |          ctrl+shift+alt+[KeyK] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyL |   l   |                         L |     |                         L |                              l |                         L |                         [KeyL] |         |
+|                      Ctrl+KeyL |   l   |                    Ctrl+L |     |                    Ctrl+L |                         ctrl+l |                    Ctrl+L |                    ctrl+[KeyL] |         |
+|                     Shift+KeyL |   L   |                   Shift+L |     |                   Shift+L |                        shift+l |                   Shift+L |                   shift+[KeyL] |         |
+|                Ctrl+Shift+KeyL |   L   |              Ctrl+Shift+L |     |              Ctrl+Shift+L |                   ctrl+shift+l |              Ctrl+Shift+L |              ctrl+shift+[KeyL] |         |
+|                       Alt+KeyL |   l   |                     Alt+L |     |                     Alt+L |                          alt+l |                     Alt+L |                     alt+[KeyL] |         |
+|                  Ctrl+Alt+KeyL |   l   |                Ctrl+Alt+L |     |                Ctrl+Alt+L |                     ctrl+alt+l |                Ctrl+Alt+L |                ctrl+alt+[KeyL] |         |
+|                 Shift+Alt+KeyL |   L   |               Shift+Alt+L |     |               Shift+Alt+L |                    shift+alt+l |               Shift+Alt+L |               shift+alt+[KeyL] |         |
+|            Ctrl+Shift+Alt+KeyL |   L   |          Ctrl+Shift+Alt+L |     |          Ctrl+Shift+Alt+L |               ctrl+shift+alt+l |          Ctrl+Shift+Alt+L |          ctrl+shift+alt+[KeyL] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyM |   m   |                         M |     |                         M |                              m |                         M |                         [KeyM] |         |
+|                      Ctrl+KeyM |   m   |                    Ctrl+M |     |                    Ctrl+M |                         ctrl+m |                    Ctrl+M |                    ctrl+[KeyM] |         |
+|                     Shift+KeyM |   M   |                   Shift+M |     |                   Shift+M |                        shift+m |                   Shift+M |                   shift+[KeyM] |         |
+|                Ctrl+Shift+KeyM |   M   |              Ctrl+Shift+M |     |              Ctrl+Shift+M |                   ctrl+shift+m |              Ctrl+Shift+M |              ctrl+shift+[KeyM] |         |
+|                       Alt+KeyM |   m   |                     Alt+M |     |                     Alt+M |                          alt+m |                     Alt+M |                     alt+[KeyM] |         |
+|                  Ctrl+Alt+KeyM |   m   |                Ctrl+Alt+M |     |                Ctrl+Alt+M |                     ctrl+alt+m |                Ctrl+Alt+M |                ctrl+alt+[KeyM] |         |
+|                 Shift+Alt+KeyM |   M   |               Shift+Alt+M |     |               Shift+Alt+M |                    shift+alt+m |               Shift+Alt+M |               shift+alt+[KeyM] |         |
+|            Ctrl+Shift+Alt+KeyM |   M   |          Ctrl+Shift+Alt+M |     |          Ctrl+Shift+Alt+M |               ctrl+shift+alt+m |          Ctrl+Shift+Alt+M |          ctrl+shift+alt+[KeyM] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyN |   n   |                         N |     |                         N |                              n |                         N |                         [KeyN] |         |
+|                      Ctrl+KeyN |   n   |                    Ctrl+N |     |                    Ctrl+N |                         ctrl+n |                    Ctrl+N |                    ctrl+[KeyN] |         |
+|                     Shift+KeyN |   N   |                   Shift+N |     |                   Shift+N |                        shift+n |                   Shift+N |                   shift+[KeyN] |         |
+|                Ctrl+Shift+KeyN |   N   |              Ctrl+Shift+N |     |              Ctrl+Shift+N |                   ctrl+shift+n |              Ctrl+Shift+N |              ctrl+shift+[KeyN] |         |
+|                       Alt+KeyN |   n   |                     Alt+N |     |                     Alt+N |                          alt+n |                     Alt+N |                     alt+[KeyN] |         |
+|                  Ctrl+Alt+KeyN |   n   |                Ctrl+Alt+N |     |                Ctrl+Alt+N |                     ctrl+alt+n |                Ctrl+Alt+N |                ctrl+alt+[KeyN] |         |
+|                 Shift+Alt+KeyN |   N   |               Shift+Alt+N |     |               Shift+Alt+N |                    shift+alt+n |               Shift+Alt+N |               shift+alt+[KeyN] |         |
+|            Ctrl+Shift+Alt+KeyN |   N   |          Ctrl+Shift+Alt+N |     |          Ctrl+Shift+Alt+N |               ctrl+shift+alt+n |          Ctrl+Shift+Alt+N |          ctrl+shift+alt+[KeyN] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyO |   o   |                         O |     |                         O |                              o |                         O |                         [KeyO] |         |
+|                      Ctrl+KeyO |   o   |                    Ctrl+O |     |                    Ctrl+O |                         ctrl+o |                    Ctrl+O |                    ctrl+[KeyO] |         |
+|                     Shift+KeyO |   O   |                   Shift+O |     |                   Shift+O |                        shift+o |                   Shift+O |                   shift+[KeyO] |         |
+|                Ctrl+Shift+KeyO |   O   |              Ctrl+Shift+O |     |              Ctrl+Shift+O |                   ctrl+shift+o |              Ctrl+Shift+O |              ctrl+shift+[KeyO] |         |
+|                       Alt+KeyO |   o   |                     Alt+O |     |                     Alt+O |                          alt+o |                     Alt+O |                     alt+[KeyO] |         |
+|                  Ctrl+Alt+KeyO |   o   |                Ctrl+Alt+O |     |                Ctrl+Alt+O |                     ctrl+alt+o |                Ctrl+Alt+O |                ctrl+alt+[KeyO] |         |
+|                 Shift+Alt+KeyO |   O   |               Shift+Alt+O |     |               Shift+Alt+O |                    shift+alt+o |               Shift+Alt+O |               shift+alt+[KeyO] |         |
+|            Ctrl+Shift+Alt+KeyO |   O   |          Ctrl+Shift+Alt+O |     |          Ctrl+Shift+Alt+O |               ctrl+shift+alt+o |          Ctrl+Shift+Alt+O |          ctrl+shift+alt+[KeyO] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyP |   p   |                         P |     |                         P |                              p |                         P |                         [KeyP] |         |
+|                      Ctrl+KeyP |   p   |                    Ctrl+P |     |                    Ctrl+P |                         ctrl+p |                    Ctrl+P |                    ctrl+[KeyP] |         |
+|                     Shift+KeyP |   P   |                   Shift+P |     |                   Shift+P |                        shift+p |                   Shift+P |                   shift+[KeyP] |         |
+|                Ctrl+Shift+KeyP |   P   |              Ctrl+Shift+P |     |              Ctrl+Shift+P |                   ctrl+shift+p |              Ctrl+Shift+P |              ctrl+shift+[KeyP] |         |
+|                       Alt+KeyP |   p   |                     Alt+P |     |                     Alt+P |                          alt+p |                     Alt+P |                     alt+[KeyP] |         |
+|                  Ctrl+Alt+KeyP |   p   |                Ctrl+Alt+P |     |                Ctrl+Alt+P |                     ctrl+alt+p |                Ctrl+Alt+P |                ctrl+alt+[KeyP] |         |
+|                 Shift+Alt+KeyP |   P   |               Shift+Alt+P |     |               Shift+Alt+P |                    shift+alt+p |               Shift+Alt+P |               shift+alt+[KeyP] |         |
+|            Ctrl+Shift+Alt+KeyP |   P   |          Ctrl+Shift+Alt+P |     |          Ctrl+Shift+Alt+P |               ctrl+shift+alt+p |          Ctrl+Shift+Alt+P |          ctrl+shift+alt+[KeyP] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyQ |   q   |                         Q |     |                         Q |                              q |                         Q |                         [KeyQ] |         |
+|                      Ctrl+KeyQ |   q   |                    Ctrl+Q |     |                    Ctrl+Q |                         ctrl+q |                    Ctrl+Q |                    ctrl+[KeyQ] |         |
+|                     Shift+KeyQ |   Q   |                   Shift+Q |     |                   Shift+Q |                        shift+q |                   Shift+Q |                   shift+[KeyQ] |         |
+|                Ctrl+Shift+KeyQ |   Q   |              Ctrl+Shift+Q |     |              Ctrl+Shift+Q |                   ctrl+shift+q |              Ctrl+Shift+Q |              ctrl+shift+[KeyQ] |         |
+|                       Alt+KeyQ |   q   |                     Alt+Q |     |                     Alt+Q |                          alt+q |                     Alt+Q |                     alt+[KeyQ] |         |
+|                  Ctrl+Alt+KeyQ |   q   |                Ctrl+Alt+Q |     |                Ctrl+Alt+Q |                     ctrl+alt+q |                Ctrl+Alt+Q |                ctrl+alt+[KeyQ] |         |
+|                 Shift+Alt+KeyQ |   Q   |               Shift+Alt+Q |     |               Shift+Alt+Q |                    shift+alt+q |               Shift+Alt+Q |               shift+alt+[KeyQ] |         |
+|            Ctrl+Shift+Alt+KeyQ |   Q   |          Ctrl+Shift+Alt+Q |     |          Ctrl+Shift+Alt+Q |               ctrl+shift+alt+q |          Ctrl+Shift+Alt+Q |          ctrl+shift+alt+[KeyQ] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyR |   r   |                         R |     |                         R |                              r |                         R |                         [KeyR] |         |
+|                      Ctrl+KeyR |   r   |                    Ctrl+R |     |                    Ctrl+R |                         ctrl+r |                    Ctrl+R |                    ctrl+[KeyR] |         |
+|                     Shift+KeyR |   R   |                   Shift+R |     |                   Shift+R |                        shift+r |                   Shift+R |                   shift+[KeyR] |         |
+|                Ctrl+Shift+KeyR |   R   |              Ctrl+Shift+R |     |              Ctrl+Shift+R |                   ctrl+shift+r |              Ctrl+Shift+R |              ctrl+shift+[KeyR] |         |
+|                       Alt+KeyR |   r   |                     Alt+R |     |                     Alt+R |                          alt+r |                     Alt+R |                     alt+[KeyR] |         |
+|                  Ctrl+Alt+KeyR |   r   |                Ctrl+Alt+R |     |                Ctrl+Alt+R |                     ctrl+alt+r |                Ctrl+Alt+R |                ctrl+alt+[KeyR] |         |
+|                 Shift+Alt+KeyR |   R   |               Shift+Alt+R |     |               Shift+Alt+R |                    shift+alt+r |               Shift+Alt+R |               shift+alt+[KeyR] |         |
+|            Ctrl+Shift+Alt+KeyR |   R   |          Ctrl+Shift+Alt+R |     |          Ctrl+Shift+Alt+R |               ctrl+shift+alt+r |          Ctrl+Shift+Alt+R |          ctrl+shift+alt+[KeyR] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyS |   s   |                         S |     |                         S |                              s |                         S |                         [KeyS] |         |
+|                      Ctrl+KeyS |   s   |                    Ctrl+S |     |                    Ctrl+S |                         ctrl+s |                    Ctrl+S |                    ctrl+[KeyS] |         |
+|                     Shift+KeyS |   S   |                   Shift+S |     |                   Shift+S |                        shift+s |                   Shift+S |                   shift+[KeyS] |         |
+|                Ctrl+Shift+KeyS |   S   |              Ctrl+Shift+S |     |              Ctrl+Shift+S |                   ctrl+shift+s |              Ctrl+Shift+S |              ctrl+shift+[KeyS] |         |
+|                       Alt+KeyS |   s   |                     Alt+S |     |                     Alt+S |                          alt+s |                     Alt+S |                     alt+[KeyS] |         |
+|                  Ctrl+Alt+KeyS |   s   |                Ctrl+Alt+S |     |                Ctrl+Alt+S |                     ctrl+alt+s |                Ctrl+Alt+S |                ctrl+alt+[KeyS] |         |
+|                 Shift+Alt+KeyS |   S   |               Shift+Alt+S |     |               Shift+Alt+S |                    shift+alt+s |               Shift+Alt+S |               shift+alt+[KeyS] |         |
+|            Ctrl+Shift+Alt+KeyS |   S   |          Ctrl+Shift+Alt+S |     |          Ctrl+Shift+Alt+S |               ctrl+shift+alt+s |          Ctrl+Shift+Alt+S |          ctrl+shift+alt+[KeyS] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyT |   t   |                         T |     |                         T |                              t |                         T |                         [KeyT] |         |
+|                      Ctrl+KeyT |   t   |                    Ctrl+T |     |                    Ctrl+T |                         ctrl+t |                    Ctrl+T |                    ctrl+[KeyT] |         |
+|                     Shift+KeyT |   T   |                   Shift+T |     |                   Shift+T |                        shift+t |                   Shift+T |                   shift+[KeyT] |         |
+|                Ctrl+Shift+KeyT |   T   |              Ctrl+Shift+T |     |              Ctrl+Shift+T |                   ctrl+shift+t |              Ctrl+Shift+T |              ctrl+shift+[KeyT] |         |
+|                       Alt+KeyT |   t   |                     Alt+T |     |                     Alt+T |                          alt+t |                     Alt+T |                     alt+[KeyT] |         |
+|                  Ctrl+Alt+KeyT |   t   |                Ctrl+Alt+T |     |                Ctrl+Alt+T |                     ctrl+alt+t |                Ctrl+Alt+T |                ctrl+alt+[KeyT] |         |
+|                 Shift+Alt+KeyT |   T   |               Shift+Alt+T |     |               Shift+Alt+T |                    shift+alt+t |               Shift+Alt+T |               shift+alt+[KeyT] |         |
+|            Ctrl+Shift+Alt+KeyT |   T   |          Ctrl+Shift+Alt+T |     |          Ctrl+Shift+Alt+T |               ctrl+shift+alt+t |          Ctrl+Shift+Alt+T |          ctrl+shift+alt+[KeyT] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyU |   u   |                         U |     |                         U |                              u |                         U |                         [KeyU] |         |
+|                      Ctrl+KeyU |   u   |                    Ctrl+U |     |                    Ctrl+U |                         ctrl+u |                    Ctrl+U |                    ctrl+[KeyU] |         |
+|                     Shift+KeyU |   U   |                   Shift+U |     |                   Shift+U |                        shift+u |                   Shift+U |                   shift+[KeyU] |         |
+|                Ctrl+Shift+KeyU |   U   |              Ctrl+Shift+U |     |              Ctrl+Shift+U |                   ctrl+shift+u |              Ctrl+Shift+U |              ctrl+shift+[KeyU] |         |
+|                       Alt+KeyU |   u   |                     Alt+U |     |                     Alt+U |                          alt+u |                     Alt+U |                     alt+[KeyU] |         |
+|                  Ctrl+Alt+KeyU |   u   |                Ctrl+Alt+U |     |                Ctrl+Alt+U |                     ctrl+alt+u |                Ctrl+Alt+U |                ctrl+alt+[KeyU] |         |
+|                 Shift+Alt+KeyU |   U   |               Shift+Alt+U |     |               Shift+Alt+U |                    shift+alt+u |               Shift+Alt+U |               shift+alt+[KeyU] |         |
+|            Ctrl+Shift+Alt+KeyU |   U   |          Ctrl+Shift+Alt+U |     |          Ctrl+Shift+Alt+U |               ctrl+shift+alt+u |          Ctrl+Shift+Alt+U |          ctrl+shift+alt+[KeyU] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyV |   v   |                         V |     |                         V |                              v |                         V |                         [KeyV] |         |
+|                      Ctrl+KeyV |   v   |                    Ctrl+V |     |                    Ctrl+V |                         ctrl+v |                    Ctrl+V |                    ctrl+[KeyV] |         |
+|                     Shift+KeyV |   V   |                   Shift+V |     |                   Shift+V |                        shift+v |                   Shift+V |                   shift+[KeyV] |         |
+|                Ctrl+Shift+KeyV |   V   |              Ctrl+Shift+V |     |              Ctrl+Shift+V |                   ctrl+shift+v |              Ctrl+Shift+V |              ctrl+shift+[KeyV] |         |
+|                       Alt+KeyV |   v   |                     Alt+V |     |                     Alt+V |                          alt+v |                     Alt+V |                     alt+[KeyV] |         |
+|                  Ctrl+Alt+KeyV |   v   |                Ctrl+Alt+V |     |                Ctrl+Alt+V |                     ctrl+alt+v |                Ctrl+Alt+V |                ctrl+alt+[KeyV] |         |
+|                 Shift+Alt+KeyV |   V   |               Shift+Alt+V |     |               Shift+Alt+V |                    shift+alt+v |               Shift+Alt+V |               shift+alt+[KeyV] |         |
+|            Ctrl+Shift+Alt+KeyV |   V   |          Ctrl+Shift+Alt+V |     |          Ctrl+Shift+Alt+V |               ctrl+shift+alt+v |          Ctrl+Shift+Alt+V |          ctrl+shift+alt+[KeyV] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyW |   w   |                         W |     |                         W |                              w |                         W |                         [KeyW] |         |
+|                      Ctrl+KeyW |   w   |                    Ctrl+W |     |                    Ctrl+W |                         ctrl+w |                    Ctrl+W |                    ctrl+[KeyW] |         |
+|                     Shift+KeyW |   W   |                   Shift+W |     |                   Shift+W |                        shift+w |                   Shift+W |                   shift+[KeyW] |         |
+|                Ctrl+Shift+KeyW |   W   |              Ctrl+Shift+W |     |              Ctrl+Shift+W |                   ctrl+shift+w |              Ctrl+Shift+W |              ctrl+shift+[KeyW] |         |
+|                       Alt+KeyW |   w   |                     Alt+W |     |                     Alt+W |                          alt+w |                     Alt+W |                     alt+[KeyW] |         |
+|                  Ctrl+Alt+KeyW |   w   |                Ctrl+Alt+W |     |                Ctrl+Alt+W |                     ctrl+alt+w |                Ctrl+Alt+W |                ctrl+alt+[KeyW] |         |
+|                 Shift+Alt+KeyW |   W   |               Shift+Alt+W |     |               Shift+Alt+W |                    shift+alt+w |               Shift+Alt+W |               shift+alt+[KeyW] |         |
+|            Ctrl+Shift+Alt+KeyW |   W   |          Ctrl+Shift+Alt+W |     |          Ctrl+Shift+Alt+W |               ctrl+shift+alt+w |          Ctrl+Shift+Alt+W |          ctrl+shift+alt+[KeyW] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyX |   x   |                         X |     |                         X |                              x |                         X |                         [KeyX] |         |
+|                      Ctrl+KeyX |   x   |                    Ctrl+X |     |                    Ctrl+X |                         ctrl+x |                    Ctrl+X |                    ctrl+[KeyX] |         |
+|                     Shift+KeyX |   X   |                   Shift+X |     |                   Shift+X |                        shift+x |                   Shift+X |                   shift+[KeyX] |         |
+|                Ctrl+Shift+KeyX |   X   |              Ctrl+Shift+X |     |              Ctrl+Shift+X |                   ctrl+shift+x |              Ctrl+Shift+X |              ctrl+shift+[KeyX] |         |
+|                       Alt+KeyX |   x   |                     Alt+X |     |                     Alt+X |                          alt+x |                     Alt+X |                     alt+[KeyX] |         |
+|                  Ctrl+Alt+KeyX |   x   |                Ctrl+Alt+X |     |                Ctrl+Alt+X |                     ctrl+alt+x |                Ctrl+Alt+X |                ctrl+alt+[KeyX] |         |
+|                 Shift+Alt+KeyX |   X   |               Shift+Alt+X |     |               Shift+Alt+X |                    shift+alt+x |               Shift+Alt+X |               shift+alt+[KeyX] |         |
+|            Ctrl+Shift+Alt+KeyX |   X   |          Ctrl+Shift+Alt+X |     |          Ctrl+Shift+Alt+X |               ctrl+shift+alt+x |          Ctrl+Shift+Alt+X |          ctrl+shift+alt+[KeyX] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyY |   y   |                         Y |     |                         Y |                              y |                         Y |                         [KeyY] |         |
+|                      Ctrl+KeyY |   y   |                    Ctrl+Y |     |                    Ctrl+Y |                         ctrl+y |                    Ctrl+Y |                    ctrl+[KeyY] |         |
+|                     Shift+KeyY |   Y   |                   Shift+Y |     |                   Shift+Y |                        shift+y |                   Shift+Y |                   shift+[KeyY] |         |
+|                Ctrl+Shift+KeyY |   Y   |              Ctrl+Shift+Y |     |              Ctrl+Shift+Y |                   ctrl+shift+y |              Ctrl+Shift+Y |              ctrl+shift+[KeyY] |         |
+|                       Alt+KeyY |   y   |                     Alt+Y |     |                     Alt+Y |                          alt+y |                     Alt+Y |                     alt+[KeyY] |         |
+|                  Ctrl+Alt+KeyY |   y   |                Ctrl+Alt+Y |     |                Ctrl+Alt+Y |                     ctrl+alt+y |                Ctrl+Alt+Y |                ctrl+alt+[KeyY] |         |
+|                 Shift+Alt+KeyY |   Y   |               Shift+Alt+Y |     |               Shift+Alt+Y |                    shift+alt+y |               Shift+Alt+Y |               shift+alt+[KeyY] |         |
+|            Ctrl+Shift+Alt+KeyY |   Y   |          Ctrl+Shift+Alt+Y |     |          Ctrl+Shift+Alt+Y |               ctrl+shift+alt+y |          Ctrl+Shift+Alt+Y |          ctrl+shift+alt+[KeyY] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyZ |   z   |                         Z |     |                         Z |                              z |                         Z |                         [KeyZ] |         |
+|                      Ctrl+KeyZ |   z   |                    Ctrl+Z |     |                    Ctrl+Z |                         ctrl+z |                    Ctrl+Z |                    ctrl+[KeyZ] |         |
+|                     Shift+KeyZ |   Z   |                   Shift+Z |     |                   Shift+Z |                        shift+z |                   Shift+Z |                   shift+[KeyZ] |         |
+|                Ctrl+Shift+KeyZ |   Z   |              Ctrl+Shift+Z |     |              Ctrl+Shift+Z |                   ctrl+shift+z |              Ctrl+Shift+Z |              ctrl+shift+[KeyZ] |         |
+|                       Alt+KeyZ |   z   |                     Alt+Z |     |                     Alt+Z |                          alt+z |                     Alt+Z |                     alt+[KeyZ] |         |
+|                  Ctrl+Alt+KeyZ |   z   |                Ctrl+Alt+Z |     |                Ctrl+Alt+Z |                     ctrl+alt+z |                Ctrl+Alt+Z |                ctrl+alt+[KeyZ] |         |
+|                 Shift+Alt+KeyZ |   Z   |               Shift+Alt+Z |     |               Shift+Alt+Z |                    shift+alt+z |               Shift+Alt+Z |               shift+alt+[KeyZ] |         |
+|            Ctrl+Shift+Alt+KeyZ |   Z   |          Ctrl+Shift+Alt+Z |     |          Ctrl+Shift+Alt+Z |               ctrl+shift+alt+z |          Ctrl+Shift+Alt+Z |          ctrl+shift+alt+[KeyZ] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit1 |   1   |                         1 |     |                         1 |                              1 |                         1 |                       [Digit1] |         |
+|                    Ctrl+Digit1 |   1   |                    Ctrl+1 |     |                    Ctrl+1 |                         ctrl+1 |                    Ctrl+1 |                  ctrl+[Digit1] |         |
+|                   Shift+Digit1 |   !   |                   Shift+1 |     |                   Shift+1 |                        shift+1 |                   Shift+1 |                 shift+[Digit1] |         |
+|              Ctrl+Shift+Digit1 |   !   |              Ctrl+Shift+1 |     |              Ctrl+Shift+1 |                   ctrl+shift+1 |              Ctrl+Shift+1 |            ctrl+shift+[Digit1] |         |
+|                     Alt+Digit1 |   1   |                     Alt+1 |     |                     Alt+1 |                          alt+1 |                     Alt+1 |                   alt+[Digit1] |         |
+|                Ctrl+Alt+Digit1 |   1   |                Ctrl+Alt+1 |     |                Ctrl+Alt+1 |                     ctrl+alt+1 |                Ctrl+Alt+1 |              ctrl+alt+[Digit1] |         |
+|               Shift+Alt+Digit1 |   !   |               Shift+Alt+1 |     |               Shift+Alt+1 |                    shift+alt+1 |               Shift+Alt+1 |             shift+alt+[Digit1] |         |
+|          Ctrl+Shift+Alt+Digit1 |   !   |          Ctrl+Shift+Alt+1 |     |          Ctrl+Shift+Alt+1 |               ctrl+shift+alt+1 |          Ctrl+Shift+Alt+1 |        ctrl+shift+alt+[Digit1] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit2 |   2   |                         2 |     |                         2 |                              2 |                         2 |                       [Digit2] |         |
+|                    Ctrl+Digit2 |   2   |                    Ctrl+2 |     |                    Ctrl+2 |                         ctrl+2 |                    Ctrl+2 |                  ctrl+[Digit2] |         |
+|                   Shift+Digit2 |   @   |                   Shift+2 |     |                   Shift+2 |                        shift+2 |                   Shift+2 |                 shift+[Digit2] |         |
+|              Ctrl+Shift+Digit2 |   @   |              Ctrl+Shift+2 |     |              Ctrl+Shift+2 |                   ctrl+shift+2 |              Ctrl+Shift+2 |            ctrl+shift+[Digit2] |         |
+|                     Alt+Digit2 |   2   |                     Alt+2 |     |                     Alt+2 |                          alt+2 |                     Alt+2 |                   alt+[Digit2] |         |
+|                Ctrl+Alt+Digit2 |   2   |                Ctrl+Alt+2 |     |                Ctrl+Alt+2 |                     ctrl+alt+2 |                Ctrl+Alt+2 |              ctrl+alt+[Digit2] |         |
+|               Shift+Alt+Digit2 |   @   |               Shift+Alt+2 |     |               Shift+Alt+2 |                    shift+alt+2 |               Shift+Alt+2 |             shift+alt+[Digit2] |         |
+|          Ctrl+Shift+Alt+Digit2 |   @   |          Ctrl+Shift+Alt+2 |     |          Ctrl+Shift+Alt+2 |               ctrl+shift+alt+2 |          Ctrl+Shift+Alt+2 |        ctrl+shift+alt+[Digit2] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit3 |   3   |                         3 |     |                         3 |                              3 |                         3 |                       [Digit3] |         |
+|                    Ctrl+Digit3 |   3   |                    Ctrl+3 |     |                    Ctrl+3 |                         ctrl+3 |                    Ctrl+3 |                  ctrl+[Digit3] |         |
+|                   Shift+Digit3 |   #   |                   Shift+3 |     |                   Shift+3 |                        shift+3 |                   Shift+3 |                 shift+[Digit3] |         |
+|              Ctrl+Shift+Digit3 |   #   |              Ctrl+Shift+3 |     |              Ctrl+Shift+3 |                   ctrl+shift+3 |              Ctrl+Shift+3 |            ctrl+shift+[Digit3] |         |
+|                     Alt+Digit3 |   3   |                     Alt+3 |     |                     Alt+3 |                          alt+3 |                     Alt+3 |                   alt+[Digit3] |         |
+|                Ctrl+Alt+Digit3 |   3   |                Ctrl+Alt+3 |     |                Ctrl+Alt+3 |                     ctrl+alt+3 |                Ctrl+Alt+3 |              ctrl+alt+[Digit3] |         |
+|               Shift+Alt+Digit3 |   #   |               Shift+Alt+3 |     |               Shift+Alt+3 |                    shift+alt+3 |               Shift+Alt+3 |             shift+alt+[Digit3] |         |
+|          Ctrl+Shift+Alt+Digit3 |   #   |          Ctrl+Shift+Alt+3 |     |          Ctrl+Shift+Alt+3 |               ctrl+shift+alt+3 |          Ctrl+Shift+Alt+3 |        ctrl+shift+alt+[Digit3] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit4 |   4   |                         4 |     |                         4 |                              4 |                         4 |                       [Digit4] |         |
+|                    Ctrl+Digit4 |   4   |                    Ctrl+4 |     |                    Ctrl+4 |                         ctrl+4 |                    Ctrl+4 |                  ctrl+[Digit4] |         |
+|                   Shift+Digit4 |   $   |                   Shift+4 |     |                   Shift+4 |                        shift+4 |                   Shift+4 |                 shift+[Digit4] |         |
+|              Ctrl+Shift+Digit4 |   $   |              Ctrl+Shift+4 |     |              Ctrl+Shift+4 |                   ctrl+shift+4 |              Ctrl+Shift+4 |            ctrl+shift+[Digit4] |         |
+|                     Alt+Digit4 |   4   |                     Alt+4 |     |                     Alt+4 |                          alt+4 |                     Alt+4 |                   alt+[Digit4] |         |
+|                Ctrl+Alt+Digit4 |   4   |                Ctrl+Alt+4 |     |                Ctrl+Alt+4 |                     ctrl+alt+4 |                Ctrl+Alt+4 |              ctrl+alt+[Digit4] |         |
+|               Shift+Alt+Digit4 |   $   |               Shift+Alt+4 |     |               Shift+Alt+4 |                    shift+alt+4 |               Shift+Alt+4 |             shift+alt+[Digit4] |         |
+|          Ctrl+Shift+Alt+Digit4 |   $   |          Ctrl+Shift+Alt+4 |     |          Ctrl+Shift+Alt+4 |               ctrl+shift+alt+4 |          Ctrl+Shift+Alt+4 |        ctrl+shift+alt+[Digit4] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit5 |   5   |                         5 |     |                         5 |                              5 |                         5 |                       [Digit5] |         |
+|                    Ctrl+Digit5 |   5   |                    Ctrl+5 |     |                    Ctrl+5 |                         ctrl+5 |                    Ctrl+5 |                  ctrl+[Digit5] |         |
+|                   Shift+Digit5 |   %   |                   Shift+5 |     |                   Shift+5 |                        shift+5 |                   Shift+5 |                 shift+[Digit5] |         |
+|              Ctrl+Shift+Digit5 |   %   |              Ctrl+Shift+5 |     |              Ctrl+Shift+5 |                   ctrl+shift+5 |              Ctrl+Shift+5 |            ctrl+shift+[Digit5] |         |
+|                     Alt+Digit5 |   5   |                     Alt+5 |     |                     Alt+5 |                          alt+5 |                     Alt+5 |                   alt+[Digit5] |         |
+|                Ctrl+Alt+Digit5 |   5   |                Ctrl+Alt+5 |     |                Ctrl+Alt+5 |                     ctrl+alt+5 |                Ctrl+Alt+5 |              ctrl+alt+[Digit5] |         |
+|               Shift+Alt+Digit5 |   %   |               Shift+Alt+5 |     |               Shift+Alt+5 |                    shift+alt+5 |               Shift+Alt+5 |             shift+alt+[Digit5] |         |
+|          Ctrl+Shift+Alt+Digit5 |   %   |          Ctrl+Shift+Alt+5 |     |          Ctrl+Shift+Alt+5 |               ctrl+shift+alt+5 |          Ctrl+Shift+Alt+5 |        ctrl+shift+alt+[Digit5] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit6 |   6   |                         6 |     |                         6 |                              6 |                         6 |                       [Digit6] |         |
+|                    Ctrl+Digit6 |   6   |                    Ctrl+6 |     |                    Ctrl+6 |                         ctrl+6 |                    Ctrl+6 |                  ctrl+[Digit6] |         |
+|                   Shift+Digit6 |   ^   |                   Shift+6 |     |                   Shift+6 |                        shift+6 |                   Shift+6 |                 shift+[Digit6] |         |
+|              Ctrl+Shift+Digit6 |   ^   |              Ctrl+Shift+6 |     |              Ctrl+Shift+6 |                   ctrl+shift+6 |              Ctrl+Shift+6 |            ctrl+shift+[Digit6] |         |
+|                     Alt+Digit6 |   6   |                     Alt+6 |     |                     Alt+6 |                          alt+6 |                     Alt+6 |                   alt+[Digit6] |         |
+|                Ctrl+Alt+Digit6 |   6   |                Ctrl+Alt+6 |     |                Ctrl+Alt+6 |                     ctrl+alt+6 |                Ctrl+Alt+6 |              ctrl+alt+[Digit6] |         |
+|               Shift+Alt+Digit6 |   ^   |               Shift+Alt+6 |     |               Shift+Alt+6 |                    shift+alt+6 |               Shift+Alt+6 |             shift+alt+[Digit6] |         |
+|          Ctrl+Shift+Alt+Digit6 |   ^   |          Ctrl+Shift+Alt+6 |     |          Ctrl+Shift+Alt+6 |               ctrl+shift+alt+6 |          Ctrl+Shift+Alt+6 |        ctrl+shift+alt+[Digit6] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit7 |   7   |                         7 |     |                         7 |                              7 |                         7 |                       [Digit7] |         |
+|                    Ctrl+Digit7 |   7   |                    Ctrl+7 |     |                    Ctrl+7 |                         ctrl+7 |                    Ctrl+7 |                  ctrl+[Digit7] |         |
+|                   Shift+Digit7 |   &   |                   Shift+7 |     |                   Shift+7 |                        shift+7 |                   Shift+7 |                 shift+[Digit7] |         |
+|              Ctrl+Shift+Digit7 |   &   |              Ctrl+Shift+7 |     |              Ctrl+Shift+7 |                   ctrl+shift+7 |              Ctrl+Shift+7 |            ctrl+shift+[Digit7] |         |
+|                     Alt+Digit7 |   7   |                     Alt+7 |     |                     Alt+7 |                          alt+7 |                     Alt+7 |                   alt+[Digit7] |         |
+|                Ctrl+Alt+Digit7 |   7   |                Ctrl+Alt+7 |     |                Ctrl+Alt+7 |                     ctrl+alt+7 |                Ctrl+Alt+7 |              ctrl+alt+[Digit7] |         |
+|               Shift+Alt+Digit7 |   &   |               Shift+Alt+7 |     |               Shift+Alt+7 |                    shift+alt+7 |               Shift+Alt+7 |             shift+alt+[Digit7] |         |
+|          Ctrl+Shift+Alt+Digit7 |   &   |          Ctrl+Shift+Alt+7 |     |          Ctrl+Shift+Alt+7 |               ctrl+shift+alt+7 |          Ctrl+Shift+Alt+7 |        ctrl+shift+alt+[Digit7] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit8 |   8   |                         8 |     |                         8 |                              8 |                         8 |                       [Digit8] |         |
+|                    Ctrl+Digit8 |   8   |                    Ctrl+8 |     |                    Ctrl+8 |                         ctrl+8 |                    Ctrl+8 |                  ctrl+[Digit8] |         |
+|                   Shift+Digit8 |   *   |                   Shift+8 |     |                   Shift+8 |                        shift+8 |                   Shift+8 |                 shift+[Digit8] |         |
+|              Ctrl+Shift+Digit8 |   *   |              Ctrl+Shift+8 |     |              Ctrl+Shift+8 |                   ctrl+shift+8 |              Ctrl+Shift+8 |            ctrl+shift+[Digit8] |         |
+|                     Alt+Digit8 |   8   |                     Alt+8 |     |                     Alt+8 |                          alt+8 |                     Alt+8 |                   alt+[Digit8] |         |
+|                Ctrl+Alt+Digit8 |   8   |                Ctrl+Alt+8 |     |                Ctrl+Alt+8 |                     ctrl+alt+8 |                Ctrl+Alt+8 |              ctrl+alt+[Digit8] |         |
+|               Shift+Alt+Digit8 |   *   |               Shift+Alt+8 |     |               Shift+Alt+8 |                    shift+alt+8 |               Shift+Alt+8 |             shift+alt+[Digit8] |         |
+|          Ctrl+Shift+Alt+Digit8 |   *   |          Ctrl+Shift+Alt+8 |     |          Ctrl+Shift+Alt+8 |               ctrl+shift+alt+8 |          Ctrl+Shift+Alt+8 |        ctrl+shift+alt+[Digit8] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit9 |   9   |                         9 |     |                         9 |                              9 |                         9 |                       [Digit9] |         |
+|                    Ctrl+Digit9 |   9   |                    Ctrl+9 |     |                    Ctrl+9 |                         ctrl+9 |                    Ctrl+9 |                  ctrl+[Digit9] |         |
+|                   Shift+Digit9 |   (   |                   Shift+9 |     |                   Shift+9 |                        shift+9 |                   Shift+9 |                 shift+[Digit9] |         |
+|              Ctrl+Shift+Digit9 |   (   |              Ctrl+Shift+9 |     |              Ctrl+Shift+9 |                   ctrl+shift+9 |              Ctrl+Shift+9 |            ctrl+shift+[Digit9] |         |
+|                     Alt+Digit9 |   9   |                     Alt+9 |     |                     Alt+9 |                          alt+9 |                     Alt+9 |                   alt+[Digit9] |         |
+|                Ctrl+Alt+Digit9 |   9   |                Ctrl+Alt+9 |     |                Ctrl+Alt+9 |                     ctrl+alt+9 |                Ctrl+Alt+9 |              ctrl+alt+[Digit9] |         |
+|               Shift+Alt+Digit9 |   (   |               Shift+Alt+9 |     |               Shift+Alt+9 |                    shift+alt+9 |               Shift+Alt+9 |             shift+alt+[Digit9] |         |
+|          Ctrl+Shift+Alt+Digit9 |   (   |          Ctrl+Shift+Alt+9 |     |          Ctrl+Shift+Alt+9 |               ctrl+shift+alt+9 |          Ctrl+Shift+Alt+9 |        ctrl+shift+alt+[Digit9] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit0 |   0   |                         0 |     |                         0 |                              0 |                         0 |                       [Digit0] |         |
+|                    Ctrl+Digit0 |   0   |                    Ctrl+0 |     |                    Ctrl+0 |                         ctrl+0 |                    Ctrl+0 |                  ctrl+[Digit0] |         |
+|                   Shift+Digit0 |   )   |                   Shift+0 |     |                   Shift+0 |                        shift+0 |                   Shift+0 |                 shift+[Digit0] |         |
+|              Ctrl+Shift+Digit0 |   )   |              Ctrl+Shift+0 |     |              Ctrl+Shift+0 |                   ctrl+shift+0 |              Ctrl+Shift+0 |            ctrl+shift+[Digit0] |         |
+|                     Alt+Digit0 |   0   |                     Alt+0 |     |                     Alt+0 |                          alt+0 |                     Alt+0 |                   alt+[Digit0] |         |
+|                Ctrl+Alt+Digit0 |   0   |                Ctrl+Alt+0 |     |                Ctrl+Alt+0 |                     ctrl+alt+0 |                Ctrl+Alt+0 |              ctrl+alt+[Digit0] |         |
+|               Shift+Alt+Digit0 |   )   |               Shift+Alt+0 |     |               Shift+Alt+0 |                    shift+alt+0 |               Shift+Alt+0 |             shift+alt+[Digit0] |         |
+|          Ctrl+Shift+Alt+Digit0 |   )   |          Ctrl+Shift+Alt+0 |     |          Ctrl+Shift+Alt+0 |               ctrl+shift+alt+0 |          Ctrl+Shift+Alt+0 |        ctrl+shift+alt+[Digit0] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Minus |   -   |                         - |     |                         - |                              - |                         - |                        [Minus] |         |
+|                     Ctrl+Minus |   -   |                    Ctrl+- |     |                    Ctrl+- |                         ctrl+- |                    Ctrl+- |                   ctrl+[Minus] |         |
+|                    Shift+Minus |   _   |                   Shift+- |     |                   Shift+- |                        shift+- |                   Shift+- |                  shift+[Minus] |         |
+|               Ctrl+Shift+Minus |   _   |              Ctrl+Shift+- |     |              Ctrl+Shift+- |                   ctrl+shift+- |              Ctrl+Shift+- |             ctrl+shift+[Minus] |         |
+|                      Alt+Minus |   -   |                     Alt+- |     |                     Alt+- |                          alt+- |                     Alt+- |                    alt+[Minus] |         |
+|                 Ctrl+Alt+Minus |   -   |                Ctrl+Alt+- |     |                Ctrl+Alt+- |                     ctrl+alt+- |                Ctrl+Alt+- |               ctrl+alt+[Minus] |         |
+|                Shift+Alt+Minus |   _   |               Shift+Alt+- |     |               Shift+Alt+- |                    shift+alt+- |               Shift+Alt+- |              shift+alt+[Minus] |         |
+|           Ctrl+Shift+Alt+Minus |   _   |          Ctrl+Shift+Alt+- |     |          Ctrl+Shift+Alt+- |               ctrl+shift+alt+- |          Ctrl+Shift+Alt+- |         ctrl+shift+alt+[Minus] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Equal |   =   |                         = |     |                         = |                              = |                         = |                        [Equal] |         |
+|                     Ctrl+Equal |   =   |                    Ctrl+= |     |                    Ctrl+= |                         ctrl+= |                    Ctrl+= |                   ctrl+[Equal] |         |
+|                    Shift+Equal |   +   |                   Shift+= |     |                   Shift+= |                        shift+= |                   Shift+= |                  shift+[Equal] |         |
+|               Ctrl+Shift+Equal |   +   |              Ctrl+Shift+= |     |              Ctrl+Shift+= |                   ctrl+shift+= |              Ctrl+Shift+= |             ctrl+shift+[Equal] |         |
+|                      Alt+Equal |   =   |                     Alt+= |     |                     Alt+= |                          alt+= |                     Alt+= |                    alt+[Equal] |         |
+|                 Ctrl+Alt+Equal |   =   |                Ctrl+Alt+= |     |                Ctrl+Alt+= |                     ctrl+alt+= |                Ctrl+Alt+= |               ctrl+alt+[Equal] |         |
+|                Shift+Alt+Equal |   +   |               Shift+Alt+= |     |               Shift+Alt+= |                    shift+alt+= |               Shift+Alt+= |              shift+alt+[Equal] |         |
+|           Ctrl+Shift+Alt+Equal |   +   |          Ctrl+Shift+Alt+= |     |          Ctrl+Shift+Alt+= |               ctrl+shift+alt+= |          Ctrl+Shift+Alt+= |         ctrl+shift+alt+[Equal] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                    BracketLeft |   [   |                         [ |     |                         [ |                              [ |                         [ |                  [BracketLeft] |         |
+|               Ctrl+BracketLeft |   [   |                    Ctrl+[ |     |                    Ctrl+[ |                         ctrl+[ |                    Ctrl+[ |             ctrl+[BracketLeft] |         |
+|              Shift+BracketLeft |   {   |                   Shift+[ |     |                   Shift+[ |                        shift+[ |                   Shift+[ |            shift+[BracketLeft] |         |
+|         Ctrl+Shift+BracketLeft |   {   |              Ctrl+Shift+[ |     |              Ctrl+Shift+[ |                   ctrl+shift+[ |              Ctrl+Shift+[ |       ctrl+shift+[BracketLeft] |         |
+|                Alt+BracketLeft |   [   |                     Alt+[ |     |                     Alt+[ |                          alt+[ |                     Alt+[ |              alt+[BracketLeft] |         |
+|           Ctrl+Alt+BracketLeft |   [   |                Ctrl+Alt+[ |     |                Ctrl+Alt+[ |                     ctrl+alt+[ |                Ctrl+Alt+[ |         ctrl+alt+[BracketLeft] |         |
+|          Shift+Alt+BracketLeft |   {   |               Shift+Alt+[ |     |               Shift+Alt+[ |                    shift+alt+[ |               Shift+Alt+[ |        shift+alt+[BracketLeft] |         |
+|     Ctrl+Shift+Alt+BracketLeft |   {   |          Ctrl+Shift+Alt+[ |     |          Ctrl+Shift+Alt+[ |               ctrl+shift+alt+[ |          Ctrl+Shift+Alt+[ |   ctrl+shift+alt+[BracketLeft] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                   BracketRight |   ]   |                         ] |     |                         ] |                              ] |                         ] |                 [BracketRight] |         |
+|              Ctrl+BracketRight |   ]   |                    Ctrl+] |     |                    Ctrl+] |                         ctrl+] |                    Ctrl+] |            ctrl+[BracketRight] |         |
+|             Shift+BracketRight |   }   |                   Shift+] |     |                   Shift+] |                        shift+] |                   Shift+] |           shift+[BracketRight] |         |
+|        Ctrl+Shift+BracketRight |   }   |              Ctrl+Shift+] |     |              Ctrl+Shift+] |                   ctrl+shift+] |              Ctrl+Shift+] |      ctrl+shift+[BracketRight] |         |
+|               Alt+BracketRight |   ]   |                     Alt+] |     |                     Alt+] |                          alt+] |                     Alt+] |             alt+[BracketRight] |         |
+|          Ctrl+Alt+BracketRight |   ]   |                Ctrl+Alt+] |     |                Ctrl+Alt+] |                     ctrl+alt+] |                Ctrl+Alt+] |        ctrl+alt+[BracketRight] |         |
+|         Shift+Alt+BracketRight |   }   |               Shift+Alt+] |     |               Shift+Alt+] |                    shift+alt+] |               Shift+Alt+] |       shift+alt+[BracketRight] |         |
+|    Ctrl+Shift+Alt+BracketRight |   }   |          Ctrl+Shift+Alt+] |     |          Ctrl+Shift+Alt+] |               ctrl+shift+alt+] |          Ctrl+Shift+Alt+] |  ctrl+shift+alt+[BracketRight] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                      Backslash |   \   |                         \ |     |                         \ |                              \ |                         \ |                    [Backslash] |         |
+|                 Ctrl+Backslash |   \   |                    Ctrl+\ |     |                    Ctrl+\ |                         ctrl+\ |                    Ctrl+\ |               ctrl+[Backslash] |         |
+|                Shift+Backslash |   |   |                   Shift+\ |   1 |                   Shift+\ |                        shift+\ |                   Shift+\ |              shift+[Backslash] |         |
+|           Ctrl+Shift+Backslash |   |   |              Ctrl+Shift+\ |     |              Ctrl+Shift+\ |                   ctrl+shift+\ |              Ctrl+Shift+\ |         ctrl+shift+[Backslash] |         |
+|                  Alt+Backslash |   \   |                     Alt+\ |     |                     Alt+\ |                          alt+\ |                     Alt+\ |                alt+[Backslash] |         |
+|             Ctrl+Alt+Backslash |   \   |                Ctrl+Alt+\ |     |                Ctrl+Alt+\ |                     ctrl+alt+\ |                Ctrl+Alt+\ |           ctrl+alt+[Backslash] |         |
+|            Shift+Alt+Backslash |   |   |               Shift+Alt+\ |     |               Shift+Alt+\ |                    shift+alt+\ |               Shift+Alt+\ |          shift+alt+[Backslash] |         |
+|       Ctrl+Shift+Alt+Backslash |   |   |          Ctrl+Shift+Alt+\ |     |          Ctrl+Shift+Alt+\ |               ctrl+shift+alt+\ |          Ctrl+Shift+Alt+\ |     ctrl+shift+alt+[Backslash] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                       IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|                  Ctrl+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|                 Shift+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|            Ctrl+Shift+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|                   Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|              Ctrl+Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|             Shift+Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|        Ctrl+Shift+Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                      Semicolon |   ;   |                         ; |     |                         ; |                              ; |                         ; |                    [Semicolon] |         |
+|                 Ctrl+Semicolon |   ;   |                    Ctrl+; |     |                    Ctrl+; |                         ctrl+; |                    Ctrl+; |               ctrl+[Semicolon] |         |
+|                Shift+Semicolon |   :   |                   Shift+; |     |                   Shift+; |                        shift+; |                   Shift+; |              shift+[Semicolon] |         |
+|           Ctrl+Shift+Semicolon |   :   |              Ctrl+Shift+; |     |              Ctrl+Shift+; |                   ctrl+shift+; |              Ctrl+Shift+; |         ctrl+shift+[Semicolon] |         |
+|                  Alt+Semicolon |   ;   |                     Alt+; |     |                     Alt+; |                          alt+; |                     Alt+; |                alt+[Semicolon] |         |
+|             Ctrl+Alt+Semicolon |   ;   |                Ctrl+Alt+; |     |                Ctrl+Alt+; |                     ctrl+alt+; |                Ctrl+Alt+; |           ctrl+alt+[Semicolon] |         |
+|            Shift+Alt+Semicolon |   :   |               Shift+Alt+; |     |               Shift+Alt+; |                    shift+alt+; |               Shift+Alt+; |          shift+alt+[Semicolon] |         |
+|       Ctrl+Shift+Alt+Semicolon |   :   |          Ctrl+Shift+Alt+; |     |          Ctrl+Shift+Alt+; |               ctrl+shift+alt+; |          Ctrl+Shift+Alt+; |     ctrl+shift+alt+[Semicolon] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Quote |   '   |                         ' |     |                         ' |                              ' |                         ' |                        [Quote] |         |
+|                     Ctrl+Quote |   '   |                    Ctrl+' |     |                    Ctrl+' |                         ctrl+' |                    Ctrl+' |                   ctrl+[Quote] |         |
+|                    Shift+Quote |   "   |                   Shift+' |     |                   Shift+' |                        shift+' |                   Shift+' |                  shift+[Quote] |         |
+|               Ctrl+Shift+Quote |   "   |              Ctrl+Shift+' |     |              Ctrl+Shift+' |                   ctrl+shift+' |              Ctrl+Shift+' |             ctrl+shift+[Quote] |         |
+|                      Alt+Quote |   '   |                     Alt+' |     |                     Alt+' |                          alt+' |                     Alt+' |                    alt+[Quote] |         |
+|                 Ctrl+Alt+Quote |   '   |                Ctrl+Alt+' |     |                Ctrl+Alt+' |                     ctrl+alt+' |                Ctrl+Alt+' |               ctrl+alt+[Quote] |         |
+|                Shift+Alt+Quote |   "   |               Shift+Alt+' |     |               Shift+Alt+' |                    shift+alt+' |               Shift+Alt+' |              shift+alt+[Quote] |         |
+|           Ctrl+Shift+Alt+Quote |   "   |          Ctrl+Shift+Alt+' |     |          Ctrl+Shift+Alt+' |               ctrl+shift+alt+' |          Ctrl+Shift+Alt+' |         ctrl+shift+alt+[Quote] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                      Backquote |   `   |                         ` |     |                         ` |                              ` |                         ` |                    [Backquote] |         |
+|                 Ctrl+Backquote |   `   |                    Ctrl+` |     |                    Ctrl+` |                         ctrl+` |                    Ctrl+` |               ctrl+[Backquote] |         |
+|                Shift+Backquote |   ~   |                   Shift+` |     |                   Shift+` |                        shift+` |                   Shift+` |              shift+[Backquote] |         |
+|           Ctrl+Shift+Backquote |   ~   |              Ctrl+Shift+` |     |              Ctrl+Shift+` |                   ctrl+shift+` |              Ctrl+Shift+` |         ctrl+shift+[Backquote] |         |
+|                  Alt+Backquote |   `   |                     Alt+` |     |                     Alt+` |                          alt+` |                     Alt+` |                alt+[Backquote] |         |
+|             Ctrl+Alt+Backquote |   `   |                Ctrl+Alt+` |     |                Ctrl+Alt+` |                     ctrl+alt+` |                Ctrl+Alt+` |           ctrl+alt+[Backquote] |         |
+|            Shift+Alt+Backquote |   ~   |               Shift+Alt+` |     |               Shift+Alt+` |                    shift+alt+` |               Shift+Alt+` |          shift+alt+[Backquote] |         |
+|       Ctrl+Shift+Alt+Backquote |   ~   |          Ctrl+Shift+Alt+` |     |          Ctrl+Shift+Alt+` |               ctrl+shift+alt+` |          Ctrl+Shift+Alt+` |     ctrl+shift+alt+[Backquote] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Comma |   ,   |                         , |     |                         , |                              , |                         , |                        [Comma] |         |
+|                     Ctrl+Comma |   ,   |                    Ctrl+, |     |                    Ctrl+, |                         ctrl+, |                    Ctrl+, |                   ctrl+[Comma] |         |
+|                    Shift+Comma |   <   |                   Shift+, |   1 |                   Shift+, |                        shift+, |                   Shift+, |                  shift+[Comma] |         |
+|               Ctrl+Shift+Comma |   <   |              Ctrl+Shift+, |   1 |              Ctrl+Shift+, |                   ctrl+shift+, |              Ctrl+Shift+, |             ctrl+shift+[Comma] |         |
+|                      Alt+Comma |   ,   |                     Alt+, |     |                     Alt+, |                          alt+, |                     Alt+, |                    alt+[Comma] |         |
+|                 Ctrl+Alt+Comma |   ,   |                Ctrl+Alt+, |     |                Ctrl+Alt+, |                     ctrl+alt+, |                Ctrl+Alt+, |               ctrl+alt+[Comma] |         |
+|                Shift+Alt+Comma |   <   |               Shift+Alt+, |   1 |               Shift+Alt+, |                    shift+alt+, |               Shift+Alt+, |              shift+alt+[Comma] |         |
+|           Ctrl+Shift+Alt+Comma |   <   |          Ctrl+Shift+Alt+, |     |          Ctrl+Shift+Alt+, |               ctrl+shift+alt+, |          Ctrl+Shift+Alt+, |         ctrl+shift+alt+[Comma] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Period |   .   |                         . |     |                         . |                              . |                         . |                       [Period] |         |
+|                    Ctrl+Period |   .   |                    Ctrl+. |     |                    Ctrl+. |                         ctrl+. |                    Ctrl+. |                  ctrl+[Period] |         |
+|                   Shift+Period |   >   |                   Shift+. |   1 |                   Shift+. |                        shift+. |                   Shift+. |                 shift+[Period] |         |
+|              Ctrl+Shift+Period |   >   |              Ctrl+Shift+. |   1 |              Ctrl+Shift+. |                   ctrl+shift+. |              Ctrl+Shift+. |            ctrl+shift+[Period] |         |
+|                     Alt+Period |   .   |                     Alt+. |     |                     Alt+. |                          alt+. |                     Alt+. |                   alt+[Period] |         |
+|                Ctrl+Alt+Period |   .   |                Ctrl+Alt+. |     |                Ctrl+Alt+. |                     ctrl+alt+. |                Ctrl+Alt+. |              ctrl+alt+[Period] |         |
+|               Shift+Alt+Period |   >   |               Shift+Alt+. |   1 |               Shift+Alt+. |                    shift+alt+. |               Shift+Alt+. |             shift+alt+[Period] |         |
+|          Ctrl+Shift+Alt+Period |   >   |          Ctrl+Shift+Alt+. |   1 |          Ctrl+Shift+Alt+. |               ctrl+shift+alt+. |          Ctrl+Shift+Alt+. |        ctrl+shift+alt+[Period] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Slash |   /   |                         / |     |                         / |                              / |                         / |                        [Slash] |         |
+|                     Ctrl+Slash |   /   |                    Ctrl+/ |     |                    Ctrl+/ |                         ctrl+/ |                    Ctrl+/ |                   ctrl+[Slash] |         |
+|                    Shift+Slash |   ?   |                   Shift+/ |     |                   Shift+/ |                        shift+/ |                   Shift+/ |                  shift+[Slash] |         |
+|               Ctrl+Shift+Slash |   ?   |              Ctrl+Shift+/ |     |              Ctrl+Shift+/ |                   ctrl+shift+/ |              Ctrl+Shift+/ |             ctrl+shift+[Slash] |         |
+|                      Alt+Slash |   /   |                     Alt+/ |     |                     Alt+/ |                          alt+/ |                     Alt+/ |                    alt+[Slash] |         |
+|                 Ctrl+Alt+Slash |   /   |                Ctrl+Alt+/ |     |                Ctrl+Alt+/ |                     ctrl+alt+/ |                Ctrl+Alt+/ |               ctrl+alt+[Slash] |         |
+|                Shift+Alt+Slash |   ?   |               Shift+Alt+/ |     |               Shift+Alt+/ |                    shift+alt+/ |               Shift+Alt+/ |              shift+alt+[Slash] |         |
+|           Ctrl+Shift+Alt+Slash |   ?   |          Ctrl+Shift+Alt+/ |     |          Ctrl+Shift+Alt+/ |               ctrl+shift+alt+/ |          Ctrl+Shift+Alt+/ |         ctrl+shift+alt+[Slash] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                        ArrowUp |  ---  |                   UpArrow |     |                   UpArrow |                             up |                        Up |                      [ArrowUp] |         |
+|                   Ctrl+ArrowUp |  ---  |              Ctrl+UpArrow |     |              Ctrl+UpArrow |                        ctrl+up |                   Ctrl+Up |                 ctrl+[ArrowUp] |         |
+|                  Shift+ArrowUp |  ---  |             Shift+UpArrow |     |             Shift+UpArrow |                       shift+up |                  Shift+Up |                shift+[ArrowUp] |         |
+|             Ctrl+Shift+ArrowUp |  ---  |        Ctrl+Shift+UpArrow |     |        Ctrl+Shift+UpArrow |                  ctrl+shift+up |             Ctrl+Shift+Up |           ctrl+shift+[ArrowUp] |         |
+|                    Alt+ArrowUp |  ---  |               Alt+UpArrow |     |               Alt+UpArrow |                         alt+up |                    Alt+Up |                  alt+[ArrowUp] |         |
+|               Ctrl+Alt+ArrowUp |  ---  |          Ctrl+Alt+UpArrow |     |          Ctrl+Alt+UpArrow |                    ctrl+alt+up |               Ctrl+Alt+Up |             ctrl+alt+[ArrowUp] |         |
+|              Shift+Alt+ArrowUp |  ---  |         Shift+Alt+UpArrow |     |         Shift+Alt+UpArrow |                   shift+alt+up |              Shift+Alt+Up |            shift+alt+[ArrowUp] |         |
+|         Ctrl+Shift+Alt+ArrowUp |  ---  |    Ctrl+Shift+Alt+UpArrow |     |    Ctrl+Shift+Alt+UpArrow |              ctrl+shift+alt+up |         Ctrl+Shift+Alt+Up |       ctrl+shift+alt+[ArrowUp] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                        Numpad0 |  ---  |                   NumPad0 |     |                   NumPad0 |                        numpad0 |                      null |                      [Numpad0] |         |
+|                   Ctrl+Numpad0 |  ---  |              Ctrl+NumPad0 |     |              Ctrl+NumPad0 |                   ctrl+numpad0 |                      null |                 ctrl+[Numpad0] |         |
+|                  Shift+Numpad0 |  ---  |             Shift+NumPad0 |     |             Shift+NumPad0 |                  shift+numpad0 |                      null |                shift+[Numpad0] |         |
+|             Ctrl+Shift+Numpad0 |  ---  |        Ctrl+Shift+NumPad0 |     |        Ctrl+Shift+NumPad0 |             ctrl+shift+numpad0 |                      null |           ctrl+shift+[Numpad0] |         |
+|                    Alt+Numpad0 |  ---  |               Alt+NumPad0 |     |               Alt+NumPad0 |                    alt+numpad0 |                      null |                  alt+[Numpad0] |         |
+|               Ctrl+Alt+Numpad0 |  ---  |          Ctrl+Alt+NumPad0 |     |          Ctrl+Alt+NumPad0 |               ctrl+alt+numpad0 |                      null |             ctrl+alt+[Numpad0] |         |
+|              Shift+Alt+Numpad0 |  ---  |         Shift+Alt+NumPad0 |     |         Shift+Alt+NumPad0 |              shift+alt+numpad0 |                      null |            shift+alt+[Numpad0] |         |
+|         Ctrl+Shift+Alt+Numpad0 |  ---  |    Ctrl+Shift+Alt+NumPad0 |     |    Ctrl+Shift+Alt+NumPad0 |         ctrl+shift+alt+numpad0 |                      null |       ctrl+shift+alt+[Numpad0] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                  IntlBackslash |   <   |                   Shift+, |   2 |                         < |                [IntlBackslash] |                      null |                [IntlBackslash] |    NO   |
+|             Ctrl+IntlBackslash |   <   |              Ctrl+Shift+, |   2 |                    Ctrl+< |           ctrl+[IntlBackslash] |                      null |           ctrl+[IntlBackslash] |    NO   |
+|            Shift+IntlBackslash |   >   |                   Shift+. |   2 |                   Shift+< |          shift+[IntlBackslash] |                      null |          shift+[IntlBackslash] |    NO   |
+|       Ctrl+Shift+IntlBackslash |   >   |              Ctrl+Shift+. |   2 |              Ctrl+Shift+< |     ctrl+shift+[IntlBackslash] |                      null |     ctrl+shift+[IntlBackslash] |    NO   |
+|              Alt+IntlBackslash |   <   |               Shift+Alt+, |   2 |                     Alt+< |            alt+[IntlBackslash] |                      null |            alt+[IntlBackslash] |    NO   |
+|         Ctrl+Alt+IntlBackslash |   |   |                   Shift+\ |   2 |                Ctrl+Alt+< |       ctrl+alt+[IntlBackslash] |                      null |       ctrl+alt+[IntlBackslash] |    NO   |
+|        Shift+Alt+IntlBackslash |   >   |               Shift+Alt+. |   2 |               Shift+Alt+< |      shift+alt+[IntlBackslash] |                      null |      shift+alt+[IntlBackslash] |    NO   |
+|   Ctrl+Shift+Alt+IntlBackslash |   ¦   |          Ctrl+Shift+Alt+. |   2 |          Ctrl+Shift+Alt+< | ctrl+shift+alt+[IntlBackslash] |                      null | ctrl+shift+alt+[IntlBackslash] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         IntlRo |  ---  |                           |     |                      null |                       [IntlRo] |                      null |                       [IntlRo] |    NO   |
+|                    Ctrl+IntlRo |  ---  |                           |     |                      null |                  ctrl+[IntlRo] |                      null |                  ctrl+[IntlRo] |    NO   |
+|                   Shift+IntlRo |  ---  |                           |     |                      null |                 shift+[IntlRo] |                      null |                 shift+[IntlRo] |    NO   |
+|              Ctrl+Shift+IntlRo |  ---  |                           |     |                      null |            ctrl+shift+[IntlRo] |                      null |            ctrl+shift+[IntlRo] |    NO   |
+|                     Alt+IntlRo |  ---  |                           |     |                      null |                   alt+[IntlRo] |                      null |                   alt+[IntlRo] |    NO   |
+|                Ctrl+Alt+IntlRo |  ---  |                           |     |                      null |              ctrl+alt+[IntlRo] |                      null |              ctrl+alt+[IntlRo] |    NO   |
+|               Shift+Alt+IntlRo |  ---  |                           |     |                      null |             shift+alt+[IntlRo] |                      null |             shift+alt+[IntlRo] |    NO   |
+|          Ctrl+Shift+Alt+IntlRo |  ---  |                           |     |                      null |        ctrl+shift+alt+[IntlRo] |                      null |        ctrl+shift+alt+[IntlRo] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                        IntlYen |  ---  |                           |     |                      null |                      [IntlYen] |                      null |                      [IntlYen] |    NO   |
+|                   Ctrl+IntlYen |  ---  |                           |     |                      null |                 ctrl+[IntlYen] |                      null |                 ctrl+[IntlYen] |    NO   |
+|                  Shift+IntlYen |  ---  |                           |     |                      null |                shift+[IntlYen] |                      null |                shift+[IntlYen] |    NO   |
+|             Ctrl+Shift+IntlYen |  ---  |                           |     |                      null |           ctrl+shift+[IntlYen] |                      null |           ctrl+shift+[IntlYen] |    NO   |
+|                    Alt+IntlYen |  ---  |                           |     |                      null |                  alt+[IntlYen] |                      null |                  alt+[IntlYen] |    NO   |
+|               Ctrl+Alt+IntlYen |  ---  |                           |     |                      null |             ctrl+alt+[IntlYen] |                      null |             ctrl+alt+[IntlYen] |    NO   |
+|              Shift+Alt+IntlYen |  ---  |                           |     |                      null |            shift+alt+[IntlYen] |                      null |            shift+alt+[IntlYen] |    NO   |
+|         Ctrl+Shift+Alt+IntlYen |  ---  |                           |     |                      null |       ctrl+shift+alt+[IntlYen] |                      null |       ctrl+shift+alt+[IntlYen] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

lib/vscode/src/vs/workbench/services/keybinding/test/electron-browser/linux_ru.txt

@@ -0,0 +1,523 @@
+isUSStandard: false
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyA |   ф   |                         A |     |                         A |                              a |                         A |                         [KeyA] |         |
+|                      Ctrl+KeyA |   ф   |                    Ctrl+A |     |                    Ctrl+A |                         ctrl+a |                    Ctrl+A |                    ctrl+[KeyA] |         |
+|                     Shift+KeyA |   Ф   |                   Shift+A |     |                   Shift+A |                        shift+a |                   Shift+A |                   shift+[KeyA] |         |
+|                Ctrl+Shift+KeyA |   Ф   |              Ctrl+Shift+A |     |              Ctrl+Shift+A |                   ctrl+shift+a |              Ctrl+Shift+A |              ctrl+shift+[KeyA] |         |
+|                       Alt+KeyA |   ф   |                     Alt+A |     |                     Alt+A |                          alt+a |                     Alt+A |                     alt+[KeyA] |         |
+|                  Ctrl+Alt+KeyA |   ф   |                Ctrl+Alt+A |     |                Ctrl+Alt+A |                     ctrl+alt+a |                Ctrl+Alt+A |                ctrl+alt+[KeyA] |         |
+|                 Shift+Alt+KeyA |   Ф   |               Shift+Alt+A |     |               Shift+Alt+A |                    shift+alt+a |               Shift+Alt+A |               shift+alt+[KeyA] |         |
+|            Ctrl+Shift+Alt+KeyA |   Ф   |          Ctrl+Shift+Alt+A |     |          Ctrl+Shift+Alt+A |               ctrl+shift+alt+a |          Ctrl+Shift+Alt+A |          ctrl+shift+alt+[KeyA] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyB |   и   |                         B |     |                         B |                              b |                         B |                         [KeyB] |         |
+|                      Ctrl+KeyB |   и   |                    Ctrl+B |     |                    Ctrl+B |                         ctrl+b |                    Ctrl+B |                    ctrl+[KeyB] |         |
+|                     Shift+KeyB |   И   |                   Shift+B |     |                   Shift+B |                        shift+b |                   Shift+B |                   shift+[KeyB] |         |
+|                Ctrl+Shift+KeyB |   И   |              Ctrl+Shift+B |     |              Ctrl+Shift+B |                   ctrl+shift+b |              Ctrl+Shift+B |              ctrl+shift+[KeyB] |         |
+|                       Alt+KeyB |   и   |                     Alt+B |     |                     Alt+B |                          alt+b |                     Alt+B |                     alt+[KeyB] |         |
+|                  Ctrl+Alt+KeyB |   и   |                Ctrl+Alt+B |     |                Ctrl+Alt+B |                     ctrl+alt+b |                Ctrl+Alt+B |                ctrl+alt+[KeyB] |         |
+|                 Shift+Alt+KeyB |   И   |               Shift+Alt+B |     |               Shift+Alt+B |                    shift+alt+b |               Shift+Alt+B |               shift+alt+[KeyB] |         |
+|            Ctrl+Shift+Alt+KeyB |   И   |          Ctrl+Shift+Alt+B |     |          Ctrl+Shift+Alt+B |               ctrl+shift+alt+b |          Ctrl+Shift+Alt+B |          ctrl+shift+alt+[KeyB] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyC |   с   |                         C |     |                         C |                              c |                         C |                         [KeyC] |         |
+|                      Ctrl+KeyC |   с   |                    Ctrl+C |     |                    Ctrl+C |                         ctrl+c |                    Ctrl+C |                    ctrl+[KeyC] |         |
+|                     Shift+KeyC |   С   |                   Shift+C |     |                   Shift+C |                        shift+c |                   Shift+C |                   shift+[KeyC] |         |
+|                Ctrl+Shift+KeyC |   С   |              Ctrl+Shift+C |     |              Ctrl+Shift+C |                   ctrl+shift+c |              Ctrl+Shift+C |              ctrl+shift+[KeyC] |         |
+|                       Alt+KeyC |   с   |                     Alt+C |     |                     Alt+C |                          alt+c |                     Alt+C |                     alt+[KeyC] |         |
+|                  Ctrl+Alt+KeyC |   с   |                Ctrl+Alt+C |     |                Ctrl+Alt+C |                     ctrl+alt+c |                Ctrl+Alt+C |                ctrl+alt+[KeyC] |         |
+|                 Shift+Alt+KeyC |   С   |               Shift+Alt+C |     |               Shift+Alt+C |                    shift+alt+c |               Shift+Alt+C |               shift+alt+[KeyC] |         |
+|            Ctrl+Shift+Alt+KeyC |   С   |          Ctrl+Shift+Alt+C |     |          Ctrl+Shift+Alt+C |               ctrl+shift+alt+c |          Ctrl+Shift+Alt+C |          ctrl+shift+alt+[KeyC] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyD |   в   |                         D |     |                         D |                              d |                         D |                         [KeyD] |         |
+|                      Ctrl+KeyD |   в   |                    Ctrl+D |     |                    Ctrl+D |                         ctrl+d |                    Ctrl+D |                    ctrl+[KeyD] |         |
+|                     Shift+KeyD |   В   |                   Shift+D |     |                   Shift+D |                        shift+d |                   Shift+D |                   shift+[KeyD] |         |
+|                Ctrl+Shift+KeyD |   В   |              Ctrl+Shift+D |     |              Ctrl+Shift+D |                   ctrl+shift+d |              Ctrl+Shift+D |              ctrl+shift+[KeyD] |         |
+|                       Alt+KeyD |   в   |                     Alt+D |     |                     Alt+D |                          alt+d |                     Alt+D |                     alt+[KeyD] |         |
+|                  Ctrl+Alt+KeyD |   в   |                Ctrl+Alt+D |     |                Ctrl+Alt+D |                     ctrl+alt+d |                Ctrl+Alt+D |                ctrl+alt+[KeyD] |         |
+|                 Shift+Alt+KeyD |   В   |               Shift+Alt+D |     |               Shift+Alt+D |                    shift+alt+d |               Shift+Alt+D |               shift+alt+[KeyD] |         |
+|            Ctrl+Shift+Alt+KeyD |   В   |          Ctrl+Shift+Alt+D |     |          Ctrl+Shift+Alt+D |               ctrl+shift+alt+d |          Ctrl+Shift+Alt+D |          ctrl+shift+alt+[KeyD] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyE |   у   |                         E |     |                         E |                              e |                         E |                         [KeyE] |         |
+|                      Ctrl+KeyE |   у   |                    Ctrl+E |     |                    Ctrl+E |                         ctrl+e |                    Ctrl+E |                    ctrl+[KeyE] |         |
+|                     Shift+KeyE |   У   |                   Shift+E |     |                   Shift+E |                        shift+e |                   Shift+E |                   shift+[KeyE] |         |
+|                Ctrl+Shift+KeyE |   У   |              Ctrl+Shift+E |     |              Ctrl+Shift+E |                   ctrl+shift+e |              Ctrl+Shift+E |              ctrl+shift+[KeyE] |         |
+|                       Alt+KeyE |   у   |                     Alt+E |     |                     Alt+E |                          alt+e |                     Alt+E |                     alt+[KeyE] |         |
+|                  Ctrl+Alt+KeyE |   у   |                Ctrl+Alt+E |     |                Ctrl+Alt+E |                     ctrl+alt+e |                Ctrl+Alt+E |                ctrl+alt+[KeyE] |         |
+|                 Shift+Alt+KeyE |   У   |               Shift+Alt+E |     |               Shift+Alt+E |                    shift+alt+e |               Shift+Alt+E |               shift+alt+[KeyE] |         |
+|            Ctrl+Shift+Alt+KeyE |   У   |          Ctrl+Shift+Alt+E |     |          Ctrl+Shift+Alt+E |               ctrl+shift+alt+e |          Ctrl+Shift+Alt+E |          ctrl+shift+alt+[KeyE] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyF |   а   |                         F |     |                         F |                              f |                         F |                         [KeyF] |         |
+|                      Ctrl+KeyF |   а   |                    Ctrl+F |     |                    Ctrl+F |                         ctrl+f |                    Ctrl+F |                    ctrl+[KeyF] |         |
+|                     Shift+KeyF |   А   |                   Shift+F |     |                   Shift+F |                        shift+f |                   Shift+F |                   shift+[KeyF] |         |
+|                Ctrl+Shift+KeyF |   А   |              Ctrl+Shift+F |     |              Ctrl+Shift+F |                   ctrl+shift+f |              Ctrl+Shift+F |              ctrl+shift+[KeyF] |         |
+|                       Alt+KeyF |   а   |                     Alt+F |     |                     Alt+F |                          alt+f |                     Alt+F |                     alt+[KeyF] |         |
+|                  Ctrl+Alt+KeyF |   а   |                Ctrl+Alt+F |     |                Ctrl+Alt+F |                     ctrl+alt+f |                Ctrl+Alt+F |                ctrl+alt+[KeyF] |         |
+|                 Shift+Alt+KeyF |   А   |               Shift+Alt+F |     |               Shift+Alt+F |                    shift+alt+f |               Shift+Alt+F |               shift+alt+[KeyF] |         |
+|            Ctrl+Shift+Alt+KeyF |   А   |          Ctrl+Shift+Alt+F |     |          Ctrl+Shift+Alt+F |               ctrl+shift+alt+f |          Ctrl+Shift+Alt+F |          ctrl+shift+alt+[KeyF] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyG |   п   |                         G |     |                         G |                              g |                         G |                         [KeyG] |         |
+|                      Ctrl+KeyG |   п   |                    Ctrl+G |     |                    Ctrl+G |                         ctrl+g |                    Ctrl+G |                    ctrl+[KeyG] |         |
+|                     Shift+KeyG |   П   |                   Shift+G |     |                   Shift+G |                        shift+g |                   Shift+G |                   shift+[KeyG] |         |
+|                Ctrl+Shift+KeyG |   П   |              Ctrl+Shift+G |     |              Ctrl+Shift+G |                   ctrl+shift+g |              Ctrl+Shift+G |              ctrl+shift+[KeyG] |         |
+|                       Alt+KeyG |   п   |                     Alt+G |     |                     Alt+G |                          alt+g |                     Alt+G |                     alt+[KeyG] |         |
+|                  Ctrl+Alt+KeyG |   п   |                Ctrl+Alt+G |     |                Ctrl+Alt+G |                     ctrl+alt+g |                Ctrl+Alt+G |                ctrl+alt+[KeyG] |         |
+|                 Shift+Alt+KeyG |   П   |               Shift+Alt+G |     |               Shift+Alt+G |                    shift+alt+g |               Shift+Alt+G |               shift+alt+[KeyG] |         |
+|            Ctrl+Shift+Alt+KeyG |   П   |          Ctrl+Shift+Alt+G |     |          Ctrl+Shift+Alt+G |               ctrl+shift+alt+g |          Ctrl+Shift+Alt+G |          ctrl+shift+alt+[KeyG] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyH |   р   |                         H |     |                         H |                              h |                         H |                         [KeyH] |         |
+|                      Ctrl+KeyH |   р   |                    Ctrl+H |     |                    Ctrl+H |                         ctrl+h |                    Ctrl+H |                    ctrl+[KeyH] |         |
+|                     Shift+KeyH |   Р   |                   Shift+H |     |                   Shift+H |                        shift+h |                   Shift+H |                   shift+[KeyH] |         |
+|                Ctrl+Shift+KeyH |   Р   |              Ctrl+Shift+H |     |              Ctrl+Shift+H |                   ctrl+shift+h |              Ctrl+Shift+H |              ctrl+shift+[KeyH] |         |
+|                       Alt+KeyH |   р   |                     Alt+H |     |                     Alt+H |                          alt+h |                     Alt+H |                     alt+[KeyH] |         |
+|                  Ctrl+Alt+KeyH |   р   |                Ctrl+Alt+H |     |                Ctrl+Alt+H |                     ctrl+alt+h |                Ctrl+Alt+H |                ctrl+alt+[KeyH] |         |
+|                 Shift+Alt+KeyH |   Р   |               Shift+Alt+H |     |               Shift+Alt+H |                    shift+alt+h |               Shift+Alt+H |               shift+alt+[KeyH] |         |
+|            Ctrl+Shift+Alt+KeyH |   Р   |          Ctrl+Shift+Alt+H |     |          Ctrl+Shift+Alt+H |               ctrl+shift+alt+h |          Ctrl+Shift+Alt+H |          ctrl+shift+alt+[KeyH] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyI |   ш   |                         I |     |                         I |                              i |                         I |                         [KeyI] |         |
+|                      Ctrl+KeyI |   ш   |                    Ctrl+I |     |                    Ctrl+I |                         ctrl+i |                    Ctrl+I |                    ctrl+[KeyI] |         |
+|                     Shift+KeyI |   Ш   |                   Shift+I |     |                   Shift+I |                        shift+i |                   Shift+I |                   shift+[KeyI] |         |
+|                Ctrl+Shift+KeyI |   Ш   |              Ctrl+Shift+I |     |              Ctrl+Shift+I |                   ctrl+shift+i |              Ctrl+Shift+I |              ctrl+shift+[KeyI] |         |
+|                       Alt+KeyI |   ш   |                     Alt+I |     |                     Alt+I |                          alt+i |                     Alt+I |                     alt+[KeyI] |         |
+|                  Ctrl+Alt+KeyI |   ш   |                Ctrl+Alt+I |     |                Ctrl+Alt+I |                     ctrl+alt+i |                Ctrl+Alt+I |                ctrl+alt+[KeyI] |         |
+|                 Shift+Alt+KeyI |   Ш   |               Shift+Alt+I |     |               Shift+Alt+I |                    shift+alt+i |               Shift+Alt+I |               shift+alt+[KeyI] |         |
+|            Ctrl+Shift+Alt+KeyI |   Ш   |          Ctrl+Shift+Alt+I |     |          Ctrl+Shift+Alt+I |               ctrl+shift+alt+i |          Ctrl+Shift+Alt+I |          ctrl+shift+alt+[KeyI] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyJ |   о   |                         J |     |                         J |                              j |                         J |                         [KeyJ] |         |
+|                      Ctrl+KeyJ |   о   |                    Ctrl+J |     |                    Ctrl+J |                         ctrl+j |                    Ctrl+J |                    ctrl+[KeyJ] |         |
+|                     Shift+KeyJ |   О   |                   Shift+J |     |                   Shift+J |                        shift+j |                   Shift+J |                   shift+[KeyJ] |         |
+|                Ctrl+Shift+KeyJ |   О   |              Ctrl+Shift+J |     |              Ctrl+Shift+J |                   ctrl+shift+j |              Ctrl+Shift+J |              ctrl+shift+[KeyJ] |         |
+|                       Alt+KeyJ |   о   |                     Alt+J |     |                     Alt+J |                          alt+j |                     Alt+J |                     alt+[KeyJ] |         |
+|                  Ctrl+Alt+KeyJ |   о   |                Ctrl+Alt+J |     |                Ctrl+Alt+J |                     ctrl+alt+j |                Ctrl+Alt+J |                ctrl+alt+[KeyJ] |         |
+|                 Shift+Alt+KeyJ |   О   |               Shift+Alt+J |     |               Shift+Alt+J |                    shift+alt+j |               Shift+Alt+J |               shift+alt+[KeyJ] |         |
+|            Ctrl+Shift+Alt+KeyJ |   О   |          Ctrl+Shift+Alt+J |     |          Ctrl+Shift+Alt+J |               ctrl+shift+alt+j |          Ctrl+Shift+Alt+J |          ctrl+shift+alt+[KeyJ] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyK |   л   |                         K |     |                         K |                              k |                         K |                         [KeyK] |         |
+|                      Ctrl+KeyK |   л   |                    Ctrl+K |     |                    Ctrl+K |                         ctrl+k |                    Ctrl+K |                    ctrl+[KeyK] |         |
+|                     Shift+KeyK |   Л   |                   Shift+K |     |                   Shift+K |                        shift+k |                   Shift+K |                   shift+[KeyK] |         |
+|                Ctrl+Shift+KeyK |   Л   |              Ctrl+Shift+K |     |              Ctrl+Shift+K |                   ctrl+shift+k |              Ctrl+Shift+K |              ctrl+shift+[KeyK] |         |
+|                       Alt+KeyK |   л   |                     Alt+K |     |                     Alt+K |                          alt+k |                     Alt+K |                     alt+[KeyK] |         |
+|                  Ctrl+Alt+KeyK |   л   |                Ctrl+Alt+K |     |                Ctrl+Alt+K |                     ctrl+alt+k |                Ctrl+Alt+K |                ctrl+alt+[KeyK] |         |
+|                 Shift+Alt+KeyK |   Л   |               Shift+Alt+K |     |               Shift+Alt+K |                    shift+alt+k |               Shift+Alt+K |               shift+alt+[KeyK] |         |
+|            Ctrl+Shift+Alt+KeyK |   Л   |          Ctrl+Shift+Alt+K |     |          Ctrl+Shift+Alt+K |               ctrl+shift+alt+k |          Ctrl+Shift+Alt+K |          ctrl+shift+alt+[KeyK] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyL |   д   |                         L |     |                         L |                              l |                         L |                         [KeyL] |         |
+|                      Ctrl+KeyL |   д   |                    Ctrl+L |     |                    Ctrl+L |                         ctrl+l |                    Ctrl+L |                    ctrl+[KeyL] |         |
+|                     Shift+KeyL |   Д   |                   Shift+L |     |                   Shift+L |                        shift+l |                   Shift+L |                   shift+[KeyL] |         |
+|                Ctrl+Shift+KeyL |   Д   |              Ctrl+Shift+L |     |              Ctrl+Shift+L |                   ctrl+shift+l |              Ctrl+Shift+L |              ctrl+shift+[KeyL] |         |
+|                       Alt+KeyL |   д   |                     Alt+L |     |                     Alt+L |                          alt+l |                     Alt+L |                     alt+[KeyL] |         |
+|                  Ctrl+Alt+KeyL |   д   |                Ctrl+Alt+L |     |                Ctrl+Alt+L |                     ctrl+alt+l |                Ctrl+Alt+L |                ctrl+alt+[KeyL] |         |
+|                 Shift+Alt+KeyL |   Д   |               Shift+Alt+L |     |               Shift+Alt+L |                    shift+alt+l |               Shift+Alt+L |               shift+alt+[KeyL] |         |
+|            Ctrl+Shift+Alt+KeyL |   Д   |          Ctrl+Shift+Alt+L |     |          Ctrl+Shift+Alt+L |               ctrl+shift+alt+l |          Ctrl+Shift+Alt+L |          ctrl+shift+alt+[KeyL] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyM |   ь   |                         M |     |                         M |                              m |                         M |                         [KeyM] |         |
+|                      Ctrl+KeyM |   ь   |                    Ctrl+M |     |                    Ctrl+M |                         ctrl+m |                    Ctrl+M |                    ctrl+[KeyM] |         |
+|                     Shift+KeyM |   Ь   |                   Shift+M |     |                   Shift+M |                        shift+m |                   Shift+M |                   shift+[KeyM] |         |
+|                Ctrl+Shift+KeyM |   Ь   |              Ctrl+Shift+M |     |              Ctrl+Shift+M |                   ctrl+shift+m |              Ctrl+Shift+M |              ctrl+shift+[KeyM] |         |
+|                       Alt+KeyM |   ь   |                     Alt+M |     |                     Alt+M |                          alt+m |                     Alt+M |                     alt+[KeyM] |         |
+|                  Ctrl+Alt+KeyM |   ь   |                Ctrl+Alt+M |     |                Ctrl+Alt+M |                     ctrl+alt+m |                Ctrl+Alt+M |                ctrl+alt+[KeyM] |         |
+|                 Shift+Alt+KeyM |   Ь   |               Shift+Alt+M |     |               Shift+Alt+M |                    shift+alt+m |               Shift+Alt+M |               shift+alt+[KeyM] |         |
+|            Ctrl+Shift+Alt+KeyM |   Ь   |          Ctrl+Shift+Alt+M |     |          Ctrl+Shift+Alt+M |               ctrl+shift+alt+m |          Ctrl+Shift+Alt+M |          ctrl+shift+alt+[KeyM] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyN |   т   |                         N |     |                         N |                              n |                         N |                         [KeyN] |         |
+|                      Ctrl+KeyN |   т   |                    Ctrl+N |     |                    Ctrl+N |                         ctrl+n |                    Ctrl+N |                    ctrl+[KeyN] |         |
+|                     Shift+KeyN |   Т   |                   Shift+N |     |                   Shift+N |                        shift+n |                   Shift+N |                   shift+[KeyN] |         |
+|                Ctrl+Shift+KeyN |   Т   |              Ctrl+Shift+N |     |              Ctrl+Shift+N |                   ctrl+shift+n |              Ctrl+Shift+N |              ctrl+shift+[KeyN] |         |
+|                       Alt+KeyN |   т   |                     Alt+N |     |                     Alt+N |                          alt+n |                     Alt+N |                     alt+[KeyN] |         |
+|                  Ctrl+Alt+KeyN |   т   |                Ctrl+Alt+N |     |                Ctrl+Alt+N |                     ctrl+alt+n |                Ctrl+Alt+N |                ctrl+alt+[KeyN] |         |
+|                 Shift+Alt+KeyN |   Т   |               Shift+Alt+N |     |               Shift+Alt+N |                    shift+alt+n |               Shift+Alt+N |               shift+alt+[KeyN] |         |
+|            Ctrl+Shift+Alt+KeyN |   Т   |          Ctrl+Shift+Alt+N |     |          Ctrl+Shift+Alt+N |               ctrl+shift+alt+n |          Ctrl+Shift+Alt+N |          ctrl+shift+alt+[KeyN] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyO |   щ   |                         O |     |                         O |                              o |                         O |                         [KeyO] |         |
+|                      Ctrl+KeyO |   щ   |                    Ctrl+O |     |                    Ctrl+O |                         ctrl+o |                    Ctrl+O |                    ctrl+[KeyO] |         |
+|                     Shift+KeyO |   Щ   |                   Shift+O |     |                   Shift+O |                        shift+o |                   Shift+O |                   shift+[KeyO] |         |
+|                Ctrl+Shift+KeyO |   Щ   |              Ctrl+Shift+O |     |              Ctrl+Shift+O |                   ctrl+shift+o |              Ctrl+Shift+O |              ctrl+shift+[KeyO] |         |
+|                       Alt+KeyO |   щ   |                     Alt+O |     |                     Alt+O |                          alt+o |                     Alt+O |                     alt+[KeyO] |         |
+|                  Ctrl+Alt+KeyO |   щ   |                Ctrl+Alt+O |     |                Ctrl+Alt+O |                     ctrl+alt+o |                Ctrl+Alt+O |                ctrl+alt+[KeyO] |         |
+|                 Shift+Alt+KeyO |   Щ   |               Shift+Alt+O |     |               Shift+Alt+O |                    shift+alt+o |               Shift+Alt+O |               shift+alt+[KeyO] |         |
+|            Ctrl+Shift+Alt+KeyO |   Щ   |          Ctrl+Shift+Alt+O |     |          Ctrl+Shift+Alt+O |               ctrl+shift+alt+o |          Ctrl+Shift+Alt+O |          ctrl+shift+alt+[KeyO] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyP |   з   |                         P |     |                         P |                              p |                         P |                         [KeyP] |         |
+|                      Ctrl+KeyP |   з   |                    Ctrl+P |     |                    Ctrl+P |                         ctrl+p |                    Ctrl+P |                    ctrl+[KeyP] |         |
+|                     Shift+KeyP |   З   |                   Shift+P |     |                   Shift+P |                        shift+p |                   Shift+P |                   shift+[KeyP] |         |
+|                Ctrl+Shift+KeyP |   З   |              Ctrl+Shift+P |     |              Ctrl+Shift+P |                   ctrl+shift+p |              Ctrl+Shift+P |              ctrl+shift+[KeyP] |         |
+|                       Alt+KeyP |   з   |                     Alt+P |     |                     Alt+P |                          alt+p |                     Alt+P |                     alt+[KeyP] |         |
+|                  Ctrl+Alt+KeyP |   з   |                Ctrl+Alt+P |     |                Ctrl+Alt+P |                     ctrl+alt+p |                Ctrl+Alt+P |                ctrl+alt+[KeyP] |         |
+|                 Shift+Alt+KeyP |   З   |               Shift+Alt+P |     |               Shift+Alt+P |                    shift+alt+p |               Shift+Alt+P |               shift+alt+[KeyP] |         |
+|            Ctrl+Shift+Alt+KeyP |   З   |          Ctrl+Shift+Alt+P |     |          Ctrl+Shift+Alt+P |               ctrl+shift+alt+p |          Ctrl+Shift+Alt+P |          ctrl+shift+alt+[KeyP] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyQ |   й   |                         Q |     |                         Q |                              q |                         Q |                         [KeyQ] |         |
+|                      Ctrl+KeyQ |   й   |                    Ctrl+Q |     |                    Ctrl+Q |                         ctrl+q |                    Ctrl+Q |                    ctrl+[KeyQ] |         |
+|                     Shift+KeyQ |   Й   |                   Shift+Q |     |                   Shift+Q |                        shift+q |                   Shift+Q |                   shift+[KeyQ] |         |
+|                Ctrl+Shift+KeyQ |   Й   |              Ctrl+Shift+Q |     |              Ctrl+Shift+Q |                   ctrl+shift+q |              Ctrl+Shift+Q |              ctrl+shift+[KeyQ] |         |
+|                       Alt+KeyQ |   й   |                     Alt+Q |     |                     Alt+Q |                          alt+q |                     Alt+Q |                     alt+[KeyQ] |         |
+|                  Ctrl+Alt+KeyQ |   й   |                Ctrl+Alt+Q |     |                Ctrl+Alt+Q |                     ctrl+alt+q |                Ctrl+Alt+Q |                ctrl+alt+[KeyQ] |         |
+|                 Shift+Alt+KeyQ |   Й   |               Shift+Alt+Q |     |               Shift+Alt+Q |                    shift+alt+q |               Shift+Alt+Q |               shift+alt+[KeyQ] |         |
+|            Ctrl+Shift+Alt+KeyQ |   Й   |          Ctrl+Shift+Alt+Q |     |          Ctrl+Shift+Alt+Q |               ctrl+shift+alt+q |          Ctrl+Shift+Alt+Q |          ctrl+shift+alt+[KeyQ] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyR |   к   |                         R |     |                         R |                              r |                         R |                         [KeyR] |         |
+|                      Ctrl+KeyR |   к   |                    Ctrl+R |     |                    Ctrl+R |                         ctrl+r |                    Ctrl+R |                    ctrl+[KeyR] |         |
+|                     Shift+KeyR |   К   |                   Shift+R |     |                   Shift+R |                        shift+r |                   Shift+R |                   shift+[KeyR] |         |
+|                Ctrl+Shift+KeyR |   К   |              Ctrl+Shift+R |     |              Ctrl+Shift+R |                   ctrl+shift+r |              Ctrl+Shift+R |              ctrl+shift+[KeyR] |         |
+|                       Alt+KeyR |   к   |                     Alt+R |     |                     Alt+R |                          alt+r |                     Alt+R |                     alt+[KeyR] |         |
+|                  Ctrl+Alt+KeyR |   к   |                Ctrl+Alt+R |     |                Ctrl+Alt+R |                     ctrl+alt+r |                Ctrl+Alt+R |                ctrl+alt+[KeyR] |         |
+|                 Shift+Alt+KeyR |   К   |               Shift+Alt+R |     |               Shift+Alt+R |                    shift+alt+r |               Shift+Alt+R |               shift+alt+[KeyR] |         |
+|            Ctrl+Shift+Alt+KeyR |   К   |          Ctrl+Shift+Alt+R |     |          Ctrl+Shift+Alt+R |               ctrl+shift+alt+r |          Ctrl+Shift+Alt+R |          ctrl+shift+alt+[KeyR] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyS |   ы   |                         S |     |                         S |                              s |                         S |                         [KeyS] |         |
+|                      Ctrl+KeyS |   ы   |                    Ctrl+S |     |                    Ctrl+S |                         ctrl+s |                    Ctrl+S |                    ctrl+[KeyS] |         |
+|                     Shift+KeyS |   Ы   |                   Shift+S |     |                   Shift+S |                        shift+s |                   Shift+S |                   shift+[KeyS] |         |
+|                Ctrl+Shift+KeyS |   Ы   |              Ctrl+Shift+S |     |              Ctrl+Shift+S |                   ctrl+shift+s |              Ctrl+Shift+S |              ctrl+shift+[KeyS] |         |
+|                       Alt+KeyS |   ы   |                     Alt+S |     |                     Alt+S |                          alt+s |                     Alt+S |                     alt+[KeyS] |         |
+|                  Ctrl+Alt+KeyS |   ы   |                Ctrl+Alt+S |     |                Ctrl+Alt+S |                     ctrl+alt+s |                Ctrl+Alt+S |                ctrl+alt+[KeyS] |         |
+|                 Shift+Alt+KeyS |   Ы   |               Shift+Alt+S |     |               Shift+Alt+S |                    shift+alt+s |               Shift+Alt+S |               shift+alt+[KeyS] |         |
+|            Ctrl+Shift+Alt+KeyS |   Ы   |          Ctrl+Shift+Alt+S |     |          Ctrl+Shift+Alt+S |               ctrl+shift+alt+s |          Ctrl+Shift+Alt+S |          ctrl+shift+alt+[KeyS] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyT |   е   |                         T |     |                         T |                              t |                         T |                         [KeyT] |         |
+|                      Ctrl+KeyT |   е   |                    Ctrl+T |     |                    Ctrl+T |                         ctrl+t |                    Ctrl+T |                    ctrl+[KeyT] |         |
+|                     Shift+KeyT |   Е   |                   Shift+T |     |                   Shift+T |                        shift+t |                   Shift+T |                   shift+[KeyT] |         |
+|                Ctrl+Shift+KeyT |   Е   |              Ctrl+Shift+T |     |              Ctrl+Shift+T |                   ctrl+shift+t |              Ctrl+Shift+T |              ctrl+shift+[KeyT] |         |
+|                       Alt+KeyT |   е   |                     Alt+T |     |                     Alt+T |                          alt+t |                     Alt+T |                     alt+[KeyT] |         |
+|                  Ctrl+Alt+KeyT |   е   |                Ctrl+Alt+T |     |                Ctrl+Alt+T |                     ctrl+alt+t |                Ctrl+Alt+T |                ctrl+alt+[KeyT] |         |
+|                 Shift+Alt+KeyT |   Е   |               Shift+Alt+T |     |               Shift+Alt+T |                    shift+alt+t |               Shift+Alt+T |               shift+alt+[KeyT] |         |
+|            Ctrl+Shift+Alt+KeyT |   Е   |          Ctrl+Shift+Alt+T |     |          Ctrl+Shift+Alt+T |               ctrl+shift+alt+t |          Ctrl+Shift+Alt+T |          ctrl+shift+alt+[KeyT] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyU |   г   |                         U |     |                         U |                              u |                         U |                         [KeyU] |         |
+|                      Ctrl+KeyU |   г   |                    Ctrl+U |     |                    Ctrl+U |                         ctrl+u |                    Ctrl+U |                    ctrl+[KeyU] |         |
+|                     Shift+KeyU |   Г   |                   Shift+U |     |                   Shift+U |                        shift+u |                   Shift+U |                   shift+[KeyU] |         |
+|                Ctrl+Shift+KeyU |   Г   |              Ctrl+Shift+U |     |              Ctrl+Shift+U |                   ctrl+shift+u |              Ctrl+Shift+U |              ctrl+shift+[KeyU] |         |
+|                       Alt+KeyU |   г   |                     Alt+U |     |                     Alt+U |                          alt+u |                     Alt+U |                     alt+[KeyU] |         |
+|                  Ctrl+Alt+KeyU |   г   |                Ctrl+Alt+U |     |                Ctrl+Alt+U |                     ctrl+alt+u |                Ctrl+Alt+U |                ctrl+alt+[KeyU] |         |
+|                 Shift+Alt+KeyU |   Г   |               Shift+Alt+U |     |               Shift+Alt+U |                    shift+alt+u |               Shift+Alt+U |               shift+alt+[KeyU] |         |
+|            Ctrl+Shift+Alt+KeyU |   Г   |          Ctrl+Shift+Alt+U |     |          Ctrl+Shift+Alt+U |               ctrl+shift+alt+u |          Ctrl+Shift+Alt+U |          ctrl+shift+alt+[KeyU] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyV |   м   |                         V |     |                         V |                              v |                         V |                         [KeyV] |         |
+|                      Ctrl+KeyV |   м   |                    Ctrl+V |     |                    Ctrl+V |                         ctrl+v |                    Ctrl+V |                    ctrl+[KeyV] |         |
+|                     Shift+KeyV |   М   |                   Shift+V |     |                   Shift+V |                        shift+v |                   Shift+V |                   shift+[KeyV] |         |
+|                Ctrl+Shift+KeyV |   М   |              Ctrl+Shift+V |     |              Ctrl+Shift+V |                   ctrl+shift+v |              Ctrl+Shift+V |              ctrl+shift+[KeyV] |         |
+|                       Alt+KeyV |   м   |                     Alt+V |     |                     Alt+V |                          alt+v |                     Alt+V |                     alt+[KeyV] |         |
+|                  Ctrl+Alt+KeyV |   м   |                Ctrl+Alt+V |     |                Ctrl+Alt+V |                     ctrl+alt+v |                Ctrl+Alt+V |                ctrl+alt+[KeyV] |         |
+|                 Shift+Alt+KeyV |   М   |               Shift+Alt+V |     |               Shift+Alt+V |                    shift+alt+v |               Shift+Alt+V |               shift+alt+[KeyV] |         |
+|            Ctrl+Shift+Alt+KeyV |   М   |          Ctrl+Shift+Alt+V |     |          Ctrl+Shift+Alt+V |               ctrl+shift+alt+v |          Ctrl+Shift+Alt+V |          ctrl+shift+alt+[KeyV] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyW |   ц   |                         W |     |                         W |                              w |                         W |                         [KeyW] |         |
+|                      Ctrl+KeyW |   ц   |                    Ctrl+W |     |                    Ctrl+W |                         ctrl+w |                    Ctrl+W |                    ctrl+[KeyW] |         |
+|                     Shift+KeyW |   Ц   |                   Shift+W |     |                   Shift+W |                        shift+w |                   Shift+W |                   shift+[KeyW] |         |
+|                Ctrl+Shift+KeyW |   Ц   |              Ctrl+Shift+W |     |              Ctrl+Shift+W |                   ctrl+shift+w |              Ctrl+Shift+W |              ctrl+shift+[KeyW] |         |
+|                       Alt+KeyW |   ц   |                     Alt+W |     |                     Alt+W |                          alt+w |                     Alt+W |                     alt+[KeyW] |         |
+|                  Ctrl+Alt+KeyW |   ц   |                Ctrl+Alt+W |     |                Ctrl+Alt+W |                     ctrl+alt+w |                Ctrl+Alt+W |                ctrl+alt+[KeyW] |         |
+|                 Shift+Alt+KeyW |   Ц   |               Shift+Alt+W |     |               Shift+Alt+W |                    shift+alt+w |               Shift+Alt+W |               shift+alt+[KeyW] |         |
+|            Ctrl+Shift+Alt+KeyW |   Ц   |          Ctrl+Shift+Alt+W |     |          Ctrl+Shift+Alt+W |               ctrl+shift+alt+w |          Ctrl+Shift+Alt+W |          ctrl+shift+alt+[KeyW] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyX |   ч   |                         X |     |                         X |                              x |                         X |                         [KeyX] |         |
+|                      Ctrl+KeyX |   ч   |                    Ctrl+X |     |                    Ctrl+X |                         ctrl+x |                    Ctrl+X |                    ctrl+[KeyX] |         |
+|                     Shift+KeyX |   Ч   |                   Shift+X |     |                   Shift+X |                        shift+x |                   Shift+X |                   shift+[KeyX] |         |
+|                Ctrl+Shift+KeyX |   Ч   |              Ctrl+Shift+X |     |              Ctrl+Shift+X |                   ctrl+shift+x |              Ctrl+Shift+X |              ctrl+shift+[KeyX] |         |
+|                       Alt+KeyX |   ч   |                     Alt+X |     |                     Alt+X |                          alt+x |                     Alt+X |                     alt+[KeyX] |         |
+|                  Ctrl+Alt+KeyX |   ч   |                Ctrl+Alt+X |     |                Ctrl+Alt+X |                     ctrl+alt+x |                Ctrl+Alt+X |                ctrl+alt+[KeyX] |         |
+|                 Shift+Alt+KeyX |   Ч   |               Shift+Alt+X |     |               Shift+Alt+X |                    shift+alt+x |               Shift+Alt+X |               shift+alt+[KeyX] |         |
+|            Ctrl+Shift+Alt+KeyX |   Ч   |          Ctrl+Shift+Alt+X |     |          Ctrl+Shift+Alt+X |               ctrl+shift+alt+x |          Ctrl+Shift+Alt+X |          ctrl+shift+alt+[KeyX] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyY |   н   |                         Y |     |                         Y |                              y |                         Y |                         [KeyY] |         |
+|                      Ctrl+KeyY |   н   |                    Ctrl+Y |     |                    Ctrl+Y |                         ctrl+y |                    Ctrl+Y |                    ctrl+[KeyY] |         |
+|                     Shift+KeyY |   Н   |                   Shift+Y |     |                   Shift+Y |                        shift+y |                   Shift+Y |                   shift+[KeyY] |         |
+|                Ctrl+Shift+KeyY |   Н   |              Ctrl+Shift+Y |     |              Ctrl+Shift+Y |                   ctrl+shift+y |              Ctrl+Shift+Y |              ctrl+shift+[KeyY] |         |
+|                       Alt+KeyY |   н   |                     Alt+Y |     |                     Alt+Y |                          alt+y |                     Alt+Y |                     alt+[KeyY] |         |
+|                  Ctrl+Alt+KeyY |   н   |                Ctrl+Alt+Y |     |                Ctrl+Alt+Y |                     ctrl+alt+y |                Ctrl+Alt+Y |                ctrl+alt+[KeyY] |         |
+|                 Shift+Alt+KeyY |   Н   |               Shift+Alt+Y |     |               Shift+Alt+Y |                    shift+alt+y |               Shift+Alt+Y |               shift+alt+[KeyY] |         |
+|            Ctrl+Shift+Alt+KeyY |   Н   |          Ctrl+Shift+Alt+Y |     |          Ctrl+Shift+Alt+Y |               ctrl+shift+alt+y |          Ctrl+Shift+Alt+Y |          ctrl+shift+alt+[KeyY] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyZ |   я   |                         Z |     |                         Z |                              z |                         Z |                         [KeyZ] |         |
+|                      Ctrl+KeyZ |   я   |                    Ctrl+Z |     |                    Ctrl+Z |                         ctrl+z |                    Ctrl+Z |                    ctrl+[KeyZ] |         |
+|                     Shift+KeyZ |   Я   |                   Shift+Z |     |                   Shift+Z |                        shift+z |                   Shift+Z |                   shift+[KeyZ] |         |
+|                Ctrl+Shift+KeyZ |   Я   |              Ctrl+Shift+Z |     |              Ctrl+Shift+Z |                   ctrl+shift+z |              Ctrl+Shift+Z |              ctrl+shift+[KeyZ] |         |
+|                       Alt+KeyZ |   я   |                     Alt+Z |     |                     Alt+Z |                          alt+z |                     Alt+Z |                     alt+[KeyZ] |         |
+|                  Ctrl+Alt+KeyZ |   я   |                Ctrl+Alt+Z |     |                Ctrl+Alt+Z |                     ctrl+alt+z |                Ctrl+Alt+Z |                ctrl+alt+[KeyZ] |         |
+|                 Shift+Alt+KeyZ |   Я   |               Shift+Alt+Z |     |               Shift+Alt+Z |                    shift+alt+z |               Shift+Alt+Z |               shift+alt+[KeyZ] |         |
+|            Ctrl+Shift+Alt+KeyZ |   Я   |          Ctrl+Shift+Alt+Z |     |          Ctrl+Shift+Alt+Z |               ctrl+shift+alt+z |          Ctrl+Shift+Alt+Z |          ctrl+shift+alt+[KeyZ] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit1 |   1   |                         1 |     |                         1 |                              1 |                         1 |                       [Digit1] |         |
+|                    Ctrl+Digit1 |   1   |                    Ctrl+1 |     |                    Ctrl+1 |                         ctrl+1 |                    Ctrl+1 |                  ctrl+[Digit1] |         |
+|                   Shift+Digit1 |   !   |                   Shift+1 |     |                   Shift+1 |                        shift+1 |                   Shift+1 |                 shift+[Digit1] |         |
+|              Ctrl+Shift+Digit1 |   !   |              Ctrl+Shift+1 |     |              Ctrl+Shift+1 |                   ctrl+shift+1 |              Ctrl+Shift+1 |            ctrl+shift+[Digit1] |         |
+|                     Alt+Digit1 |   1   |                     Alt+1 |     |                     Alt+1 |                          alt+1 |                     Alt+1 |                   alt+[Digit1] |         |
+|                Ctrl+Alt+Digit1 |   1   |                Ctrl+Alt+1 |     |                Ctrl+Alt+1 |                     ctrl+alt+1 |                Ctrl+Alt+1 |              ctrl+alt+[Digit1] |         |
+|               Shift+Alt+Digit1 |   !   |               Shift+Alt+1 |     |               Shift+Alt+1 |                    shift+alt+1 |               Shift+Alt+1 |             shift+alt+[Digit1] |         |
+|          Ctrl+Shift+Alt+Digit1 |   !   |          Ctrl+Shift+Alt+1 |     |          Ctrl+Shift+Alt+1 |               ctrl+shift+alt+1 |          Ctrl+Shift+Alt+1 |        ctrl+shift+alt+[Digit1] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit2 |   2   |                         2 |     |                         2 |                              2 |                         2 |                       [Digit2] |         |
+|                    Ctrl+Digit2 |   2   |                    Ctrl+2 |     |                    Ctrl+2 |                         ctrl+2 |                    Ctrl+2 |                  ctrl+[Digit2] |         |
+|                   Shift+Digit2 |   "   |                   Shift+2 |     |                   Shift+2 |                        shift+2 |                   Shift+2 |                 shift+[Digit2] |         |
+|                                |       |                   Shift+' |     |                           |                                |                           |                                |         |
+|              Ctrl+Shift+Digit2 |   "   |              Ctrl+Shift+2 |     |              Ctrl+Shift+2 |                   ctrl+shift+2 |              Ctrl+Shift+2 |            ctrl+shift+[Digit2] |         |
+|                                |       |              Ctrl+Shift+' |     |                           |                                |                           |                                |         |
+|                     Alt+Digit2 |   2   |                     Alt+2 |     |                     Alt+2 |                          alt+2 |                     Alt+2 |                   alt+[Digit2] |         |
+|                Ctrl+Alt+Digit2 |   2   |                Ctrl+Alt+2 |     |                Ctrl+Alt+2 |                     ctrl+alt+2 |                Ctrl+Alt+2 |              ctrl+alt+[Digit2] |         |
+|               Shift+Alt+Digit2 |   "   |               Shift+Alt+2 |     |               Shift+Alt+2 |                    shift+alt+2 |               Shift+Alt+2 |             shift+alt+[Digit2] |         |
+|                                |       |               Shift+Alt+' |     |                           |                                |                           |                                |         |
+|          Ctrl+Shift+Alt+Digit2 |   "   |          Ctrl+Shift+Alt+2 |     |          Ctrl+Shift+Alt+2 |               ctrl+shift+alt+2 |          Ctrl+Shift+Alt+2 |        ctrl+shift+alt+[Digit2] |         |
+|                                |       |          Ctrl+Shift+Alt+' |     |                           |                                |                           |                                |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit3 |   3   |                         3 |     |                         3 |                              3 |                         3 |                       [Digit3] |         |
+|                    Ctrl+Digit3 |   3   |                    Ctrl+3 |     |                    Ctrl+3 |                         ctrl+3 |                    Ctrl+3 |                  ctrl+[Digit3] |         |
+|                   Shift+Digit3 |   №   |                   Shift+3 |     |                   Shift+3 |                        shift+3 |                   Shift+3 |                 shift+[Digit3] |         |
+|              Ctrl+Shift+Digit3 |   №   |              Ctrl+Shift+3 |     |              Ctrl+Shift+3 |                   ctrl+shift+3 |              Ctrl+Shift+3 |            ctrl+shift+[Digit3] |         |
+|                     Alt+Digit3 |   3   |                     Alt+3 |     |                     Alt+3 |                          alt+3 |                     Alt+3 |                   alt+[Digit3] |         |
+|                Ctrl+Alt+Digit3 |   3   |                Ctrl+Alt+3 |     |                Ctrl+Alt+3 |                     ctrl+alt+3 |                Ctrl+Alt+3 |              ctrl+alt+[Digit3] |         |
+|               Shift+Alt+Digit3 |   №   |               Shift+Alt+3 |     |               Shift+Alt+3 |                    shift+alt+3 |               Shift+Alt+3 |             shift+alt+[Digit3] |         |
+|          Ctrl+Shift+Alt+Digit3 |   №   |          Ctrl+Shift+Alt+3 |     |          Ctrl+Shift+Alt+3 |               ctrl+shift+alt+3 |          Ctrl+Shift+Alt+3 |        ctrl+shift+alt+[Digit3] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit4 |   4   |                         4 |     |                         4 |                              4 |                         4 |                       [Digit4] |         |
+|                    Ctrl+Digit4 |   4   |                    Ctrl+4 |     |                    Ctrl+4 |                         ctrl+4 |                    Ctrl+4 |                  ctrl+[Digit4] |         |
+|                   Shift+Digit4 |   ;   |                   Shift+4 |     |                   Shift+4 |                        shift+4 |                   Shift+4 |                 shift+[Digit4] |         |
+|                                |       |                         ; |     |                           |                                |                           |                                |         |
+|              Ctrl+Shift+Digit4 |   ;   |              Ctrl+Shift+4 |     |              Ctrl+Shift+4 |                   ctrl+shift+4 |              Ctrl+Shift+4 |            ctrl+shift+[Digit4] |         |
+|                                |       |                    Ctrl+; |     |                           |                                |                           |                                |         |
+|                     Alt+Digit4 |   4   |                     Alt+4 |     |                     Alt+4 |                          alt+4 |                     Alt+4 |                   alt+[Digit4] |         |
+|                Ctrl+Alt+Digit4 |   4   |                Ctrl+Alt+4 |     |                Ctrl+Alt+4 |                     ctrl+alt+4 |                Ctrl+Alt+4 |              ctrl+alt+[Digit4] |         |
+|               Shift+Alt+Digit4 |   ;   |               Shift+Alt+4 |     |               Shift+Alt+4 |                    shift+alt+4 |               Shift+Alt+4 |             shift+alt+[Digit4] |         |
+|                                |       |                     Alt+; |     |                           |                                |                           |                                |         |
+|          Ctrl+Shift+Alt+Digit4 |   ;   |          Ctrl+Shift+Alt+4 |     |          Ctrl+Shift+Alt+4 |               ctrl+shift+alt+4 |          Ctrl+Shift+Alt+4 |        ctrl+shift+alt+[Digit4] |         |
+|                                |       |                Ctrl+Alt+; |     |                           |                                |                           |                                |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit5 |   5   |                         5 |     |                         5 |                              5 |                         5 |                       [Digit5] |         |
+|                    Ctrl+Digit5 |   5   |                    Ctrl+5 |     |                    Ctrl+5 |                         ctrl+5 |                    Ctrl+5 |                  ctrl+[Digit5] |         |
+|                   Shift+Digit5 |   %   |                   Shift+5 |     |                   Shift+5 |                        shift+5 |                   Shift+5 |                 shift+[Digit5] |         |
+|              Ctrl+Shift+Digit5 |   %   |              Ctrl+Shift+5 |     |              Ctrl+Shift+5 |                   ctrl+shift+5 |              Ctrl+Shift+5 |            ctrl+shift+[Digit5] |         |
+|                     Alt+Digit5 |   5   |                     Alt+5 |     |                     Alt+5 |                          alt+5 |                     Alt+5 |                   alt+[Digit5] |         |
+|                Ctrl+Alt+Digit5 |   5   |                Ctrl+Alt+5 |     |                Ctrl+Alt+5 |                     ctrl+alt+5 |                Ctrl+Alt+5 |              ctrl+alt+[Digit5] |         |
+|               Shift+Alt+Digit5 |   %   |               Shift+Alt+5 |     |               Shift+Alt+5 |                    shift+alt+5 |               Shift+Alt+5 |             shift+alt+[Digit5] |         |
+|          Ctrl+Shift+Alt+Digit5 |   %   |          Ctrl+Shift+Alt+5 |     |          Ctrl+Shift+Alt+5 |               ctrl+shift+alt+5 |          Ctrl+Shift+Alt+5 |        ctrl+shift+alt+[Digit5] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit6 |   6   |                         6 |     |                         6 |                              6 |                         6 |                       [Digit6] |         |
+|                    Ctrl+Digit6 |   6   |                    Ctrl+6 |     |                    Ctrl+6 |                         ctrl+6 |                    Ctrl+6 |                  ctrl+[Digit6] |         |
+|                   Shift+Digit6 |   :   |                   Shift+6 |     |                   Shift+6 |                        shift+6 |                   Shift+6 |                 shift+[Digit6] |         |
+|                                |       |                   Shift+; |     |                           |                                |                           |                                |         |
+|              Ctrl+Shift+Digit6 |   :   |              Ctrl+Shift+6 |     |              Ctrl+Shift+6 |                   ctrl+shift+6 |              Ctrl+Shift+6 |            ctrl+shift+[Digit6] |         |
+|                                |       |              Ctrl+Shift+; |     |                           |                                |                           |                                |         |
+|                     Alt+Digit6 |   6   |                     Alt+6 |     |                     Alt+6 |                          alt+6 |                     Alt+6 |                   alt+[Digit6] |         |
+|                Ctrl+Alt+Digit6 |   6   |                Ctrl+Alt+6 |     |                Ctrl+Alt+6 |                     ctrl+alt+6 |                Ctrl+Alt+6 |              ctrl+alt+[Digit6] |         |
+|               Shift+Alt+Digit6 |   :   |               Shift+Alt+6 |     |               Shift+Alt+6 |                    shift+alt+6 |               Shift+Alt+6 |             shift+alt+[Digit6] |         |
+|                                |       |               Shift+Alt+; |     |                           |                                |                           |                                |         |
+|          Ctrl+Shift+Alt+Digit6 |   :   |          Ctrl+Shift+Alt+6 |     |          Ctrl+Shift+Alt+6 |               ctrl+shift+alt+6 |          Ctrl+Shift+Alt+6 |        ctrl+shift+alt+[Digit6] |         |
+|                                |       |          Ctrl+Shift+Alt+; |     |                           |                                |                           |                                |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit7 |   7   |                         7 |     |                         7 |                              7 |                         7 |                       [Digit7] |         |
+|                    Ctrl+Digit7 |   7   |                    Ctrl+7 |     |                    Ctrl+7 |                         ctrl+7 |                    Ctrl+7 |                  ctrl+[Digit7] |         |
+|                   Shift+Digit7 |   ?   |                   Shift+7 |     |                   Shift+7 |                        shift+7 |                   Shift+7 |                 shift+[Digit7] |         |
+|                                |       |                   Shift+/ |     |                           |                                |                           |                                |         |
+|              Ctrl+Shift+Digit7 |   ?   |              Ctrl+Shift+7 |     |              Ctrl+Shift+7 |                   ctrl+shift+7 |              Ctrl+Shift+7 |            ctrl+shift+[Digit7] |         |
+|                                |       |              Ctrl+Shift+/ |     |                           |                                |                           |                                |         |
+|                     Alt+Digit7 |   7   |                     Alt+7 |     |                     Alt+7 |                          alt+7 |                     Alt+7 |                   alt+[Digit7] |         |
+|                Ctrl+Alt+Digit7 |   7   |                Ctrl+Alt+7 |     |                Ctrl+Alt+7 |                     ctrl+alt+7 |                Ctrl+Alt+7 |              ctrl+alt+[Digit7] |         |
+|               Shift+Alt+Digit7 |   ?   |               Shift+Alt+7 |     |               Shift+Alt+7 |                    shift+alt+7 |               Shift+Alt+7 |             shift+alt+[Digit7] |         |
+|                                |       |               Shift+Alt+/ |     |                           |                                |                           |                                |         |
+|          Ctrl+Shift+Alt+Digit7 |   ?   |          Ctrl+Shift+Alt+7 |     |          Ctrl+Shift+Alt+7 |               ctrl+shift+alt+7 |          Ctrl+Shift+Alt+7 |        ctrl+shift+alt+[Digit7] |         |
+|                                |       |          Ctrl+Shift+Alt+/ |     |                           |                                |                           |                                |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit8 |   8   |                         8 |     |                         8 |                              8 |                         8 |                       [Digit8] |         |
+|                    Ctrl+Digit8 |   8   |                    Ctrl+8 |     |                    Ctrl+8 |                         ctrl+8 |                    Ctrl+8 |                  ctrl+[Digit8] |         |
+|                   Shift+Digit8 |   *   |                   Shift+8 |     |                   Shift+8 |                        shift+8 |                   Shift+8 |                 shift+[Digit8] |         |
+|              Ctrl+Shift+Digit8 |   *   |              Ctrl+Shift+8 |     |              Ctrl+Shift+8 |                   ctrl+shift+8 |              Ctrl+Shift+8 |            ctrl+shift+[Digit8] |         |
+|                     Alt+Digit8 |   8   |                     Alt+8 |     |                     Alt+8 |                          alt+8 |                     Alt+8 |                   alt+[Digit8] |         |
+|                Ctrl+Alt+Digit8 |   8   |                Ctrl+Alt+8 |     |                Ctrl+Alt+8 |                     ctrl+alt+8 |                Ctrl+Alt+8 |              ctrl+alt+[Digit8] |         |
+|               Shift+Alt+Digit8 |   *   |               Shift+Alt+8 |     |               Shift+Alt+8 |                    shift+alt+8 |               Shift+Alt+8 |             shift+alt+[Digit8] |         |
+|          Ctrl+Shift+Alt+Digit8 |   *   |          Ctrl+Shift+Alt+8 |     |          Ctrl+Shift+Alt+8 |               ctrl+shift+alt+8 |          Ctrl+Shift+Alt+8 |        ctrl+shift+alt+[Digit8] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit9 |   9   |                         9 |     |                         9 |                              9 |                         9 |                       [Digit9] |         |
+|                    Ctrl+Digit9 |   9   |                    Ctrl+9 |     |                    Ctrl+9 |                         ctrl+9 |                    Ctrl+9 |                  ctrl+[Digit9] |         |
+|                   Shift+Digit9 |   (   |                   Shift+9 |     |                   Shift+9 |                        shift+9 |                   Shift+9 |                 shift+[Digit9] |         |
+|              Ctrl+Shift+Digit9 |   (   |              Ctrl+Shift+9 |     |              Ctrl+Shift+9 |                   ctrl+shift+9 |              Ctrl+Shift+9 |            ctrl+shift+[Digit9] |         |
+|                     Alt+Digit9 |   9   |                     Alt+9 |     |                     Alt+9 |                          alt+9 |                     Alt+9 |                   alt+[Digit9] |         |
+|                Ctrl+Alt+Digit9 |   9   |                Ctrl+Alt+9 |     |                Ctrl+Alt+9 |                     ctrl+alt+9 |                Ctrl+Alt+9 |              ctrl+alt+[Digit9] |         |
+|               Shift+Alt+Digit9 |   (   |               Shift+Alt+9 |     |               Shift+Alt+9 |                    shift+alt+9 |               Shift+Alt+9 |             shift+alt+[Digit9] |         |
+|          Ctrl+Shift+Alt+Digit9 |   (   |          Ctrl+Shift+Alt+9 |     |          Ctrl+Shift+Alt+9 |               ctrl+shift+alt+9 |          Ctrl+Shift+Alt+9 |        ctrl+shift+alt+[Digit9] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit0 |   0   |                         0 |     |                         0 |                              0 |                         0 |                       [Digit0] |         |
+|                    Ctrl+Digit0 |   0   |                    Ctrl+0 |     |                    Ctrl+0 |                         ctrl+0 |                    Ctrl+0 |                  ctrl+[Digit0] |         |
+|                   Shift+Digit0 |   )   |                   Shift+0 |     |                   Shift+0 |                        shift+0 |                   Shift+0 |                 shift+[Digit0] |         |
+|              Ctrl+Shift+Digit0 |   )   |              Ctrl+Shift+0 |     |              Ctrl+Shift+0 |                   ctrl+shift+0 |              Ctrl+Shift+0 |            ctrl+shift+[Digit0] |         |
+|                     Alt+Digit0 |   0   |                     Alt+0 |     |                     Alt+0 |                          alt+0 |                     Alt+0 |                   alt+[Digit0] |         |
+|                Ctrl+Alt+Digit0 |   0   |                Ctrl+Alt+0 |     |                Ctrl+Alt+0 |                     ctrl+alt+0 |                Ctrl+Alt+0 |              ctrl+alt+[Digit0] |         |
+|               Shift+Alt+Digit0 |   )   |               Shift+Alt+0 |     |               Shift+Alt+0 |                    shift+alt+0 |               Shift+Alt+0 |             shift+alt+[Digit0] |         |
+|          Ctrl+Shift+Alt+Digit0 |   )   |          Ctrl+Shift+Alt+0 |     |          Ctrl+Shift+Alt+0 |               ctrl+shift+alt+0 |          Ctrl+Shift+Alt+0 |        ctrl+shift+alt+[Digit0] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Minus |   -   |                         - |     |                         - |                              - |                      null |                        [Minus] |         |
+|                     Ctrl+Minus |   -   |                    Ctrl+- |     |                    Ctrl+- |                         ctrl+- |                      null |                   ctrl+[Minus] |         |
+|                    Shift+Minus |   _   |                   Shift+- |     |                   Shift+- |                        shift+- |                      null |                  shift+[Minus] |         |
+|               Ctrl+Shift+Minus |   _   |              Ctrl+Shift+- |     |              Ctrl+Shift+- |                   ctrl+shift+- |                      null |             ctrl+shift+[Minus] |         |
+|                      Alt+Minus |   -   |                     Alt+- |     |                     Alt+- |                          alt+- |                      null |                    alt+[Minus] |         |
+|                 Ctrl+Alt+Minus |   -   |                Ctrl+Alt+- |     |                Ctrl+Alt+- |                     ctrl+alt+- |                      null |               ctrl+alt+[Minus] |         |
+|                Shift+Alt+Minus |   _   |               Shift+Alt+- |     |               Shift+Alt+- |                    shift+alt+- |                      null |              shift+alt+[Minus] |         |
+|           Ctrl+Shift+Alt+Minus |   _   |          Ctrl+Shift+Alt+- |     |          Ctrl+Shift+Alt+- |               ctrl+shift+alt+- |                      null |         ctrl+shift+alt+[Minus] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Equal |   =   |                         = |     |                         = |                              = |                      null |                        [Equal] |         |
+|                     Ctrl+Equal |   =   |                    Ctrl+= |     |                    Ctrl+= |                         ctrl+= |                      null |                   ctrl+[Equal] |         |
+|                    Shift+Equal |   +   |                   Shift+= |     |                   Shift+= |                        shift+= |                      null |                  shift+[Equal] |         |
+|               Ctrl+Shift+Equal |   +   |              Ctrl+Shift+= |     |              Ctrl+Shift+= |                   ctrl+shift+= |                      null |             ctrl+shift+[Equal] |         |
+|                      Alt+Equal |   =   |                     Alt+= |     |                     Alt+= |                          alt+= |                      null |                    alt+[Equal] |         |
+|                 Ctrl+Alt+Equal |   =   |                Ctrl+Alt+= |     |                Ctrl+Alt+= |                     ctrl+alt+= |                      null |               ctrl+alt+[Equal] |         |
+|                Shift+Alt+Equal |   +   |               Shift+Alt+= |     |               Shift+Alt+= |                    shift+alt+= |                      null |              shift+alt+[Equal] |         |
+|           Ctrl+Shift+Alt+Equal |   +   |          Ctrl+Shift+Alt+= |     |          Ctrl+Shift+Alt+= |               ctrl+shift+alt+= |                      null |         ctrl+shift+alt+[Equal] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                    BracketLeft |   х   |                           |     |                         х |                  [BracketLeft] |                      null |                  [BracketLeft] |    NO   |
+|               Ctrl+BracketLeft |   х   |                           |     |                    Ctrl+х |             ctrl+[BracketLeft] |                      null |             ctrl+[BracketLeft] |    NO   |
+|              Shift+BracketLeft |   Х   |                           |     |                   Shift+х |            shift+[BracketLeft] |                      null |            shift+[BracketLeft] |    NO   |
+|         Ctrl+Shift+BracketLeft |   Х   |                           |     |              Ctrl+Shift+х |       ctrl+shift+[BracketLeft] |                      null |       ctrl+shift+[BracketLeft] |    NO   |
+|                Alt+BracketLeft |   х   |                           |     |                     Alt+х |              alt+[BracketLeft] |                      null |              alt+[BracketLeft] |    NO   |
+|           Ctrl+Alt+BracketLeft |   х   |                           |     |                Ctrl+Alt+х |         ctrl+alt+[BracketLeft] |                      null |         ctrl+alt+[BracketLeft] |    NO   |
+|          Shift+Alt+BracketLeft |   Х   |                           |     |               Shift+Alt+х |        shift+alt+[BracketLeft] |                      null |        shift+alt+[BracketLeft] |    NO   |
+|     Ctrl+Shift+Alt+BracketLeft |   Х   |                           |     |          Ctrl+Shift+Alt+х |   ctrl+shift+alt+[BracketLeft] |                      null |   ctrl+shift+alt+[BracketLeft] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                   BracketRight |   ъ   |                           |     |                         ъ |                 [BracketRight] |                      null |                 [BracketRight] |    NO   |
+|              Ctrl+BracketRight |   ъ   |                           |     |                    Ctrl+ъ |            ctrl+[BracketRight] |                      null |            ctrl+[BracketRight] |    NO   |
+|             Shift+BracketRight |   Ъ   |                           |     |                   Shift+ъ |           shift+[BracketRight] |                      null |           shift+[BracketRight] |    NO   |
+|        Ctrl+Shift+BracketRight |   Ъ   |                           |     |              Ctrl+Shift+ъ |      ctrl+shift+[BracketRight] |                      null |      ctrl+shift+[BracketRight] |    NO   |
+|               Alt+BracketRight |   ъ   |                           |     |                     Alt+ъ |             alt+[BracketRight] |                      null |             alt+[BracketRight] |    NO   |
+|          Ctrl+Alt+BracketRight |   ъ   |                           |     |                Ctrl+Alt+ъ |        ctrl+alt+[BracketRight] |                      null |        ctrl+alt+[BracketRight] |    NO   |
+|         Shift+Alt+BracketRight |   Ъ   |                           |     |               Shift+Alt+ъ |       shift+alt+[BracketRight] |                      null |       shift+alt+[BracketRight] |    NO   |
+|    Ctrl+Shift+Alt+BracketRight |   Ъ   |                           |     |          Ctrl+Shift+Alt+ъ |  ctrl+shift+alt+[BracketRight] |                      null |  ctrl+shift+alt+[BracketRight] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                      Backslash |   \   |                         \ |     |                         \ |                    [Backslash] |                      null |                    [Backslash] |    NO   |
+|                 Ctrl+Backslash |   \   |                    Ctrl+\ |     |                    Ctrl+\ |               ctrl+[Backslash] |                      null |               ctrl+[Backslash] |    NO   |
+|                Shift+Backslash |   /   |                         / |   1 |                   Shift+\ |              shift+[Backslash] |                      null |              shift+[Backslash] |    NO   |
+|           Ctrl+Shift+Backslash |   /   |                    Ctrl+/ |   1 |              Ctrl+Shift+\ |         ctrl+shift+[Backslash] |                      null |         ctrl+shift+[Backslash] |    NO   |
+|                  Alt+Backslash |   \   |                     Alt+\ |     |                     Alt+\ |                alt+[Backslash] |                      null |                alt+[Backslash] |    NO   |
+|             Ctrl+Alt+Backslash |   \   |                Ctrl+Alt+\ |     |                Ctrl+Alt+\ |           ctrl+alt+[Backslash] |                      null |           ctrl+alt+[Backslash] |    NO   |
+|            Shift+Alt+Backslash |   /   |                     Alt+/ |   1 |               Shift+Alt+\ |          shift+alt+[Backslash] |                      null |          shift+alt+[Backslash] |    NO   |
+|       Ctrl+Shift+Alt+Backslash |   /   |                Ctrl+Alt+/ |   1 |          Ctrl+Shift+Alt+\ |     ctrl+shift+alt+[Backslash] |                      null |     ctrl+shift+alt+[Backslash] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                       IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|                  Ctrl+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|                 Shift+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|            Ctrl+Shift+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|                   Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|              Ctrl+Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|             Shift+Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|        Ctrl+Shift+Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                      Semicolon |   ж   |                           |     |                         ж |                    [Semicolon] |                      null |                    [Semicolon] |    NO   |
+|                 Ctrl+Semicolon |   ж   |                           |     |                    Ctrl+ж |               ctrl+[Semicolon] |                      null |               ctrl+[Semicolon] |    NO   |
+|                Shift+Semicolon |   Ж   |                           |     |                   Shift+ж |              shift+[Semicolon] |                      null |              shift+[Semicolon] |    NO   |
+|           Ctrl+Shift+Semicolon |   Ж   |                           |     |              Ctrl+Shift+ж |         ctrl+shift+[Semicolon] |                      null |         ctrl+shift+[Semicolon] |    NO   |
+|                  Alt+Semicolon |   ж   |                           |     |                     Alt+ж |                alt+[Semicolon] |                      null |                alt+[Semicolon] |    NO   |
+|             Ctrl+Alt+Semicolon |   ж   |                           |     |                Ctrl+Alt+ж |           ctrl+alt+[Semicolon] |                      null |           ctrl+alt+[Semicolon] |    NO   |
+|            Shift+Alt+Semicolon |   Ж   |                           |     |               Shift+Alt+ж |          shift+alt+[Semicolon] |                      null |          shift+alt+[Semicolon] |    NO   |
+|       Ctrl+Shift+Alt+Semicolon |   Ж   |                           |     |          Ctrl+Shift+Alt+ж |     ctrl+shift+alt+[Semicolon] |                      null |     ctrl+shift+alt+[Semicolon] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Quote |   э   |                           |     |                         э |                        [Quote] |                      null |                        [Quote] |    NO   |
+|                     Ctrl+Quote |   э   |                           |     |                    Ctrl+э |                   ctrl+[Quote] |                      null |                   ctrl+[Quote] |    NO   |
+|                    Shift+Quote |   Э   |                           |     |                   Shift+э |                  shift+[Quote] |                      null |                  shift+[Quote] |    NO   |
+|               Ctrl+Shift+Quote |   Э   |                           |     |              Ctrl+Shift+э |             ctrl+shift+[Quote] |                      null |             ctrl+shift+[Quote] |    NO   |
+|                      Alt+Quote |   э   |                           |     |                     Alt+э |                    alt+[Quote] |                      null |                    alt+[Quote] |    NO   |
+|                 Ctrl+Alt+Quote |   э   |                           |     |                Ctrl+Alt+э |               ctrl+alt+[Quote] |                      null |               ctrl+alt+[Quote] |    NO   |
+|                Shift+Alt+Quote |   Э   |                           |     |               Shift+Alt+э |              shift+alt+[Quote] |                      null |              shift+alt+[Quote] |    NO   |
+|           Ctrl+Shift+Alt+Quote |   Э   |                           |     |          Ctrl+Shift+Alt+э |         ctrl+shift+alt+[Quote] |                      null |         ctrl+shift+alt+[Quote] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                      Backquote |   ё   |                           |     |                         ё |                    [Backquote] |                      null |                    [Backquote] |    NO   |
+|                 Ctrl+Backquote |   ё   |                           |     |                    Ctrl+ё |               ctrl+[Backquote] |                      null |               ctrl+[Backquote] |    NO   |
+|                Shift+Backquote |   Ё   |                           |     |                   Shift+ё |              shift+[Backquote] |                      null |              shift+[Backquote] |    NO   |
+|           Ctrl+Shift+Backquote |   Ё   |                           |     |              Ctrl+Shift+ё |         ctrl+shift+[Backquote] |                      null |         ctrl+shift+[Backquote] |    NO   |
+|                  Alt+Backquote |   ё   |                           |     |                     Alt+ё |                alt+[Backquote] |                      null |                alt+[Backquote] |    NO   |
+|             Ctrl+Alt+Backquote |   ё   |                           |     |                Ctrl+Alt+ё |           ctrl+alt+[Backquote] |                      null |           ctrl+alt+[Backquote] |    NO   |
+|            Shift+Alt+Backquote |   Ё   |                           |     |               Shift+Alt+ё |          shift+alt+[Backquote] |                      null |          shift+alt+[Backquote] |    NO   |
+|       Ctrl+Shift+Alt+Backquote |   Ё   |                           |     |          Ctrl+Shift+Alt+ё |     ctrl+shift+alt+[Backquote] |                      null |     ctrl+shift+alt+[Backquote] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Comma |   б   |                           |     |                         б |                        [Comma] |                      null |                        [Comma] |    NO   |
+|                     Ctrl+Comma |   б   |                           |     |                    Ctrl+б |                   ctrl+[Comma] |                      null |                   ctrl+[Comma] |    NO   |
+|                    Shift+Comma |   Б   |                           |     |                   Shift+б |                  shift+[Comma] |                      null |                  shift+[Comma] |    NO   |
+|               Ctrl+Shift+Comma |   Б   |                           |     |              Ctrl+Shift+б |             ctrl+shift+[Comma] |                      null |             ctrl+shift+[Comma] |    NO   |
+|                      Alt+Comma |   б   |                           |     |                     Alt+б |                    alt+[Comma] |                      null |                    alt+[Comma] |    NO   |
+|                 Ctrl+Alt+Comma |   б   |                           |     |                Ctrl+Alt+б |               ctrl+alt+[Comma] |                      null |               ctrl+alt+[Comma] |    NO   |
+|                Shift+Alt+Comma |   Б   |                           |     |               Shift+Alt+б |              shift+alt+[Comma] |                      null |              shift+alt+[Comma] |    NO   |
+|           Ctrl+Shift+Alt+Comma |   Б   |                           |     |          Ctrl+Shift+Alt+б |         ctrl+shift+alt+[Comma] |                      null |         ctrl+shift+alt+[Comma] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Period |   ю   |                           |     |                         ю |                       [Period] |                      null |                       [Period] |    NO   |
+|                    Ctrl+Period |   ю   |                           |     |                    Ctrl+ю |                  ctrl+[Period] |                      null |                  ctrl+[Period] |    NO   |
+|                   Shift+Period |   Ю   |                           |     |                   Shift+ю |                 shift+[Period] |                      null |                 shift+[Period] |    NO   |
+|              Ctrl+Shift+Period |   Ю   |                           |     |              Ctrl+Shift+ю |            ctrl+shift+[Period] |                      null |            ctrl+shift+[Period] |    NO   |
+|                     Alt+Period |   ю   |                           |     |                     Alt+ю |                   alt+[Period] |                      null |                   alt+[Period] |    NO   |
+|                Ctrl+Alt+Period |   ю   |                           |     |                Ctrl+Alt+ю |              ctrl+alt+[Period] |                      null |              ctrl+alt+[Period] |    NO   |
+|               Shift+Alt+Period |   Ю   |                           |     |               Shift+Alt+ю |             shift+alt+[Period] |                      null |             shift+alt+[Period] |    NO   |
+|          Ctrl+Shift+Alt+Period |   Ю   |                           |     |          Ctrl+Shift+Alt+ю |        ctrl+shift+alt+[Period] |                      null |        ctrl+shift+alt+[Period] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Slash |   .   |                         . |     |                         . |                        [Slash] |                      null |                        [Slash] |    NO   |
+|                     Ctrl+Slash |   .   |                    Ctrl+. |     |                    Ctrl+. |                   ctrl+[Slash] |                      null |                   ctrl+[Slash] |    NO   |
+|                    Shift+Slash |   ,   |                         , |     |                   Shift+. |                  shift+[Slash] |                      null |                  shift+[Slash] |    NO   |
+|               Ctrl+Shift+Slash |   ,   |                    Ctrl+, |     |              Ctrl+Shift+. |             ctrl+shift+[Slash] |                      null |             ctrl+shift+[Slash] |    NO   |
+|                      Alt+Slash |   .   |                     Alt+. |     |                     Alt+. |                    alt+[Slash] |                      null |                    alt+[Slash] |    NO   |
+|                 Ctrl+Alt+Slash |   .   |                Ctrl+Alt+. |     |                Ctrl+Alt+. |               ctrl+alt+[Slash] |                      null |               ctrl+alt+[Slash] |    NO   |
+|                Shift+Alt+Slash |   ,   |                     Alt+, |     |               Shift+Alt+. |              shift+alt+[Slash] |                      null |              shift+alt+[Slash] |    NO   |
+|           Ctrl+Shift+Alt+Slash |   ,   |                Ctrl+Alt+, |     |          Ctrl+Shift+Alt+. |         ctrl+shift+alt+[Slash] |                      null |         ctrl+shift+alt+[Slash] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                        ArrowUp |  ---  |                   UpArrow |     |                   UpArrow |                             up |                        Up |                      [ArrowUp] |         |
+|                   Ctrl+ArrowUp |  ---  |              Ctrl+UpArrow |     |              Ctrl+UpArrow |                        ctrl+up |                   Ctrl+Up |                 ctrl+[ArrowUp] |         |
+|                  Shift+ArrowUp |  ---  |             Shift+UpArrow |     |             Shift+UpArrow |                       shift+up |                  Shift+Up |                shift+[ArrowUp] |         |
+|             Ctrl+Shift+ArrowUp |  ---  |        Ctrl+Shift+UpArrow |     |        Ctrl+Shift+UpArrow |                  ctrl+shift+up |             Ctrl+Shift+Up |           ctrl+shift+[ArrowUp] |         |
+|                    Alt+ArrowUp |  ---  |               Alt+UpArrow |     |               Alt+UpArrow |                         alt+up |                    Alt+Up |                  alt+[ArrowUp] |         |
+|               Ctrl+Alt+ArrowUp |  ---  |          Ctrl+Alt+UpArrow |     |          Ctrl+Alt+UpArrow |                    ctrl+alt+up |               Ctrl+Alt+Up |             ctrl+alt+[ArrowUp] |         |
+|              Shift+Alt+ArrowUp |  ---  |         Shift+Alt+UpArrow |     |         Shift+Alt+UpArrow |                   shift+alt+up |              Shift+Alt+Up |            shift+alt+[ArrowUp] |         |
+|         Ctrl+Shift+Alt+ArrowUp |  ---  |    Ctrl+Shift+Alt+UpArrow |     |    Ctrl+Shift+Alt+UpArrow |              ctrl+shift+alt+up |         Ctrl+Shift+Alt+Up |       ctrl+shift+alt+[ArrowUp] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                        Numpad0 |  ---  |                   NumPad0 |     |                   NumPad0 |                        numpad0 |                      null |                      [Numpad0] |         |
+|                   Ctrl+Numpad0 |  ---  |              Ctrl+NumPad0 |     |              Ctrl+NumPad0 |                   ctrl+numpad0 |                      null |                 ctrl+[Numpad0] |         |
+|                  Shift+Numpad0 |  ---  |             Shift+NumPad0 |     |             Shift+NumPad0 |                  shift+numpad0 |                      null |                shift+[Numpad0] |         |
+|             Ctrl+Shift+Numpad0 |  ---  |        Ctrl+Shift+NumPad0 |     |        Ctrl+Shift+NumPad0 |             ctrl+shift+numpad0 |                      null |           ctrl+shift+[Numpad0] |         |
+|                    Alt+Numpad0 |  ---  |               Alt+NumPad0 |     |               Alt+NumPad0 |                    alt+numpad0 |                      null |                  alt+[Numpad0] |         |
+|               Ctrl+Alt+Numpad0 |  ---  |          Ctrl+Alt+NumPad0 |     |          Ctrl+Alt+NumPad0 |               ctrl+alt+numpad0 |                      null |             ctrl+alt+[Numpad0] |         |
+|              Shift+Alt+Numpad0 |  ---  |         Shift+Alt+NumPad0 |     |         Shift+Alt+NumPad0 |              shift+alt+numpad0 |                      null |            shift+alt+[Numpad0] |         |
+|         Ctrl+Shift+Alt+Numpad0 |  ---  |    Ctrl+Shift+Alt+NumPad0 |     |    Ctrl+Shift+Alt+NumPad0 |         ctrl+shift+alt+numpad0 |                      null |       ctrl+shift+alt+[Numpad0] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                  IntlBackslash |   /   |                         / |   2 |                         / |                [IntlBackslash] |                      null |                [IntlBackslash] |    NO   |
+|             Ctrl+IntlBackslash |   /   |                    Ctrl+/ |   2 |                    Ctrl+/ |           ctrl+[IntlBackslash] |                      null |           ctrl+[IntlBackslash] |    NO   |
+|            Shift+IntlBackslash |   |   |                   Shift+\ |     |                   Shift+/ |          shift+[IntlBackslash] |                      null |          shift+[IntlBackslash] |    NO   |
+|       Ctrl+Shift+IntlBackslash |   |   |              Ctrl+Shift+\ |     |              Ctrl+Shift+/ |     ctrl+shift+[IntlBackslash] |                      null |     ctrl+shift+[IntlBackslash] |    NO   |
+|              Alt+IntlBackslash |   /   |                     Alt+/ |   2 |                     Alt+/ |            alt+[IntlBackslash] |                      null |            alt+[IntlBackslash] |    NO   |
+|         Ctrl+Alt+IntlBackslash |   |   |                Ctrl+Alt+/ |   2 |                Ctrl+Alt+/ |       ctrl+alt+[IntlBackslash] |                      null |       ctrl+alt+[IntlBackslash] |    NO   |
+|        Shift+Alt+IntlBackslash |   |   |               Shift+Alt+\ |     |               Shift+Alt+/ |      shift+alt+[IntlBackslash] |                      null |      shift+alt+[IntlBackslash] |    NO   |
+|   Ctrl+Shift+Alt+IntlBackslash |   ¦   |          Ctrl+Shift+Alt+\ |     |          Ctrl+Shift+Alt+/ | ctrl+shift+alt+[IntlBackslash] |                      null | ctrl+shift+alt+[IntlBackslash] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         IntlRo |  ---  |                           |     |                      null |                       [IntlRo] |                      null |                       [IntlRo] |    NO   |
+|                    Ctrl+IntlRo |  ---  |                           |     |                      null |                  ctrl+[IntlRo] |                      null |                  ctrl+[IntlRo] |    NO   |
+|                   Shift+IntlRo |  ---  |                           |     |                      null |                 shift+[IntlRo] |                      null |                 shift+[IntlRo] |    NO   |
+|              Ctrl+Shift+IntlRo |  ---  |                           |     |                      null |            ctrl+shift+[IntlRo] |                      null |            ctrl+shift+[IntlRo] |    NO   |
+|                     Alt+IntlRo |  ---  |                           |     |                      null |                   alt+[IntlRo] |                      null |                   alt+[IntlRo] |    NO   |
+|                Ctrl+Alt+IntlRo |  ---  |                           |     |                      null |              ctrl+alt+[IntlRo] |                      null |              ctrl+alt+[IntlRo] |    NO   |
+|               Shift+Alt+IntlRo |  ---  |                           |     |                      null |             shift+alt+[IntlRo] |                      null |             shift+alt+[IntlRo] |    NO   |
+|          Ctrl+Shift+Alt+IntlRo |  ---  |                           |     |                      null |        ctrl+shift+alt+[IntlRo] |                      null |        ctrl+shift+alt+[IntlRo] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                        IntlYen |  ---  |                           |     |                      null |                      [IntlYen] |                      null |                      [IntlYen] |    NO   |
+|                   Ctrl+IntlYen |  ---  |                           |     |                      null |                 ctrl+[IntlYen] |                      null |                 ctrl+[IntlYen] |    NO   |
+|                  Shift+IntlYen |  ---  |                           |     |                      null |                shift+[IntlYen] |                      null |                shift+[IntlYen] |    NO   |
+|             Ctrl+Shift+IntlYen |  ---  |                           |     |                      null |           ctrl+shift+[IntlYen] |                      null |           ctrl+shift+[IntlYen] |    NO   |
+|                    Alt+IntlYen |  ---  |                           |     |                      null |                  alt+[IntlYen] |                      null |                  alt+[IntlYen] |    NO   |
+|               Ctrl+Alt+IntlYen |  ---  |                           |     |                      null |             ctrl+alt+[IntlYen] |                      null |             ctrl+alt+[IntlYen] |    NO   |
+|              Shift+Alt+IntlYen |  ---  |                           |     |                      null |            shift+alt+[IntlYen] |                      null |            shift+alt+[IntlYen] |    NO   |
+|         Ctrl+Shift+Alt+IntlYen |  ---  |                           |     |                      null |       ctrl+shift+alt+[IntlYen] |                      null |       ctrl+shift+alt+[IntlYen] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

lib/vscode/src/vs/workbench/services/keybinding/test/electron-browser/macLinuxFallbackKeyboardMapper.test.ts

@@ -0,0 +1,241 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyChord, KeyCode, KeyMod, SimpleKeybinding, createKeybinding } from 'vs/base/common/keyCodes';
+import { OperatingSystem } from 'vs/base/common/platform';
+import { ScanCode, ScanCodeBinding } from 'vs/base/common/scanCode';
+import { MacLinuxFallbackKeyboardMapper } from 'vs/workbench/services/keybinding/common/macLinuxFallbackKeyboardMapper';
+import { IResolvedKeybinding, assertResolveKeybinding, assertResolveKeyboardEvent, assertResolveUserBinding } from 'vs/workbench/services/keybinding/test/electron-browser/keyboardMapperTestUtils';
+
+suite('keyboardMapper - MAC fallback', () => {
+
+	let mapper = new MacLinuxFallbackKeyboardMapper(OperatingSystem.Macintosh);
+
+	function _assertResolveKeybinding(k: number, expected: IResolvedKeybinding[]): void {
+		assertResolveKeybinding(mapper, createKeybinding(k, OperatingSystem.Macintosh)!, expected);
+	}
+
+	test('resolveKeybinding Cmd+Z', () => {
+		_assertResolveKeybinding(
+			KeyMod.CtrlCmd | KeyCode.KEY_Z,
+			[{
+				label: '⌘Z',
+				ariaLabel: 'Command+Z',
+				electronAccelerator: 'Cmd+Z',
+				userSettingsLabel: 'cmd+z',
+				isWYSIWYG: true,
+				isChord: false,
+				dispatchParts: ['meta+Z'],
+			}]
+		);
+	});
+
+	test('resolveKeybinding Cmd+K Cmd+=', () => {
+		_assertResolveKeybinding(
+			KeyChord(KeyMod.CtrlCmd | KeyCode.KEY_K, KeyMod.CtrlCmd | KeyCode.US_EQUAL),
+			[{
+				label: '⌘K ⌘=',
+				ariaLabel: 'Command+K Command+=',
+				electronAccelerator: null,
+				userSettingsLabel: 'cmd+k cmd+=',
+				isWYSIWYG: true,
+				isChord: true,
+				dispatchParts: ['meta+K', 'meta+='],
+			}]
+		);
+	});
+
+	test('resolveKeyboardEvent Cmd+Z', () => {
+		assertResolveKeyboardEvent(
+			mapper,
+			{
+				_standardKeyboardEventBrand: true,
+				ctrlKey: false,
+				shiftKey: false,
+				altKey: false,
+				metaKey: true,
+				keyCode: KeyCode.KEY_Z,
+				code: null!
+			},
+			{
+				label: '⌘Z',
+				ariaLabel: 'Command+Z',
+				electronAccelerator: 'Cmd+Z',
+				userSettingsLabel: 'cmd+z',
+				isWYSIWYG: true,
+				isChord: false,
+				dispatchParts: ['meta+Z'],
+			}
+		);
+	});
+
+	test('resolveUserBinding empty', () => {
+		assertResolveUserBinding(mapper, [], []);
+	});
+
+	test('resolveUserBinding Cmd+[Comma] Cmd+/', () => {
+		assertResolveUserBinding(
+			mapper, [
+			new ScanCodeBinding(false, false, false, true, ScanCode.Comma),
+			new SimpleKeybinding(false, false, false, true, KeyCode.US_SLASH),
+		],
+			[{
+				label: '⌘, ⌘/',
+				ariaLabel: 'Command+, Command+/',
+				electronAccelerator: null,
+				userSettingsLabel: 'cmd+, cmd+/',
+				isWYSIWYG: true,
+				isChord: true,
+				dispatchParts: ['meta+,', 'meta+/'],
+			}]
+		);
+	});
+
+	test('resolveKeyboardEvent Modifier only Meta+', () => {
+		assertResolveKeyboardEvent(
+			mapper,
+			{
+				_standardKeyboardEventBrand: true,
+				ctrlKey: false,
+				shiftKey: false,
+				altKey: false,
+				metaKey: true,
+				keyCode: KeyCode.Meta,
+				code: null!
+			},
+			{
+				label: '⌘',
+				ariaLabel: 'Command',
+				electronAccelerator: null,
+				userSettingsLabel: 'cmd',
+				isWYSIWYG: true,
+				isChord: false,
+				dispatchParts: [null],
+			}
+		);
+	});
+});
+
+suite('keyboardMapper - LINUX fallback', () => {
+
+	let mapper = new MacLinuxFallbackKeyboardMapper(OperatingSystem.Linux);
+
+	function _assertResolveKeybinding(k: number, expected: IResolvedKeybinding[]): void {
+		assertResolveKeybinding(mapper, createKeybinding(k, OperatingSystem.Linux)!, expected);
+	}
+
+	test('resolveKeybinding Ctrl+Z', () => {
+		_assertResolveKeybinding(
+			KeyMod.CtrlCmd | KeyCode.KEY_Z,
+			[{
+				label: 'Ctrl+Z',
+				ariaLabel: 'Control+Z',
+				electronAccelerator: 'Ctrl+Z',
+				userSettingsLabel: 'ctrl+z',
+				isWYSIWYG: true,
+				isChord: false,
+				dispatchParts: ['ctrl+Z'],
+			}]
+		);
+	});
+
+	test('resolveKeybinding Ctrl+K Ctrl+=', () => {
+		_assertResolveKeybinding(
+			KeyChord(KeyMod.CtrlCmd | KeyCode.KEY_K, KeyMod.CtrlCmd | KeyCode.US_EQUAL),
+			[{
+				label: 'Ctrl+K Ctrl+=',
+				ariaLabel: 'Control+K Control+=',
+				electronAccelerator: null,
+				userSettingsLabel: 'ctrl+k ctrl+=',
+				isWYSIWYG: true,
+				isChord: true,
+				dispatchParts: ['ctrl+K', 'ctrl+='],
+			}]
+		);
+	});
+
+	test('resolveKeyboardEvent Ctrl+Z', () => {
+		assertResolveKeyboardEvent(
+			mapper,
+			{
+				_standardKeyboardEventBrand: true,
+				ctrlKey: true,
+				shiftKey: false,
+				altKey: false,
+				metaKey: false,
+				keyCode: KeyCode.KEY_Z,
+				code: null!
+			},
+			{
+				label: 'Ctrl+Z',
+				ariaLabel: 'Control+Z',
+				electronAccelerator: 'Ctrl+Z',
+				userSettingsLabel: 'ctrl+z',
+				isWYSIWYG: true,
+				isChord: false,
+				dispatchParts: ['ctrl+Z'],
+			}
+		);
+	});
+
+	test('resolveUserBinding Ctrl+[Comma] Ctrl+/', () => {
+		assertResolveUserBinding(
+			mapper, [
+			new ScanCodeBinding(true, false, false, false, ScanCode.Comma),
+			new SimpleKeybinding(true, false, false, false, KeyCode.US_SLASH),
+		],
+			[{
+				label: 'Ctrl+, Ctrl+/',
+				ariaLabel: 'Control+, Control+/',
+				electronAccelerator: null,
+				userSettingsLabel: 'ctrl+, ctrl+/',
+				isWYSIWYG: true,
+				isChord: true,
+				dispatchParts: ['ctrl+,', 'ctrl+/'],
+			}]
+		);
+	});
+
+	test('resolveUserBinding Ctrl+[Comma]', () => {
+		assertResolveUserBinding(
+			mapper, [
+			new ScanCodeBinding(true, false, false, false, ScanCode.Comma),
+		],
+			[{
+				label: 'Ctrl+,',
+				ariaLabel: 'Control+,',
+				electronAccelerator: 'Ctrl+,',
+				userSettingsLabel: 'ctrl+,',
+				isWYSIWYG: true,
+				isChord: false,
+				dispatchParts: ['ctrl+,'],
+			}]
+		);
+	});
+
+	test('resolveKeyboardEvent Modifier only Ctrl+', () => {
+		assertResolveKeyboardEvent(
+			mapper,
+			{
+				_standardKeyboardEventBrand: true,
+				ctrlKey: true,
+				shiftKey: false,
+				altKey: false,
+				metaKey: false,
+				keyCode: KeyCode.Ctrl,
+				code: null!
+			},
+			{
+				label: 'Ctrl',
+				ariaLabel: 'Control',
+				electronAccelerator: null,
+				userSettingsLabel: 'ctrl',
+				isWYSIWYG: true,
+				isChord: false,
+				dispatchParts: [null],
+			}
+		);
+	});
+});

lib/vscode/src/vs/workbench/services/keybinding/test/electron-browser/mac_de_ch.txt

@@ -0,0 +1,529 @@
+isUSStandard: false
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyA |   a   |                         A |     |                         A |                              a |                         A |                         [KeyA] |         |
+|                      Ctrl+KeyA |   a   |                    Ctrl+A |     |                    Ctrl+A |                         ctrl+a |                    Ctrl+A |                    ctrl+[KeyA] |         |
+|                     Shift+KeyA |   A   |                   Shift+A |     |                   Shift+A |                        shift+a |                   Shift+A |                   shift+[KeyA] |         |
+|                Ctrl+Shift+KeyA |   A   |              Ctrl+Shift+A |     |              Ctrl+Shift+A |                   ctrl+shift+a |              Ctrl+Shift+A |              ctrl+shift+[KeyA] |         |
+|                       Alt+KeyA |   a   |                     Alt+A |     |                     Alt+A |                          alt+a |                     Alt+A |                     alt+[KeyA] |         |
+|                  Ctrl+Alt+KeyA |   å   |                Ctrl+Alt+A |     |                Ctrl+Alt+A |                     ctrl+alt+a |                Ctrl+Alt+A |                ctrl+alt+[KeyA] |         |
+|                 Shift+Alt+KeyA |   A   |               Shift+Alt+A |     |               Shift+Alt+A |                    shift+alt+a |               Shift+Alt+A |               shift+alt+[KeyA] |         |
+|            Ctrl+Shift+Alt+KeyA |   Å   |          Ctrl+Shift+Alt+A |     |          Ctrl+Shift+Alt+A |               ctrl+shift+alt+a |          Ctrl+Shift+Alt+A |          ctrl+shift+alt+[KeyA] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyB |   b   |                         B |     |                         B |                              b |                         B |                         [KeyB] |         |
+|                      Ctrl+KeyB |   b   |                    Ctrl+B |     |                    Ctrl+B |                         ctrl+b |                    Ctrl+B |                    ctrl+[KeyB] |         |
+|                     Shift+KeyB |   B   |                   Shift+B |     |                   Shift+B |                        shift+b |                   Shift+B |                   shift+[KeyB] |         |
+|                Ctrl+Shift+KeyB |   B   |              Ctrl+Shift+B |     |              Ctrl+Shift+B |                   ctrl+shift+b |              Ctrl+Shift+B |              ctrl+shift+[KeyB] |         |
+|                       Alt+KeyB |   b   |                     Alt+B |     |                     Alt+B |                          alt+b |                     Alt+B |                     alt+[KeyB] |         |
+|                  Ctrl+Alt+KeyB |   ∫   |                Ctrl+Alt+B |     |                Ctrl+Alt+B |                     ctrl+alt+b |                Ctrl+Alt+B |                ctrl+alt+[KeyB] |         |
+|                 Shift+Alt+KeyB |   B   |               Shift+Alt+B |     |               Shift+Alt+B |                    shift+alt+b |               Shift+Alt+B |               shift+alt+[KeyB] |         |
+|            Ctrl+Shift+Alt+KeyB |  ---  |          Ctrl+Shift+Alt+B |     |          Ctrl+Shift+Alt+B |               ctrl+shift+alt+b |          Ctrl+Shift+Alt+B |          ctrl+shift+alt+[KeyB] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyC |   c   |                         C |     |                         C |                              c |                         C |                         [KeyC] |         |
+|                      Ctrl+KeyC |   c   |                    Ctrl+C |     |                    Ctrl+C |                         ctrl+c |                    Ctrl+C |                    ctrl+[KeyC] |         |
+|                     Shift+KeyC |   C   |                   Shift+C |     |                   Shift+C |                        shift+c |                   Shift+C |                   shift+[KeyC] |         |
+|                Ctrl+Shift+KeyC |   C   |              Ctrl+Shift+C |     |              Ctrl+Shift+C |                   ctrl+shift+c |              Ctrl+Shift+C |              ctrl+shift+[KeyC] |         |
+|                       Alt+KeyC |   c   |                     Alt+C |     |                     Alt+C |                          alt+c |                     Alt+C |                     alt+[KeyC] |         |
+|                  Ctrl+Alt+KeyC |   ©   |                Ctrl+Alt+C |     |                Ctrl+Alt+C |                     ctrl+alt+c |                Ctrl+Alt+C |                ctrl+alt+[KeyC] |         |
+|                 Shift+Alt+KeyC |   C   |               Shift+Alt+C |     |               Shift+Alt+C |                    shift+alt+c |               Shift+Alt+C |               shift+alt+[KeyC] |         |
+|            Ctrl+Shift+Alt+KeyC |  ---  |          Ctrl+Shift+Alt+C |     |          Ctrl+Shift+Alt+C |               ctrl+shift+alt+c |          Ctrl+Shift+Alt+C |          ctrl+shift+alt+[KeyC] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyD |   d   |                         D |     |                         D |                              d |                         D |                         [KeyD] |         |
+|                      Ctrl+KeyD |   d   |                    Ctrl+D |     |                    Ctrl+D |                         ctrl+d |                    Ctrl+D |                    ctrl+[KeyD] |         |
+|                     Shift+KeyD |   D   |                   Shift+D |     |                   Shift+D |                        shift+d |                   Shift+D |                   shift+[KeyD] |         |
+|                Ctrl+Shift+KeyD |   D   |              Ctrl+Shift+D |     |              Ctrl+Shift+D |                   ctrl+shift+d |              Ctrl+Shift+D |              ctrl+shift+[KeyD] |         |
+|                       Alt+KeyD |   d   |                     Alt+D |     |                     Alt+D |                          alt+d |                     Alt+D |                     alt+[KeyD] |         |
+|                  Ctrl+Alt+KeyD |   ∂   |                Ctrl+Alt+D |     |                Ctrl+Alt+D |                     ctrl+alt+d |                Ctrl+Alt+D |                ctrl+alt+[KeyD] |         |
+|                 Shift+Alt+KeyD |   D   |               Shift+Alt+D |     |               Shift+Alt+D |                    shift+alt+d |               Shift+Alt+D |               shift+alt+[KeyD] |         |
+|            Ctrl+Shift+Alt+KeyD |   fl   |          Ctrl+Shift+Alt+D |     |          Ctrl+Shift+Alt+D |               ctrl+shift+alt+d |          Ctrl+Shift+Alt+D |          ctrl+shift+alt+[KeyD] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyE |   e   |                         E |     |                         E |                              e |                         E |                         [KeyE] |         |
+|                      Ctrl+KeyE |   e   |                    Ctrl+E |     |                    Ctrl+E |                         ctrl+e |                    Ctrl+E |                    ctrl+[KeyE] |         |
+|                     Shift+KeyE |   E   |                   Shift+E |     |                   Shift+E |                        shift+e |                   Shift+E |                   shift+[KeyE] |         |
+|                Ctrl+Shift+KeyE |   E   |              Ctrl+Shift+E |     |              Ctrl+Shift+E |                   ctrl+shift+e |              Ctrl+Shift+E |              ctrl+shift+[KeyE] |         |
+|                       Alt+KeyE |   e   |                     Alt+E |     |                     Alt+E |                          alt+e |                     Alt+E |                     alt+[KeyE] |         |
+|                  Ctrl+Alt+KeyE |   €   |                Ctrl+Alt+E |     |                Ctrl+Alt+E |                     ctrl+alt+e |                Ctrl+Alt+E |                ctrl+alt+[KeyE] |         |
+|                 Shift+Alt+KeyE |   E   |               Shift+Alt+E |     |               Shift+Alt+E |                    shift+alt+e |               Shift+Alt+E |               shift+alt+[KeyE] |         |
+|            Ctrl+Shift+Alt+KeyE |   Ë   |          Ctrl+Shift+Alt+E |     |          Ctrl+Shift+Alt+E |               ctrl+shift+alt+e |          Ctrl+Shift+Alt+E |          ctrl+shift+alt+[KeyE] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyF |   f   |                         F |     |                         F |                              f |                         F |                         [KeyF] |         |
+|                      Ctrl+KeyF |   f   |                    Ctrl+F |     |                    Ctrl+F |                         ctrl+f |                    Ctrl+F |                    ctrl+[KeyF] |         |
+|                     Shift+KeyF |   F   |                   Shift+F |     |                   Shift+F |                        shift+f |                   Shift+F |                   shift+[KeyF] |         |
+|                Ctrl+Shift+KeyF |   F   |              Ctrl+Shift+F |     |              Ctrl+Shift+F |                   ctrl+shift+f |              Ctrl+Shift+F |              ctrl+shift+[KeyF] |         |
+|                       Alt+KeyF |   f   |                     Alt+F |     |                     Alt+F |                          alt+f |                     Alt+F |                     alt+[KeyF] |         |
+|                  Ctrl+Alt+KeyF |   ƒ   |                Ctrl+Alt+F |     |                Ctrl+Alt+F |                     ctrl+alt+f |                Ctrl+Alt+F |                ctrl+alt+[KeyF] |         |
+|                 Shift+Alt+KeyF |   F   |               Shift+Alt+F |     |               Shift+Alt+F |                    shift+alt+f |               Shift+Alt+F |               shift+alt+[KeyF] |         |
+|            Ctrl+Shift+Alt+KeyF |   ‡   |          Ctrl+Shift+Alt+F |     |          Ctrl+Shift+Alt+F |               ctrl+shift+alt+f |          Ctrl+Shift+Alt+F |          ctrl+shift+alt+[KeyF] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyG |   g   |                         G |     |                         G |                              g |                         G |                         [KeyG] |         |
+|                      Ctrl+KeyG |   g   |                    Ctrl+G |     |                    Ctrl+G |                         ctrl+g |                    Ctrl+G |                    ctrl+[KeyG] |         |
+|                     Shift+KeyG |   G   |                   Shift+G |     |                   Shift+G |                        shift+g |                   Shift+G |                   shift+[KeyG] |         |
+|                Ctrl+Shift+KeyG |   G   |              Ctrl+Shift+G |     |              Ctrl+Shift+G |                   ctrl+shift+g |              Ctrl+Shift+G |              ctrl+shift+[KeyG] |         |
+|                       Alt+KeyG |   g   |                     Alt+G |     |                     Alt+G |                          alt+g |                     Alt+G |                     alt+[KeyG] |         |
+|                  Ctrl+Alt+KeyG |   @   |                Ctrl+Alt+G |     |                Ctrl+Alt+G |                     ctrl+alt+g |                Ctrl+Alt+G |                ctrl+alt+[KeyG] |         |
+|                 Shift+Alt+KeyG |   G   |               Shift+Alt+G |     |               Shift+Alt+G |                    shift+alt+g |               Shift+Alt+G |               shift+alt+[KeyG] |         |
+|            Ctrl+Shift+Alt+KeyG |   ‚   |          Ctrl+Shift+Alt+G |     |          Ctrl+Shift+Alt+G |               ctrl+shift+alt+g |          Ctrl+Shift+Alt+G |          ctrl+shift+alt+[KeyG] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyH |   h   |                         H |     |                         H |                              h |                         H |                         [KeyH] |         |
+|                      Ctrl+KeyH |   h   |                    Ctrl+H |     |                    Ctrl+H |                         ctrl+h |                    Ctrl+H |                    ctrl+[KeyH] |         |
+|                     Shift+KeyH |   H   |                   Shift+H |     |                   Shift+H |                        shift+h |                   Shift+H |                   shift+[KeyH] |         |
+|                Ctrl+Shift+KeyH |   H   |              Ctrl+Shift+H |     |              Ctrl+Shift+H |                   ctrl+shift+h |              Ctrl+Shift+H |              ctrl+shift+[KeyH] |         |
+|                       Alt+KeyH |   h   |                     Alt+H |     |                     Alt+H |                          alt+h |                     Alt+H |                     alt+[KeyH] |         |
+|                  Ctrl+Alt+KeyH |   ª   |                Ctrl+Alt+H |     |                Ctrl+Alt+H |                     ctrl+alt+h |                Ctrl+Alt+H |                ctrl+alt+[KeyH] |         |
+|                 Shift+Alt+KeyH |   H   |               Shift+Alt+H |     |               Shift+Alt+H |                    shift+alt+h |               Shift+Alt+H |               shift+alt+[KeyH] |         |
+|            Ctrl+Shift+Alt+KeyH |   ·   |          Ctrl+Shift+Alt+H |     |          Ctrl+Shift+Alt+H |               ctrl+shift+alt+h |          Ctrl+Shift+Alt+H |          ctrl+shift+alt+[KeyH] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyI |   i   |                         I |     |                         I |                              i |                         I |                         [KeyI] |         |
+|                      Ctrl+KeyI |   i   |                    Ctrl+I |     |                    Ctrl+I |                         ctrl+i |                    Ctrl+I |                    ctrl+[KeyI] |         |
+|                     Shift+KeyI |   I   |                   Shift+I |     |                   Shift+I |                        shift+i |                   Shift+I |                   shift+[KeyI] |         |
+|                Ctrl+Shift+KeyI |   I   |              Ctrl+Shift+I |     |              Ctrl+Shift+I |                   ctrl+shift+i |              Ctrl+Shift+I |              ctrl+shift+[KeyI] |         |
+|                       Alt+KeyI |   i   |                     Alt+I |     |                     Alt+I |                          alt+i |                     Alt+I |                     alt+[KeyI] |         |
+|                  Ctrl+Alt+KeyI |   ¡   |                Ctrl+Alt+I |     |                Ctrl+Alt+I |                     ctrl+alt+i |                Ctrl+Alt+I |                ctrl+alt+[KeyI] |         |
+|                 Shift+Alt+KeyI |   I   |               Shift+Alt+I |     |               Shift+Alt+I |                    shift+alt+i |               Shift+Alt+I |               shift+alt+[KeyI] |         |
+|            Ctrl+Shift+Alt+KeyI |   ı   |          Ctrl+Shift+Alt+I |     |          Ctrl+Shift+Alt+I |               ctrl+shift+alt+i |          Ctrl+Shift+Alt+I |          ctrl+shift+alt+[KeyI] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyJ |   j   |                         J |     |                         J |                              j |                         J |                         [KeyJ] |         |
+|                      Ctrl+KeyJ |   j   |                    Ctrl+J |     |                    Ctrl+J |                         ctrl+j |                    Ctrl+J |                    ctrl+[KeyJ] |         |
+|                     Shift+KeyJ |   J   |                   Shift+J |     |                   Shift+J |                        shift+j |                   Shift+J |                   shift+[KeyJ] |         |
+|                Ctrl+Shift+KeyJ |   J   |              Ctrl+Shift+J |     |              Ctrl+Shift+J |                   ctrl+shift+j |              Ctrl+Shift+J |              ctrl+shift+[KeyJ] |         |
+|                       Alt+KeyJ |   j   |                     Alt+J |     |                     Alt+J |                          alt+j |                     Alt+J |                     alt+[KeyJ] |         |
+|                  Ctrl+Alt+KeyJ |   º   |                Ctrl+Alt+J |     |                Ctrl+Alt+J |                     ctrl+alt+j |                Ctrl+Alt+J |                ctrl+alt+[KeyJ] |         |
+|                 Shift+Alt+KeyJ |   J   |               Shift+Alt+J |     |               Shift+Alt+J |                    shift+alt+j |               Shift+Alt+J |               shift+alt+[KeyJ] |         |
+|            Ctrl+Shift+Alt+KeyJ |   ˜   |          Ctrl+Shift+Alt+J |     |          Ctrl+Shift+Alt+J |               ctrl+shift+alt+j |          Ctrl+Shift+Alt+J |          ctrl+shift+alt+[KeyJ] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyK |   k   |                         K |     |                         K |                              k |                         K |                         [KeyK] |         |
+|                      Ctrl+KeyK |   k   |                    Ctrl+K |     |                    Ctrl+K |                         ctrl+k |                    Ctrl+K |                    ctrl+[KeyK] |         |
+|                     Shift+KeyK |   K   |                   Shift+K |     |                   Shift+K |                        shift+k |                   Shift+K |                   shift+[KeyK] |         |
+|                Ctrl+Shift+KeyK |   K   |              Ctrl+Shift+K |     |              Ctrl+Shift+K |                   ctrl+shift+k |              Ctrl+Shift+K |              ctrl+shift+[KeyK] |         |
+|                       Alt+KeyK |   k   |                     Alt+K |     |                     Alt+K |                          alt+k |                     Alt+K |                     alt+[KeyK] |         |
+|                  Ctrl+Alt+KeyK |   ∆   |                Ctrl+Alt+K |     |                Ctrl+Alt+K |                     ctrl+alt+k |                Ctrl+Alt+K |                ctrl+alt+[KeyK] |         |
+|                 Shift+Alt+KeyK |   K   |               Shift+Alt+K |     |               Shift+Alt+K |                    shift+alt+k |               Shift+Alt+K |               shift+alt+[KeyK] |         |
+|            Ctrl+Shift+Alt+KeyK |   ¯   |          Ctrl+Shift+Alt+K |     |          Ctrl+Shift+Alt+K |               ctrl+shift+alt+k |          Ctrl+Shift+Alt+K |          ctrl+shift+alt+[KeyK] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyL |   l   |                         L |     |                         L |                              l |                         L |                         [KeyL] |         |
+|                      Ctrl+KeyL |   l   |                    Ctrl+L |     |                    Ctrl+L |                         ctrl+l |                    Ctrl+L |                    ctrl+[KeyL] |         |
+|                     Shift+KeyL |   L   |                   Shift+L |     |                   Shift+L |                        shift+l |                   Shift+L |                   shift+[KeyL] |         |
+|                Ctrl+Shift+KeyL |   L   |              Ctrl+Shift+L |     |              Ctrl+Shift+L |                   ctrl+shift+l |              Ctrl+Shift+L |              ctrl+shift+[KeyL] |         |
+|                       Alt+KeyL |   l   |                     Alt+L |     |                     Alt+L |                          alt+l |                     Alt+L |                     alt+[KeyL] |         |
+|                  Ctrl+Alt+KeyL |   ¬   |                Ctrl+Alt+L |     |                Ctrl+Alt+L |                     ctrl+alt+l |                Ctrl+Alt+L |                ctrl+alt+[KeyL] |         |
+|                 Shift+Alt+KeyL |   L   |               Shift+Alt+L |     |               Shift+Alt+L |                    shift+alt+l |               Shift+Alt+L |               shift+alt+[KeyL] |         |
+|            Ctrl+Shift+Alt+KeyL |   ˆ   |          Ctrl+Shift+Alt+L |     |          Ctrl+Shift+Alt+L |               ctrl+shift+alt+l |          Ctrl+Shift+Alt+L |          ctrl+shift+alt+[KeyL] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyM |   m   |                         M |     |                         M |                              m |                         M |                         [KeyM] |         |
+|                      Ctrl+KeyM |   m   |                    Ctrl+M |     |                    Ctrl+M |                         ctrl+m |                    Ctrl+M |                    ctrl+[KeyM] |         |
+|                     Shift+KeyM |   M   |                   Shift+M |     |                   Shift+M |                        shift+m |                   Shift+M |                   shift+[KeyM] |         |
+|                Ctrl+Shift+KeyM |   M   |              Ctrl+Shift+M |     |              Ctrl+Shift+M |                   ctrl+shift+m |              Ctrl+Shift+M |              ctrl+shift+[KeyM] |         |
+|                       Alt+KeyM |   m   |                     Alt+M |     |                     Alt+M |                          alt+m |                     Alt+M |                     alt+[KeyM] |         |
+|                  Ctrl+Alt+KeyM |   µ   |                Ctrl+Alt+M |     |                Ctrl+Alt+M |                     ctrl+alt+m |                Ctrl+Alt+M |                ctrl+alt+[KeyM] |         |
+|                 Shift+Alt+KeyM |   M   |               Shift+Alt+M |     |               Shift+Alt+M |                    shift+alt+m |               Shift+Alt+M |               shift+alt+[KeyM] |         |
+|            Ctrl+Shift+Alt+KeyM |   ˚   |          Ctrl+Shift+Alt+M |     |          Ctrl+Shift+Alt+M |               ctrl+shift+alt+m |          Ctrl+Shift+Alt+M |          ctrl+shift+alt+[KeyM] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyN |   n   |                         N |     |                         N |                              n |                         N |                         [KeyN] |         |
+|                      Ctrl+KeyN |   n   |                    Ctrl+N |     |                    Ctrl+N |                         ctrl+n |                    Ctrl+N |                    ctrl+[KeyN] |         |
+|                     Shift+KeyN |   N   |                   Shift+N |     |                   Shift+N |                        shift+n |                   Shift+N |                   shift+[KeyN] |         |
+|                Ctrl+Shift+KeyN |   N   |              Ctrl+Shift+N |     |              Ctrl+Shift+N |                   ctrl+shift+n |              Ctrl+Shift+N |              ctrl+shift+[KeyN] |         |
+|                       Alt+KeyN |   n   |                     Alt+N |     |                     Alt+N |                          alt+n |                     Alt+N |                     alt+[KeyN] |         |
+|                  Ctrl+Alt+KeyN |   ~   |                Ctrl+Alt+N |     |                Ctrl+Alt+N |                     ctrl+alt+n |                Ctrl+Alt+N |                ctrl+alt+[KeyN] |         |
+|                                |       |                   Shift+` |     |                           |                                |                           |                                |         |
+|                 Shift+Alt+KeyN |   N   |               Shift+Alt+N |     |               Shift+Alt+N |                    shift+alt+n |               Shift+Alt+N |               shift+alt+[KeyN] |         |
+|            Ctrl+Shift+Alt+KeyN |   ˙   |          Ctrl+Shift+Alt+N |     |          Ctrl+Shift+Alt+N |               ctrl+shift+alt+n |          Ctrl+Shift+Alt+N |          ctrl+shift+alt+[KeyN] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyO |   o   |                         O |     |                         O |                              o |                         O |                         [KeyO] |         |
+|                      Ctrl+KeyO |   o   |                    Ctrl+O |     |                    Ctrl+O |                         ctrl+o |                    Ctrl+O |                    ctrl+[KeyO] |         |
+|                     Shift+KeyO |   O   |                   Shift+O |     |                   Shift+O |                        shift+o |                   Shift+O |                   shift+[KeyO] |         |
+|                Ctrl+Shift+KeyO |   O   |              Ctrl+Shift+O |     |              Ctrl+Shift+O |                   ctrl+shift+o |              Ctrl+Shift+O |              ctrl+shift+[KeyO] |         |
+|                       Alt+KeyO |   o   |                     Alt+O |     |                     Alt+O |                          alt+o |                     Alt+O |                     alt+[KeyO] |         |
+|                  Ctrl+Alt+KeyO |   ø   |                Ctrl+Alt+O |     |                Ctrl+Alt+O |                     ctrl+alt+o |                Ctrl+Alt+O |                ctrl+alt+[KeyO] |         |
+|                 Shift+Alt+KeyO |   O   |               Shift+Alt+O |     |               Shift+Alt+O |                    shift+alt+o |               Shift+Alt+O |               shift+alt+[KeyO] |         |
+|            Ctrl+Shift+Alt+KeyO |   Ø   |          Ctrl+Shift+Alt+O |     |          Ctrl+Shift+Alt+O |               ctrl+shift+alt+o |          Ctrl+Shift+Alt+O |          ctrl+shift+alt+[KeyO] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyP |   p   |                         P |     |                         P |                              p |                         P |                         [KeyP] |         |
+|                      Ctrl+KeyP |   p   |                    Ctrl+P |     |                    Ctrl+P |                         ctrl+p |                    Ctrl+P |                    ctrl+[KeyP] |         |
+|                     Shift+KeyP |   P   |                   Shift+P |     |                   Shift+P |                        shift+p |                   Shift+P |                   shift+[KeyP] |         |
+|                Ctrl+Shift+KeyP |   P   |              Ctrl+Shift+P |     |              Ctrl+Shift+P |                   ctrl+shift+p |              Ctrl+Shift+P |              ctrl+shift+[KeyP] |         |
+|                       Alt+KeyP |   p   |                     Alt+P |     |                     Alt+P |                          alt+p |                     Alt+P |                     alt+[KeyP] |         |
+|                  Ctrl+Alt+KeyP |   π   |                Ctrl+Alt+P |     |                Ctrl+Alt+P |                     ctrl+alt+p |                Ctrl+Alt+P |                ctrl+alt+[KeyP] |         |
+|                 Shift+Alt+KeyP |   P   |               Shift+Alt+P |     |               Shift+Alt+P |                    shift+alt+p |               Shift+Alt+P |               shift+alt+[KeyP] |         |
+|            Ctrl+Shift+Alt+KeyP |   ∏   |          Ctrl+Shift+Alt+P |     |          Ctrl+Shift+Alt+P |               ctrl+shift+alt+p |          Ctrl+Shift+Alt+P |          ctrl+shift+alt+[KeyP] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyQ |   q   |                         Q |     |                         Q |                              q |                         Q |                         [KeyQ] |         |
+|                      Ctrl+KeyQ |   q   |                    Ctrl+Q |     |                    Ctrl+Q |                         ctrl+q |                    Ctrl+Q |                    ctrl+[KeyQ] |         |
+|                     Shift+KeyQ |   Q   |                   Shift+Q |     |                   Shift+Q |                        shift+q |                   Shift+Q |                   shift+[KeyQ] |         |
+|                Ctrl+Shift+KeyQ |   Q   |              Ctrl+Shift+Q |     |              Ctrl+Shift+Q |                   ctrl+shift+q |              Ctrl+Shift+Q |              ctrl+shift+[KeyQ] |         |
+|                       Alt+KeyQ |   q   |                     Alt+Q |     |                     Alt+Q |                          alt+q |                     Alt+Q |                     alt+[KeyQ] |         |
+|                  Ctrl+Alt+KeyQ |   œ   |                Ctrl+Alt+Q |     |                Ctrl+Alt+Q |                     ctrl+alt+q |                Ctrl+Alt+Q |                ctrl+alt+[KeyQ] |         |
+|                 Shift+Alt+KeyQ |   Q   |               Shift+Alt+Q |     |               Shift+Alt+Q |                    shift+alt+q |               Shift+Alt+Q |               shift+alt+[KeyQ] |         |
+|            Ctrl+Shift+Alt+KeyQ |   Π  |          Ctrl+Shift+Alt+Q |     |          Ctrl+Shift+Alt+Q |               ctrl+shift+alt+q |          Ctrl+Shift+Alt+Q |          ctrl+shift+alt+[KeyQ] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyR |   r   |                         R |     |                         R |                              r |                         R |                         [KeyR] |         |
+|                      Ctrl+KeyR |   r   |                    Ctrl+R |     |                    Ctrl+R |                         ctrl+r |                    Ctrl+R |                    ctrl+[KeyR] |         |
+|                     Shift+KeyR |   R   |                   Shift+R |     |                   Shift+R |                        shift+r |                   Shift+R |                   shift+[KeyR] |         |
+|                Ctrl+Shift+KeyR |   R   |              Ctrl+Shift+R |     |              Ctrl+Shift+R |                   ctrl+shift+r |              Ctrl+Shift+R |              ctrl+shift+[KeyR] |         |
+|                       Alt+KeyR |   r   |                     Alt+R |     |                     Alt+R |                          alt+r |                     Alt+R |                     alt+[KeyR] |         |
+|                  Ctrl+Alt+KeyR |   ®   |                Ctrl+Alt+R |     |                Ctrl+Alt+R |                     ctrl+alt+r |                Ctrl+Alt+R |                ctrl+alt+[KeyR] |         |
+|                 Shift+Alt+KeyR |   R   |               Shift+Alt+R |     |               Shift+Alt+R |                    shift+alt+r |               Shift+Alt+R |               shift+alt+[KeyR] |         |
+|            Ctrl+Shift+Alt+KeyR |   È   |          Ctrl+Shift+Alt+R |     |          Ctrl+Shift+Alt+R |               ctrl+shift+alt+r |          Ctrl+Shift+Alt+R |          ctrl+shift+alt+[KeyR] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyS |   s   |                         S |     |                         S |                              s |                         S |                         [KeyS] |         |
+|                      Ctrl+KeyS |   s   |                    Ctrl+S |     |                    Ctrl+S |                         ctrl+s |                    Ctrl+S |                    ctrl+[KeyS] |         |
+|                     Shift+KeyS |   S   |                   Shift+S |     |                   Shift+S |                        shift+s |                   Shift+S |                   shift+[KeyS] |         |
+|                Ctrl+Shift+KeyS |   S   |              Ctrl+Shift+S |     |              Ctrl+Shift+S |                   ctrl+shift+s |              Ctrl+Shift+S |              ctrl+shift+[KeyS] |         |
+|                       Alt+KeyS |   s   |                     Alt+S |     |                     Alt+S |                          alt+s |                     Alt+S |                     alt+[KeyS] |         |
+|                  Ctrl+Alt+KeyS |   ß   |                Ctrl+Alt+S |     |                Ctrl+Alt+S |                     ctrl+alt+s |                Ctrl+Alt+S |                ctrl+alt+[KeyS] |         |
+|                 Shift+Alt+KeyS |   S   |               Shift+Alt+S |     |               Shift+Alt+S |                    shift+alt+s |               Shift+Alt+S |               shift+alt+[KeyS] |         |
+|            Ctrl+Shift+Alt+KeyS |   fi   |          Ctrl+Shift+Alt+S |     |          Ctrl+Shift+Alt+S |               ctrl+shift+alt+s |          Ctrl+Shift+Alt+S |          ctrl+shift+alt+[KeyS] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyT |   t   |                         T |     |                         T |                              t |                         T |                         [KeyT] |         |
+|                      Ctrl+KeyT |   t   |                    Ctrl+T |     |                    Ctrl+T |                         ctrl+t |                    Ctrl+T |                    ctrl+[KeyT] |         |
+|                     Shift+KeyT |   T   |                   Shift+T |     |                   Shift+T |                        shift+t |                   Shift+T |                   shift+[KeyT] |         |
+|                Ctrl+Shift+KeyT |   T   |              Ctrl+Shift+T |     |              Ctrl+Shift+T |                   ctrl+shift+t |              Ctrl+Shift+T |              ctrl+shift+[KeyT] |         |
+|                       Alt+KeyT |   t   |                     Alt+T |     |                     Alt+T |                          alt+t |                     Alt+T |                     alt+[KeyT] |         |
+|                  Ctrl+Alt+KeyT |   †   |                Ctrl+Alt+T |     |                Ctrl+Alt+T |                     ctrl+alt+t |                Ctrl+Alt+T |                ctrl+alt+[KeyT] |         |
+|                 Shift+Alt+KeyT |   T   |               Shift+Alt+T |     |               Shift+Alt+T |                    shift+alt+t |               Shift+Alt+T |               shift+alt+[KeyT] |         |
+|            Ctrl+Shift+Alt+KeyT |   Î   |          Ctrl+Shift+Alt+T |     |          Ctrl+Shift+Alt+T |               ctrl+shift+alt+t |          Ctrl+Shift+Alt+T |          ctrl+shift+alt+[KeyT] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyU |   u   |                         U |     |                         U |                              u |                         U |                         [KeyU] |         |
+|                      Ctrl+KeyU |   u   |                    Ctrl+U |     |                    Ctrl+U |                         ctrl+u |                    Ctrl+U |                    ctrl+[KeyU] |         |
+|                     Shift+KeyU |   U   |                   Shift+U |     |                   Shift+U |                        shift+u |                   Shift+U |                   shift+[KeyU] |         |
+|                Ctrl+Shift+KeyU |   U   |              Ctrl+Shift+U |     |              Ctrl+Shift+U |                   ctrl+shift+u |              Ctrl+Shift+U |              ctrl+shift+[KeyU] |         |
+|                       Alt+KeyU |   u   |                     Alt+U |     |                     Alt+U |                          alt+u |                     Alt+U |                     alt+[KeyU] |         |
+|                  Ctrl+Alt+KeyU |   °   |                Ctrl+Alt+U |     |                Ctrl+Alt+U |                     ctrl+alt+u |                Ctrl+Alt+U |                ctrl+alt+[KeyU] |         |
+|                 Shift+Alt+KeyU |   U   |               Shift+Alt+U |     |               Shift+Alt+U |                    shift+alt+u |               Shift+Alt+U |               shift+alt+[KeyU] |         |
+|            Ctrl+Shift+Alt+KeyU |   Ù   |          Ctrl+Shift+Alt+U |     |          Ctrl+Shift+Alt+U |               ctrl+shift+alt+u |          Ctrl+Shift+Alt+U |          ctrl+shift+alt+[KeyU] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyV |   v   |                         V |     |                         V |                              v |                         V |                         [KeyV] |         |
+|                      Ctrl+KeyV |   v   |                    Ctrl+V |     |                    Ctrl+V |                         ctrl+v |                    Ctrl+V |                    ctrl+[KeyV] |         |
+|                     Shift+KeyV |   V   |                   Shift+V |     |                   Shift+V |                        shift+v |                   Shift+V |                   shift+[KeyV] |         |
+|                Ctrl+Shift+KeyV |   V   |              Ctrl+Shift+V |     |              Ctrl+Shift+V |                   ctrl+shift+v |              Ctrl+Shift+V |              ctrl+shift+[KeyV] |         |
+|                       Alt+KeyV |   v   |                     Alt+V |     |                     Alt+V |                          alt+v |                     Alt+V |                     alt+[KeyV] |         |
+|                  Ctrl+Alt+KeyV |   √   |                Ctrl+Alt+V |     |                Ctrl+Alt+V |                     ctrl+alt+v |                Ctrl+Alt+V |                ctrl+alt+[KeyV] |         |
+|                 Shift+Alt+KeyV |   V   |               Shift+Alt+V |     |               Shift+Alt+V |                    shift+alt+v |               Shift+Alt+V |               shift+alt+[KeyV] |         |
+|            Ctrl+Shift+Alt+KeyV |   ◊   |          Ctrl+Shift+Alt+V |     |          Ctrl+Shift+Alt+V |               ctrl+shift+alt+v |          Ctrl+Shift+Alt+V |          ctrl+shift+alt+[KeyV] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyW |   w   |                         W |     |                         W |                              w |                         W |                         [KeyW] |         |
+|                      Ctrl+KeyW |   w   |                    Ctrl+W |     |                    Ctrl+W |                         ctrl+w |                    Ctrl+W |                    ctrl+[KeyW] |         |
+|                     Shift+KeyW |   W   |                   Shift+W |     |                   Shift+W |                        shift+w |                   Shift+W |                   shift+[KeyW] |         |
+|                Ctrl+Shift+KeyW |   W   |              Ctrl+Shift+W |     |              Ctrl+Shift+W |                   ctrl+shift+w |              Ctrl+Shift+W |              ctrl+shift+[KeyW] |         |
+|                       Alt+KeyW |   w   |                     Alt+W |     |                     Alt+W |                          alt+w |                     Alt+W |                     alt+[KeyW] |         |
+|                  Ctrl+Alt+KeyW |   ∑   |                Ctrl+Alt+W |     |                Ctrl+Alt+W |                     ctrl+alt+w |                Ctrl+Alt+W |                ctrl+alt+[KeyW] |         |
+|                 Shift+Alt+KeyW |   W   |               Shift+Alt+W |     |               Shift+Alt+W |                    shift+alt+w |               Shift+Alt+W |               shift+alt+[KeyW] |         |
+|            Ctrl+Shift+Alt+KeyW |   Á   |          Ctrl+Shift+Alt+W |     |          Ctrl+Shift+Alt+W |               ctrl+shift+alt+w |          Ctrl+Shift+Alt+W |          ctrl+shift+alt+[KeyW] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyX |   x   |                         X |     |                         X |                              x |                         X |                         [KeyX] |         |
+|                      Ctrl+KeyX |   x   |                    Ctrl+X |     |                    Ctrl+X |                         ctrl+x |                    Ctrl+X |                    ctrl+[KeyX] |         |
+|                     Shift+KeyX |   X   |                   Shift+X |     |                   Shift+X |                        shift+x |                   Shift+X |                   shift+[KeyX] |         |
+|                Ctrl+Shift+KeyX |   X   |              Ctrl+Shift+X |     |              Ctrl+Shift+X |                   ctrl+shift+x |              Ctrl+Shift+X |              ctrl+shift+[KeyX] |         |
+|                       Alt+KeyX |   x   |                     Alt+X |     |                     Alt+X |                          alt+x |                     Alt+X |                     alt+[KeyX] |         |
+|                  Ctrl+Alt+KeyX |   ≈   |                Ctrl+Alt+X |     |                Ctrl+Alt+X |                     ctrl+alt+x |                Ctrl+Alt+X |                ctrl+alt+[KeyX] |         |
+|                 Shift+Alt+KeyX |   X   |               Shift+Alt+X |     |               Shift+Alt+X |                    shift+alt+x |               Shift+Alt+X |               shift+alt+[KeyX] |         |
+|            Ctrl+Shift+Alt+KeyX |   ™   |          Ctrl+Shift+Alt+X |     |          Ctrl+Shift+Alt+X |               ctrl+shift+alt+x |          Ctrl+Shift+Alt+X |          ctrl+shift+alt+[KeyX] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyY |   z   |                         Z |     |                         Z |                              z |                         Z |                         [KeyY] |         |
+|                      Ctrl+KeyY |   z   |                    Ctrl+Z |     |                    Ctrl+Z |                         ctrl+z |                    Ctrl+Z |                    ctrl+[KeyY] |         |
+|                     Shift+KeyY |   Z   |                   Shift+Z |     |                   Shift+Z |                        shift+z |                   Shift+Z |                   shift+[KeyY] |         |
+|                Ctrl+Shift+KeyY |   Z   |              Ctrl+Shift+Z |     |              Ctrl+Shift+Z |                   ctrl+shift+z |              Ctrl+Shift+Z |              ctrl+shift+[KeyY] |         |
+|                       Alt+KeyY |   z   |                     Alt+Z |     |                     Alt+Z |                          alt+z |                     Alt+Z |                     alt+[KeyY] |         |
+|                  Ctrl+Alt+KeyY |   Ω   |                Ctrl+Alt+Z |     |                Ctrl+Alt+Z |                     ctrl+alt+z |                Ctrl+Alt+Z |                ctrl+alt+[KeyY] |         |
+|                 Shift+Alt+KeyY |   Z   |               Shift+Alt+Z |     |               Shift+Alt+Z |                    shift+alt+z |               Shift+Alt+Z |               shift+alt+[KeyY] |         |
+|            Ctrl+Shift+Alt+KeyY |   Í   |          Ctrl+Shift+Alt+Z |     |          Ctrl+Shift+Alt+Z |               ctrl+shift+alt+z |          Ctrl+Shift+Alt+Z |          ctrl+shift+alt+[KeyY] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyZ |   y   |                         Y |     |                         Y |                              y |                         Y |                         [KeyZ] |         |
+|                      Ctrl+KeyZ |   y   |                    Ctrl+Y |     |                    Ctrl+Y |                         ctrl+y |                    Ctrl+Y |                    ctrl+[KeyZ] |         |
+|                     Shift+KeyZ |   Y   |                   Shift+Y |     |                   Shift+Y |                        shift+y |                   Shift+Y |                   shift+[KeyZ] |         |
+|                Ctrl+Shift+KeyZ |   Y   |              Ctrl+Shift+Y |     |              Ctrl+Shift+Y |                   ctrl+shift+y |              Ctrl+Shift+Y |              ctrl+shift+[KeyZ] |         |
+|                       Alt+KeyZ |   y   |                     Alt+Y |     |                     Alt+Y |                          alt+y |                     Alt+Y |                     alt+[KeyZ] |         |
+|                  Ctrl+Alt+KeyZ |   ¥   |                Ctrl+Alt+Y |     |                Ctrl+Alt+Y |                     ctrl+alt+y |                Ctrl+Alt+Y |                ctrl+alt+[KeyZ] |         |
+|                 Shift+Alt+KeyZ |   Y   |               Shift+Alt+Y |     |               Shift+Alt+Y |                    shift+alt+y |               Shift+Alt+Y |               shift+alt+[KeyZ] |         |
+|            Ctrl+Shift+Alt+KeyZ |   Ÿ   |          Ctrl+Shift+Alt+Y |     |          Ctrl+Shift+Alt+Y |               ctrl+shift+alt+y |          Ctrl+Shift+Alt+Y |          ctrl+shift+alt+[KeyZ] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit1 |   1   |                         1 |     |                         1 |                              1 |                         1 |                       [Digit1] |         |
+|                    Ctrl+Digit1 |   1   |                    Ctrl+1 |     |                    Ctrl+1 |                         ctrl+1 |                    Ctrl+1 |                  ctrl+[Digit1] |         |
+|                   Shift+Digit1 |   +   |                   Shift+1 |     |                   Shift+1 |                        shift+1 |                   Shift+1 |                 shift+[Digit1] |         |
+|                                |       |                   Shift+= |     |                           |                                |                           |                                |         |
+|              Ctrl+Shift+Digit1 |   +   |              Ctrl+Shift+1 |     |              Ctrl+Shift+1 |                   ctrl+shift+1 |              Ctrl+Shift+1 |            ctrl+shift+[Digit1] |         |
+|                                |       |              Ctrl+Shift+= |     |                           |                                |                           |                                |         |
+|                     Alt+Digit1 |   1   |                     Alt+1 |     |                     Alt+1 |                          alt+1 |                     Alt+1 |                   alt+[Digit1] |         |
+|                Ctrl+Alt+Digit1 |   ±   |                Ctrl+Alt+1 |     |                Ctrl+Alt+1 |                     ctrl+alt+1 |                Ctrl+Alt+1 |              ctrl+alt+[Digit1] |         |
+|               Shift+Alt+Digit1 |   +   |               Shift+Alt+1 |     |               Shift+Alt+1 |                    shift+alt+1 |               Shift+Alt+1 |             shift+alt+[Digit1] |         |
+|                                |       |               Shift+Alt+= |     |                           |                                |                           |                                |         |
+|          Ctrl+Shift+Alt+Digit1 |   ∞   |          Ctrl+Shift+Alt+1 |     |          Ctrl+Shift+Alt+1 |               ctrl+shift+alt+1 |          Ctrl+Shift+Alt+1 |        ctrl+shift+alt+[Digit1] |         |
+|                                |       |          Ctrl+Shift+Alt+= |     |                           |                                |                           |                                |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit2 |   2   |                         2 |     |                         2 |                              2 |                         2 |                       [Digit2] |         |
+|                    Ctrl+Digit2 |   2   |                    Ctrl+2 |     |                    Ctrl+2 |                         ctrl+2 |                    Ctrl+2 |                  ctrl+[Digit2] |         |
+|                   Shift+Digit2 |   "   |                   Shift+2 |     |                   Shift+2 |                        shift+2 |                   Shift+2 |                 shift+[Digit2] |         |
+|                                |       |                   Shift+' |     |                           |                                |                           |                                |         |
+|              Ctrl+Shift+Digit2 |   "   |              Ctrl+Shift+2 |     |              Ctrl+Shift+2 |                   ctrl+shift+2 |              Ctrl+Shift+2 |            ctrl+shift+[Digit2] |         |
+|                                |       |              Ctrl+Shift+' |     |                           |                                |                           |                                |         |
+|                     Alt+Digit2 |   2   |                     Alt+2 |     |                     Alt+2 |                          alt+2 |                     Alt+2 |                   alt+[Digit2] |         |
+|                Ctrl+Alt+Digit2 |   “   |                Ctrl+Alt+2 |     |                Ctrl+Alt+2 |                     ctrl+alt+2 |                Ctrl+Alt+2 |              ctrl+alt+[Digit2] |         |
+|               Shift+Alt+Digit2 |   "   |               Shift+Alt+2 |     |               Shift+Alt+2 |                    shift+alt+2 |               Shift+Alt+2 |             shift+alt+[Digit2] |         |
+|                                |       |               Shift+Alt+' |     |                           |                                |                           |                                |         |
+|          Ctrl+Shift+Alt+Digit2 |   ”   |          Ctrl+Shift+Alt+2 |     |          Ctrl+Shift+Alt+2 |               ctrl+shift+alt+2 |          Ctrl+Shift+Alt+2 |        ctrl+shift+alt+[Digit2] |         |
+|                                |       |          Ctrl+Shift+Alt+' |     |                           |                                |                           |                                |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit3 |   3   |                         3 |     |                         3 |                              3 |                         3 |                       [Digit3] |         |
+|                    Ctrl+Digit3 |   3   |                    Ctrl+3 |     |                    Ctrl+3 |                         ctrl+3 |                    Ctrl+3 |                  ctrl+[Digit3] |         |
+|                   Shift+Digit3 |   *   |                   Shift+3 |     |                   Shift+3 |                        shift+3 |                   Shift+3 |                 shift+[Digit3] |         |
+|              Ctrl+Shift+Digit3 |   *   |              Ctrl+Shift+3 |     |              Ctrl+Shift+3 |                   ctrl+shift+3 |              Ctrl+Shift+3 |            ctrl+shift+[Digit3] |         |
+|                     Alt+Digit3 |   3   |                     Alt+3 |     |                     Alt+3 |                          alt+3 |                     Alt+3 |                   alt+[Digit3] |         |
+|                Ctrl+Alt+Digit3 |   #   |                Ctrl+Alt+3 |     |                Ctrl+Alt+3 |                     ctrl+alt+3 |                Ctrl+Alt+3 |              ctrl+alt+[Digit3] |         |
+|               Shift+Alt+Digit3 |   *   |               Shift+Alt+3 |     |               Shift+Alt+3 |                    shift+alt+3 |               Shift+Alt+3 |             shift+alt+[Digit3] |         |
+|          Ctrl+Shift+Alt+Digit3 |   ‹   |          Ctrl+Shift+Alt+3 |     |          Ctrl+Shift+Alt+3 |               ctrl+shift+alt+3 |          Ctrl+Shift+Alt+3 |        ctrl+shift+alt+[Digit3] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit4 |   4   |                         4 |     |                         4 |                              4 |                         4 |                       [Digit4] |         |
+|                    Ctrl+Digit4 |   4   |                    Ctrl+4 |     |                    Ctrl+4 |                         ctrl+4 |                    Ctrl+4 |                  ctrl+[Digit4] |         |
+|                   Shift+Digit4 |   ç   |                   Shift+4 |     |                   Shift+4 |                        shift+4 |                   Shift+4 |                 shift+[Digit4] |         |
+|              Ctrl+Shift+Digit4 |   ç   |              Ctrl+Shift+4 |     |              Ctrl+Shift+4 |                   ctrl+shift+4 |              Ctrl+Shift+4 |            ctrl+shift+[Digit4] |         |
+|                     Alt+Digit4 |   4   |                     Alt+4 |     |                     Alt+4 |                          alt+4 |                     Alt+4 |                   alt+[Digit4] |         |
+|                Ctrl+Alt+Digit4 |   Ç   |                Ctrl+Alt+4 |     |                Ctrl+Alt+4 |                     ctrl+alt+4 |                Ctrl+Alt+4 |              ctrl+alt+[Digit4] |         |
+|               Shift+Alt+Digit4 |   ç   |               Shift+Alt+4 |     |               Shift+Alt+4 |                    shift+alt+4 |               Shift+Alt+4 |             shift+alt+[Digit4] |         |
+|          Ctrl+Shift+Alt+Digit4 |   ⁄   |          Ctrl+Shift+Alt+4 |     |          Ctrl+Shift+Alt+4 |               ctrl+shift+alt+4 |          Ctrl+Shift+Alt+4 |        ctrl+shift+alt+[Digit4] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit5 |   5   |                         5 |     |                         5 |                              5 |                         5 |                       [Digit5] |         |
+|                    Ctrl+Digit5 |   5   |                    Ctrl+5 |     |                    Ctrl+5 |                         ctrl+5 |                    Ctrl+5 |                  ctrl+[Digit5] |         |
+|                   Shift+Digit5 |   %   |                   Shift+5 |     |                   Shift+5 |                        shift+5 |                   Shift+5 |                 shift+[Digit5] |         |
+|              Ctrl+Shift+Digit5 |   %   |              Ctrl+Shift+5 |     |              Ctrl+Shift+5 |                   ctrl+shift+5 |              Ctrl+Shift+5 |            ctrl+shift+[Digit5] |         |
+|                     Alt+Digit5 |   5   |                     Alt+5 |     |                     Alt+5 |                          alt+5 |                     Alt+5 |                   alt+[Digit5] |         |
+|                Ctrl+Alt+Digit5 |   [   |                Ctrl+Alt+5 |     |                Ctrl+Alt+5 |                     ctrl+alt+5 |                Ctrl+Alt+5 |              ctrl+alt+[Digit5] |         |
+|                                |       |                         [ |     |                           |                                |                           |                                |         |
+|               Shift+Alt+Digit5 |   %   |               Shift+Alt+5 |     |               Shift+Alt+5 |                    shift+alt+5 |               Shift+Alt+5 |             shift+alt+[Digit5] |         |
+|          Ctrl+Shift+Alt+Digit5 |   [   |          Ctrl+Shift+Alt+5 |     |          Ctrl+Shift+Alt+5 |               ctrl+shift+alt+5 |          Ctrl+Shift+Alt+5 |        ctrl+shift+alt+[Digit5] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit6 |   6   |                         6 |     |                         6 |                              6 |                         6 |                       [Digit6] |         |
+|                    Ctrl+Digit6 |   6   |                    Ctrl+6 |     |                    Ctrl+6 |                         ctrl+6 |                    Ctrl+6 |                  ctrl+[Digit6] |         |
+|                   Shift+Digit6 |   &   |                   Shift+6 |     |                   Shift+6 |                        shift+6 |                   Shift+6 |                 shift+[Digit6] |         |
+|              Ctrl+Shift+Digit6 |   &   |              Ctrl+Shift+6 |     |              Ctrl+Shift+6 |                   ctrl+shift+6 |              Ctrl+Shift+6 |            ctrl+shift+[Digit6] |         |
+|                     Alt+Digit6 |   6   |                     Alt+6 |     |                     Alt+6 |                          alt+6 |                     Alt+6 |                   alt+[Digit6] |         |
+|                Ctrl+Alt+Digit6 |   ]   |                Ctrl+Alt+6 |     |                Ctrl+Alt+6 |                     ctrl+alt+6 |                Ctrl+Alt+6 |              ctrl+alt+[Digit6] |         |
+|                                |       |                         ] |     |                           |                                |                           |                                |         |
+|               Shift+Alt+Digit6 |   &   |               Shift+Alt+6 |     |               Shift+Alt+6 |                    shift+alt+6 |               Shift+Alt+6 |             shift+alt+[Digit6] |         |
+|          Ctrl+Shift+Alt+Digit6 |   ]   |          Ctrl+Shift+Alt+6 |     |          Ctrl+Shift+Alt+6 |               ctrl+shift+alt+6 |          Ctrl+Shift+Alt+6 |        ctrl+shift+alt+[Digit6] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit7 |   7   |                         7 |     |                         7 |                              7 |                         7 |                       [Digit7] |         |
+|                    Ctrl+Digit7 |   7   |                    Ctrl+7 |     |                    Ctrl+7 |                         ctrl+7 |                    Ctrl+7 |                  ctrl+[Digit7] |         |
+|                   Shift+Digit7 |   /   |                   Shift+7 |     |                   Shift+7 |                        shift+7 |                   Shift+7 |                 shift+[Digit7] |         |
+|                                |       |                         / |     |                           |                                |                           |                                |         |
+|              Ctrl+Shift+Digit7 |   /   |              Ctrl+Shift+7 |     |              Ctrl+Shift+7 |                   ctrl+shift+7 |              Ctrl+Shift+7 |            ctrl+shift+[Digit7] |         |
+|                                |       |                    Ctrl+/ |     |                           |                                |                           |                                |         |
+|                     Alt+Digit7 |   7   |                     Alt+7 |     |                     Alt+7 |                          alt+7 |                     Alt+7 |                   alt+[Digit7] |         |
+|                Ctrl+Alt+Digit7 |   |   |                Ctrl+Alt+7 |     |                Ctrl+Alt+7 |                     ctrl+alt+7 |                Ctrl+Alt+7 |              ctrl+alt+[Digit7] |         |
+|                                |       |                   Shift+\ |     |                           |                                |                           |                                |         |
+|               Shift+Alt+Digit7 |   /   |               Shift+Alt+7 |     |               Shift+Alt+7 |                    shift+alt+7 |               Shift+Alt+7 |             shift+alt+[Digit7] |         |
+|                                |       |                     Alt+/ |     |                           |                                |                           |                                |         |
+|          Ctrl+Shift+Alt+Digit7 |   \   |          Ctrl+Shift+Alt+7 |     |          Ctrl+Shift+Alt+7 |               ctrl+shift+alt+7 |          Ctrl+Shift+Alt+7 |        ctrl+shift+alt+[Digit7] |         |
+|                                |       |                         \ |     |                           |                                |                           |                                |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit8 |   8   |                         8 |     |                         8 |                              8 |                         8 |                       [Digit8] |         |
+|                    Ctrl+Digit8 |   8   |                    Ctrl+8 |     |                    Ctrl+8 |                         ctrl+8 |                    Ctrl+8 |                  ctrl+[Digit8] |         |
+|                   Shift+Digit8 |   (   |                   Shift+8 |     |                   Shift+8 |                        shift+8 |                   Shift+8 |                 shift+[Digit8] |         |
+|              Ctrl+Shift+Digit8 |   (   |              Ctrl+Shift+8 |     |              Ctrl+Shift+8 |                   ctrl+shift+8 |              Ctrl+Shift+8 |            ctrl+shift+[Digit8] |         |
+|                     Alt+Digit8 |   8   |                     Alt+8 |     |                     Alt+8 |                          alt+8 |                     Alt+8 |                   alt+[Digit8] |         |
+|                Ctrl+Alt+Digit8 |   {   |                Ctrl+Alt+8 |     |                Ctrl+Alt+8 |                     ctrl+alt+8 |                Ctrl+Alt+8 |              ctrl+alt+[Digit8] |         |
+|                                |       |                   Shift+[ |     |                           |                                |                           |                                |         |
+|               Shift+Alt+Digit8 |   (   |               Shift+Alt+8 |     |               Shift+Alt+8 |                    shift+alt+8 |               Shift+Alt+8 |             shift+alt+[Digit8] |         |
+|          Ctrl+Shift+Alt+Digit8 |   Ò   |          Ctrl+Shift+Alt+8 |     |          Ctrl+Shift+Alt+8 |               ctrl+shift+alt+8 |          Ctrl+Shift+Alt+8 |        ctrl+shift+alt+[Digit8] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit9 |   9   |                         9 |     |                         9 |                              9 |                         9 |                       [Digit9] |         |
+|                    Ctrl+Digit9 |   9   |                    Ctrl+9 |     |                    Ctrl+9 |                         ctrl+9 |                    Ctrl+9 |                  ctrl+[Digit9] |         |
+|                   Shift+Digit9 |   )   |                   Shift+9 |     |                   Shift+9 |                        shift+9 |                   Shift+9 |                 shift+[Digit9] |         |
+|              Ctrl+Shift+Digit9 |   )   |              Ctrl+Shift+9 |     |              Ctrl+Shift+9 |                   ctrl+shift+9 |              Ctrl+Shift+9 |            ctrl+shift+[Digit9] |         |
+|                     Alt+Digit9 |   9   |                     Alt+9 |     |                     Alt+9 |                          alt+9 |                     Alt+9 |                   alt+[Digit9] |         |
+|                Ctrl+Alt+Digit9 |   }   |                Ctrl+Alt+9 |     |                Ctrl+Alt+9 |                     ctrl+alt+9 |                Ctrl+Alt+9 |              ctrl+alt+[Digit9] |         |
+|                                |       |                   Shift+] |     |                           |                                |                           |                                |         |
+|               Shift+Alt+Digit9 |   )   |               Shift+Alt+9 |     |               Shift+Alt+9 |                    shift+alt+9 |               Shift+Alt+9 |             shift+alt+[Digit9] |         |
+|          Ctrl+Shift+Alt+Digit9 |   Ô   |          Ctrl+Shift+Alt+9 |     |          Ctrl+Shift+Alt+9 |               ctrl+shift+alt+9 |          Ctrl+Shift+Alt+9 |        ctrl+shift+alt+[Digit9] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit0 |   0   |                         0 |     |                         0 |                              0 |                         0 |                       [Digit0] |         |
+|                    Ctrl+Digit0 |   0   |                    Ctrl+0 |     |                    Ctrl+0 |                         ctrl+0 |                    Ctrl+0 |                  ctrl+[Digit0] |         |
+|                   Shift+Digit0 |   =   |                   Shift+0 |     |                   Shift+0 |                        shift+0 |                   Shift+0 |                 shift+[Digit0] |         |
+|                                |       |                         = |     |                           |                                |                           |                                |         |
+|              Ctrl+Shift+Digit0 |   =   |              Ctrl+Shift+0 |     |              Ctrl+Shift+0 |                   ctrl+shift+0 |              Ctrl+Shift+0 |            ctrl+shift+[Digit0] |         |
+|                                |       |                    Ctrl+= |     |                           |                                |                           |                                |         |
+|                     Alt+Digit0 |   0   |                     Alt+0 |     |                     Alt+0 |                          alt+0 |                     Alt+0 |                   alt+[Digit0] |         |
+|                Ctrl+Alt+Digit0 |   ≠   |                Ctrl+Alt+0 |     |                Ctrl+Alt+0 |                     ctrl+alt+0 |                Ctrl+Alt+0 |              ctrl+alt+[Digit0] |         |
+|               Shift+Alt+Digit0 |   =   |               Shift+Alt+0 |     |               Shift+Alt+0 |                    shift+alt+0 |               Shift+Alt+0 |             shift+alt+[Digit0] |         |
+|                                |       |                     Alt+= |     |                           |                                |                           |                                |         |
+|          Ctrl+Shift+Alt+Digit0 |   Ú   |          Ctrl+Shift+Alt+0 |     |          Ctrl+Shift+Alt+0 |               ctrl+shift+alt+0 |          Ctrl+Shift+Alt+0 |        ctrl+shift+alt+[Digit0] |         |
+|                                |       |                Ctrl+Alt+= |     |                           |                                |                           |                                |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Minus |   '   |                         ' |     |                         ' |                        [Minus] |                      null |                        [Minus] |    NO   |
+|                     Ctrl+Minus |   '   |                    Ctrl+' |     |                    Ctrl+' |                   ctrl+[Minus] |                      null |                   ctrl+[Minus] |    NO   |
+|                    Shift+Minus |   ?   |                   Shift+/ |     |                   Shift+' |                  shift+[Minus] |                      null |                  shift+[Minus] |    NO   |
+|               Ctrl+Shift+Minus |   ?   |              Ctrl+Shift+/ |     |              Ctrl+Shift+' |             ctrl+shift+[Minus] |                      null |             ctrl+shift+[Minus] |    NO   |
+|                      Alt+Minus |   '   |                     Alt+' |     |                     Alt+' |                    alt+[Minus] |                      null |                    alt+[Minus] |    NO   |
+|                 Ctrl+Alt+Minus |   ¿   |                Ctrl+Alt+' |     |                Ctrl+Alt+' |               ctrl+alt+[Minus] |                      null |               ctrl+alt+[Minus] |    NO   |
+|                Shift+Alt+Minus |   ?   |               Shift+Alt+/ |     |               Shift+Alt+' |              shift+alt+[Minus] |                      null |              shift+alt+[Minus] |    NO   |
+|           Ctrl+Shift+Alt+Minus |      |          Ctrl+Shift+Alt+/ |     |          Ctrl+Shift+Alt+' |         ctrl+shift+alt+[Minus] |                      null |         ctrl+shift+alt+[Minus] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Equal |   ^   |                           |     |                         ^ |                        [Equal] |                      null |                        [Equal] |    NO   |
+|                     Ctrl+Equal |   ^   |                           |     |                    Ctrl+^ |                   ctrl+[Equal] |                      null |                   ctrl+[Equal] |    NO   |
+|                    Shift+Equal |   `   |                         ` |     |                   Shift+^ |                  shift+[Equal] |                      null |                  shift+[Equal] |    NO   |
+|               Ctrl+Shift+Equal |   `   |                    Ctrl+` |     |              Ctrl+Shift+^ |             ctrl+shift+[Equal] |                      null |             ctrl+shift+[Equal] |    NO   |
+|                      Alt+Equal |   ^   |                           |     |                     Alt+^ |                    alt+[Equal] |                      null |                    alt+[Equal] |    NO   |
+|                 Ctrl+Alt+Equal |   ´   |                           |     |                Ctrl+Alt+^ |               ctrl+alt+[Equal] |                      null |               ctrl+alt+[Equal] |    NO   |
+|                Shift+Alt+Equal |   `   |                     Alt+` |     |               Shift+Alt+^ |              shift+alt+[Equal] |                      null |              shift+alt+[Equal] |    NO   |
+|           Ctrl+Shift+Alt+Equal |   ^   |                Ctrl+Alt+` |     |          Ctrl+Shift+Alt+^ |         ctrl+shift+alt+[Equal] |                      null |         ctrl+shift+alt+[Equal] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                    BracketLeft |   ü   |                           |     |                         ü |                  [BracketLeft] |                      null |                  [BracketLeft] |    NO   |
+|               Ctrl+BracketLeft |   ü   |                           |     |                    Ctrl+ü |             ctrl+[BracketLeft] |                      null |             ctrl+[BracketLeft] |    NO   |
+|              Shift+BracketLeft |   è   |                           |     |                   Shift+ü |            shift+[BracketLeft] |                      null |            shift+[BracketLeft] |    NO   |
+|         Ctrl+Shift+BracketLeft |   è   |                           |     |              Ctrl+Shift+ü |       ctrl+shift+[BracketLeft] |                      null |       ctrl+shift+[BracketLeft] |    NO   |
+|                Alt+BracketLeft |   ü   |                           |     |                     Alt+ü |              alt+[BracketLeft] |                      null |              alt+[BracketLeft] |    NO   |
+|           Ctrl+Alt+BracketLeft |   §   |                           |     |                Ctrl+Alt+ü |         ctrl+alt+[BracketLeft] |                      null |         ctrl+alt+[BracketLeft] |    NO   |
+|          Shift+Alt+BracketLeft |   è   |                           |     |               Shift+Alt+ü |        shift+alt+[BracketLeft] |                      null |        shift+alt+[BracketLeft] |    NO   |
+|     Ctrl+Shift+Alt+BracketLeft |   ÿ   |                           |     |          Ctrl+Shift+Alt+ü |   ctrl+shift+alt+[BracketLeft] |                      null |   ctrl+shift+alt+[BracketLeft] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                   BracketRight |   ¨   |                           |     |                         ¨ |                 [BracketRight] |                      null |                 [BracketRight] |    NO   |
+|              Ctrl+BracketRight |   ¨   |                           |     |                    Ctrl+¨ |            ctrl+[BracketRight] |                      null |            ctrl+[BracketRight] |    NO   |
+|             Shift+BracketRight |   !   |                           |     |                   Shift+¨ |           shift+[BracketRight] |                      null |           shift+[BracketRight] |    NO   |
+|        Ctrl+Shift+BracketRight |   !   |                           |     |              Ctrl+Shift+¨ |      ctrl+shift+[BracketRight] |                      null |      ctrl+shift+[BracketRight] |    NO   |
+|               Alt+BracketRight |   ¨   |                           |     |                     Alt+¨ |             alt+[BracketRight] |                      null |             alt+[BracketRight] |    NO   |
+|          Ctrl+Alt+BracketRight |   ‘   |                           |     |                Ctrl+Alt+¨ |        ctrl+alt+[BracketRight] |                      null |        ctrl+alt+[BracketRight] |    NO   |
+|         Shift+Alt+BracketRight |   !   |                           |     |               Shift+Alt+¨ |       shift+alt+[BracketRight] |                      null |       shift+alt+[BracketRight] |    NO   |
+|    Ctrl+Shift+Alt+BracketRight |   ’   |                           |     |          Ctrl+Shift+Alt+¨ |  ctrl+shift+alt+[BracketRight] |                      null |  ctrl+shift+alt+[BracketRight] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                      Backslash |   $   |                           |     |                         $ |                    [Backslash] |                      null |                    [Backslash] |    NO   |
+|                 Ctrl+Backslash |   $   |                           |     |                    Ctrl+$ |               ctrl+[Backslash] |                      null |               ctrl+[Backslash] |    NO   |
+|                Shift+Backslash |   £   |                           |     |                   Shift+$ |              shift+[Backslash] |                      null |              shift+[Backslash] |    NO   |
+|           Ctrl+Shift+Backslash |   £   |                           |     |              Ctrl+Shift+$ |         ctrl+shift+[Backslash] |                      null |         ctrl+shift+[Backslash] |    NO   |
+|                  Alt+Backslash |   $   |                           |     |                     Alt+$ |                alt+[Backslash] |                      null |                alt+[Backslash] |    NO   |
+|             Ctrl+Alt+Backslash |   ¶   |                           |     |                Ctrl+Alt+$ |           ctrl+alt+[Backslash] |                      null |           ctrl+alt+[Backslash] |    NO   |
+|            Shift+Alt+Backslash |   £   |                           |     |               Shift+Alt+$ |          shift+alt+[Backslash] |                      null |          shift+alt+[Backslash] |    NO   |
+|       Ctrl+Shift+Alt+Backslash |   •   |                           |     |          Ctrl+Shift+Alt+$ |     ctrl+shift+alt+[Backslash] |                      null |     ctrl+shift+alt+[Backslash] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                       IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|                  Ctrl+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|                 Shift+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|            Ctrl+Shift+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|                   Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|              Ctrl+Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|             Shift+Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|        Ctrl+Shift+Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                      Semicolon |   ö   |                           |     |                         ö |                    [Semicolon] |                      null |                    [Semicolon] |    NO   |
+|                 Ctrl+Semicolon |   ö   |                           |     |                    Ctrl+ö |               ctrl+[Semicolon] |                      null |               ctrl+[Semicolon] |    NO   |
+|                Shift+Semicolon |   é   |                           |     |                   Shift+ö |              shift+[Semicolon] |                      null |              shift+[Semicolon] |    NO   |
+|           Ctrl+Shift+Semicolon |   é   |                           |     |              Ctrl+Shift+ö |         ctrl+shift+[Semicolon] |                      null |         ctrl+shift+[Semicolon] |    NO   |
+|                  Alt+Semicolon |   ö   |                           |     |                     Alt+ö |                alt+[Semicolon] |                      null |                alt+[Semicolon] |    NO   |
+|             Ctrl+Alt+Semicolon |   ¢   |                           |     |                Ctrl+Alt+ö |           ctrl+alt+[Semicolon] |                      null |           ctrl+alt+[Semicolon] |    NO   |
+|            Shift+Alt+Semicolon |   é   |                           |     |               Shift+Alt+ö |          shift+alt+[Semicolon] |                      null |          shift+alt+[Semicolon] |    NO   |
+|       Ctrl+Shift+Alt+Semicolon |   ˘   |                           |     |          Ctrl+Shift+Alt+ö |     ctrl+shift+alt+[Semicolon] |                      null |     ctrl+shift+alt+[Semicolon] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Quote |   ä   |                           |     |                         ä |                        [Quote] |                      null |                        [Quote] |    NO   |
+|                     Ctrl+Quote |   ä   |                           |     |                    Ctrl+ä |                   ctrl+[Quote] |                      null |                   ctrl+[Quote] |    NO   |
+|                    Shift+Quote |   à   |                           |     |                   Shift+ä |                  shift+[Quote] |                      null |                  shift+[Quote] |    NO   |
+|               Ctrl+Shift+Quote |   à   |                           |     |              Ctrl+Shift+ä |             ctrl+shift+[Quote] |                      null |             ctrl+shift+[Quote] |    NO   |
+|                      Alt+Quote |   ä   |                           |     |                     Alt+ä |                    alt+[Quote] |                      null |                    alt+[Quote] |    NO   |
+|                 Ctrl+Alt+Quote |   æ   |                           |     |                Ctrl+Alt+ä |               ctrl+alt+[Quote] |                      null |               ctrl+alt+[Quote] |    NO   |
+|                Shift+Alt+Quote |   à   |                           |     |               Shift+Alt+ä |              shift+alt+[Quote] |                      null |              shift+alt+[Quote] |    NO   |
+|           Ctrl+Shift+Alt+Quote |   Æ   |                           |     |          Ctrl+Shift+Alt+ä |         ctrl+shift+alt+[Quote] |                      null |         ctrl+shift+alt+[Quote] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                      Backquote |   <   |                   Shift+, |     |                         < |                    [Backquote] |                      null |                    [Backquote] |    NO   |
+|                 Ctrl+Backquote |   <   |              Ctrl+Shift+, |     |                    Ctrl+< |               ctrl+[Backquote] |                      null |               ctrl+[Backquote] |    NO   |
+|                Shift+Backquote |   >   |                   Shift+. |     |                   Shift+< |              shift+[Backquote] |                      null |              shift+[Backquote] |    NO   |
+|           Ctrl+Shift+Backquote |   >   |              Ctrl+Shift+. |     |              Ctrl+Shift+< |         ctrl+shift+[Backquote] |                      null |         ctrl+shift+[Backquote] |    NO   |
+|                  Alt+Backquote |   <   |               Shift+Alt+, |     |                     Alt+< |                alt+[Backquote] |                      null |                alt+[Backquote] |    NO   |
+|             Ctrl+Alt+Backquote |   ≤   |          Ctrl+Shift+Alt+, |     |                Ctrl+Alt+< |           ctrl+alt+[Backquote] |                      null |           ctrl+alt+[Backquote] |    NO   |
+|            Shift+Alt+Backquote |   >   |               Shift+Alt+. |     |               Shift+Alt+< |          shift+alt+[Backquote] |                      null |          shift+alt+[Backquote] |    NO   |
+|       Ctrl+Shift+Alt+Backquote |   ≥   |          Ctrl+Shift+Alt+. |     |          Ctrl+Shift+Alt+< |     ctrl+shift+alt+[Backquote] |                      null |     ctrl+shift+alt+[Backquote] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Comma |   ,   |                         , |     |                         , |                        [Comma] |                      null |                        [Comma] |    NO   |
+|                     Ctrl+Comma |   ,   |                    Ctrl+, |     |                    Ctrl+, |                   ctrl+[Comma] |                      null |                   ctrl+[Comma] |    NO   |
+|                    Shift+Comma |   ;   |                         ; |     |                   Shift+, |                  shift+[Comma] |                      null |                  shift+[Comma] |    NO   |
+|               Ctrl+Shift+Comma |   ;   |                    Ctrl+; |     |              Ctrl+Shift+, |             ctrl+shift+[Comma] |                      null |             ctrl+shift+[Comma] |    NO   |
+|                      Alt+Comma |   ,   |                     Alt+, |     |                     Alt+, |                    alt+[Comma] |                      null |                    alt+[Comma] |    NO   |
+|                 Ctrl+Alt+Comma |   «   |                Ctrl+Alt+, |     |                Ctrl+Alt+, |               ctrl+alt+[Comma] |                      null |               ctrl+alt+[Comma] |    NO   |
+|                Shift+Alt+Comma |   ;   |                     Alt+; |     |               Shift+Alt+, |              shift+alt+[Comma] |                      null |              shift+alt+[Comma] |    NO   |
+|           Ctrl+Shift+Alt+Comma |   »   |                Ctrl+Alt+; |     |          Ctrl+Shift+Alt+, |         ctrl+shift+alt+[Comma] |                      null |         ctrl+shift+alt+[Comma] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Period |   .   |                         . |     |                         . |                       [Period] |                      null |                       [Period] |    NO   |
+|                    Ctrl+Period |   .   |                    Ctrl+. |     |                    Ctrl+. |                  ctrl+[Period] |                      null |                  ctrl+[Period] |    NO   |
+|                   Shift+Period |   :   |                   Shift+; |     |                   Shift+. |                 shift+[Period] |                      null |                 shift+[Period] |    NO   |
+|              Ctrl+Shift+Period |   :   |              Ctrl+Shift+; |     |              Ctrl+Shift+. |            ctrl+shift+[Period] |                      null |            ctrl+shift+[Period] |    NO   |
+|                     Alt+Period |   .   |                     Alt+. |     |                     Alt+. |                   alt+[Period] |                      null |                   alt+[Period] |    NO   |
+|                Ctrl+Alt+Period |   …   |                Ctrl+Alt+. |     |                Ctrl+Alt+. |              ctrl+alt+[Period] |                      null |              ctrl+alt+[Period] |    NO   |
+|               Shift+Alt+Period |   :   |               Shift+Alt+; |     |               Shift+Alt+. |             shift+alt+[Period] |                      null |             shift+alt+[Period] |    NO   |
+|          Ctrl+Shift+Alt+Period |   ÷   |          Ctrl+Shift+Alt+; |     |          Ctrl+Shift+Alt+. |        ctrl+shift+alt+[Period] |                      null |        ctrl+shift+alt+[Period] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Slash |   -   |                         - |     |                         - |                              - |                      null |                        [Slash] |         |
+|                     Ctrl+Slash |   -   |                    Ctrl+- |     |                    Ctrl+- |                         ctrl+- |                      null |                   ctrl+[Slash] |         |
+|                    Shift+Slash |   _   |                   Shift+- |     |                   Shift+- |                        shift+- |                      null |                  shift+[Slash] |         |
+|               Ctrl+Shift+Slash |   _   |              Ctrl+Shift+- |     |              Ctrl+Shift+- |                   ctrl+shift+- |                      null |             ctrl+shift+[Slash] |         |
+|                      Alt+Slash |   -   |                     Alt+- |     |                     Alt+- |                          alt+- |                      null |                    alt+[Slash] |         |
+|                 Ctrl+Alt+Slash |   –   |                Ctrl+Alt+- |     |                Ctrl+Alt+- |                     ctrl+alt+- |                      null |               ctrl+alt+[Slash] |         |
+|                Shift+Alt+Slash |   _   |               Shift+Alt+- |     |               Shift+Alt+- |                    shift+alt+- |                      null |              shift+alt+[Slash] |         |
+|           Ctrl+Shift+Alt+Slash |   —   |          Ctrl+Shift+Alt+- |     |          Ctrl+Shift+Alt+- |               ctrl+shift+alt+- |                      null |         ctrl+shift+alt+[Slash] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                        ArrowUp |  ---  |                   UpArrow |     |                   UpArrow |                             up |                        Up |                      [ArrowUp] |         |
+|                   Ctrl+ArrowUp |  ---  |              Ctrl+UpArrow |     |              Ctrl+UpArrow |                        ctrl+up |                   Ctrl+Up |                 ctrl+[ArrowUp] |         |
+|                  Shift+ArrowUp |  ---  |             Shift+UpArrow |     |             Shift+UpArrow |                       shift+up |                  Shift+Up |                shift+[ArrowUp] |         |
+|             Ctrl+Shift+ArrowUp |  ---  |        Ctrl+Shift+UpArrow |     |        Ctrl+Shift+UpArrow |                  ctrl+shift+up |             Ctrl+Shift+Up |           ctrl+shift+[ArrowUp] |         |
+|                    Alt+ArrowUp |  ---  |               Alt+UpArrow |     |               Alt+UpArrow |                         alt+up |                    Alt+Up |                  alt+[ArrowUp] |         |
+|               Ctrl+Alt+ArrowUp |  ---  |          Ctrl+Alt+UpArrow |     |          Ctrl+Alt+UpArrow |                    ctrl+alt+up |               Ctrl+Alt+Up |             ctrl+alt+[ArrowUp] |         |
+|              Shift+Alt+ArrowUp |  ---  |         Shift+Alt+UpArrow |     |         Shift+Alt+UpArrow |                   shift+alt+up |              Shift+Alt+Up |            shift+alt+[ArrowUp] |         |
+|         Ctrl+Shift+Alt+ArrowUp |  ---  |    Ctrl+Shift+Alt+UpArrow |     |    Ctrl+Shift+Alt+UpArrow |              ctrl+shift+alt+up |         Ctrl+Shift+Alt+Up |       ctrl+shift+alt+[ArrowUp] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                        Numpad0 |  ---  |                   NumPad0 |     |                   NumPad0 |                        numpad0 |                      null |                      [Numpad0] |         |
+|                   Ctrl+Numpad0 |  ---  |              Ctrl+NumPad0 |     |              Ctrl+NumPad0 |                   ctrl+numpad0 |                      null |                 ctrl+[Numpad0] |         |
+|                  Shift+Numpad0 |  ---  |             Shift+NumPad0 |     |             Shift+NumPad0 |                  shift+numpad0 |                      null |                shift+[Numpad0] |         |
+|             Ctrl+Shift+Numpad0 |  ---  |        Ctrl+Shift+NumPad0 |     |        Ctrl+Shift+NumPad0 |             ctrl+shift+numpad0 |                      null |           ctrl+shift+[Numpad0] |         |
+|                    Alt+Numpad0 |  ---  |               Alt+NumPad0 |     |               Alt+NumPad0 |                    alt+numpad0 |                      null |                  alt+[Numpad0] |         |
+|               Ctrl+Alt+Numpad0 |  ---  |          Ctrl+Alt+NumPad0 |     |          Ctrl+Alt+NumPad0 |               ctrl+alt+numpad0 |                      null |             ctrl+alt+[Numpad0] |         |
+|              Shift+Alt+Numpad0 |  ---  |         Shift+Alt+NumPad0 |     |         Shift+Alt+NumPad0 |              shift+alt+numpad0 |                      null |            shift+alt+[Numpad0] |         |
+|         Ctrl+Shift+Alt+Numpad0 |  ---  |    Ctrl+Shift+Alt+NumPad0 |     |    Ctrl+Shift+Alt+NumPad0 |         ctrl+shift+alt+numpad0 |                      null |       ctrl+shift+alt+[Numpad0] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                  IntlBackslash |   §   |                           |     |                         § |                [IntlBackslash] |                      null |                [IntlBackslash] |    NO   |
+|             Ctrl+IntlBackslash |   §   |                           |     |                    Ctrl+§ |           ctrl+[IntlBackslash] |                      null |           ctrl+[IntlBackslash] |    NO   |
+|            Shift+IntlBackslash |   °   |                           |     |                   Shift+§ |          shift+[IntlBackslash] |                      null |          shift+[IntlBackslash] |    NO   |
+|       Ctrl+Shift+IntlBackslash |   °   |                           |     |              Ctrl+Shift+§ |     ctrl+shift+[IntlBackslash] |                      null |     ctrl+shift+[IntlBackslash] |    NO   |
+|              Alt+IntlBackslash |   §   |                           |     |                     Alt+§ |            alt+[IntlBackslash] |                      null |            alt+[IntlBackslash] |    NO   |
+|         Ctrl+Alt+IntlBackslash |   fi   |                           |     |                Ctrl+Alt+§ |       ctrl+alt+[IntlBackslash] |                      null |       ctrl+alt+[IntlBackslash] |    NO   |
+|        Shift+Alt+IntlBackslash |   °   |                           |     |               Shift+Alt+§ |      shift+alt+[IntlBackslash] |                      null |      shift+alt+[IntlBackslash] |    NO   |
+|   Ctrl+Shift+Alt+IntlBackslash |   ‰   |                           |     |          Ctrl+Shift+Alt+§ | ctrl+shift+alt+[IntlBackslash] |                      null | ctrl+shift+alt+[IntlBackslash] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         IntlRo |  ---  |                           |     |                      null |                       [IntlRo] |                      null |                       [IntlRo] |    NO   |
+|                    Ctrl+IntlRo |  ---  |                           |     |                      null |                  ctrl+[IntlRo] |                      null |                  ctrl+[IntlRo] |    NO   |
+|                   Shift+IntlRo |  ---  |                           |     |                      null |                 shift+[IntlRo] |                      null |                 shift+[IntlRo] |    NO   |
+|              Ctrl+Shift+IntlRo |  ---  |                           |     |                      null |            ctrl+shift+[IntlRo] |                      null |            ctrl+shift+[IntlRo] |    NO   |
+|                     Alt+IntlRo |  ---  |                           |     |                      null |                   alt+[IntlRo] |                      null |                   alt+[IntlRo] |    NO   |
+|                Ctrl+Alt+IntlRo |  ---  |                           |     |                      null |              ctrl+alt+[IntlRo] |                      null |              ctrl+alt+[IntlRo] |    NO   |
+|               Shift+Alt+IntlRo |  ---  |                           |     |                      null |             shift+alt+[IntlRo] |                      null |             shift+alt+[IntlRo] |    NO   |
+|          Ctrl+Shift+Alt+IntlRo |  ---  |                           |     |                      null |        ctrl+shift+alt+[IntlRo] |                      null |        ctrl+shift+alt+[IntlRo] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                        IntlYen |  ---  |                           |     |                      null |                      [IntlYen] |                      null |                      [IntlYen] |    NO   |
+|                   Ctrl+IntlYen |  ---  |                           |     |                      null |                 ctrl+[IntlYen] |                      null |                 ctrl+[IntlYen] |    NO   |
+|                  Shift+IntlYen |  ---  |                           |     |                      null |                shift+[IntlYen] |                      null |                shift+[IntlYen] |    NO   |
+|             Ctrl+Shift+IntlYen |  ---  |                           |     |                      null |           ctrl+shift+[IntlYen] |                      null |           ctrl+shift+[IntlYen] |    NO   |
+|                    Alt+IntlYen |  ---  |                           |     |                      null |                  alt+[IntlYen] |                      null |                  alt+[IntlYen] |    NO   |
+|               Ctrl+Alt+IntlYen |  ---  |                           |     |                      null |             ctrl+alt+[IntlYen] |                      null |             ctrl+alt+[IntlYen] |    NO   |
+|              Shift+Alt+IntlYen |  ---  |                           |     |                      null |            shift+alt+[IntlYen] |                      null |            shift+alt+[IntlYen] |    NO   |
+|         Ctrl+Shift+Alt+IntlYen |  ---  |                           |     |                      null |       ctrl+shift+alt+[IntlYen] |                      null |       ctrl+shift+alt+[IntlYen] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

lib/vscode/src/vs/workbench/services/keybinding/test/electron-browser/mac_en_us.txt

@@ -0,0 +1,507 @@
+isUSStandard: true
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyA |   a   |                         A |     |                         A |                              a |                         A |                         [KeyA] |         |
+|                      Ctrl+KeyA |   a   |                    Ctrl+A |     |                    Ctrl+A |                         ctrl+a |                    Ctrl+A |                    ctrl+[KeyA] |         |
+|                     Shift+KeyA |   A   |                   Shift+A |     |                   Shift+A |                        shift+a |                   Shift+A |                   shift+[KeyA] |         |
+|                Ctrl+Shift+KeyA |   A   |              Ctrl+Shift+A |     |              Ctrl+Shift+A |                   ctrl+shift+a |              Ctrl+Shift+A |              ctrl+shift+[KeyA] |         |
+|                       Alt+KeyA |   a   |                     Alt+A |     |                     Alt+A |                          alt+a |                     Alt+A |                     alt+[KeyA] |         |
+|                  Ctrl+Alt+KeyA |   å   |                Ctrl+Alt+A |     |                Ctrl+Alt+A |                     ctrl+alt+a |                Ctrl+Alt+A |                ctrl+alt+[KeyA] |         |
+|                 Shift+Alt+KeyA |   A   |               Shift+Alt+A |     |               Shift+Alt+A |                    shift+alt+a |               Shift+Alt+A |               shift+alt+[KeyA] |         |
+|            Ctrl+Shift+Alt+KeyA |   Å   |          Ctrl+Shift+Alt+A |     |          Ctrl+Shift+Alt+A |               ctrl+shift+alt+a |          Ctrl+Shift+Alt+A |          ctrl+shift+alt+[KeyA] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyB |   b   |                         B |     |                         B |                              b |                         B |                         [KeyB] |         |
+|                      Ctrl+KeyB |   b   |                    Ctrl+B |     |                    Ctrl+B |                         ctrl+b |                    Ctrl+B |                    ctrl+[KeyB] |         |
+|                     Shift+KeyB |   B   |                   Shift+B |     |                   Shift+B |                        shift+b |                   Shift+B |                   shift+[KeyB] |         |
+|                Ctrl+Shift+KeyB |   B   |              Ctrl+Shift+B |     |              Ctrl+Shift+B |                   ctrl+shift+b |              Ctrl+Shift+B |              ctrl+shift+[KeyB] |         |
+|                       Alt+KeyB |   b   |                     Alt+B |     |                     Alt+B |                          alt+b |                     Alt+B |                     alt+[KeyB] |         |
+|                  Ctrl+Alt+KeyB |   ∫   |                Ctrl+Alt+B |     |                Ctrl+Alt+B |                     ctrl+alt+b |                Ctrl+Alt+B |                ctrl+alt+[KeyB] |         |
+|                 Shift+Alt+KeyB |   B   |               Shift+Alt+B |     |               Shift+Alt+B |                    shift+alt+b |               Shift+Alt+B |               shift+alt+[KeyB] |         |
+|            Ctrl+Shift+Alt+KeyB |   ı   |          Ctrl+Shift+Alt+B |     |          Ctrl+Shift+Alt+B |               ctrl+shift+alt+b |          Ctrl+Shift+Alt+B |          ctrl+shift+alt+[KeyB] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyC |   c   |                         C |     |                         C |                              c |                         C |                         [KeyC] |         |
+|                      Ctrl+KeyC |   c   |                    Ctrl+C |     |                    Ctrl+C |                         ctrl+c |                    Ctrl+C |                    ctrl+[KeyC] |         |
+|                     Shift+KeyC |   C   |                   Shift+C |     |                   Shift+C |                        shift+c |                   Shift+C |                   shift+[KeyC] |         |
+|                Ctrl+Shift+KeyC |   C   |              Ctrl+Shift+C |     |              Ctrl+Shift+C |                   ctrl+shift+c |              Ctrl+Shift+C |              ctrl+shift+[KeyC] |         |
+|                       Alt+KeyC |   c   |                     Alt+C |     |                     Alt+C |                          alt+c |                     Alt+C |                     alt+[KeyC] |         |
+|                  Ctrl+Alt+KeyC |   ç   |                Ctrl+Alt+C |     |                Ctrl+Alt+C |                     ctrl+alt+c |                Ctrl+Alt+C |                ctrl+alt+[KeyC] |         |
+|                 Shift+Alt+KeyC |   C   |               Shift+Alt+C |     |               Shift+Alt+C |                    shift+alt+c |               Shift+Alt+C |               shift+alt+[KeyC] |         |
+|            Ctrl+Shift+Alt+KeyC |   Ç   |          Ctrl+Shift+Alt+C |     |          Ctrl+Shift+Alt+C |               ctrl+shift+alt+c |          Ctrl+Shift+Alt+C |          ctrl+shift+alt+[KeyC] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyD |   d   |                         D |     |                         D |                              d |                         D |                         [KeyD] |         |
+|                      Ctrl+KeyD |   d   |                    Ctrl+D |     |                    Ctrl+D |                         ctrl+d |                    Ctrl+D |                    ctrl+[KeyD] |         |
+|                     Shift+KeyD |   D   |                   Shift+D |     |                   Shift+D |                        shift+d |                   Shift+D |                   shift+[KeyD] |         |
+|                Ctrl+Shift+KeyD |   D   |              Ctrl+Shift+D |     |              Ctrl+Shift+D |                   ctrl+shift+d |              Ctrl+Shift+D |              ctrl+shift+[KeyD] |         |
+|                       Alt+KeyD |   d   |                     Alt+D |     |                     Alt+D |                          alt+d |                     Alt+D |                     alt+[KeyD] |         |
+|                  Ctrl+Alt+KeyD |   ∂   |                Ctrl+Alt+D |     |                Ctrl+Alt+D |                     ctrl+alt+d |                Ctrl+Alt+D |                ctrl+alt+[KeyD] |         |
+|                 Shift+Alt+KeyD |   D   |               Shift+Alt+D |     |               Shift+Alt+D |                    shift+alt+d |               Shift+Alt+D |               shift+alt+[KeyD] |         |
+|            Ctrl+Shift+Alt+KeyD |   Î   |          Ctrl+Shift+Alt+D |     |          Ctrl+Shift+Alt+D |               ctrl+shift+alt+d |          Ctrl+Shift+Alt+D |          ctrl+shift+alt+[KeyD] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyE |   e   |                         E |     |                         E |                              e |                         E |                         [KeyE] |         |
+|                      Ctrl+KeyE |   e   |                    Ctrl+E |     |                    Ctrl+E |                         ctrl+e |                    Ctrl+E |                    ctrl+[KeyE] |         |
+|                     Shift+KeyE |   E   |                   Shift+E |     |                   Shift+E |                        shift+e |                   Shift+E |                   shift+[KeyE] |         |
+|                Ctrl+Shift+KeyE |   E   |              Ctrl+Shift+E |     |              Ctrl+Shift+E |                   ctrl+shift+e |              Ctrl+Shift+E |              ctrl+shift+[KeyE] |         |
+|                       Alt+KeyE |   e   |                     Alt+E |     |                     Alt+E |                          alt+e |                     Alt+E |                     alt+[KeyE] |         |
+|                  Ctrl+Alt+KeyE |   ´   |                Ctrl+Alt+E |     |                Ctrl+Alt+E |                     ctrl+alt+e |                Ctrl+Alt+E |                ctrl+alt+[KeyE] |         |
+|                 Shift+Alt+KeyE |   E   |               Shift+Alt+E |     |               Shift+Alt+E |                    shift+alt+e |               Shift+Alt+E |               shift+alt+[KeyE] |         |
+|            Ctrl+Shift+Alt+KeyE |   ´   |          Ctrl+Shift+Alt+E |     |          Ctrl+Shift+Alt+E |               ctrl+shift+alt+e |          Ctrl+Shift+Alt+E |          ctrl+shift+alt+[KeyE] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyF |   f   |                         F |     |                         F |                              f |                         F |                         [KeyF] |         |
+|                      Ctrl+KeyF |   f   |                    Ctrl+F |     |                    Ctrl+F |                         ctrl+f |                    Ctrl+F |                    ctrl+[KeyF] |         |
+|                     Shift+KeyF |   F   |                   Shift+F |     |                   Shift+F |                        shift+f |                   Shift+F |                   shift+[KeyF] |         |
+|                Ctrl+Shift+KeyF |   F   |              Ctrl+Shift+F |     |              Ctrl+Shift+F |                   ctrl+shift+f |              Ctrl+Shift+F |              ctrl+shift+[KeyF] |         |
+|                       Alt+KeyF |   f   |                     Alt+F |     |                     Alt+F |                          alt+f |                     Alt+F |                     alt+[KeyF] |         |
+|                  Ctrl+Alt+KeyF |   ƒ   |                Ctrl+Alt+F |     |                Ctrl+Alt+F |                     ctrl+alt+f |                Ctrl+Alt+F |                ctrl+alt+[KeyF] |         |
+|                 Shift+Alt+KeyF |   F   |               Shift+Alt+F |     |               Shift+Alt+F |                    shift+alt+f |               Shift+Alt+F |               shift+alt+[KeyF] |         |
+|            Ctrl+Shift+Alt+KeyF |   Ï   |          Ctrl+Shift+Alt+F |     |          Ctrl+Shift+Alt+F |               ctrl+shift+alt+f |          Ctrl+Shift+Alt+F |          ctrl+shift+alt+[KeyF] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyG |   g   |                         G |     |                         G |                              g |                         G |                         [KeyG] |         |
+|                      Ctrl+KeyG |   g   |                    Ctrl+G |     |                    Ctrl+G |                         ctrl+g |                    Ctrl+G |                    ctrl+[KeyG] |         |
+|                     Shift+KeyG |   G   |                   Shift+G |     |                   Shift+G |                        shift+g |                   Shift+G |                   shift+[KeyG] |         |
+|                Ctrl+Shift+KeyG |   G   |              Ctrl+Shift+G |     |              Ctrl+Shift+G |                   ctrl+shift+g |              Ctrl+Shift+G |              ctrl+shift+[KeyG] |         |
+|                       Alt+KeyG |   g   |                     Alt+G |     |                     Alt+G |                          alt+g |                     Alt+G |                     alt+[KeyG] |         |
+|                  Ctrl+Alt+KeyG |   ©   |                Ctrl+Alt+G |     |                Ctrl+Alt+G |                     ctrl+alt+g |                Ctrl+Alt+G |                ctrl+alt+[KeyG] |         |
+|                 Shift+Alt+KeyG |   G   |               Shift+Alt+G |     |               Shift+Alt+G |                    shift+alt+g |               Shift+Alt+G |               shift+alt+[KeyG] |         |
+|            Ctrl+Shift+Alt+KeyG |   ˝   |          Ctrl+Shift+Alt+G |     |          Ctrl+Shift+Alt+G |               ctrl+shift+alt+g |          Ctrl+Shift+Alt+G |          ctrl+shift+alt+[KeyG] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyH |   h   |                         H |     |                         H |                              h |                         H |                         [KeyH] |         |
+|                      Ctrl+KeyH |   h   |                    Ctrl+H |     |                    Ctrl+H |                         ctrl+h |                    Ctrl+H |                    ctrl+[KeyH] |         |
+|                     Shift+KeyH |   H   |                   Shift+H |     |                   Shift+H |                        shift+h |                   Shift+H |                   shift+[KeyH] |         |
+|                Ctrl+Shift+KeyH |   H   |              Ctrl+Shift+H |     |              Ctrl+Shift+H |                   ctrl+shift+h |              Ctrl+Shift+H |              ctrl+shift+[KeyH] |         |
+|                       Alt+KeyH |   h   |                     Alt+H |     |                     Alt+H |                          alt+h |                     Alt+H |                     alt+[KeyH] |         |
+|                  Ctrl+Alt+KeyH |   ˙   |                Ctrl+Alt+H |     |                Ctrl+Alt+H |                     ctrl+alt+h |                Ctrl+Alt+H |                ctrl+alt+[KeyH] |         |
+|                 Shift+Alt+KeyH |   H   |               Shift+Alt+H |     |               Shift+Alt+H |                    shift+alt+h |               Shift+Alt+H |               shift+alt+[KeyH] |         |
+|            Ctrl+Shift+Alt+KeyH |   Ó   |          Ctrl+Shift+Alt+H |     |          Ctrl+Shift+Alt+H |               ctrl+shift+alt+h |          Ctrl+Shift+Alt+H |          ctrl+shift+alt+[KeyH] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyI |   i   |                         I |     |                         I |                              i |                         I |                         [KeyI] |         |
+|                      Ctrl+KeyI |   i   |                    Ctrl+I |     |                    Ctrl+I |                         ctrl+i |                    Ctrl+I |                    ctrl+[KeyI] |         |
+|                     Shift+KeyI |   I   |                   Shift+I |     |                   Shift+I |                        shift+i |                   Shift+I |                   shift+[KeyI] |         |
+|                Ctrl+Shift+KeyI |   I   |              Ctrl+Shift+I |     |              Ctrl+Shift+I |                   ctrl+shift+i |              Ctrl+Shift+I |              ctrl+shift+[KeyI] |         |
+|                       Alt+KeyI |   i   |                     Alt+I |     |                     Alt+I |                          alt+i |                     Alt+I |                     alt+[KeyI] |         |
+|                  Ctrl+Alt+KeyI |   ˆ   |                Ctrl+Alt+I |     |                Ctrl+Alt+I |                     ctrl+alt+i |                Ctrl+Alt+I |                ctrl+alt+[KeyI] |         |
+|                 Shift+Alt+KeyI |   I   |               Shift+Alt+I |     |               Shift+Alt+I |                    shift+alt+i |               Shift+Alt+I |               shift+alt+[KeyI] |         |
+|            Ctrl+Shift+Alt+KeyI |   ˆ   |          Ctrl+Shift+Alt+I |     |          Ctrl+Shift+Alt+I |               ctrl+shift+alt+i |          Ctrl+Shift+Alt+I |          ctrl+shift+alt+[KeyI] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyJ |   j   |                         J |     |                         J |                              j |                         J |                         [KeyJ] |         |
+|                      Ctrl+KeyJ |   j   |                    Ctrl+J |     |                    Ctrl+J |                         ctrl+j |                    Ctrl+J |                    ctrl+[KeyJ] |         |
+|                     Shift+KeyJ |   J   |                   Shift+J |     |                   Shift+J |                        shift+j |                   Shift+J |                   shift+[KeyJ] |         |
+|                Ctrl+Shift+KeyJ |   J   |              Ctrl+Shift+J |     |              Ctrl+Shift+J |                   ctrl+shift+j |              Ctrl+Shift+J |              ctrl+shift+[KeyJ] |         |
+|                       Alt+KeyJ |   j   |                     Alt+J |     |                     Alt+J |                          alt+j |                     Alt+J |                     alt+[KeyJ] |         |
+|                  Ctrl+Alt+KeyJ |   ∆   |                Ctrl+Alt+J |     |                Ctrl+Alt+J |                     ctrl+alt+j |                Ctrl+Alt+J |                ctrl+alt+[KeyJ] |         |
+|                 Shift+Alt+KeyJ |   J   |               Shift+Alt+J |     |               Shift+Alt+J |                    shift+alt+j |               Shift+Alt+J |               shift+alt+[KeyJ] |         |
+|            Ctrl+Shift+Alt+KeyJ |   Ô   |          Ctrl+Shift+Alt+J |     |          Ctrl+Shift+Alt+J |               ctrl+shift+alt+j |          Ctrl+Shift+Alt+J |          ctrl+shift+alt+[KeyJ] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyK |   k   |                         K |     |                         K |                              k |                         K |                         [KeyK] |         |
+|                      Ctrl+KeyK |   k   |                    Ctrl+K |     |                    Ctrl+K |                         ctrl+k |                    Ctrl+K |                    ctrl+[KeyK] |         |
+|                     Shift+KeyK |   K   |                   Shift+K |     |                   Shift+K |                        shift+k |                   Shift+K |                   shift+[KeyK] |         |
+|                Ctrl+Shift+KeyK |   K   |              Ctrl+Shift+K |     |              Ctrl+Shift+K |                   ctrl+shift+k |              Ctrl+Shift+K |              ctrl+shift+[KeyK] |         |
+|                       Alt+KeyK |   k   |                     Alt+K |     |                     Alt+K |                          alt+k |                     Alt+K |                     alt+[KeyK] |         |
+|                  Ctrl+Alt+KeyK |   ˚   |                Ctrl+Alt+K |     |                Ctrl+Alt+K |                     ctrl+alt+k |                Ctrl+Alt+K |                ctrl+alt+[KeyK] |         |
+|                 Shift+Alt+KeyK |   K   |               Shift+Alt+K |     |               Shift+Alt+K |                    shift+alt+k |               Shift+Alt+K |               shift+alt+[KeyK] |         |
+|            Ctrl+Shift+Alt+KeyK |      |          Ctrl+Shift+Alt+K |     |          Ctrl+Shift+Alt+K |               ctrl+shift+alt+k |          Ctrl+Shift+Alt+K |          ctrl+shift+alt+[KeyK] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyL |   l   |                         L |     |                         L |                              l |                         L |                         [KeyL] |         |
+|                      Ctrl+KeyL |   l   |                    Ctrl+L |     |                    Ctrl+L |                         ctrl+l |                    Ctrl+L |                    ctrl+[KeyL] |         |
+|                     Shift+KeyL |   L   |                   Shift+L |     |                   Shift+L |                        shift+l |                   Shift+L |                   shift+[KeyL] |         |
+|                Ctrl+Shift+KeyL |   L   |              Ctrl+Shift+L |     |              Ctrl+Shift+L |                   ctrl+shift+l |              Ctrl+Shift+L |              ctrl+shift+[KeyL] |         |
+|                       Alt+KeyL |   l   |                     Alt+L |     |                     Alt+L |                          alt+l |                     Alt+L |                     alt+[KeyL] |         |
+|                  Ctrl+Alt+KeyL |   ¬   |                Ctrl+Alt+L |     |                Ctrl+Alt+L |                     ctrl+alt+l |                Ctrl+Alt+L |                ctrl+alt+[KeyL] |         |
+|                 Shift+Alt+KeyL |   L   |               Shift+Alt+L |     |               Shift+Alt+L |                    shift+alt+l |               Shift+Alt+L |               shift+alt+[KeyL] |         |
+|            Ctrl+Shift+Alt+KeyL |   Ò   |          Ctrl+Shift+Alt+L |     |          Ctrl+Shift+Alt+L |               ctrl+shift+alt+l |          Ctrl+Shift+Alt+L |          ctrl+shift+alt+[KeyL] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyM |   m   |                         M |     |                         M |                              m |                         M |                         [KeyM] |         |
+|                      Ctrl+KeyM |   m   |                    Ctrl+M |     |                    Ctrl+M |                         ctrl+m |                    Ctrl+M |                    ctrl+[KeyM] |         |
+|                     Shift+KeyM |   M   |                   Shift+M |     |                   Shift+M |                        shift+m |                   Shift+M |                   shift+[KeyM] |         |
+|                Ctrl+Shift+KeyM |   M   |              Ctrl+Shift+M |     |              Ctrl+Shift+M |                   ctrl+shift+m |              Ctrl+Shift+M |              ctrl+shift+[KeyM] |         |
+|                       Alt+KeyM |   m   |                     Alt+M |     |                     Alt+M |                          alt+m |                     Alt+M |                     alt+[KeyM] |         |
+|                  Ctrl+Alt+KeyM |   µ   |                Ctrl+Alt+M |     |                Ctrl+Alt+M |                     ctrl+alt+m |                Ctrl+Alt+M |                ctrl+alt+[KeyM] |         |
+|                 Shift+Alt+KeyM |   M   |               Shift+Alt+M |     |               Shift+Alt+M |                    shift+alt+m |               Shift+Alt+M |               shift+alt+[KeyM] |         |
+|            Ctrl+Shift+Alt+KeyM |   Â   |          Ctrl+Shift+Alt+M |     |          Ctrl+Shift+Alt+M |               ctrl+shift+alt+m |          Ctrl+Shift+Alt+M |          ctrl+shift+alt+[KeyM] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyN |   n   |                         N |     |                         N |                              n |                         N |                         [KeyN] |         |
+|                      Ctrl+KeyN |   n   |                    Ctrl+N |     |                    Ctrl+N |                         ctrl+n |                    Ctrl+N |                    ctrl+[KeyN] |         |
+|                     Shift+KeyN |   N   |                   Shift+N |     |                   Shift+N |                        shift+n |                   Shift+N |                   shift+[KeyN] |         |
+|                Ctrl+Shift+KeyN |   N   |              Ctrl+Shift+N |     |              Ctrl+Shift+N |                   ctrl+shift+n |              Ctrl+Shift+N |              ctrl+shift+[KeyN] |         |
+|                       Alt+KeyN |   n   |                     Alt+N |     |                     Alt+N |                          alt+n |                     Alt+N |                     alt+[KeyN] |         |
+|                  Ctrl+Alt+KeyN |   ˜   |                Ctrl+Alt+N |     |                Ctrl+Alt+N |                     ctrl+alt+n |                Ctrl+Alt+N |                ctrl+alt+[KeyN] |         |
+|                 Shift+Alt+KeyN |   N   |               Shift+Alt+N |     |               Shift+Alt+N |                    shift+alt+n |               Shift+Alt+N |               shift+alt+[KeyN] |         |
+|            Ctrl+Shift+Alt+KeyN |   ˜   |          Ctrl+Shift+Alt+N |     |          Ctrl+Shift+Alt+N |               ctrl+shift+alt+n |          Ctrl+Shift+Alt+N |          ctrl+shift+alt+[KeyN] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyO |   o   |                         O |     |                         O |                              o |                         O |                         [KeyO] |         |
+|                      Ctrl+KeyO |   o   |                    Ctrl+O |     |                    Ctrl+O |                         ctrl+o |                    Ctrl+O |                    ctrl+[KeyO] |         |
+|                     Shift+KeyO |   O   |                   Shift+O |     |                   Shift+O |                        shift+o |                   Shift+O |                   shift+[KeyO] |         |
+|                Ctrl+Shift+KeyO |   O   |              Ctrl+Shift+O |     |              Ctrl+Shift+O |                   ctrl+shift+o |              Ctrl+Shift+O |              ctrl+shift+[KeyO] |         |
+|                       Alt+KeyO |   o   |                     Alt+O |     |                     Alt+O |                          alt+o |                     Alt+O |                     alt+[KeyO] |         |
+|                  Ctrl+Alt+KeyO |   ø   |                Ctrl+Alt+O |     |                Ctrl+Alt+O |                     ctrl+alt+o |                Ctrl+Alt+O |                ctrl+alt+[KeyO] |         |
+|                 Shift+Alt+KeyO |   O   |               Shift+Alt+O |     |               Shift+Alt+O |                    shift+alt+o |               Shift+Alt+O |               shift+alt+[KeyO] |         |
+|            Ctrl+Shift+Alt+KeyO |   Ø   |          Ctrl+Shift+Alt+O |     |          Ctrl+Shift+Alt+O |               ctrl+shift+alt+o |          Ctrl+Shift+Alt+O |          ctrl+shift+alt+[KeyO] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyP |   p   |                         P |     |                         P |                              p |                         P |                         [KeyP] |         |
+|                      Ctrl+KeyP |   p   |                    Ctrl+P |     |                    Ctrl+P |                         ctrl+p |                    Ctrl+P |                    ctrl+[KeyP] |         |
+|                     Shift+KeyP |   P   |                   Shift+P |     |                   Shift+P |                        shift+p |                   Shift+P |                   shift+[KeyP] |         |
+|                Ctrl+Shift+KeyP |   P   |              Ctrl+Shift+P |     |              Ctrl+Shift+P |                   ctrl+shift+p |              Ctrl+Shift+P |              ctrl+shift+[KeyP] |         |
+|                       Alt+KeyP |   p   |                     Alt+P |     |                     Alt+P |                          alt+p |                     Alt+P |                     alt+[KeyP] |         |
+|                  Ctrl+Alt+KeyP |   π   |                Ctrl+Alt+P |     |                Ctrl+Alt+P |                     ctrl+alt+p |                Ctrl+Alt+P |                ctrl+alt+[KeyP] |         |
+|                 Shift+Alt+KeyP |   P   |               Shift+Alt+P |     |               Shift+Alt+P |                    shift+alt+p |               Shift+Alt+P |               shift+alt+[KeyP] |         |
+|            Ctrl+Shift+Alt+KeyP |   ∏   |          Ctrl+Shift+Alt+P |     |          Ctrl+Shift+Alt+P |               ctrl+shift+alt+p |          Ctrl+Shift+Alt+P |          ctrl+shift+alt+[KeyP] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyQ |   q   |                         Q |     |                         Q |                              q |                         Q |                         [KeyQ] |         |
+|                      Ctrl+KeyQ |   q   |                    Ctrl+Q |     |                    Ctrl+Q |                         ctrl+q |                    Ctrl+Q |                    ctrl+[KeyQ] |         |
+|                     Shift+KeyQ |   Q   |                   Shift+Q |     |                   Shift+Q |                        shift+q |                   Shift+Q |                   shift+[KeyQ] |         |
+|                Ctrl+Shift+KeyQ |   Q   |              Ctrl+Shift+Q |     |              Ctrl+Shift+Q |                   ctrl+shift+q |              Ctrl+Shift+Q |              ctrl+shift+[KeyQ] |         |
+|                       Alt+KeyQ |   q   |                     Alt+Q |     |                     Alt+Q |                          alt+q |                     Alt+Q |                     alt+[KeyQ] |         |
+|                  Ctrl+Alt+KeyQ |   œ   |                Ctrl+Alt+Q |     |                Ctrl+Alt+Q |                     ctrl+alt+q |                Ctrl+Alt+Q |                ctrl+alt+[KeyQ] |         |
+|                 Shift+Alt+KeyQ |   Q   |               Shift+Alt+Q |     |               Shift+Alt+Q |                    shift+alt+q |               Shift+Alt+Q |               shift+alt+[KeyQ] |         |
+|            Ctrl+Shift+Alt+KeyQ |   Π  |          Ctrl+Shift+Alt+Q |     |          Ctrl+Shift+Alt+Q |               ctrl+shift+alt+q |          Ctrl+Shift+Alt+Q |          ctrl+shift+alt+[KeyQ] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyR |   r   |                         R |     |                         R |                              r |                         R |                         [KeyR] |         |
+|                      Ctrl+KeyR |   r   |                    Ctrl+R |     |                    Ctrl+R |                         ctrl+r |                    Ctrl+R |                    ctrl+[KeyR] |         |
+|                     Shift+KeyR |   R   |                   Shift+R |     |                   Shift+R |                        shift+r |                   Shift+R |                   shift+[KeyR] |         |
+|                Ctrl+Shift+KeyR |   R   |              Ctrl+Shift+R |     |              Ctrl+Shift+R |                   ctrl+shift+r |              Ctrl+Shift+R |              ctrl+shift+[KeyR] |         |
+|                       Alt+KeyR |   r   |                     Alt+R |     |                     Alt+R |                          alt+r |                     Alt+R |                     alt+[KeyR] |         |
+|                  Ctrl+Alt+KeyR |   ®   |                Ctrl+Alt+R |     |                Ctrl+Alt+R |                     ctrl+alt+r |                Ctrl+Alt+R |                ctrl+alt+[KeyR] |         |
+|                 Shift+Alt+KeyR |   R   |               Shift+Alt+R |     |               Shift+Alt+R |                    shift+alt+r |               Shift+Alt+R |               shift+alt+[KeyR] |         |
+|            Ctrl+Shift+Alt+KeyR |   ‰   |          Ctrl+Shift+Alt+R |     |          Ctrl+Shift+Alt+R |               ctrl+shift+alt+r |          Ctrl+Shift+Alt+R |          ctrl+shift+alt+[KeyR] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyS |   s   |                         S |     |                         S |                              s |                         S |                         [KeyS] |         |
+|                      Ctrl+KeyS |   s   |                    Ctrl+S |     |                    Ctrl+S |                         ctrl+s |                    Ctrl+S |                    ctrl+[KeyS] |         |
+|                     Shift+KeyS |   S   |                   Shift+S |     |                   Shift+S |                        shift+s |                   Shift+S |                   shift+[KeyS] |         |
+|                Ctrl+Shift+KeyS |   S   |              Ctrl+Shift+S |     |              Ctrl+Shift+S |                   ctrl+shift+s |              Ctrl+Shift+S |              ctrl+shift+[KeyS] |         |
+|                       Alt+KeyS |   s   |                     Alt+S |     |                     Alt+S |                          alt+s |                     Alt+S |                     alt+[KeyS] |         |
+|                  Ctrl+Alt+KeyS |   ß   |                Ctrl+Alt+S |     |                Ctrl+Alt+S |                     ctrl+alt+s |                Ctrl+Alt+S |                ctrl+alt+[KeyS] |         |
+|                 Shift+Alt+KeyS |   S   |               Shift+Alt+S |     |               Shift+Alt+S |                    shift+alt+s |               Shift+Alt+S |               shift+alt+[KeyS] |         |
+|            Ctrl+Shift+Alt+KeyS |   Í   |          Ctrl+Shift+Alt+S |     |          Ctrl+Shift+Alt+S |               ctrl+shift+alt+s |          Ctrl+Shift+Alt+S |          ctrl+shift+alt+[KeyS] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyT |   t   |                         T |     |                         T |                              t |                         T |                         [KeyT] |         |
+|                      Ctrl+KeyT |   t   |                    Ctrl+T |     |                    Ctrl+T |                         ctrl+t |                    Ctrl+T |                    ctrl+[KeyT] |         |
+|                     Shift+KeyT |   T   |                   Shift+T |     |                   Shift+T |                        shift+t |                   Shift+T |                   shift+[KeyT] |         |
+|                Ctrl+Shift+KeyT |   T   |              Ctrl+Shift+T |     |              Ctrl+Shift+T |                   ctrl+shift+t |              Ctrl+Shift+T |              ctrl+shift+[KeyT] |         |
+|                       Alt+KeyT |   t   |                     Alt+T |     |                     Alt+T |                          alt+t |                     Alt+T |                     alt+[KeyT] |         |
+|                  Ctrl+Alt+KeyT |   †   |                Ctrl+Alt+T |     |                Ctrl+Alt+T |                     ctrl+alt+t |                Ctrl+Alt+T |                ctrl+alt+[KeyT] |         |
+|                 Shift+Alt+KeyT |   T   |               Shift+Alt+T |     |               Shift+Alt+T |                    shift+alt+t |               Shift+Alt+T |               shift+alt+[KeyT] |         |
+|            Ctrl+Shift+Alt+KeyT |   ˇ   |          Ctrl+Shift+Alt+T |     |          Ctrl+Shift+Alt+T |               ctrl+shift+alt+t |          Ctrl+Shift+Alt+T |          ctrl+shift+alt+[KeyT] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyU |   u   |                         U |     |                         U |                              u |                         U |                         [KeyU] |         |
+|                      Ctrl+KeyU |   u   |                    Ctrl+U |     |                    Ctrl+U |                         ctrl+u |                    Ctrl+U |                    ctrl+[KeyU] |         |
+|                     Shift+KeyU |   U   |                   Shift+U |     |                   Shift+U |                        shift+u |                   Shift+U |                   shift+[KeyU] |         |
+|                Ctrl+Shift+KeyU |   U   |              Ctrl+Shift+U |     |              Ctrl+Shift+U |                   ctrl+shift+u |              Ctrl+Shift+U |              ctrl+shift+[KeyU] |         |
+|                       Alt+KeyU |   u   |                     Alt+U |     |                     Alt+U |                          alt+u |                     Alt+U |                     alt+[KeyU] |         |
+|                  Ctrl+Alt+KeyU |   ¨   |                Ctrl+Alt+U |     |                Ctrl+Alt+U |                     ctrl+alt+u |                Ctrl+Alt+U |                ctrl+alt+[KeyU] |         |
+|                 Shift+Alt+KeyU |   U   |               Shift+Alt+U |     |               Shift+Alt+U |                    shift+alt+u |               Shift+Alt+U |               shift+alt+[KeyU] |         |
+|            Ctrl+Shift+Alt+KeyU |   ¨   |          Ctrl+Shift+Alt+U |     |          Ctrl+Shift+Alt+U |               ctrl+shift+alt+u |          Ctrl+Shift+Alt+U |          ctrl+shift+alt+[KeyU] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyV |   v   |                         V |     |                         V |                              v |                         V |                         [KeyV] |         |
+|                      Ctrl+KeyV |   v   |                    Ctrl+V |     |                    Ctrl+V |                         ctrl+v |                    Ctrl+V |                    ctrl+[KeyV] |         |
+|                     Shift+KeyV |   V   |                   Shift+V |     |                   Shift+V |                        shift+v |                   Shift+V |                   shift+[KeyV] |         |
+|                Ctrl+Shift+KeyV |   V   |              Ctrl+Shift+V |     |              Ctrl+Shift+V |                   ctrl+shift+v |              Ctrl+Shift+V |              ctrl+shift+[KeyV] |         |
+|                       Alt+KeyV |   v   |                     Alt+V |     |                     Alt+V |                          alt+v |                     Alt+V |                     alt+[KeyV] |         |
+|                  Ctrl+Alt+KeyV |   √   |                Ctrl+Alt+V |     |                Ctrl+Alt+V |                     ctrl+alt+v |                Ctrl+Alt+V |                ctrl+alt+[KeyV] |         |
+|                 Shift+Alt+KeyV |   V   |               Shift+Alt+V |     |               Shift+Alt+V |                    shift+alt+v |               Shift+Alt+V |               shift+alt+[KeyV] |         |
+|            Ctrl+Shift+Alt+KeyV |   ◊   |          Ctrl+Shift+Alt+V |     |          Ctrl+Shift+Alt+V |               ctrl+shift+alt+v |          Ctrl+Shift+Alt+V |          ctrl+shift+alt+[KeyV] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyW |   w   |                         W |     |                         W |                              w |                         W |                         [KeyW] |         |
+|                      Ctrl+KeyW |   w   |                    Ctrl+W |     |                    Ctrl+W |                         ctrl+w |                    Ctrl+W |                    ctrl+[KeyW] |         |
+|                     Shift+KeyW |   W   |                   Shift+W |     |                   Shift+W |                        shift+w |                   Shift+W |                   shift+[KeyW] |         |
+|                Ctrl+Shift+KeyW |   W   |              Ctrl+Shift+W |     |              Ctrl+Shift+W |                   ctrl+shift+w |              Ctrl+Shift+W |              ctrl+shift+[KeyW] |         |
+|                       Alt+KeyW |   w   |                     Alt+W |     |                     Alt+W |                          alt+w |                     Alt+W |                     alt+[KeyW] |         |
+|                  Ctrl+Alt+KeyW |   ∑   |                Ctrl+Alt+W |     |                Ctrl+Alt+W |                     ctrl+alt+w |                Ctrl+Alt+W |                ctrl+alt+[KeyW] |         |
+|                 Shift+Alt+KeyW |   W   |               Shift+Alt+W |     |               Shift+Alt+W |                    shift+alt+w |               Shift+Alt+W |               shift+alt+[KeyW] |         |
+|            Ctrl+Shift+Alt+KeyW |   „   |          Ctrl+Shift+Alt+W |     |          Ctrl+Shift+Alt+W |               ctrl+shift+alt+w |          Ctrl+Shift+Alt+W |          ctrl+shift+alt+[KeyW] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyX |   x   |                         X |     |                         X |                              x |                         X |                         [KeyX] |         |
+|                      Ctrl+KeyX |   x   |                    Ctrl+X |     |                    Ctrl+X |                         ctrl+x |                    Ctrl+X |                    ctrl+[KeyX] |         |
+|                     Shift+KeyX |   X   |                   Shift+X |     |                   Shift+X |                        shift+x |                   Shift+X |                   shift+[KeyX] |         |
+|                Ctrl+Shift+KeyX |   X   |              Ctrl+Shift+X |     |              Ctrl+Shift+X |                   ctrl+shift+x |              Ctrl+Shift+X |              ctrl+shift+[KeyX] |         |
+|                       Alt+KeyX |   x   |                     Alt+X |     |                     Alt+X |                          alt+x |                     Alt+X |                     alt+[KeyX] |         |
+|                  Ctrl+Alt+KeyX |   ≈   |                Ctrl+Alt+X |     |                Ctrl+Alt+X |                     ctrl+alt+x |                Ctrl+Alt+X |                ctrl+alt+[KeyX] |         |
+|                 Shift+Alt+KeyX |   X   |               Shift+Alt+X |     |               Shift+Alt+X |                    shift+alt+x |               Shift+Alt+X |               shift+alt+[KeyX] |         |
+|            Ctrl+Shift+Alt+KeyX |   ˛   |          Ctrl+Shift+Alt+X |     |          Ctrl+Shift+Alt+X |               ctrl+shift+alt+x |          Ctrl+Shift+Alt+X |          ctrl+shift+alt+[KeyX] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyY |   y   |                         Y |     |                         Y |                              y |                         Y |                         [KeyY] |         |
+|                      Ctrl+KeyY |   y   |                    Ctrl+Y |     |                    Ctrl+Y |                         ctrl+y |                    Ctrl+Y |                    ctrl+[KeyY] |         |
+|                     Shift+KeyY |   Y   |                   Shift+Y |     |                   Shift+Y |                        shift+y |                   Shift+Y |                   shift+[KeyY] |         |
+|                Ctrl+Shift+KeyY |   Y   |              Ctrl+Shift+Y |     |              Ctrl+Shift+Y |                   ctrl+shift+y |              Ctrl+Shift+Y |              ctrl+shift+[KeyY] |         |
+|                       Alt+KeyY |   y   |                     Alt+Y |     |                     Alt+Y |                          alt+y |                     Alt+Y |                     alt+[KeyY] |         |
+|                  Ctrl+Alt+KeyY |   ¥   |                Ctrl+Alt+Y |     |                Ctrl+Alt+Y |                     ctrl+alt+y |                Ctrl+Alt+Y |                ctrl+alt+[KeyY] |         |
+|                 Shift+Alt+KeyY |   Y   |               Shift+Alt+Y |     |               Shift+Alt+Y |                    shift+alt+y |               Shift+Alt+Y |               shift+alt+[KeyY] |         |
+|            Ctrl+Shift+Alt+KeyY |   Á   |          Ctrl+Shift+Alt+Y |     |          Ctrl+Shift+Alt+Y |               ctrl+shift+alt+y |          Ctrl+Shift+Alt+Y |          ctrl+shift+alt+[KeyY] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyZ |   z   |                         Z |     |                         Z |                              z |                         Z |                         [KeyZ] |         |
+|                      Ctrl+KeyZ |   z   |                    Ctrl+Z |     |                    Ctrl+Z |                         ctrl+z |                    Ctrl+Z |                    ctrl+[KeyZ] |         |
+|                     Shift+KeyZ |   Z   |                   Shift+Z |     |                   Shift+Z |                        shift+z |                   Shift+Z |                   shift+[KeyZ] |         |
+|                Ctrl+Shift+KeyZ |   Z   |              Ctrl+Shift+Z |     |              Ctrl+Shift+Z |                   ctrl+shift+z |              Ctrl+Shift+Z |              ctrl+shift+[KeyZ] |         |
+|                       Alt+KeyZ |   z   |                     Alt+Z |     |                     Alt+Z |                          alt+z |                     Alt+Z |                     alt+[KeyZ] |         |
+|                  Ctrl+Alt+KeyZ |   Ω   |                Ctrl+Alt+Z |     |                Ctrl+Alt+Z |                     ctrl+alt+z |                Ctrl+Alt+Z |                ctrl+alt+[KeyZ] |         |
+|                 Shift+Alt+KeyZ |   Z   |               Shift+Alt+Z |     |               Shift+Alt+Z |                    shift+alt+z |               Shift+Alt+Z |               shift+alt+[KeyZ] |         |
+|            Ctrl+Shift+Alt+KeyZ |   ¸   |          Ctrl+Shift+Alt+Z |     |          Ctrl+Shift+Alt+Z |               ctrl+shift+alt+z |          Ctrl+Shift+Alt+Z |          ctrl+shift+alt+[KeyZ] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit1 |   1   |                         1 |     |                         1 |                              1 |                         1 |                       [Digit1] |         |
+|                    Ctrl+Digit1 |   1   |                    Ctrl+1 |     |                    Ctrl+1 |                         ctrl+1 |                    Ctrl+1 |                  ctrl+[Digit1] |         |
+|                   Shift+Digit1 |   !   |                   Shift+1 |     |                   Shift+1 |                        shift+1 |                   Shift+1 |                 shift+[Digit1] |         |
+|              Ctrl+Shift+Digit1 |   !   |              Ctrl+Shift+1 |     |              Ctrl+Shift+1 |                   ctrl+shift+1 |              Ctrl+Shift+1 |            ctrl+shift+[Digit1] |         |
+|                     Alt+Digit1 |   1   |                     Alt+1 |     |                     Alt+1 |                          alt+1 |                     Alt+1 |                   alt+[Digit1] |         |
+|                Ctrl+Alt+Digit1 |   ¡   |                Ctrl+Alt+1 |     |                Ctrl+Alt+1 |                     ctrl+alt+1 |                Ctrl+Alt+1 |              ctrl+alt+[Digit1] |         |
+|               Shift+Alt+Digit1 |   !   |               Shift+Alt+1 |     |               Shift+Alt+1 |                    shift+alt+1 |               Shift+Alt+1 |             shift+alt+[Digit1] |         |
+|          Ctrl+Shift+Alt+Digit1 |   ⁄   |          Ctrl+Shift+Alt+1 |     |          Ctrl+Shift+Alt+1 |               ctrl+shift+alt+1 |          Ctrl+Shift+Alt+1 |        ctrl+shift+alt+[Digit1] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit2 |   2   |                         2 |     |                         2 |                              2 |                         2 |                       [Digit2] |         |
+|                    Ctrl+Digit2 |   2   |                    Ctrl+2 |     |                    Ctrl+2 |                         ctrl+2 |                    Ctrl+2 |                  ctrl+[Digit2] |         |
+|                   Shift+Digit2 |   @   |                   Shift+2 |     |                   Shift+2 |                        shift+2 |                   Shift+2 |                 shift+[Digit2] |         |
+|              Ctrl+Shift+Digit2 |   @   |              Ctrl+Shift+2 |     |              Ctrl+Shift+2 |                   ctrl+shift+2 |              Ctrl+Shift+2 |            ctrl+shift+[Digit2] |         |
+|                     Alt+Digit2 |   2   |                     Alt+2 |     |                     Alt+2 |                          alt+2 |                     Alt+2 |                   alt+[Digit2] |         |
+|                Ctrl+Alt+Digit2 |   ™   |                Ctrl+Alt+2 |     |                Ctrl+Alt+2 |                     ctrl+alt+2 |                Ctrl+Alt+2 |              ctrl+alt+[Digit2] |         |
+|               Shift+Alt+Digit2 |   @   |               Shift+Alt+2 |     |               Shift+Alt+2 |                    shift+alt+2 |               Shift+Alt+2 |             shift+alt+[Digit2] |         |
+|          Ctrl+Shift+Alt+Digit2 |   €   |          Ctrl+Shift+Alt+2 |     |          Ctrl+Shift+Alt+2 |               ctrl+shift+alt+2 |          Ctrl+Shift+Alt+2 |        ctrl+shift+alt+[Digit2] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit3 |   3   |                         3 |     |                         3 |                              3 |                         3 |                       [Digit3] |         |
+|                    Ctrl+Digit3 |   3   |                    Ctrl+3 |     |                    Ctrl+3 |                         ctrl+3 |                    Ctrl+3 |                  ctrl+[Digit3] |         |
+|                   Shift+Digit3 |   #   |                   Shift+3 |     |                   Shift+3 |                        shift+3 |                   Shift+3 |                 shift+[Digit3] |         |
+|              Ctrl+Shift+Digit3 |   #   |              Ctrl+Shift+3 |     |              Ctrl+Shift+3 |                   ctrl+shift+3 |              Ctrl+Shift+3 |            ctrl+shift+[Digit3] |         |
+|                     Alt+Digit3 |   3   |                     Alt+3 |     |                     Alt+3 |                          alt+3 |                     Alt+3 |                   alt+[Digit3] |         |
+|                Ctrl+Alt+Digit3 |   £   |                Ctrl+Alt+3 |     |                Ctrl+Alt+3 |                     ctrl+alt+3 |                Ctrl+Alt+3 |              ctrl+alt+[Digit3] |         |
+|               Shift+Alt+Digit3 |   #   |               Shift+Alt+3 |     |               Shift+Alt+3 |                    shift+alt+3 |               Shift+Alt+3 |             shift+alt+[Digit3] |         |
+|          Ctrl+Shift+Alt+Digit3 |   ‹   |          Ctrl+Shift+Alt+3 |     |          Ctrl+Shift+Alt+3 |               ctrl+shift+alt+3 |          Ctrl+Shift+Alt+3 |        ctrl+shift+alt+[Digit3] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit4 |   4   |                         4 |     |                         4 |                              4 |                         4 |                       [Digit4] |         |
+|                    Ctrl+Digit4 |   4   |                    Ctrl+4 |     |                    Ctrl+4 |                         ctrl+4 |                    Ctrl+4 |                  ctrl+[Digit4] |         |
+|                   Shift+Digit4 |   $   |                   Shift+4 |     |                   Shift+4 |                        shift+4 |                   Shift+4 |                 shift+[Digit4] |         |
+|              Ctrl+Shift+Digit4 |   $   |              Ctrl+Shift+4 |     |              Ctrl+Shift+4 |                   ctrl+shift+4 |              Ctrl+Shift+4 |            ctrl+shift+[Digit4] |         |
+|                     Alt+Digit4 |   4   |                     Alt+4 |     |                     Alt+4 |                          alt+4 |                     Alt+4 |                   alt+[Digit4] |         |
+|                Ctrl+Alt+Digit4 |   ¢   |                Ctrl+Alt+4 |     |                Ctrl+Alt+4 |                     ctrl+alt+4 |                Ctrl+Alt+4 |              ctrl+alt+[Digit4] |         |
+|               Shift+Alt+Digit4 |   $   |               Shift+Alt+4 |     |               Shift+Alt+4 |                    shift+alt+4 |               Shift+Alt+4 |             shift+alt+[Digit4] |         |
+|          Ctrl+Shift+Alt+Digit4 |   ›   |          Ctrl+Shift+Alt+4 |     |          Ctrl+Shift+Alt+4 |               ctrl+shift+alt+4 |          Ctrl+Shift+Alt+4 |        ctrl+shift+alt+[Digit4] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit5 |   5   |                         5 |     |                         5 |                              5 |                         5 |                       [Digit5] |         |
+|                    Ctrl+Digit5 |   5   |                    Ctrl+5 |     |                    Ctrl+5 |                         ctrl+5 |                    Ctrl+5 |                  ctrl+[Digit5] |         |
+|                   Shift+Digit5 |   %   |                   Shift+5 |     |                   Shift+5 |                        shift+5 |                   Shift+5 |                 shift+[Digit5] |         |
+|              Ctrl+Shift+Digit5 |   %   |              Ctrl+Shift+5 |     |              Ctrl+Shift+5 |                   ctrl+shift+5 |              Ctrl+Shift+5 |            ctrl+shift+[Digit5] |         |
+|                     Alt+Digit5 |   5   |                     Alt+5 |     |                     Alt+5 |                          alt+5 |                     Alt+5 |                   alt+[Digit5] |         |
+|                Ctrl+Alt+Digit5 |   ∞   |                Ctrl+Alt+5 |     |                Ctrl+Alt+5 |                     ctrl+alt+5 |                Ctrl+Alt+5 |              ctrl+alt+[Digit5] |         |
+|               Shift+Alt+Digit5 |   %   |               Shift+Alt+5 |     |               Shift+Alt+5 |                    shift+alt+5 |               Shift+Alt+5 |             shift+alt+[Digit5] |         |
+|          Ctrl+Shift+Alt+Digit5 |   fi   |          Ctrl+Shift+Alt+5 |     |          Ctrl+Shift+Alt+5 |               ctrl+shift+alt+5 |          Ctrl+Shift+Alt+5 |        ctrl+shift+alt+[Digit5] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit6 |   6   |                         6 |     |                         6 |                              6 |                         6 |                       [Digit6] |         |
+|                    Ctrl+Digit6 |   6   |                    Ctrl+6 |     |                    Ctrl+6 |                         ctrl+6 |                    Ctrl+6 |                  ctrl+[Digit6] |         |
+|                   Shift+Digit6 |   ^   |                   Shift+6 |     |                   Shift+6 |                        shift+6 |                   Shift+6 |                 shift+[Digit6] |         |
+|              Ctrl+Shift+Digit6 |   ^   |              Ctrl+Shift+6 |     |              Ctrl+Shift+6 |                   ctrl+shift+6 |              Ctrl+Shift+6 |            ctrl+shift+[Digit6] |         |
+|                     Alt+Digit6 |   6   |                     Alt+6 |     |                     Alt+6 |                          alt+6 |                     Alt+6 |                   alt+[Digit6] |         |
+|                Ctrl+Alt+Digit6 |   §   |                Ctrl+Alt+6 |     |                Ctrl+Alt+6 |                     ctrl+alt+6 |                Ctrl+Alt+6 |              ctrl+alt+[Digit6] |         |
+|               Shift+Alt+Digit6 |   ^   |               Shift+Alt+6 |     |               Shift+Alt+6 |                    shift+alt+6 |               Shift+Alt+6 |             shift+alt+[Digit6] |         |
+|          Ctrl+Shift+Alt+Digit6 |   fl   |          Ctrl+Shift+Alt+6 |     |          Ctrl+Shift+Alt+6 |               ctrl+shift+alt+6 |          Ctrl+Shift+Alt+6 |        ctrl+shift+alt+[Digit6] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit7 |   7   |                         7 |     |                         7 |                              7 |                         7 |                       [Digit7] |         |
+|                    Ctrl+Digit7 |   7   |                    Ctrl+7 |     |                    Ctrl+7 |                         ctrl+7 |                    Ctrl+7 |                  ctrl+[Digit7] |         |
+|                   Shift+Digit7 |   &   |                   Shift+7 |     |                   Shift+7 |                        shift+7 |                   Shift+7 |                 shift+[Digit7] |         |
+|              Ctrl+Shift+Digit7 |   &   |              Ctrl+Shift+7 |     |              Ctrl+Shift+7 |                   ctrl+shift+7 |              Ctrl+Shift+7 |            ctrl+shift+[Digit7] |         |
+|                     Alt+Digit7 |   7   |                     Alt+7 |     |                     Alt+7 |                          alt+7 |                     Alt+7 |                   alt+[Digit7] |         |
+|                Ctrl+Alt+Digit7 |   ¶   |                Ctrl+Alt+7 |     |                Ctrl+Alt+7 |                     ctrl+alt+7 |                Ctrl+Alt+7 |              ctrl+alt+[Digit7] |         |
+|               Shift+Alt+Digit7 |   &   |               Shift+Alt+7 |     |               Shift+Alt+7 |                    shift+alt+7 |               Shift+Alt+7 |             shift+alt+[Digit7] |         |
+|          Ctrl+Shift+Alt+Digit7 |   ‡   |          Ctrl+Shift+Alt+7 |     |          Ctrl+Shift+Alt+7 |               ctrl+shift+alt+7 |          Ctrl+Shift+Alt+7 |        ctrl+shift+alt+[Digit7] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit8 |   8   |                         8 |     |                         8 |                              8 |                         8 |                       [Digit8] |         |
+|                    Ctrl+Digit8 |   8   |                    Ctrl+8 |     |                    Ctrl+8 |                         ctrl+8 |                    Ctrl+8 |                  ctrl+[Digit8] |         |
+|                   Shift+Digit8 |   *   |                   Shift+8 |     |                   Shift+8 |                        shift+8 |                   Shift+8 |                 shift+[Digit8] |         |
+|              Ctrl+Shift+Digit8 |   *   |              Ctrl+Shift+8 |     |              Ctrl+Shift+8 |                   ctrl+shift+8 |              Ctrl+Shift+8 |            ctrl+shift+[Digit8] |         |
+|                     Alt+Digit8 |   8   |                     Alt+8 |     |                     Alt+8 |                          alt+8 |                     Alt+8 |                   alt+[Digit8] |         |
+|                Ctrl+Alt+Digit8 |   •   |                Ctrl+Alt+8 |     |                Ctrl+Alt+8 |                     ctrl+alt+8 |                Ctrl+Alt+8 |              ctrl+alt+[Digit8] |         |
+|               Shift+Alt+Digit8 |   *   |               Shift+Alt+8 |     |               Shift+Alt+8 |                    shift+alt+8 |               Shift+Alt+8 |             shift+alt+[Digit8] |         |
+|          Ctrl+Shift+Alt+Digit8 |   °   |          Ctrl+Shift+Alt+8 |     |          Ctrl+Shift+Alt+8 |               ctrl+shift+alt+8 |          Ctrl+Shift+Alt+8 |        ctrl+shift+alt+[Digit8] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit9 |   9   |                         9 |     |                         9 |                              9 |                         9 |                       [Digit9] |         |
+|                    Ctrl+Digit9 |   9   |                    Ctrl+9 |     |                    Ctrl+9 |                         ctrl+9 |                    Ctrl+9 |                  ctrl+[Digit9] |         |
+|                   Shift+Digit9 |   (   |                   Shift+9 |     |                   Shift+9 |                        shift+9 |                   Shift+9 |                 shift+[Digit9] |         |
+|              Ctrl+Shift+Digit9 |   (   |              Ctrl+Shift+9 |     |              Ctrl+Shift+9 |                   ctrl+shift+9 |              Ctrl+Shift+9 |            ctrl+shift+[Digit9] |         |
+|                     Alt+Digit9 |   9   |                     Alt+9 |     |                     Alt+9 |                          alt+9 |                     Alt+9 |                   alt+[Digit9] |         |
+|                Ctrl+Alt+Digit9 |   ª   |                Ctrl+Alt+9 |     |                Ctrl+Alt+9 |                     ctrl+alt+9 |                Ctrl+Alt+9 |              ctrl+alt+[Digit9] |         |
+|               Shift+Alt+Digit9 |   (   |               Shift+Alt+9 |     |               Shift+Alt+9 |                    shift+alt+9 |               Shift+Alt+9 |             shift+alt+[Digit9] |         |
+|          Ctrl+Shift+Alt+Digit9 |   ·   |          Ctrl+Shift+Alt+9 |     |          Ctrl+Shift+Alt+9 |               ctrl+shift+alt+9 |          Ctrl+Shift+Alt+9 |        ctrl+shift+alt+[Digit9] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit0 |   0   |                         0 |     |                         0 |                              0 |                         0 |                       [Digit0] |         |
+|                    Ctrl+Digit0 |   0   |                    Ctrl+0 |     |                    Ctrl+0 |                         ctrl+0 |                    Ctrl+0 |                  ctrl+[Digit0] |         |
+|                   Shift+Digit0 |   )   |                   Shift+0 |     |                   Shift+0 |                        shift+0 |                   Shift+0 |                 shift+[Digit0] |         |
+|              Ctrl+Shift+Digit0 |   )   |              Ctrl+Shift+0 |     |              Ctrl+Shift+0 |                   ctrl+shift+0 |              Ctrl+Shift+0 |            ctrl+shift+[Digit0] |         |
+|                     Alt+Digit0 |   0   |                     Alt+0 |     |                     Alt+0 |                          alt+0 |                     Alt+0 |                   alt+[Digit0] |         |
+|                Ctrl+Alt+Digit0 |   º   |                Ctrl+Alt+0 |     |                Ctrl+Alt+0 |                     ctrl+alt+0 |                Ctrl+Alt+0 |              ctrl+alt+[Digit0] |         |
+|               Shift+Alt+Digit0 |   )   |               Shift+Alt+0 |     |               Shift+Alt+0 |                    shift+alt+0 |               Shift+Alt+0 |             shift+alt+[Digit0] |         |
+|          Ctrl+Shift+Alt+Digit0 |   ‚   |          Ctrl+Shift+Alt+0 |     |          Ctrl+Shift+Alt+0 |               ctrl+shift+alt+0 |          Ctrl+Shift+Alt+0 |        ctrl+shift+alt+[Digit0] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Minus |   -   |                         - |     |                         - |                              - |                         - |                        [Minus] |         |
+|                     Ctrl+Minus |   -   |                    Ctrl+- |     |                    Ctrl+- |                         ctrl+- |                      null |                   ctrl+[Minus] |         |
+|                    Shift+Minus |   _   |                   Shift+- |     |                   Shift+- |                        shift+- |                   Shift+- |                  shift+[Minus] |         |
+|               Ctrl+Shift+Minus |   _   |              Ctrl+Shift+- |     |              Ctrl+Shift+- |                   ctrl+shift+- |                      null |             ctrl+shift+[Minus] |         |
+|                      Alt+Minus |   -   |                     Alt+- |     |                     Alt+- |                          alt+- |                     Alt+- |                    alt+[Minus] |         |
+|                 Ctrl+Alt+Minus |   –   |                Ctrl+Alt+- |     |                Ctrl+Alt+- |                     ctrl+alt+- |                Ctrl+Alt+- |               ctrl+alt+[Minus] |         |
+|                Shift+Alt+Minus |   _   |               Shift+Alt+- |     |               Shift+Alt+- |                    shift+alt+- |               Shift+Alt+- |              shift+alt+[Minus] |         |
+|           Ctrl+Shift+Alt+Minus |   —   |          Ctrl+Shift+Alt+- |     |          Ctrl+Shift+Alt+- |               ctrl+shift+alt+- |          Ctrl+Shift+Alt+- |         ctrl+shift+alt+[Minus] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Equal |   =   |                         = |     |                         = |                              = |                         = |                        [Equal] |         |
+|                     Ctrl+Equal |   =   |                    Ctrl+= |     |                    Ctrl+= |                         ctrl+= |                    Ctrl+= |                   ctrl+[Equal] |         |
+|                    Shift+Equal |   +   |                   Shift+= |     |                   Shift+= |                        shift+= |                   Shift+= |                  shift+[Equal] |         |
+|               Ctrl+Shift+Equal |   +   |              Ctrl+Shift+= |     |              Ctrl+Shift+= |                   ctrl+shift+= |              Ctrl+Shift+= |             ctrl+shift+[Equal] |         |
+|                      Alt+Equal |   =   |                     Alt+= |     |                     Alt+= |                          alt+= |                     Alt+= |                    alt+[Equal] |         |
+|                 Ctrl+Alt+Equal |   ≠   |                Ctrl+Alt+= |     |                Ctrl+Alt+= |                     ctrl+alt+= |                Ctrl+Alt+= |               ctrl+alt+[Equal] |         |
+|                Shift+Alt+Equal |   +   |               Shift+Alt+= |     |               Shift+Alt+= |                    shift+alt+= |               Shift+Alt+= |              shift+alt+[Equal] |         |
+|           Ctrl+Shift+Alt+Equal |   ±   |          Ctrl+Shift+Alt+= |     |          Ctrl+Shift+Alt+= |               ctrl+shift+alt+= |          Ctrl+Shift+Alt+= |         ctrl+shift+alt+[Equal] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                    BracketLeft |   [   |                         [ |     |                         [ |                              [ |                         [ |                  [BracketLeft] |         |
+|               Ctrl+BracketLeft |   [   |                    Ctrl+[ |     |                    Ctrl+[ |                         ctrl+[ |                    Ctrl+[ |             ctrl+[BracketLeft] |         |
+|              Shift+BracketLeft |   {   |                   Shift+[ |     |                   Shift+[ |                        shift+[ |                   Shift+[ |            shift+[BracketLeft] |         |
+|         Ctrl+Shift+BracketLeft |   {   |              Ctrl+Shift+[ |     |              Ctrl+Shift+[ |                   ctrl+shift+[ |              Ctrl+Shift+[ |       ctrl+shift+[BracketLeft] |         |
+|                Alt+BracketLeft |   [   |                     Alt+[ |     |                     Alt+[ |                          alt+[ |                     Alt+[ |              alt+[BracketLeft] |         |
+|           Ctrl+Alt+BracketLeft |   “   |                Ctrl+Alt+[ |     |                Ctrl+Alt+[ |                     ctrl+alt+[ |                Ctrl+Alt+[ |         ctrl+alt+[BracketLeft] |         |
+|          Shift+Alt+BracketLeft |   {   |               Shift+Alt+[ |     |               Shift+Alt+[ |                    shift+alt+[ |               Shift+Alt+[ |        shift+alt+[BracketLeft] |         |
+|     Ctrl+Shift+Alt+BracketLeft |   ”   |          Ctrl+Shift+Alt+[ |     |          Ctrl+Shift+Alt+[ |               ctrl+shift+alt+[ |          Ctrl+Shift+Alt+[ |   ctrl+shift+alt+[BracketLeft] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                   BracketRight |   ]   |                         ] |     |                         ] |                              ] |                         ] |                 [BracketRight] |         |
+|              Ctrl+BracketRight |   ]   |                    Ctrl+] |     |                    Ctrl+] |                         ctrl+] |                    Ctrl+] |            ctrl+[BracketRight] |         |
+|             Shift+BracketRight |   }   |                   Shift+] |     |                   Shift+] |                        shift+] |                   Shift+] |           shift+[BracketRight] |         |
+|        Ctrl+Shift+BracketRight |   }   |              Ctrl+Shift+] |     |              Ctrl+Shift+] |                   ctrl+shift+] |              Ctrl+Shift+] |      ctrl+shift+[BracketRight] |         |
+|               Alt+BracketRight |   ]   |                     Alt+] |     |                     Alt+] |                          alt+] |                     Alt+] |             alt+[BracketRight] |         |
+|          Ctrl+Alt+BracketRight |   ‘   |                Ctrl+Alt+] |     |                Ctrl+Alt+] |                     ctrl+alt+] |                Ctrl+Alt+] |        ctrl+alt+[BracketRight] |         |
+|         Shift+Alt+BracketRight |   }   |               Shift+Alt+] |     |               Shift+Alt+] |                    shift+alt+] |               Shift+Alt+] |       shift+alt+[BracketRight] |         |
+|    Ctrl+Shift+Alt+BracketRight |   ’   |          Ctrl+Shift+Alt+] |     |          Ctrl+Shift+Alt+] |               ctrl+shift+alt+] |          Ctrl+Shift+Alt+] |  ctrl+shift+alt+[BracketRight] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                      Backslash |   \   |                         \ |     |                         \ |                              \ |                         \ |                    [Backslash] |         |
+|                 Ctrl+Backslash |   \   |                    Ctrl+\ |     |                    Ctrl+\ |                         ctrl+\ |                    Ctrl+\ |               ctrl+[Backslash] |         |
+|                Shift+Backslash |   |   |                   Shift+\ |     |                   Shift+\ |                        shift+\ |                   Shift+\ |              shift+[Backslash] |         |
+|           Ctrl+Shift+Backslash |   |   |              Ctrl+Shift+\ |     |              Ctrl+Shift+\ |                   ctrl+shift+\ |              Ctrl+Shift+\ |         ctrl+shift+[Backslash] |         |
+|                  Alt+Backslash |   \   |                     Alt+\ |     |                     Alt+\ |                          alt+\ |                     Alt+\ |                alt+[Backslash] |         |
+|             Ctrl+Alt+Backslash |   «   |                Ctrl+Alt+\ |     |                Ctrl+Alt+\ |                     ctrl+alt+\ |                Ctrl+Alt+\ |           ctrl+alt+[Backslash] |         |
+|            Shift+Alt+Backslash |   |   |               Shift+Alt+\ |     |               Shift+Alt+\ |                    shift+alt+\ |               Shift+Alt+\ |          shift+alt+[Backslash] |         |
+|       Ctrl+Shift+Alt+Backslash |   »   |          Ctrl+Shift+Alt+\ |     |          Ctrl+Shift+Alt+\ |               ctrl+shift+alt+\ |          Ctrl+Shift+Alt+\ |     ctrl+shift+alt+[Backslash] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                       IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|                  Ctrl+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|                 Shift+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|            Ctrl+Shift+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|                   Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|              Ctrl+Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|             Shift+Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|        Ctrl+Shift+Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                      Semicolon |   ;   |                         ; |     |                         ; |                              ; |                         ; |                    [Semicolon] |         |
+|                 Ctrl+Semicolon |   ;   |                    Ctrl+; |     |                    Ctrl+; |                         ctrl+; |                    Ctrl+; |               ctrl+[Semicolon] |         |
+|                Shift+Semicolon |   :   |                   Shift+; |     |                   Shift+; |                        shift+; |                   Shift+; |              shift+[Semicolon] |         |
+|           Ctrl+Shift+Semicolon |   :   |              Ctrl+Shift+; |     |              Ctrl+Shift+; |                   ctrl+shift+; |              Ctrl+Shift+; |         ctrl+shift+[Semicolon] |         |
+|                  Alt+Semicolon |   ;   |                     Alt+; |     |                     Alt+; |                          alt+; |                     Alt+; |                alt+[Semicolon] |         |
+|             Ctrl+Alt+Semicolon |   …   |                Ctrl+Alt+; |     |                Ctrl+Alt+; |                     ctrl+alt+; |                Ctrl+Alt+; |           ctrl+alt+[Semicolon] |         |
+|            Shift+Alt+Semicolon |   :   |               Shift+Alt+; |     |               Shift+Alt+; |                    shift+alt+; |               Shift+Alt+; |          shift+alt+[Semicolon] |         |
+|       Ctrl+Shift+Alt+Semicolon |   Ú   |          Ctrl+Shift+Alt+; |     |          Ctrl+Shift+Alt+; |               ctrl+shift+alt+; |          Ctrl+Shift+Alt+; |     ctrl+shift+alt+[Semicolon] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Quote |   '   |                         ' |     |                         ' |                              ' |                         ' |                        [Quote] |         |
+|                     Ctrl+Quote |   '   |                    Ctrl+' |     |                    Ctrl+' |                         ctrl+' |                    Ctrl+' |                   ctrl+[Quote] |         |
+|                    Shift+Quote |   "   |                   Shift+' |     |                   Shift+' |                        shift+' |                   Shift+' |                  shift+[Quote] |         |
+|               Ctrl+Shift+Quote |   "   |              Ctrl+Shift+' |     |              Ctrl+Shift+' |                   ctrl+shift+' |              Ctrl+Shift+' |             ctrl+shift+[Quote] |         |
+|                      Alt+Quote |   '   |                     Alt+' |     |                     Alt+' |                          alt+' |                     Alt+' |                    alt+[Quote] |         |
+|                 Ctrl+Alt+Quote |   æ   |                Ctrl+Alt+' |     |                Ctrl+Alt+' |                     ctrl+alt+' |                Ctrl+Alt+' |               ctrl+alt+[Quote] |         |
+|                Shift+Alt+Quote |   "   |               Shift+Alt+' |     |               Shift+Alt+' |                    shift+alt+' |               Shift+Alt+' |              shift+alt+[Quote] |         |
+|           Ctrl+Shift+Alt+Quote |   Æ   |          Ctrl+Shift+Alt+' |     |          Ctrl+Shift+Alt+' |               ctrl+shift+alt+' |          Ctrl+Shift+Alt+' |         ctrl+shift+alt+[Quote] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                      Backquote |   `   |                         ` |     |                         ` |                              ` |                         ` |                    [Backquote] |         |
+|                 Ctrl+Backquote |   `   |                    Ctrl+` |     |                    Ctrl+` |                         ctrl+` |                    Ctrl+` |               ctrl+[Backquote] |         |
+|                Shift+Backquote |   ~   |                   Shift+` |     |                   Shift+` |                        shift+` |                   Shift+` |              shift+[Backquote] |         |
+|           Ctrl+Shift+Backquote |   ~   |              Ctrl+Shift+` |     |              Ctrl+Shift+` |                   ctrl+shift+` |              Ctrl+Shift+` |         ctrl+shift+[Backquote] |         |
+|                  Alt+Backquote |   `   |                     Alt+` |     |                     Alt+` |                          alt+` |                     Alt+` |                alt+[Backquote] |         |
+|             Ctrl+Alt+Backquote |   `   |                Ctrl+Alt+` |     |                Ctrl+Alt+` |                     ctrl+alt+` |                Ctrl+Alt+` |           ctrl+alt+[Backquote] |         |
+|            Shift+Alt+Backquote |   ~   |               Shift+Alt+` |     |               Shift+Alt+` |                    shift+alt+` |               Shift+Alt+` |          shift+alt+[Backquote] |         |
+|       Ctrl+Shift+Alt+Backquote |   `   |          Ctrl+Shift+Alt+` |     |          Ctrl+Shift+Alt+` |               ctrl+shift+alt+` |          Ctrl+Shift+Alt+` |     ctrl+shift+alt+[Backquote] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Comma |   ,   |                         , |     |                         , |                              , |                         , |                        [Comma] |         |
+|                     Ctrl+Comma |   ,   |                    Ctrl+, |     |                    Ctrl+, |                         ctrl+, |                    Ctrl+, |                   ctrl+[Comma] |         |
+|                    Shift+Comma |   <   |                   Shift+, |     |                   Shift+, |                        shift+, |                   Shift+, |                  shift+[Comma] |         |
+|               Ctrl+Shift+Comma |   <   |              Ctrl+Shift+, |     |              Ctrl+Shift+, |                   ctrl+shift+, |              Ctrl+Shift+, |             ctrl+shift+[Comma] |         |
+|                      Alt+Comma |   ,   |                     Alt+, |     |                     Alt+, |                          alt+, |                     Alt+, |                    alt+[Comma] |         |
+|                 Ctrl+Alt+Comma |   ≤   |                Ctrl+Alt+, |     |                Ctrl+Alt+, |                     ctrl+alt+, |                Ctrl+Alt+, |               ctrl+alt+[Comma] |         |
+|                Shift+Alt+Comma |   <   |               Shift+Alt+, |     |               Shift+Alt+, |                    shift+alt+, |               Shift+Alt+, |              shift+alt+[Comma] |         |
+|           Ctrl+Shift+Alt+Comma |   ¯   |          Ctrl+Shift+Alt+, |     |          Ctrl+Shift+Alt+, |               ctrl+shift+alt+, |          Ctrl+Shift+Alt+, |         ctrl+shift+alt+[Comma] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Period |   .   |                         . |     |                         . |                              . |                         . |                       [Period] |         |
+|                    Ctrl+Period |   .   |                    Ctrl+. |     |                    Ctrl+. |                         ctrl+. |                    Ctrl+. |                  ctrl+[Period] |         |
+|                   Shift+Period |   >   |                   Shift+. |     |                   Shift+. |                        shift+. |                   Shift+. |                 shift+[Period] |         |
+|              Ctrl+Shift+Period |   >   |              Ctrl+Shift+. |     |              Ctrl+Shift+. |                   ctrl+shift+. |              Ctrl+Shift+. |            ctrl+shift+[Period] |         |
+|                     Alt+Period |   .   |                     Alt+. |     |                     Alt+. |                          alt+. |                     Alt+. |                   alt+[Period] |         |
+|                Ctrl+Alt+Period |   ≥   |                Ctrl+Alt+. |     |                Ctrl+Alt+. |                     ctrl+alt+. |                Ctrl+Alt+. |              ctrl+alt+[Period] |         |
+|               Shift+Alt+Period |   >   |               Shift+Alt+. |     |               Shift+Alt+. |                    shift+alt+. |               Shift+Alt+. |             shift+alt+[Period] |         |
+|          Ctrl+Shift+Alt+Period |   ˘   |          Ctrl+Shift+Alt+. |     |          Ctrl+Shift+Alt+. |               ctrl+shift+alt+. |          Ctrl+Shift+Alt+. |        ctrl+shift+alt+[Period] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Slash |   /   |                         / |     |                         / |                              / |                         / |                        [Slash] |         |
+|                     Ctrl+Slash |   /   |                    Ctrl+/ |     |                    Ctrl+/ |                         ctrl+/ |                    Ctrl+/ |                   ctrl+[Slash] |         |
+|                    Shift+Slash |   ?   |                   Shift+/ |     |                   Shift+/ |                        shift+/ |                   Shift+/ |                  shift+[Slash] |         |
+|               Ctrl+Shift+Slash |   ?   |              Ctrl+Shift+/ |     |              Ctrl+Shift+/ |                   ctrl+shift+/ |              Ctrl+Shift+/ |             ctrl+shift+[Slash] |         |
+|                      Alt+Slash |   /   |                     Alt+/ |     |                     Alt+/ |                          alt+/ |                     Alt+/ |                    alt+[Slash] |         |
+|                 Ctrl+Alt+Slash |   ÷   |                Ctrl+Alt+/ |     |                Ctrl+Alt+/ |                     ctrl+alt+/ |                Ctrl+Alt+/ |               ctrl+alt+[Slash] |         |
+|                Shift+Alt+Slash |   ?   |               Shift+Alt+/ |     |               Shift+Alt+/ |                    shift+alt+/ |               Shift+Alt+/ |              shift+alt+[Slash] |         |
+|           Ctrl+Shift+Alt+Slash |   ¿   |          Ctrl+Shift+Alt+/ |     |          Ctrl+Shift+Alt+/ |               ctrl+shift+alt+/ |          Ctrl+Shift+Alt+/ |         ctrl+shift+alt+[Slash] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                        ArrowUp |  ---  |                   UpArrow |     |                   UpArrow |                             up |                        Up |                      [ArrowUp] |         |
+|                   Ctrl+ArrowUp |  ---  |              Ctrl+UpArrow |     |              Ctrl+UpArrow |                        ctrl+up |                   Ctrl+Up |                 ctrl+[ArrowUp] |         |
+|                  Shift+ArrowUp |  ---  |             Shift+UpArrow |     |             Shift+UpArrow |                       shift+up |                  Shift+Up |                shift+[ArrowUp] |         |
+|             Ctrl+Shift+ArrowUp |  ---  |        Ctrl+Shift+UpArrow |     |        Ctrl+Shift+UpArrow |                  ctrl+shift+up |             Ctrl+Shift+Up |           ctrl+shift+[ArrowUp] |         |
+|                    Alt+ArrowUp |  ---  |               Alt+UpArrow |     |               Alt+UpArrow |                         alt+up |                    Alt+Up |                  alt+[ArrowUp] |         |
+|               Ctrl+Alt+ArrowUp |  ---  |          Ctrl+Alt+UpArrow |     |          Ctrl+Alt+UpArrow |                    ctrl+alt+up |               Ctrl+Alt+Up |             ctrl+alt+[ArrowUp] |         |
+|              Shift+Alt+ArrowUp |  ---  |         Shift+Alt+UpArrow |     |         Shift+Alt+UpArrow |                   shift+alt+up |              Shift+Alt+Up |            shift+alt+[ArrowUp] |         |
+|         Ctrl+Shift+Alt+ArrowUp |  ---  |    Ctrl+Shift+Alt+UpArrow |     |    Ctrl+Shift+Alt+UpArrow |              ctrl+shift+alt+up |         Ctrl+Shift+Alt+Up |       ctrl+shift+alt+[ArrowUp] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                        Numpad0 |  ---  |                   NumPad0 |     |                   NumPad0 |                        numpad0 |                      null |                      [Numpad0] |         |
+|                   Ctrl+Numpad0 |  ---  |              Ctrl+NumPad0 |     |              Ctrl+NumPad0 |                   ctrl+numpad0 |                      null |                 ctrl+[Numpad0] |         |
+|                  Shift+Numpad0 |  ---  |             Shift+NumPad0 |     |             Shift+NumPad0 |                  shift+numpad0 |                      null |                shift+[Numpad0] |         |
+|             Ctrl+Shift+Numpad0 |  ---  |        Ctrl+Shift+NumPad0 |     |        Ctrl+Shift+NumPad0 |             ctrl+shift+numpad0 |                      null |           ctrl+shift+[Numpad0] |         |
+|                    Alt+Numpad0 |  ---  |               Alt+NumPad0 |     |               Alt+NumPad0 |                    alt+numpad0 |                      null |                  alt+[Numpad0] |         |
+|               Ctrl+Alt+Numpad0 |  ---  |          Ctrl+Alt+NumPad0 |     |          Ctrl+Alt+NumPad0 |               ctrl+alt+numpad0 |                      null |             ctrl+alt+[Numpad0] |         |
+|              Shift+Alt+Numpad0 |  ---  |         Shift+Alt+NumPad0 |     |         Shift+Alt+NumPad0 |              shift+alt+numpad0 |                      null |            shift+alt+[Numpad0] |         |
+|         Ctrl+Shift+Alt+Numpad0 |  ---  |    Ctrl+Shift+Alt+NumPad0 |     |    Ctrl+Shift+Alt+NumPad0 |         ctrl+shift+alt+numpad0 |                      null |       ctrl+shift+alt+[Numpad0] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                  IntlBackslash |   §   |                           |     |                         § |                [IntlBackslash] |                      null |                [IntlBackslash] |    NO   |
+|             Ctrl+IntlBackslash |   §   |                           |     |                    Ctrl+§ |           ctrl+[IntlBackslash] |                      null |           ctrl+[IntlBackslash] |    NO   |
+|            Shift+IntlBackslash |   ±   |                           |     |                   Shift+§ |          shift+[IntlBackslash] |                      null |          shift+[IntlBackslash] |    NO   |
+|       Ctrl+Shift+IntlBackslash |   ±   |                           |     |              Ctrl+Shift+§ |     ctrl+shift+[IntlBackslash] |                      null |     ctrl+shift+[IntlBackslash] |    NO   |
+|              Alt+IntlBackslash |   §   |                           |     |                     Alt+§ |            alt+[IntlBackslash] |                      null |            alt+[IntlBackslash] |    NO   |
+|         Ctrl+Alt+IntlBackslash |   §   |                           |     |                Ctrl+Alt+§ |       ctrl+alt+[IntlBackslash] |                      null |       ctrl+alt+[IntlBackslash] |    NO   |
+|        Shift+Alt+IntlBackslash |   ±   |                           |     |               Shift+Alt+§ |      shift+alt+[IntlBackslash] |                      null |      shift+alt+[IntlBackslash] |    NO   |
+|   Ctrl+Shift+Alt+IntlBackslash |   ±   |                           |     |          Ctrl+Shift+Alt+§ | ctrl+shift+alt+[IntlBackslash] |                      null | ctrl+shift+alt+[IntlBackslash] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         IntlRo |  ---  |                           |     |                      null |                       [IntlRo] |                      null |                       [IntlRo] |    NO   |
+|                    Ctrl+IntlRo |  ---  |                           |     |                      null |                  ctrl+[IntlRo] |                      null |                  ctrl+[IntlRo] |    NO   |
+|                   Shift+IntlRo |  ---  |                           |     |                      null |                 shift+[IntlRo] |                      null |                 shift+[IntlRo] |    NO   |
+|              Ctrl+Shift+IntlRo |  ---  |                           |     |                      null |            ctrl+shift+[IntlRo] |                      null |            ctrl+shift+[IntlRo] |    NO   |
+|                     Alt+IntlRo |  ---  |                           |     |                      null |                   alt+[IntlRo] |                      null |                   alt+[IntlRo] |    NO   |
+|                Ctrl+Alt+IntlRo |  ---  |                           |     |                      null |              ctrl+alt+[IntlRo] |                      null |              ctrl+alt+[IntlRo] |    NO   |
+|               Shift+Alt+IntlRo |  ---  |                           |     |                      null |             shift+alt+[IntlRo] |                      null |             shift+alt+[IntlRo] |    NO   |
+|          Ctrl+Shift+Alt+IntlRo |  ---  |                           |     |                      null |        ctrl+shift+alt+[IntlRo] |                      null |        ctrl+shift+alt+[IntlRo] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                        IntlYen |  ---  |                           |     |                      null |                      [IntlYen] |                      null |                      [IntlYen] |    NO   |
+|                   Ctrl+IntlYen |  ---  |                           |     |                      null |                 ctrl+[IntlYen] |                      null |                 ctrl+[IntlYen] |    NO   |
+|                  Shift+IntlYen |  ---  |                           |     |                      null |                shift+[IntlYen] |                      null |                shift+[IntlYen] |    NO   |
+|             Ctrl+Shift+IntlYen |  ---  |                           |     |                      null |           ctrl+shift+[IntlYen] |                      null |           ctrl+shift+[IntlYen] |    NO   |
+|                    Alt+IntlYen |  ---  |                           |     |                      null |                  alt+[IntlYen] |                      null |                  alt+[IntlYen] |    NO   |
+|               Ctrl+Alt+IntlYen |  ---  |                           |     |                      null |             ctrl+alt+[IntlYen] |                      null |             ctrl+alt+[IntlYen] |    NO   |
+|              Shift+Alt+IntlYen |  ---  |                           |     |                      null |            shift+alt+[IntlYen] |                      null |            shift+alt+[IntlYen] |    NO   |
+|         Ctrl+Shift+Alt+IntlYen |  ---  |                           |     |                      null |       ctrl+shift+alt+[IntlYen] |                      null |       ctrl+shift+alt+[IntlYen] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

lib/vscode/src/vs/workbench/services/keybinding/test/electron-browser/mac_zh_hant.txt

@@ -0,0 +1,507 @@
+isUSStandard: false
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyA |   ㄇ   |                         A |     |                         A |                              a |                         A |                         [KeyA] |         |
+|                      Ctrl+KeyA |   ㄇ   |                    Ctrl+A |     |                    Ctrl+A |                         ctrl+a |                    Ctrl+A |                    ctrl+[KeyA] |         |
+|                     Shift+KeyA |   A   |                   Shift+A |     |                   Shift+A |                        shift+a |                   Shift+A |                   shift+[KeyA] |         |
+|                Ctrl+Shift+KeyA |   A   |              Ctrl+Shift+A |     |              Ctrl+Shift+A |                   ctrl+shift+a |              Ctrl+Shift+A |              ctrl+shift+[KeyA] |         |
+|                       Alt+KeyA |   ㄇ   |                     Alt+A |     |                     Alt+A |                          alt+a |                     Alt+A |                     alt+[KeyA] |         |
+|                  Ctrl+Alt+KeyA |   a   |                Ctrl+Alt+A |     |                Ctrl+Alt+A |                     ctrl+alt+a |                Ctrl+Alt+A |                ctrl+alt+[KeyA] |         |
+|                 Shift+Alt+KeyA |   A   |               Shift+Alt+A |     |               Shift+Alt+A |                    shift+alt+a |               Shift+Alt+A |               shift+alt+[KeyA] |         |
+|            Ctrl+Shift+Alt+KeyA |   A   |          Ctrl+Shift+Alt+A |     |          Ctrl+Shift+Alt+A |               ctrl+shift+alt+a |          Ctrl+Shift+Alt+A |          ctrl+shift+alt+[KeyA] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyB |   ㄖ   |                         B |     |                         B |                              b |                         B |                         [KeyB] |         |
+|                      Ctrl+KeyB |   ㄖ   |                    Ctrl+B |     |                    Ctrl+B |                         ctrl+b |                    Ctrl+B |                    ctrl+[KeyB] |         |
+|                     Shift+KeyB |   B   |                   Shift+B |     |                   Shift+B |                        shift+b |                   Shift+B |                   shift+[KeyB] |         |
+|                Ctrl+Shift+KeyB |   B   |              Ctrl+Shift+B |     |              Ctrl+Shift+B |                   ctrl+shift+b |              Ctrl+Shift+B |              ctrl+shift+[KeyB] |         |
+|                       Alt+KeyB |   ㄖ   |                     Alt+B |     |                     Alt+B |                          alt+b |                     Alt+B |                     alt+[KeyB] |         |
+|                  Ctrl+Alt+KeyB |   b   |                Ctrl+Alt+B |     |                Ctrl+Alt+B |                     ctrl+alt+b |                Ctrl+Alt+B |                ctrl+alt+[KeyB] |         |
+|                 Shift+Alt+KeyB |   B   |               Shift+Alt+B |     |               Shift+Alt+B |                    shift+alt+b |               Shift+Alt+B |               shift+alt+[KeyB] |         |
+|            Ctrl+Shift+Alt+KeyB |   B   |          Ctrl+Shift+Alt+B |     |          Ctrl+Shift+Alt+B |               ctrl+shift+alt+b |          Ctrl+Shift+Alt+B |          ctrl+shift+alt+[KeyB] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyC |   ㄏ   |                         C |     |                         C |                              c |                         C |                         [KeyC] |         |
+|                      Ctrl+KeyC |   ㄏ   |                    Ctrl+C |     |                    Ctrl+C |                         ctrl+c |                    Ctrl+C |                    ctrl+[KeyC] |         |
+|                     Shift+KeyC |   C   |                   Shift+C |     |                   Shift+C |                        shift+c |                   Shift+C |                   shift+[KeyC] |         |
+|                Ctrl+Shift+KeyC |   C   |              Ctrl+Shift+C |     |              Ctrl+Shift+C |                   ctrl+shift+c |              Ctrl+Shift+C |              ctrl+shift+[KeyC] |         |
+|                       Alt+KeyC |   ㄏ   |                     Alt+C |     |                     Alt+C |                          alt+c |                     Alt+C |                     alt+[KeyC] |         |
+|                  Ctrl+Alt+KeyC |   c   |                Ctrl+Alt+C |     |                Ctrl+Alt+C |                     ctrl+alt+c |                Ctrl+Alt+C |                ctrl+alt+[KeyC] |         |
+|                 Shift+Alt+KeyC |   C   |               Shift+Alt+C |     |               Shift+Alt+C |                    shift+alt+c |               Shift+Alt+C |               shift+alt+[KeyC] |         |
+|            Ctrl+Shift+Alt+KeyC |   C   |          Ctrl+Shift+Alt+C |     |          Ctrl+Shift+Alt+C |               ctrl+shift+alt+c |          Ctrl+Shift+Alt+C |          ctrl+shift+alt+[KeyC] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyD |   ㄎ   |                         D |     |                         D |                              d |                         D |                         [KeyD] |         |
+|                      Ctrl+KeyD |   ㄎ   |                    Ctrl+D |     |                    Ctrl+D |                         ctrl+d |                    Ctrl+D |                    ctrl+[KeyD] |         |
+|                     Shift+KeyD |   D   |                   Shift+D |     |                   Shift+D |                        shift+d |                   Shift+D |                   shift+[KeyD] |         |
+|                Ctrl+Shift+KeyD |   D   |              Ctrl+Shift+D |     |              Ctrl+Shift+D |                   ctrl+shift+d |              Ctrl+Shift+D |              ctrl+shift+[KeyD] |         |
+|                       Alt+KeyD |   ㄎ   |                     Alt+D |     |                     Alt+D |                          alt+d |                     Alt+D |                     alt+[KeyD] |         |
+|                  Ctrl+Alt+KeyD |   d   |                Ctrl+Alt+D |     |                Ctrl+Alt+D |                     ctrl+alt+d |                Ctrl+Alt+D |                ctrl+alt+[KeyD] |         |
+|                 Shift+Alt+KeyD |   D   |               Shift+Alt+D |     |               Shift+Alt+D |                    shift+alt+d |               Shift+Alt+D |               shift+alt+[KeyD] |         |
+|            Ctrl+Shift+Alt+KeyD |   D   |          Ctrl+Shift+Alt+D |     |          Ctrl+Shift+Alt+D |               ctrl+shift+alt+d |          Ctrl+Shift+Alt+D |          ctrl+shift+alt+[KeyD] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyE |   ㄍ   |                         E |     |                         E |                              e |                         E |                         [KeyE] |         |
+|                      Ctrl+KeyE |   ㄍ   |                    Ctrl+E |     |                    Ctrl+E |                         ctrl+e |                    Ctrl+E |                    ctrl+[KeyE] |         |
+|                     Shift+KeyE |   E   |                   Shift+E |     |                   Shift+E |                        shift+e |                   Shift+E |                   shift+[KeyE] |         |
+|                Ctrl+Shift+KeyE |   E   |              Ctrl+Shift+E |     |              Ctrl+Shift+E |                   ctrl+shift+e |              Ctrl+Shift+E |              ctrl+shift+[KeyE] |         |
+|                       Alt+KeyE |   ㄍ   |                     Alt+E |     |                     Alt+E |                          alt+e |                     Alt+E |                     alt+[KeyE] |         |
+|                  Ctrl+Alt+KeyE |   e   |                Ctrl+Alt+E |     |                Ctrl+Alt+E |                     ctrl+alt+e |                Ctrl+Alt+E |                ctrl+alt+[KeyE] |         |
+|                 Shift+Alt+KeyE |   E   |               Shift+Alt+E |     |               Shift+Alt+E |                    shift+alt+e |               Shift+Alt+E |               shift+alt+[KeyE] |         |
+|            Ctrl+Shift+Alt+KeyE |   E   |          Ctrl+Shift+Alt+E |     |          Ctrl+Shift+Alt+E |               ctrl+shift+alt+e |          Ctrl+Shift+Alt+E |          ctrl+shift+alt+[KeyE] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyF |   ㄑ   |                         F |     |                         F |                              f |                         F |                         [KeyF] |         |
+|                      Ctrl+KeyF |   ㄑ   |                    Ctrl+F |     |                    Ctrl+F |                         ctrl+f |                    Ctrl+F |                    ctrl+[KeyF] |         |
+|                     Shift+KeyF |   F   |                   Shift+F |     |                   Shift+F |                        shift+f |                   Shift+F |                   shift+[KeyF] |         |
+|                Ctrl+Shift+KeyF |   F   |              Ctrl+Shift+F |     |              Ctrl+Shift+F |                   ctrl+shift+f |              Ctrl+Shift+F |              ctrl+shift+[KeyF] |         |
+|                       Alt+KeyF |   ㄑ   |                     Alt+F |     |                     Alt+F |                          alt+f |                     Alt+F |                     alt+[KeyF] |         |
+|                  Ctrl+Alt+KeyF |   f   |                Ctrl+Alt+F |     |                Ctrl+Alt+F |                     ctrl+alt+f |                Ctrl+Alt+F |                ctrl+alt+[KeyF] |         |
+|                 Shift+Alt+KeyF |   F   |               Shift+Alt+F |     |               Shift+Alt+F |                    shift+alt+f |               Shift+Alt+F |               shift+alt+[KeyF] |         |
+|            Ctrl+Shift+Alt+KeyF |   F   |          Ctrl+Shift+Alt+F |     |          Ctrl+Shift+Alt+F |               ctrl+shift+alt+f |          Ctrl+Shift+Alt+F |          ctrl+shift+alt+[KeyF] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyG |   ㄕ   |                         G |     |                         G |                              g |                         G |                         [KeyG] |         |
+|                      Ctrl+KeyG |   ㄕ   |                    Ctrl+G |     |                    Ctrl+G |                         ctrl+g |                    Ctrl+G |                    ctrl+[KeyG] |         |
+|                     Shift+KeyG |   G   |                   Shift+G |     |                   Shift+G |                        shift+g |                   Shift+G |                   shift+[KeyG] |         |
+|                Ctrl+Shift+KeyG |   G   |              Ctrl+Shift+G |     |              Ctrl+Shift+G |                   ctrl+shift+g |              Ctrl+Shift+G |              ctrl+shift+[KeyG] |         |
+|                       Alt+KeyG |   ㄕ   |                     Alt+G |     |                     Alt+G |                          alt+g |                     Alt+G |                     alt+[KeyG] |         |
+|                  Ctrl+Alt+KeyG |   g   |                Ctrl+Alt+G |     |                Ctrl+Alt+G |                     ctrl+alt+g |                Ctrl+Alt+G |                ctrl+alt+[KeyG] |         |
+|                 Shift+Alt+KeyG |   G   |               Shift+Alt+G |     |               Shift+Alt+G |                    shift+alt+g |               Shift+Alt+G |               shift+alt+[KeyG] |         |
+|            Ctrl+Shift+Alt+KeyG |   G   |          Ctrl+Shift+Alt+G |     |          Ctrl+Shift+Alt+G |               ctrl+shift+alt+g |          Ctrl+Shift+Alt+G |          ctrl+shift+alt+[KeyG] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyH |   ㄘ   |                         H |     |                         H |                              h |                         H |                         [KeyH] |         |
+|                      Ctrl+KeyH |   ㄘ   |                    Ctrl+H |     |                    Ctrl+H |                         ctrl+h |                    Ctrl+H |                    ctrl+[KeyH] |         |
+|                     Shift+KeyH |   H   |                   Shift+H |     |                   Shift+H |                        shift+h |                   Shift+H |                   shift+[KeyH] |         |
+|                Ctrl+Shift+KeyH |   H   |              Ctrl+Shift+H |     |              Ctrl+Shift+H |                   ctrl+shift+h |              Ctrl+Shift+H |              ctrl+shift+[KeyH] |         |
+|                       Alt+KeyH |   ㄘ   |                     Alt+H |     |                     Alt+H |                          alt+h |                     Alt+H |                     alt+[KeyH] |         |
+|                  Ctrl+Alt+KeyH |   h   |                Ctrl+Alt+H |     |                Ctrl+Alt+H |                     ctrl+alt+h |                Ctrl+Alt+H |                ctrl+alt+[KeyH] |         |
+|                 Shift+Alt+KeyH |   H   |               Shift+Alt+H |     |               Shift+Alt+H |                    shift+alt+h |               Shift+Alt+H |               shift+alt+[KeyH] |         |
+|            Ctrl+Shift+Alt+KeyH |   H   |          Ctrl+Shift+Alt+H |     |          Ctrl+Shift+Alt+H |               ctrl+shift+alt+h |          Ctrl+Shift+Alt+H |          ctrl+shift+alt+[KeyH] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyI |   ㄛ   |                         I |     |                         I |                              i |                         I |                         [KeyI] |         |
+|                      Ctrl+KeyI |   ㄛ   |                    Ctrl+I |     |                    Ctrl+I |                         ctrl+i |                    Ctrl+I |                    ctrl+[KeyI] |         |
+|                     Shift+KeyI |   I   |                   Shift+I |     |                   Shift+I |                        shift+i |                   Shift+I |                   shift+[KeyI] |         |
+|                Ctrl+Shift+KeyI |   I   |              Ctrl+Shift+I |     |              Ctrl+Shift+I |                   ctrl+shift+i |              Ctrl+Shift+I |              ctrl+shift+[KeyI] |         |
+|                       Alt+KeyI |   ㄛ   |                     Alt+I |     |                     Alt+I |                          alt+i |                     Alt+I |                     alt+[KeyI] |         |
+|                  Ctrl+Alt+KeyI |   i   |                Ctrl+Alt+I |     |                Ctrl+Alt+I |                     ctrl+alt+i |                Ctrl+Alt+I |                ctrl+alt+[KeyI] |         |
+|                 Shift+Alt+KeyI |   I   |               Shift+Alt+I |     |               Shift+Alt+I |                    shift+alt+i |               Shift+Alt+I |               shift+alt+[KeyI] |         |
+|            Ctrl+Shift+Alt+KeyI |   I   |          Ctrl+Shift+Alt+I |     |          Ctrl+Shift+Alt+I |               ctrl+shift+alt+i |          Ctrl+Shift+Alt+I |          ctrl+shift+alt+[KeyI] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyJ |   ㄨ   |                         J |     |                         J |                              j |                         J |                         [KeyJ] |         |
+|                      Ctrl+KeyJ |   ㄨ   |                    Ctrl+J |     |                    Ctrl+J |                         ctrl+j |                    Ctrl+J |                    ctrl+[KeyJ] |         |
+|                     Shift+KeyJ |   J   |                   Shift+J |     |                   Shift+J |                        shift+j |                   Shift+J |                   shift+[KeyJ] |         |
+|                Ctrl+Shift+KeyJ |   J   |              Ctrl+Shift+J |     |              Ctrl+Shift+J |                   ctrl+shift+j |              Ctrl+Shift+J |              ctrl+shift+[KeyJ] |         |
+|                       Alt+KeyJ |   ㄨ   |                     Alt+J |     |                     Alt+J |                          alt+j |                     Alt+J |                     alt+[KeyJ] |         |
+|                  Ctrl+Alt+KeyJ |   j   |                Ctrl+Alt+J |     |                Ctrl+Alt+J |                     ctrl+alt+j |                Ctrl+Alt+J |                ctrl+alt+[KeyJ] |         |
+|                 Shift+Alt+KeyJ |   J   |               Shift+Alt+J |     |               Shift+Alt+J |                    shift+alt+j |               Shift+Alt+J |               shift+alt+[KeyJ] |         |
+|            Ctrl+Shift+Alt+KeyJ |   J   |          Ctrl+Shift+Alt+J |     |          Ctrl+Shift+Alt+J |               ctrl+shift+alt+j |          Ctrl+Shift+Alt+J |          ctrl+shift+alt+[KeyJ] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyK |   ㄜ   |                         K |     |                         K |                              k |                         K |                         [KeyK] |         |
+|                      Ctrl+KeyK |   ㄜ   |                    Ctrl+K |     |                    Ctrl+K |                         ctrl+k |                    Ctrl+K |                    ctrl+[KeyK] |         |
+|                     Shift+KeyK |   K   |                   Shift+K |     |                   Shift+K |                        shift+k |                   Shift+K |                   shift+[KeyK] |         |
+|                Ctrl+Shift+KeyK |   K   |              Ctrl+Shift+K |     |              Ctrl+Shift+K |                   ctrl+shift+k |              Ctrl+Shift+K |              ctrl+shift+[KeyK] |         |
+|                       Alt+KeyK |   ㄜ   |                     Alt+K |     |                     Alt+K |                          alt+k |                     Alt+K |                     alt+[KeyK] |         |
+|                  Ctrl+Alt+KeyK |   k   |                Ctrl+Alt+K |     |                Ctrl+Alt+K |                     ctrl+alt+k |                Ctrl+Alt+K |                ctrl+alt+[KeyK] |         |
+|                 Shift+Alt+KeyK |   K   |               Shift+Alt+K |     |               Shift+Alt+K |                    shift+alt+k |               Shift+Alt+K |               shift+alt+[KeyK] |         |
+|            Ctrl+Shift+Alt+KeyK |   K   |          Ctrl+Shift+Alt+K |     |          Ctrl+Shift+Alt+K |               ctrl+shift+alt+k |          Ctrl+Shift+Alt+K |          ctrl+shift+alt+[KeyK] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyL |   ㄠ   |                         L |     |                         L |                              l |                         L |                         [KeyL] |         |
+|                      Ctrl+KeyL |   ㄠ   |                    Ctrl+L |     |                    Ctrl+L |                         ctrl+l |                    Ctrl+L |                    ctrl+[KeyL] |         |
+|                     Shift+KeyL |   L   |                   Shift+L |     |                   Shift+L |                        shift+l |                   Shift+L |                   shift+[KeyL] |         |
+|                Ctrl+Shift+KeyL |   L   |              Ctrl+Shift+L |     |              Ctrl+Shift+L |                   ctrl+shift+l |              Ctrl+Shift+L |              ctrl+shift+[KeyL] |         |
+|                       Alt+KeyL |   ㄠ   |                     Alt+L |     |                     Alt+L |                          alt+l |                     Alt+L |                     alt+[KeyL] |         |
+|                  Ctrl+Alt+KeyL |   l   |                Ctrl+Alt+L |     |                Ctrl+Alt+L |                     ctrl+alt+l |                Ctrl+Alt+L |                ctrl+alt+[KeyL] |         |
+|                 Shift+Alt+KeyL |   L   |               Shift+Alt+L |     |               Shift+Alt+L |                    shift+alt+l |               Shift+Alt+L |               shift+alt+[KeyL] |         |
+|            Ctrl+Shift+Alt+KeyL |   L   |          Ctrl+Shift+Alt+L |     |          Ctrl+Shift+Alt+L |               ctrl+shift+alt+l |          Ctrl+Shift+Alt+L |          ctrl+shift+alt+[KeyL] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyM |   ㄩ   |                         M |     |                         M |                              m |                         M |                         [KeyM] |         |
+|                      Ctrl+KeyM |   ㄩ   |                    Ctrl+M |     |                    Ctrl+M |                         ctrl+m |                    Ctrl+M |                    ctrl+[KeyM] |         |
+|                     Shift+KeyM |   M   |                   Shift+M |     |                   Shift+M |                        shift+m |                   Shift+M |                   shift+[KeyM] |         |
+|                Ctrl+Shift+KeyM |   M   |              Ctrl+Shift+M |     |              Ctrl+Shift+M |                   ctrl+shift+m |              Ctrl+Shift+M |              ctrl+shift+[KeyM] |         |
+|                       Alt+KeyM |   ㄩ   |                     Alt+M |     |                     Alt+M |                          alt+m |                     Alt+M |                     alt+[KeyM] |         |
+|                  Ctrl+Alt+KeyM |   m   |                Ctrl+Alt+M |     |                Ctrl+Alt+M |                     ctrl+alt+m |                Ctrl+Alt+M |                ctrl+alt+[KeyM] |         |
+|                 Shift+Alt+KeyM |   M   |               Shift+Alt+M |     |               Shift+Alt+M |                    shift+alt+m |               Shift+Alt+M |               shift+alt+[KeyM] |         |
+|            Ctrl+Shift+Alt+KeyM |   M   |          Ctrl+Shift+Alt+M |     |          Ctrl+Shift+Alt+M |               ctrl+shift+alt+m |          Ctrl+Shift+Alt+M |          ctrl+shift+alt+[KeyM] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyN |   ㄙ   |                         N |     |                         N |                              n |                         N |                         [KeyN] |         |
+|                      Ctrl+KeyN |   ㄙ   |                    Ctrl+N |     |                    Ctrl+N |                         ctrl+n |                    Ctrl+N |                    ctrl+[KeyN] |         |
+|                     Shift+KeyN |   N   |                   Shift+N |     |                   Shift+N |                        shift+n |                   Shift+N |                   shift+[KeyN] |         |
+|                Ctrl+Shift+KeyN |   N   |              Ctrl+Shift+N |     |              Ctrl+Shift+N |                   ctrl+shift+n |              Ctrl+Shift+N |              ctrl+shift+[KeyN] |         |
+|                       Alt+KeyN |   ㄙ   |                     Alt+N |     |                     Alt+N |                          alt+n |                     Alt+N |                     alt+[KeyN] |         |
+|                  Ctrl+Alt+KeyN |   n   |                Ctrl+Alt+N |     |                Ctrl+Alt+N |                     ctrl+alt+n |                Ctrl+Alt+N |                ctrl+alt+[KeyN] |         |
+|                 Shift+Alt+KeyN |   N   |               Shift+Alt+N |     |               Shift+Alt+N |                    shift+alt+n |               Shift+Alt+N |               shift+alt+[KeyN] |         |
+|            Ctrl+Shift+Alt+KeyN |   N   |          Ctrl+Shift+Alt+N |     |          Ctrl+Shift+Alt+N |               ctrl+shift+alt+n |          Ctrl+Shift+Alt+N |          ctrl+shift+alt+[KeyN] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyO |   ㄟ   |                         O |     |                         O |                              o |                         O |                         [KeyO] |         |
+|                      Ctrl+KeyO |   ㄟ   |                    Ctrl+O |     |                    Ctrl+O |                         ctrl+o |                    Ctrl+O |                    ctrl+[KeyO] |         |
+|                     Shift+KeyO |   O   |                   Shift+O |     |                   Shift+O |                        shift+o |                   Shift+O |                   shift+[KeyO] |         |
+|                Ctrl+Shift+KeyO |   O   |              Ctrl+Shift+O |     |              Ctrl+Shift+O |                   ctrl+shift+o |              Ctrl+Shift+O |              ctrl+shift+[KeyO] |         |
+|                       Alt+KeyO |   ㄟ   |                     Alt+O |     |                     Alt+O |                          alt+o |                     Alt+O |                     alt+[KeyO] |         |
+|                  Ctrl+Alt+KeyO |   o   |                Ctrl+Alt+O |     |                Ctrl+Alt+O |                     ctrl+alt+o |                Ctrl+Alt+O |                ctrl+alt+[KeyO] |         |
+|                 Shift+Alt+KeyO |   O   |               Shift+Alt+O |     |               Shift+Alt+O |                    shift+alt+o |               Shift+Alt+O |               shift+alt+[KeyO] |         |
+|            Ctrl+Shift+Alt+KeyO |   O   |          Ctrl+Shift+Alt+O |     |          Ctrl+Shift+Alt+O |               ctrl+shift+alt+o |          Ctrl+Shift+Alt+O |          ctrl+shift+alt+[KeyO] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyP |   ㄣ   |                         P |     |                         P |                              p |                         P |                         [KeyP] |         |
+|                      Ctrl+KeyP |   ㄣ   |                    Ctrl+P |     |                    Ctrl+P |                         ctrl+p |                    Ctrl+P |                    ctrl+[KeyP] |         |
+|                     Shift+KeyP |   P   |                   Shift+P |     |                   Shift+P |                        shift+p |                   Shift+P |                   shift+[KeyP] |         |
+|                Ctrl+Shift+KeyP |   P   |              Ctrl+Shift+P |     |              Ctrl+Shift+P |                   ctrl+shift+p |              Ctrl+Shift+P |              ctrl+shift+[KeyP] |         |
+|                       Alt+KeyP |   ㄣ   |                     Alt+P |     |                     Alt+P |                          alt+p |                     Alt+P |                     alt+[KeyP] |         |
+|                  Ctrl+Alt+KeyP |   p   |                Ctrl+Alt+P |     |                Ctrl+Alt+P |                     ctrl+alt+p |                Ctrl+Alt+P |                ctrl+alt+[KeyP] |         |
+|                 Shift+Alt+KeyP |   P   |               Shift+Alt+P |     |               Shift+Alt+P |                    shift+alt+p |               Shift+Alt+P |               shift+alt+[KeyP] |         |
+|            Ctrl+Shift+Alt+KeyP |   P   |          Ctrl+Shift+Alt+P |     |          Ctrl+Shift+Alt+P |               ctrl+shift+alt+p |          Ctrl+Shift+Alt+P |          ctrl+shift+alt+[KeyP] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyQ |   ㄆ   |                         Q |     |                         Q |                              q |                         Q |                         [KeyQ] |         |
+|                      Ctrl+KeyQ |   ㄆ   |                    Ctrl+Q |     |                    Ctrl+Q |                         ctrl+q |                    Ctrl+Q |                    ctrl+[KeyQ] |         |
+|                     Shift+KeyQ |   Q   |                   Shift+Q |     |                   Shift+Q |                        shift+q |                   Shift+Q |                   shift+[KeyQ] |         |
+|                Ctrl+Shift+KeyQ |   Q   |              Ctrl+Shift+Q |     |              Ctrl+Shift+Q |                   ctrl+shift+q |              Ctrl+Shift+Q |              ctrl+shift+[KeyQ] |         |
+|                       Alt+KeyQ |   ㄆ   |                     Alt+Q |     |                     Alt+Q |                          alt+q |                     Alt+Q |                     alt+[KeyQ] |         |
+|                  Ctrl+Alt+KeyQ |   q   |                Ctrl+Alt+Q |     |                Ctrl+Alt+Q |                     ctrl+alt+q |                Ctrl+Alt+Q |                ctrl+alt+[KeyQ] |         |
+|                 Shift+Alt+KeyQ |   Q   |               Shift+Alt+Q |     |               Shift+Alt+Q |                    shift+alt+q |               Shift+Alt+Q |               shift+alt+[KeyQ] |         |
+|            Ctrl+Shift+Alt+KeyQ |   Q   |          Ctrl+Shift+Alt+Q |     |          Ctrl+Shift+Alt+Q |               ctrl+shift+alt+q |          Ctrl+Shift+Alt+Q |          ctrl+shift+alt+[KeyQ] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyR |   ㄐ   |                         R |     |                         R |                              r |                         R |                         [KeyR] |         |
+|                      Ctrl+KeyR |   ㄐ   |                    Ctrl+R |     |                    Ctrl+R |                         ctrl+r |                    Ctrl+R |                    ctrl+[KeyR] |         |
+|                     Shift+KeyR |   R   |                   Shift+R |     |                   Shift+R |                        shift+r |                   Shift+R |                   shift+[KeyR] |         |
+|                Ctrl+Shift+KeyR |   R   |              Ctrl+Shift+R |     |              Ctrl+Shift+R |                   ctrl+shift+r |              Ctrl+Shift+R |              ctrl+shift+[KeyR] |         |
+|                       Alt+KeyR |   ㄐ   |                     Alt+R |     |                     Alt+R |                          alt+r |                     Alt+R |                     alt+[KeyR] |         |
+|                  Ctrl+Alt+KeyR |   r   |                Ctrl+Alt+R |     |                Ctrl+Alt+R |                     ctrl+alt+r |                Ctrl+Alt+R |                ctrl+alt+[KeyR] |         |
+|                 Shift+Alt+KeyR |   R   |               Shift+Alt+R |     |               Shift+Alt+R |                    shift+alt+r |               Shift+Alt+R |               shift+alt+[KeyR] |         |
+|            Ctrl+Shift+Alt+KeyR |   R   |          Ctrl+Shift+Alt+R |     |          Ctrl+Shift+Alt+R |               ctrl+shift+alt+r |          Ctrl+Shift+Alt+R |          ctrl+shift+alt+[KeyR] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyS |   ㄋ   |                         S |     |                         S |                              s |                         S |                         [KeyS] |         |
+|                      Ctrl+KeyS |   ㄋ   |                    Ctrl+S |     |                    Ctrl+S |                         ctrl+s |                    Ctrl+S |                    ctrl+[KeyS] |         |
+|                     Shift+KeyS |   S   |                   Shift+S |     |                   Shift+S |                        shift+s |                   Shift+S |                   shift+[KeyS] |         |
+|                Ctrl+Shift+KeyS |   S   |              Ctrl+Shift+S |     |              Ctrl+Shift+S |                   ctrl+shift+s |              Ctrl+Shift+S |              ctrl+shift+[KeyS] |         |
+|                       Alt+KeyS |   ㄋ   |                     Alt+S |     |                     Alt+S |                          alt+s |                     Alt+S |                     alt+[KeyS] |         |
+|                  Ctrl+Alt+KeyS |   s   |                Ctrl+Alt+S |     |                Ctrl+Alt+S |                     ctrl+alt+s |                Ctrl+Alt+S |                ctrl+alt+[KeyS] |         |
+|                 Shift+Alt+KeyS |   S   |               Shift+Alt+S |     |               Shift+Alt+S |                    shift+alt+s |               Shift+Alt+S |               shift+alt+[KeyS] |         |
+|            Ctrl+Shift+Alt+KeyS |   S   |          Ctrl+Shift+Alt+S |     |          Ctrl+Shift+Alt+S |               ctrl+shift+alt+s |          Ctrl+Shift+Alt+S |          ctrl+shift+alt+[KeyS] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyT |   ㄔ   |                         T |     |                         T |                              t |                         T |                         [KeyT] |         |
+|                      Ctrl+KeyT |   ㄔ   |                    Ctrl+T |     |                    Ctrl+T |                         ctrl+t |                    Ctrl+T |                    ctrl+[KeyT] |         |
+|                     Shift+KeyT |   T   |                   Shift+T |     |                   Shift+T |                        shift+t |                   Shift+T |                   shift+[KeyT] |         |
+|                Ctrl+Shift+KeyT |   T   |              Ctrl+Shift+T |     |              Ctrl+Shift+T |                   ctrl+shift+t |              Ctrl+Shift+T |              ctrl+shift+[KeyT] |         |
+|                       Alt+KeyT |   ㄔ   |                     Alt+T |     |                     Alt+T |                          alt+t |                     Alt+T |                     alt+[KeyT] |         |
+|                  Ctrl+Alt+KeyT |   t   |                Ctrl+Alt+T |     |                Ctrl+Alt+T |                     ctrl+alt+t |                Ctrl+Alt+T |                ctrl+alt+[KeyT] |         |
+|                 Shift+Alt+KeyT |   T   |               Shift+Alt+T |     |               Shift+Alt+T |                    shift+alt+t |               Shift+Alt+T |               shift+alt+[KeyT] |         |
+|            Ctrl+Shift+Alt+KeyT |   T   |          Ctrl+Shift+Alt+T |     |          Ctrl+Shift+Alt+T |               ctrl+shift+alt+t |          Ctrl+Shift+Alt+T |          ctrl+shift+alt+[KeyT] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyU |   ㄧ   |                         U |     |                         U |                              u |                         U |                         [KeyU] |         |
+|                      Ctrl+KeyU |   ㄧ   |                    Ctrl+U |     |                    Ctrl+U |                         ctrl+u |                    Ctrl+U |                    ctrl+[KeyU] |         |
+|                     Shift+KeyU |   U   |                   Shift+U |     |                   Shift+U |                        shift+u |                   Shift+U |                   shift+[KeyU] |         |
+|                Ctrl+Shift+KeyU |   U   |              Ctrl+Shift+U |     |              Ctrl+Shift+U |                   ctrl+shift+u |              Ctrl+Shift+U |              ctrl+shift+[KeyU] |         |
+|                       Alt+KeyU |   ㄧ   |                     Alt+U |     |                     Alt+U |                          alt+u |                     Alt+U |                     alt+[KeyU] |         |
+|                  Ctrl+Alt+KeyU |   u   |                Ctrl+Alt+U |     |                Ctrl+Alt+U |                     ctrl+alt+u |                Ctrl+Alt+U |                ctrl+alt+[KeyU] |         |
+|                 Shift+Alt+KeyU |   U   |               Shift+Alt+U |     |               Shift+Alt+U |                    shift+alt+u |               Shift+Alt+U |               shift+alt+[KeyU] |         |
+|            Ctrl+Shift+Alt+KeyU |   U   |          Ctrl+Shift+Alt+U |     |          Ctrl+Shift+Alt+U |               ctrl+shift+alt+u |          Ctrl+Shift+Alt+U |          ctrl+shift+alt+[KeyU] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyV |   ㄒ   |                         V |     |                         V |                              v |                         V |                         [KeyV] |         |
+|                      Ctrl+KeyV |   ㄒ   |                    Ctrl+V |     |                    Ctrl+V |                         ctrl+v |                    Ctrl+V |                    ctrl+[KeyV] |         |
+|                     Shift+KeyV |   V   |                   Shift+V |     |                   Shift+V |                        shift+v |                   Shift+V |                   shift+[KeyV] |         |
+|                Ctrl+Shift+KeyV |   V   |              Ctrl+Shift+V |     |              Ctrl+Shift+V |                   ctrl+shift+v |              Ctrl+Shift+V |              ctrl+shift+[KeyV] |         |
+|                       Alt+KeyV |   ㄒ   |                     Alt+V |     |                     Alt+V |                          alt+v |                     Alt+V |                     alt+[KeyV] |         |
+|                  Ctrl+Alt+KeyV |   v   |                Ctrl+Alt+V |     |                Ctrl+Alt+V |                     ctrl+alt+v |                Ctrl+Alt+V |                ctrl+alt+[KeyV] |         |
+|                 Shift+Alt+KeyV |   V   |               Shift+Alt+V |     |               Shift+Alt+V |                    shift+alt+v |               Shift+Alt+V |               shift+alt+[KeyV] |         |
+|            Ctrl+Shift+Alt+KeyV |   V   |          Ctrl+Shift+Alt+V |     |          Ctrl+Shift+Alt+V |               ctrl+shift+alt+v |          Ctrl+Shift+Alt+V |          ctrl+shift+alt+[KeyV] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyW |   ㄊ   |                         W |     |                         W |                              w |                         W |                         [KeyW] |         |
+|                      Ctrl+KeyW |   ㄊ   |                    Ctrl+W |     |                    Ctrl+W |                         ctrl+w |                    Ctrl+W |                    ctrl+[KeyW] |         |
+|                     Shift+KeyW |   W   |                   Shift+W |     |                   Shift+W |                        shift+w |                   Shift+W |                   shift+[KeyW] |         |
+|                Ctrl+Shift+KeyW |   W   |              Ctrl+Shift+W |     |              Ctrl+Shift+W |                   ctrl+shift+w |              Ctrl+Shift+W |              ctrl+shift+[KeyW] |         |
+|                       Alt+KeyW |   ㄊ   |                     Alt+W |     |                     Alt+W |                          alt+w |                     Alt+W |                     alt+[KeyW] |         |
+|                  Ctrl+Alt+KeyW |   w   |                Ctrl+Alt+W |     |                Ctrl+Alt+W |                     ctrl+alt+w |                Ctrl+Alt+W |                ctrl+alt+[KeyW] |         |
+|                 Shift+Alt+KeyW |   W   |               Shift+Alt+W |     |               Shift+Alt+W |                    shift+alt+w |               Shift+Alt+W |               shift+alt+[KeyW] |         |
+|            Ctrl+Shift+Alt+KeyW |   W   |          Ctrl+Shift+Alt+W |     |          Ctrl+Shift+Alt+W |               ctrl+shift+alt+w |          Ctrl+Shift+Alt+W |          ctrl+shift+alt+[KeyW] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyX |   ㄌ   |                         X |     |                         X |                              x |                         X |                         [KeyX] |         |
+|                      Ctrl+KeyX |   ㄌ   |                    Ctrl+X |     |                    Ctrl+X |                         ctrl+x |                    Ctrl+X |                    ctrl+[KeyX] |         |
+|                     Shift+KeyX |   X   |                   Shift+X |     |                   Shift+X |                        shift+x |                   Shift+X |                   shift+[KeyX] |         |
+|                Ctrl+Shift+KeyX |   X   |              Ctrl+Shift+X |     |              Ctrl+Shift+X |                   ctrl+shift+x |              Ctrl+Shift+X |              ctrl+shift+[KeyX] |         |
+|                       Alt+KeyX |   ㄌ   |                     Alt+X |     |                     Alt+X |                          alt+x |                     Alt+X |                     alt+[KeyX] |         |
+|                  Ctrl+Alt+KeyX |   x   |                Ctrl+Alt+X |     |                Ctrl+Alt+X |                     ctrl+alt+x |                Ctrl+Alt+X |                ctrl+alt+[KeyX] |         |
+|                 Shift+Alt+KeyX |   X   |               Shift+Alt+X |     |               Shift+Alt+X |                    shift+alt+x |               Shift+Alt+X |               shift+alt+[KeyX] |         |
+|            Ctrl+Shift+Alt+KeyX |   X   |          Ctrl+Shift+Alt+X |     |          Ctrl+Shift+Alt+X |               ctrl+shift+alt+x |          Ctrl+Shift+Alt+X |          ctrl+shift+alt+[KeyX] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyY |   ㄗ   |                         Y |     |                         Y |                              y |                         Y |                         [KeyY] |         |
+|                      Ctrl+KeyY |   ㄗ   |                    Ctrl+Y |     |                    Ctrl+Y |                         ctrl+y |                    Ctrl+Y |                    ctrl+[KeyY] |         |
+|                     Shift+KeyY |   Y   |                   Shift+Y |     |                   Shift+Y |                        shift+y |                   Shift+Y |                   shift+[KeyY] |         |
+|                Ctrl+Shift+KeyY |   Y   |              Ctrl+Shift+Y |     |              Ctrl+Shift+Y |                   ctrl+shift+y |              Ctrl+Shift+Y |              ctrl+shift+[KeyY] |         |
+|                       Alt+KeyY |   ㄗ   |                     Alt+Y |     |                     Alt+Y |                          alt+y |                     Alt+Y |                     alt+[KeyY] |         |
+|                  Ctrl+Alt+KeyY |   y   |                Ctrl+Alt+Y |     |                Ctrl+Alt+Y |                     ctrl+alt+y |                Ctrl+Alt+Y |                ctrl+alt+[KeyY] |         |
+|                 Shift+Alt+KeyY |   Y   |               Shift+Alt+Y |     |               Shift+Alt+Y |                    shift+alt+y |               Shift+Alt+Y |               shift+alt+[KeyY] |         |
+|            Ctrl+Shift+Alt+KeyY |   Y   |          Ctrl+Shift+Alt+Y |     |          Ctrl+Shift+Alt+Y |               ctrl+shift+alt+y |          Ctrl+Shift+Alt+Y |          ctrl+shift+alt+[KeyY] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyZ |   ㄈ   |                         Z |     |                         Z |                              z |                         Z |                         [KeyZ] |         |
+|                      Ctrl+KeyZ |   ㄈ   |                    Ctrl+Z |     |                    Ctrl+Z |                         ctrl+z |                    Ctrl+Z |                    ctrl+[KeyZ] |         |
+|                     Shift+KeyZ |   Z   |                   Shift+Z |     |                   Shift+Z |                        shift+z |                   Shift+Z |                   shift+[KeyZ] |         |
+|                Ctrl+Shift+KeyZ |   Z   |              Ctrl+Shift+Z |     |              Ctrl+Shift+Z |                   ctrl+shift+z |              Ctrl+Shift+Z |              ctrl+shift+[KeyZ] |         |
+|                       Alt+KeyZ |   ㄈ   |                     Alt+Z |     |                     Alt+Z |                          alt+z |                     Alt+Z |                     alt+[KeyZ] |         |
+|                  Ctrl+Alt+KeyZ |   z   |                Ctrl+Alt+Z |     |                Ctrl+Alt+Z |                     ctrl+alt+z |                Ctrl+Alt+Z |                ctrl+alt+[KeyZ] |         |
+|                 Shift+Alt+KeyZ |   Z   |               Shift+Alt+Z |     |               Shift+Alt+Z |                    shift+alt+z |               Shift+Alt+Z |               shift+alt+[KeyZ] |         |
+|            Ctrl+Shift+Alt+KeyZ |   Z   |          Ctrl+Shift+Alt+Z |     |          Ctrl+Shift+Alt+Z |               ctrl+shift+alt+z |          Ctrl+Shift+Alt+Z |          ctrl+shift+alt+[KeyZ] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit1 |   ㄅ   |                         1 |     |                         ㄅ |                              1 |                         1 |                       [Digit1] |    NO   |
+|                    Ctrl+Digit1 |   ㄅ   |                    Ctrl+1 |     |                    Ctrl+ㄅ |                         ctrl+1 |                    Ctrl+1 |                  ctrl+[Digit1] |    NO   |
+|                   Shift+Digit1 |   !   |                   Shift+1 |     |                   Shift+ㄅ |                        shift+1 |                   Shift+1 |                 shift+[Digit1] |    NO   |
+|              Ctrl+Shift+Digit1 |   !   |              Ctrl+Shift+1 |     |              Ctrl+Shift+ㄅ |                   ctrl+shift+1 |              Ctrl+Shift+1 |            ctrl+shift+[Digit1] |    NO   |
+|                     Alt+Digit1 |   ㄅ   |                     Alt+1 |     |                     Alt+ㄅ |                          alt+1 |                     Alt+1 |                   alt+[Digit1] |    NO   |
+|                Ctrl+Alt+Digit1 |   1   |                Ctrl+Alt+1 |     |                Ctrl+Alt+ㄅ |                     ctrl+alt+1 |                Ctrl+Alt+1 |              ctrl+alt+[Digit1] |    NO   |
+|               Shift+Alt+Digit1 |   !   |               Shift+Alt+1 |     |               Shift+Alt+ㄅ |                    shift+alt+1 |               Shift+Alt+1 |             shift+alt+[Digit1] |    NO   |
+|          Ctrl+Shift+Alt+Digit1 |   !   |          Ctrl+Shift+Alt+1 |     |          Ctrl+Shift+Alt+ㄅ |               ctrl+shift+alt+1 |          Ctrl+Shift+Alt+1 |        ctrl+shift+alt+[Digit1] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit2 |   ㄉ   |                         2 |     |                         ㄉ |                              2 |                         2 |                       [Digit2] |    NO   |
+|                    Ctrl+Digit2 |   ㄉ   |                    Ctrl+2 |     |                    Ctrl+ㄉ |                         ctrl+2 |                    Ctrl+2 |                  ctrl+[Digit2] |    NO   |
+|                   Shift+Digit2 |   @   |                   Shift+2 |     |                   Shift+ㄉ |                        shift+2 |                   Shift+2 |                 shift+[Digit2] |    NO   |
+|              Ctrl+Shift+Digit2 |   @   |              Ctrl+Shift+2 |     |              Ctrl+Shift+ㄉ |                   ctrl+shift+2 |              Ctrl+Shift+2 |            ctrl+shift+[Digit2] |    NO   |
+|                     Alt+Digit2 |   ㄉ   |                     Alt+2 |     |                     Alt+ㄉ |                          alt+2 |                     Alt+2 |                   alt+[Digit2] |    NO   |
+|                Ctrl+Alt+Digit2 |   2   |                Ctrl+Alt+2 |     |                Ctrl+Alt+ㄉ |                     ctrl+alt+2 |                Ctrl+Alt+2 |              ctrl+alt+[Digit2] |    NO   |
+|               Shift+Alt+Digit2 |   @   |               Shift+Alt+2 |     |               Shift+Alt+ㄉ |                    shift+alt+2 |               Shift+Alt+2 |             shift+alt+[Digit2] |    NO   |
+|          Ctrl+Shift+Alt+Digit2 |   @   |          Ctrl+Shift+Alt+2 |     |          Ctrl+Shift+Alt+ㄉ |               ctrl+shift+alt+2 |          Ctrl+Shift+Alt+2 |        ctrl+shift+alt+[Digit2] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit3 |   ˇ   |                         3 |     |                         ˇ |                              3 |                         3 |                       [Digit3] |    NO   |
+|                    Ctrl+Digit3 |   ˇ   |                    Ctrl+3 |     |                    Ctrl+ˇ |                         ctrl+3 |                    Ctrl+3 |                  ctrl+[Digit3] |    NO   |
+|                   Shift+Digit3 |   #   |                   Shift+3 |     |                   Shift+ˇ |                        shift+3 |                   Shift+3 |                 shift+[Digit3] |    NO   |
+|              Ctrl+Shift+Digit3 |   #   |              Ctrl+Shift+3 |     |              Ctrl+Shift+ˇ |                   ctrl+shift+3 |              Ctrl+Shift+3 |            ctrl+shift+[Digit3] |    NO   |
+|                     Alt+Digit3 |   ˇ   |                     Alt+3 |     |                     Alt+ˇ |                          alt+3 |                     Alt+3 |                   alt+[Digit3] |    NO   |
+|                Ctrl+Alt+Digit3 |   3   |                Ctrl+Alt+3 |     |                Ctrl+Alt+ˇ |                     ctrl+alt+3 |                Ctrl+Alt+3 |              ctrl+alt+[Digit3] |    NO   |
+|               Shift+Alt+Digit3 |   #   |               Shift+Alt+3 |     |               Shift+Alt+ˇ |                    shift+alt+3 |               Shift+Alt+3 |             shift+alt+[Digit3] |    NO   |
+|          Ctrl+Shift+Alt+Digit3 |   #   |          Ctrl+Shift+Alt+3 |     |          Ctrl+Shift+Alt+ˇ |               ctrl+shift+alt+3 |          Ctrl+Shift+Alt+3 |        ctrl+shift+alt+[Digit3] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit4 |   ˋ   |                         4 |     |                         ˋ |                              4 |                         4 |                       [Digit4] |    NO   |
+|                    Ctrl+Digit4 |   ˋ   |                    Ctrl+4 |     |                    Ctrl+ˋ |                         ctrl+4 |                    Ctrl+4 |                  ctrl+[Digit4] |    NO   |
+|                   Shift+Digit4 |   $   |                   Shift+4 |     |                   Shift+ˋ |                        shift+4 |                   Shift+4 |                 shift+[Digit4] |    NO   |
+|              Ctrl+Shift+Digit4 |   $   |              Ctrl+Shift+4 |     |              Ctrl+Shift+ˋ |                   ctrl+shift+4 |              Ctrl+Shift+4 |            ctrl+shift+[Digit4] |    NO   |
+|                     Alt+Digit4 |   ˋ   |                     Alt+4 |     |                     Alt+ˋ |                          alt+4 |                     Alt+4 |                   alt+[Digit4] |    NO   |
+|                Ctrl+Alt+Digit4 |   4   |                Ctrl+Alt+4 |     |                Ctrl+Alt+ˋ |                     ctrl+alt+4 |                Ctrl+Alt+4 |              ctrl+alt+[Digit4] |    NO   |
+|               Shift+Alt+Digit4 |   $   |               Shift+Alt+4 |     |               Shift+Alt+ˋ |                    shift+alt+4 |               Shift+Alt+4 |             shift+alt+[Digit4] |    NO   |
+|          Ctrl+Shift+Alt+Digit4 |   $   |          Ctrl+Shift+Alt+4 |     |          Ctrl+Shift+Alt+ˋ |               ctrl+shift+alt+4 |          Ctrl+Shift+Alt+4 |        ctrl+shift+alt+[Digit4] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit5 |   ㄓ   |                         5 |     |                         ㄓ |                              5 |                         5 |                       [Digit5] |    NO   |
+|                    Ctrl+Digit5 |   ㄓ   |                    Ctrl+5 |     |                    Ctrl+ㄓ |                         ctrl+5 |                    Ctrl+5 |                  ctrl+[Digit5] |    NO   |
+|                   Shift+Digit5 |   %   |                   Shift+5 |     |                   Shift+ㄓ |                        shift+5 |                   Shift+5 |                 shift+[Digit5] |    NO   |
+|              Ctrl+Shift+Digit5 |   %   |              Ctrl+Shift+5 |     |              Ctrl+Shift+ㄓ |                   ctrl+shift+5 |              Ctrl+Shift+5 |            ctrl+shift+[Digit5] |    NO   |
+|                     Alt+Digit5 |   ㄓ   |                     Alt+5 |     |                     Alt+ㄓ |                          alt+5 |                     Alt+5 |                   alt+[Digit5] |    NO   |
+|                Ctrl+Alt+Digit5 |   5   |                Ctrl+Alt+5 |     |                Ctrl+Alt+ㄓ |                     ctrl+alt+5 |                Ctrl+Alt+5 |              ctrl+alt+[Digit5] |    NO   |
+|               Shift+Alt+Digit5 |   %   |               Shift+Alt+5 |     |               Shift+Alt+ㄓ |                    shift+alt+5 |               Shift+Alt+5 |             shift+alt+[Digit5] |    NO   |
+|          Ctrl+Shift+Alt+Digit5 |   %   |          Ctrl+Shift+Alt+5 |     |          Ctrl+Shift+Alt+ㄓ |               ctrl+shift+alt+5 |          Ctrl+Shift+Alt+5 |        ctrl+shift+alt+[Digit5] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit6 |   ˊ   |                         6 |     |                         ˊ |                              6 |                         6 |                       [Digit6] |    NO   |
+|                    Ctrl+Digit6 |   ˊ   |                    Ctrl+6 |     |                    Ctrl+ˊ |                         ctrl+6 |                    Ctrl+6 |                  ctrl+[Digit6] |    NO   |
+|                   Shift+Digit6 |   ^   |                   Shift+6 |     |                   Shift+ˊ |                        shift+6 |                   Shift+6 |                 shift+[Digit6] |    NO   |
+|              Ctrl+Shift+Digit6 |   ^   |              Ctrl+Shift+6 |     |              Ctrl+Shift+ˊ |                   ctrl+shift+6 |              Ctrl+Shift+6 |            ctrl+shift+[Digit6] |    NO   |
+|                     Alt+Digit6 |   ˊ   |                     Alt+6 |     |                     Alt+ˊ |                          alt+6 |                     Alt+6 |                   alt+[Digit6] |    NO   |
+|                Ctrl+Alt+Digit6 |   6   |                Ctrl+Alt+6 |     |                Ctrl+Alt+ˊ |                     ctrl+alt+6 |                Ctrl+Alt+6 |              ctrl+alt+[Digit6] |    NO   |
+|               Shift+Alt+Digit6 |   ^   |               Shift+Alt+6 |     |               Shift+Alt+ˊ |                    shift+alt+6 |               Shift+Alt+6 |             shift+alt+[Digit6] |    NO   |
+|          Ctrl+Shift+Alt+Digit6 |   ^   |          Ctrl+Shift+Alt+6 |     |          Ctrl+Shift+Alt+ˊ |               ctrl+shift+alt+6 |          Ctrl+Shift+Alt+6 |        ctrl+shift+alt+[Digit6] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit7 |   ˙   |                         7 |     |                         ˙ |                              7 |                         7 |                       [Digit7] |    NO   |
+|                    Ctrl+Digit7 |   ˙   |                    Ctrl+7 |     |                    Ctrl+˙ |                         ctrl+7 |                    Ctrl+7 |                  ctrl+[Digit7] |    NO   |
+|                   Shift+Digit7 |   &   |                   Shift+7 |     |                   Shift+˙ |                        shift+7 |                   Shift+7 |                 shift+[Digit7] |    NO   |
+|              Ctrl+Shift+Digit7 |   &   |              Ctrl+Shift+7 |     |              Ctrl+Shift+˙ |                   ctrl+shift+7 |              Ctrl+Shift+7 |            ctrl+shift+[Digit7] |    NO   |
+|                     Alt+Digit7 |   ˙   |                     Alt+7 |     |                     Alt+˙ |                          alt+7 |                     Alt+7 |                   alt+[Digit7] |    NO   |
+|                Ctrl+Alt+Digit7 |   7   |                Ctrl+Alt+7 |     |                Ctrl+Alt+˙ |                     ctrl+alt+7 |                Ctrl+Alt+7 |              ctrl+alt+[Digit7] |    NO   |
+|               Shift+Alt+Digit7 |   &   |               Shift+Alt+7 |     |               Shift+Alt+˙ |                    shift+alt+7 |               Shift+Alt+7 |             shift+alt+[Digit7] |    NO   |
+|          Ctrl+Shift+Alt+Digit7 |   &   |          Ctrl+Shift+Alt+7 |     |          Ctrl+Shift+Alt+˙ |               ctrl+shift+alt+7 |          Ctrl+Shift+Alt+7 |        ctrl+shift+alt+[Digit7] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit8 |   ㄚ   |                         8 |     |                         ㄚ |                              8 |                         8 |                       [Digit8] |    NO   |
+|                    Ctrl+Digit8 |   ㄚ   |                    Ctrl+8 |     |                    Ctrl+ㄚ |                         ctrl+8 |                    Ctrl+8 |                  ctrl+[Digit8] |    NO   |
+|                   Shift+Digit8 |   *   |                   Shift+8 |     |                   Shift+ㄚ |                        shift+8 |                   Shift+8 |                 shift+[Digit8] |    NO   |
+|              Ctrl+Shift+Digit8 |   *   |              Ctrl+Shift+8 |     |              Ctrl+Shift+ㄚ |                   ctrl+shift+8 |              Ctrl+Shift+8 |            ctrl+shift+[Digit8] |    NO   |
+|                     Alt+Digit8 |   ㄚ   |                     Alt+8 |     |                     Alt+ㄚ |                          alt+8 |                     Alt+8 |                   alt+[Digit8] |    NO   |
+|                Ctrl+Alt+Digit8 |   8   |                Ctrl+Alt+8 |     |                Ctrl+Alt+ㄚ |                     ctrl+alt+8 |                Ctrl+Alt+8 |              ctrl+alt+[Digit8] |    NO   |
+|               Shift+Alt+Digit8 |   *   |               Shift+Alt+8 |     |               Shift+Alt+ㄚ |                    shift+alt+8 |               Shift+Alt+8 |             shift+alt+[Digit8] |    NO   |
+|          Ctrl+Shift+Alt+Digit8 |   *   |          Ctrl+Shift+Alt+8 |     |          Ctrl+Shift+Alt+ㄚ |               ctrl+shift+alt+8 |          Ctrl+Shift+Alt+8 |        ctrl+shift+alt+[Digit8] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit9 |   ㄞ   |                         9 |     |                         ㄞ |                              9 |                         9 |                       [Digit9] |    NO   |
+|                    Ctrl+Digit9 |   ㄞ   |                    Ctrl+9 |     |                    Ctrl+ㄞ |                         ctrl+9 |                    Ctrl+9 |                  ctrl+[Digit9] |    NO   |
+|                   Shift+Digit9 |   (   |                   Shift+9 |     |                   Shift+ㄞ |                        shift+9 |                   Shift+9 |                 shift+[Digit9] |    NO   |
+|              Ctrl+Shift+Digit9 |   (   |              Ctrl+Shift+9 |     |              Ctrl+Shift+ㄞ |                   ctrl+shift+9 |              Ctrl+Shift+9 |            ctrl+shift+[Digit9] |    NO   |
+|                     Alt+Digit9 |   ㄞ   |                     Alt+9 |     |                     Alt+ㄞ |                          alt+9 |                     Alt+9 |                   alt+[Digit9] |    NO   |
+|                Ctrl+Alt+Digit9 |   9   |                Ctrl+Alt+9 |     |                Ctrl+Alt+ㄞ |                     ctrl+alt+9 |                Ctrl+Alt+9 |              ctrl+alt+[Digit9] |    NO   |
+|               Shift+Alt+Digit9 |   (   |               Shift+Alt+9 |     |               Shift+Alt+ㄞ |                    shift+alt+9 |               Shift+Alt+9 |             shift+alt+[Digit9] |    NO   |
+|          Ctrl+Shift+Alt+Digit9 |   (   |          Ctrl+Shift+Alt+9 |     |          Ctrl+Shift+Alt+ㄞ |               ctrl+shift+alt+9 |          Ctrl+Shift+Alt+9 |        ctrl+shift+alt+[Digit9] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit0 |   ㄢ   |                         0 |     |                         ㄢ |                              0 |                         0 |                       [Digit0] |    NO   |
+|                    Ctrl+Digit0 |   ㄢ   |                    Ctrl+0 |     |                    Ctrl+ㄢ |                         ctrl+0 |                    Ctrl+0 |                  ctrl+[Digit0] |    NO   |
+|                   Shift+Digit0 |   )   |                   Shift+0 |     |                   Shift+ㄢ |                        shift+0 |                   Shift+0 |                 shift+[Digit0] |    NO   |
+|              Ctrl+Shift+Digit0 |   )   |              Ctrl+Shift+0 |     |              Ctrl+Shift+ㄢ |                   ctrl+shift+0 |              Ctrl+Shift+0 |            ctrl+shift+[Digit0] |    NO   |
+|                     Alt+Digit0 |   ㄢ   |                     Alt+0 |     |                     Alt+ㄢ |                          alt+0 |                     Alt+0 |                   alt+[Digit0] |    NO   |
+|                Ctrl+Alt+Digit0 |   0   |                Ctrl+Alt+0 |     |                Ctrl+Alt+ㄢ |                     ctrl+alt+0 |                Ctrl+Alt+0 |              ctrl+alt+[Digit0] |    NO   |
+|               Shift+Alt+Digit0 |   )   |               Shift+Alt+0 |     |               Shift+Alt+ㄢ |                    shift+alt+0 |               Shift+Alt+0 |             shift+alt+[Digit0] |    NO   |
+|          Ctrl+Shift+Alt+Digit0 |   )   |          Ctrl+Shift+Alt+0 |     |          Ctrl+Shift+Alt+ㄢ |               ctrl+shift+alt+0 |          Ctrl+Shift+Alt+0 |        ctrl+shift+alt+[Digit0] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Minus |   ㄦ   |                           |     |                         ㄦ |                        [Minus] |                      null |                        [Minus] |    NO   |
+|                     Ctrl+Minus |   ㄦ   |                           |     |                    Ctrl+ㄦ |                   ctrl+[Minus] |                      null |                   ctrl+[Minus] |    NO   |
+|                    Shift+Minus |   _   |                   Shift+- |     |                   Shift+ㄦ |                  shift+[Minus] |                      null |                  shift+[Minus] |    NO   |
+|               Ctrl+Shift+Minus |   _   |              Ctrl+Shift+- |     |              Ctrl+Shift+ㄦ |             ctrl+shift+[Minus] |                      null |             ctrl+shift+[Minus] |    NO   |
+|                      Alt+Minus |   ㄦ   |                           |     |                     Alt+ㄦ |                    alt+[Minus] |                      null |                    alt+[Minus] |    NO   |
+|                 Ctrl+Alt+Minus |   —   |                           |     |                Ctrl+Alt+ㄦ |               ctrl+alt+[Minus] |                      null |               ctrl+alt+[Minus] |    NO   |
+|                Shift+Alt+Minus |   _   |               Shift+Alt+- |     |               Shift+Alt+ㄦ |              shift+alt+[Minus] |                      null |              shift+alt+[Minus] |    NO   |
+|           Ctrl+Shift+Alt+Minus |   _   |          Ctrl+Shift+Alt+- |     |          Ctrl+Shift+Alt+ㄦ |         ctrl+shift+alt+[Minus] |                      null |         ctrl+shift+alt+[Minus] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Equal |   =   |                         = |     |                         = |                              = |                      null |                        [Equal] |         |
+|                     Ctrl+Equal |   =   |                    Ctrl+= |     |                    Ctrl+= |                         ctrl+= |                      null |                   ctrl+[Equal] |         |
+|                    Shift+Equal |   +   |                   Shift+= |     |                   Shift+= |                        shift+= |                      null |                  shift+[Equal] |         |
+|               Ctrl+Shift+Equal |   +   |              Ctrl+Shift+= |     |              Ctrl+Shift+= |                   ctrl+shift+= |                      null |             ctrl+shift+[Equal] |         |
+|                      Alt+Equal |   =   |                     Alt+= |     |                     Alt+= |                          alt+= |                      null |                    alt+[Equal] |         |
+|                 Ctrl+Alt+Equal |   =   |                Ctrl+Alt+= |     |                Ctrl+Alt+= |                     ctrl+alt+= |                      null |               ctrl+alt+[Equal] |         |
+|                Shift+Alt+Equal |   +   |               Shift+Alt+= |     |               Shift+Alt+= |                    shift+alt+= |                      null |              shift+alt+[Equal] |         |
+|           Ctrl+Shift+Alt+Equal |   +   |          Ctrl+Shift+Alt+= |     |          Ctrl+Shift+Alt+= |               ctrl+shift+alt+= |                      null |         ctrl+shift+alt+[Equal] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                    BracketLeft |   「   |                           |     |                         「 |                  [BracketLeft] |                      null |                  [BracketLeft] |    NO   |
+|               Ctrl+BracketLeft |   「   |                           |     |                    Ctrl+「 |             ctrl+[BracketLeft] |                      null |             ctrl+[BracketLeft] |    NO   |
+|              Shift+BracketLeft |   『   |                           |     |                   Shift+「 |            shift+[BracketLeft] |                      null |            shift+[BracketLeft] |    NO   |
+|         Ctrl+Shift+BracketLeft |   『   |                           |     |              Ctrl+Shift+「 |       ctrl+shift+[BracketLeft] |                      null |       ctrl+shift+[BracketLeft] |    NO   |
+|                Alt+BracketLeft |   「   |                           |     |                     Alt+「 |              alt+[BracketLeft] |                      null |              alt+[BracketLeft] |    NO   |
+|           Ctrl+Alt+BracketLeft |   [   |                         [ |     |                Ctrl+Alt+「 |         ctrl+alt+[BracketLeft] |                      null |         ctrl+alt+[BracketLeft] |    NO   |
+|          Shift+Alt+BracketLeft |   『   |                           |     |               Shift+Alt+「 |        shift+alt+[BracketLeft] |                      null |        shift+alt+[BracketLeft] |    NO   |
+|     Ctrl+Shift+Alt+BracketLeft |   {   |                   Shift+[ |     |          Ctrl+Shift+Alt+「 |   ctrl+shift+alt+[BracketLeft] |                      null |   ctrl+shift+alt+[BracketLeft] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                   BracketRight |   」   |                           |     |                         」 |                 [BracketRight] |                      null |                 [BracketRight] |    NO   |
+|              Ctrl+BracketRight |   」   |                           |     |                    Ctrl+」 |            ctrl+[BracketRight] |                      null |            ctrl+[BracketRight] |    NO   |
+|             Shift+BracketRight |   』   |                           |     |                   Shift+」 |           shift+[BracketRight] |                      null |           shift+[BracketRight] |    NO   |
+|        Ctrl+Shift+BracketRight |   』   |                           |     |              Ctrl+Shift+」 |      ctrl+shift+[BracketRight] |                      null |      ctrl+shift+[BracketRight] |    NO   |
+|               Alt+BracketRight |   」   |                           |     |                     Alt+」 |             alt+[BracketRight] |                      null |             alt+[BracketRight] |    NO   |
+|          Ctrl+Alt+BracketRight |   ]   |                         ] |     |                Ctrl+Alt+」 |        ctrl+alt+[BracketRight] |                      null |        ctrl+alt+[BracketRight] |    NO   |
+|         Shift+Alt+BracketRight |   』   |                           |     |               Shift+Alt+」 |       shift+alt+[BracketRight] |                      null |       shift+alt+[BracketRight] |    NO   |
+|    Ctrl+Shift+Alt+BracketRight |   }   |                   Shift+] |     |          Ctrl+Shift+Alt+」 |  ctrl+shift+alt+[BracketRight] |                      null |  ctrl+shift+alt+[BracketRight] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                      Backslash |   、   |                           |     |                         、 |                    [Backslash] |                      null |                    [Backslash] |    NO   |
+|                 Ctrl+Backslash |   、   |                           |     |                    Ctrl+、 |               ctrl+[Backslash] |                      null |               ctrl+[Backslash] |    NO   |
+|                Shift+Backslash |   |   |                   Shift+\ |     |                   Shift+、 |              shift+[Backslash] |                      null |              shift+[Backslash] |    NO   |
+|           Ctrl+Shift+Backslash |   |   |              Ctrl+Shift+\ |     |              Ctrl+Shift+、 |         ctrl+shift+[Backslash] |                      null |         ctrl+shift+[Backslash] |    NO   |
+|                  Alt+Backslash |   、   |                           |     |                     Alt+、 |                alt+[Backslash] |                      null |                alt+[Backslash] |    NO   |
+|             Ctrl+Alt+Backslash |   \   |                         \ |     |                Ctrl+Alt+、 |           ctrl+alt+[Backslash] |                      null |           ctrl+alt+[Backslash] |    NO   |
+|            Shift+Alt+Backslash |   |   |               Shift+Alt+\ |     |               Shift+Alt+、 |          shift+alt+[Backslash] |                      null |          shift+alt+[Backslash] |    NO   |
+|       Ctrl+Shift+Alt+Backslash |   |   |          Ctrl+Shift+Alt+\ |     |          Ctrl+Shift+Alt+、 |     ctrl+shift+alt+[Backslash] |                      null |     ctrl+shift+alt+[Backslash] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                       IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|                  Ctrl+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|                 Shift+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|            Ctrl+Shift+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|                   Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|              Ctrl+Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|             Shift+Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+|        Ctrl+Shift+Alt+IntlHash |  ---  |                           |     |                      null |                           null |                      null |                           null |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                      Semicolon |   ㄤ   |                           |     |                         ㄤ |                    [Semicolon] |                      null |                    [Semicolon] |    NO   |
+|                 Ctrl+Semicolon |   ㄤ   |                           |     |                    Ctrl+ㄤ |               ctrl+[Semicolon] |                      null |               ctrl+[Semicolon] |    NO   |
+|                Shift+Semicolon |   :   |                   Shift+; |     |                   Shift+ㄤ |              shift+[Semicolon] |                      null |              shift+[Semicolon] |    NO   |
+|           Ctrl+Shift+Semicolon |   :   |              Ctrl+Shift+; |     |              Ctrl+Shift+ㄤ |         ctrl+shift+[Semicolon] |                      null |         ctrl+shift+[Semicolon] |    NO   |
+|                  Alt+Semicolon |   ㄤ   |                           |     |                     Alt+ㄤ |                alt+[Semicolon] |                      null |                alt+[Semicolon] |    NO   |
+|             Ctrl+Alt+Semicolon |   ;   |                         ; |     |                Ctrl+Alt+ㄤ |           ctrl+alt+[Semicolon] |                      null |           ctrl+alt+[Semicolon] |    NO   |
+|            Shift+Alt+Semicolon |   :   |               Shift+Alt+; |     |               Shift+Alt+ㄤ |          shift+alt+[Semicolon] |                      null |          shift+alt+[Semicolon] |    NO   |
+|       Ctrl+Shift+Alt+Semicolon |   :   |          Ctrl+Shift+Alt+; |     |          Ctrl+Shift+Alt+ㄤ |     ctrl+shift+alt+[Semicolon] |                      null |     ctrl+shift+alt+[Semicolon] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Quote |   '   |                         ' |     |                         ' |                              ' |                         ' |                        [Quote] |         |
+|                     Ctrl+Quote |   '   |                    Ctrl+' |     |                    Ctrl+' |                         ctrl+' |                    Ctrl+' |                   ctrl+[Quote] |         |
+|                    Shift+Quote |   "   |                   Shift+' |     |                   Shift+' |                        shift+' |                   Shift+' |                  shift+[Quote] |         |
+|               Ctrl+Shift+Quote |   "   |              Ctrl+Shift+' |     |              Ctrl+Shift+' |                   ctrl+shift+' |              Ctrl+Shift+' |             ctrl+shift+[Quote] |         |
+|                      Alt+Quote |   '   |                     Alt+' |     |                     Alt+' |                          alt+' |                     Alt+' |                    alt+[Quote] |         |
+|                 Ctrl+Alt+Quote |   '   |                Ctrl+Alt+' |     |                Ctrl+Alt+' |                     ctrl+alt+' |                Ctrl+Alt+' |               ctrl+alt+[Quote] |         |
+|                Shift+Alt+Quote |   "   |               Shift+Alt+' |     |               Shift+Alt+' |                    shift+alt+' |               Shift+Alt+' |              shift+alt+[Quote] |         |
+|           Ctrl+Shift+Alt+Quote |   "   |          Ctrl+Shift+Alt+' |     |          Ctrl+Shift+Alt+' |               ctrl+shift+alt+' |          Ctrl+Shift+Alt+' |         ctrl+shift+alt+[Quote] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                      Backquote |   ·   |                           |     |                         · |                    [Backquote] |                      null |                    [Backquote] |    NO   |
+|                 Ctrl+Backquote |   ·   |                           |     |                    Ctrl+· |               ctrl+[Backquote] |                      null |               ctrl+[Backquote] |    NO   |
+|                Shift+Backquote |   ~   |                   Shift+` |     |                   Shift+· |              shift+[Backquote] |                      null |              shift+[Backquote] |    NO   |
+|           Ctrl+Shift+Backquote |   ~   |              Ctrl+Shift+` |     |              Ctrl+Shift+· |         ctrl+shift+[Backquote] |                      null |         ctrl+shift+[Backquote] |    NO   |
+|                  Alt+Backquote |   ·   |                           |     |                     Alt+· |                alt+[Backquote] |                      null |                alt+[Backquote] |    NO   |
+|             Ctrl+Alt+Backquote |   `   |                         ` |     |                Ctrl+Alt+· |           ctrl+alt+[Backquote] |                      null |           ctrl+alt+[Backquote] |    NO   |
+|            Shift+Alt+Backquote |   ~   |               Shift+Alt+` |     |               Shift+Alt+· |          shift+alt+[Backquote] |                      null |          shift+alt+[Backquote] |    NO   |
+|       Ctrl+Shift+Alt+Backquote |   ~   |          Ctrl+Shift+Alt+` |     |          Ctrl+Shift+Alt+· |     ctrl+shift+alt+[Backquote] |                      null |     ctrl+shift+alt+[Backquote] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Comma |   ㄝ   |                           |     |                         ㄝ |                        [Comma] |                      null |                        [Comma] |    NO   |
+|                     Ctrl+Comma |   ㄝ   |                           |     |                    Ctrl+ㄝ |                   ctrl+[Comma] |                      null |                   ctrl+[Comma] |    NO   |
+|                    Shift+Comma |   ，   |                           |     |                   Shift+ㄝ |                  shift+[Comma] |                      null |                  shift+[Comma] |    NO   |
+|               Ctrl+Shift+Comma |   ，   |                           |     |              Ctrl+Shift+ㄝ |             ctrl+shift+[Comma] |                      null |             ctrl+shift+[Comma] |    NO   |
+|                      Alt+Comma |   ㄝ   |                           |     |                     Alt+ㄝ |                    alt+[Comma] |                      null |                    alt+[Comma] |    NO   |
+|                 Ctrl+Alt+Comma |   ,   |                         , |     |                Ctrl+Alt+ㄝ |               ctrl+alt+[Comma] |                      null |               ctrl+alt+[Comma] |    NO   |
+|                Shift+Alt+Comma |   ，   |                           |     |               Shift+Alt+ㄝ |              shift+alt+[Comma] |                      null |              shift+alt+[Comma] |    NO   |
+|           Ctrl+Shift+Alt+Comma |   <   |                   Shift+, |     |          Ctrl+Shift+Alt+ㄝ |         ctrl+shift+alt+[Comma] |                      null |         ctrl+shift+alt+[Comma] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         Period |   ㄡ   |                           |     |                         ㄡ |                       [Period] |                      null |                       [Period] |    NO   |
+|                    Ctrl+Period |   ㄡ   |                           |     |                    Ctrl+ㄡ |                  ctrl+[Period] |                      null |                  ctrl+[Period] |    NO   |
+|                   Shift+Period |   。   |                           |     |                   Shift+ㄡ |                 shift+[Period] |                      null |                 shift+[Period] |    NO   |
+|              Ctrl+Shift+Period |   。   |                           |     |              Ctrl+Shift+ㄡ |            ctrl+shift+[Period] |                      null |            ctrl+shift+[Period] |    NO   |
+|                     Alt+Period |   ㄡ   |                           |     |                     Alt+ㄡ |                   alt+[Period] |                      null |                   alt+[Period] |    NO   |
+|                Ctrl+Alt+Period |   .   |                         . |     |                Ctrl+Alt+ㄡ |              ctrl+alt+[Period] |                      null |              ctrl+alt+[Period] |    NO   |
+|               Shift+Alt+Period |   。   |                           |     |               Shift+Alt+ㄡ |             shift+alt+[Period] |                      null |             shift+alt+[Period] |    NO   |
+|          Ctrl+Shift+Alt+Period |   >   |                   Shift+. |     |          Ctrl+Shift+Alt+ㄡ |        ctrl+shift+alt+[Period] |                      null |        ctrl+shift+alt+[Period] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                          Slash |   ㄥ   |                           |     |                         ㄥ |                        [Slash] |                      null |                        [Slash] |    NO   |
+|                     Ctrl+Slash |   ㄥ   |                           |     |                    Ctrl+ㄥ |                   ctrl+[Slash] |                      null |                   ctrl+[Slash] |    NO   |
+|                    Shift+Slash |   ?   |                   Shift+/ |     |                   Shift+ㄥ |                  shift+[Slash] |                      null |                  shift+[Slash] |    NO   |
+|               Ctrl+Shift+Slash |   ?   |              Ctrl+Shift+/ |     |              Ctrl+Shift+ㄥ |             ctrl+shift+[Slash] |                      null |             ctrl+shift+[Slash] |    NO   |
+|                      Alt+Slash |   ㄥ   |                           |     |                     Alt+ㄥ |                    alt+[Slash] |                      null |                    alt+[Slash] |    NO   |
+|                 Ctrl+Alt+Slash |   /   |                         / |     |                Ctrl+Alt+ㄥ |               ctrl+alt+[Slash] |                      null |               ctrl+alt+[Slash] |    NO   |
+|                Shift+Alt+Slash |   ?   |               Shift+Alt+/ |     |               Shift+Alt+ㄥ |              shift+alt+[Slash] |                      null |              shift+alt+[Slash] |    NO   |
+|           Ctrl+Shift+Alt+Slash |   ?   |          Ctrl+Shift+Alt+/ |     |          Ctrl+Shift+Alt+ㄥ |         ctrl+shift+alt+[Slash] |                      null |         ctrl+shift+alt+[Slash] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                        ArrowUp |  ---  |                   UpArrow |     |                   UpArrow |                             up |                        Up |                      [ArrowUp] |         |
+|                   Ctrl+ArrowUp |  ---  |              Ctrl+UpArrow |     |              Ctrl+UpArrow |                        ctrl+up |                   Ctrl+Up |                 ctrl+[ArrowUp] |         |
+|                  Shift+ArrowUp |  ---  |             Shift+UpArrow |     |             Shift+UpArrow |                       shift+up |                  Shift+Up |                shift+[ArrowUp] |         |
+|             Ctrl+Shift+ArrowUp |  ---  |        Ctrl+Shift+UpArrow |     |        Ctrl+Shift+UpArrow |                  ctrl+shift+up |             Ctrl+Shift+Up |           ctrl+shift+[ArrowUp] |         |
+|                    Alt+ArrowUp |  ---  |               Alt+UpArrow |     |               Alt+UpArrow |                         alt+up |                    Alt+Up |                  alt+[ArrowUp] |         |
+|               Ctrl+Alt+ArrowUp |  ---  |          Ctrl+Alt+UpArrow |     |          Ctrl+Alt+UpArrow |                    ctrl+alt+up |               Ctrl+Alt+Up |             ctrl+alt+[ArrowUp] |         |
+|              Shift+Alt+ArrowUp |  ---  |         Shift+Alt+UpArrow |     |         Shift+Alt+UpArrow |                   shift+alt+up |              Shift+Alt+Up |            shift+alt+[ArrowUp] |         |
+|         Ctrl+Shift+Alt+ArrowUp |  ---  |    Ctrl+Shift+Alt+UpArrow |     |    Ctrl+Shift+Alt+UpArrow |              ctrl+shift+alt+up |         Ctrl+Shift+Alt+Up |       ctrl+shift+alt+[ArrowUp] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                        Numpad0 |  ---  |                   NumPad0 |     |                   NumPad0 |                        numpad0 |                      null |                      [Numpad0] |         |
+|                   Ctrl+Numpad0 |  ---  |              Ctrl+NumPad0 |     |              Ctrl+NumPad0 |                   ctrl+numpad0 |                      null |                 ctrl+[Numpad0] |         |
+|                  Shift+Numpad0 |  ---  |             Shift+NumPad0 |     |             Shift+NumPad0 |                  shift+numpad0 |                      null |                shift+[Numpad0] |         |
+|             Ctrl+Shift+Numpad0 |  ---  |        Ctrl+Shift+NumPad0 |     |        Ctrl+Shift+NumPad0 |             ctrl+shift+numpad0 |                      null |           ctrl+shift+[Numpad0] |         |
+|                    Alt+Numpad0 |  ---  |               Alt+NumPad0 |     |               Alt+NumPad0 |                    alt+numpad0 |                      null |                  alt+[Numpad0] |         |
+|               Ctrl+Alt+Numpad0 |  ---  |          Ctrl+Alt+NumPad0 |     |          Ctrl+Alt+NumPad0 |               ctrl+alt+numpad0 |                      null |             ctrl+alt+[Numpad0] |         |
+|              Shift+Alt+Numpad0 |  ---  |         Shift+Alt+NumPad0 |     |         Shift+Alt+NumPad0 |              shift+alt+numpad0 |                      null |            shift+alt+[Numpad0] |         |
+|         Ctrl+Shift+Alt+Numpad0 |  ---  |    Ctrl+Shift+Alt+NumPad0 |     |    Ctrl+Shift+Alt+NumPad0 |         ctrl+shift+alt+numpad0 |                      null |       ctrl+shift+alt+[Numpad0] |         |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                  IntlBackslash |   §   |                           |     |                         § |                [IntlBackslash] |                      null |                [IntlBackslash] |    NO   |
+|             Ctrl+IntlBackslash |   §   |                           |     |                    Ctrl+§ |           ctrl+[IntlBackslash] |                      null |           ctrl+[IntlBackslash] |    NO   |
+|            Shift+IntlBackslash |   ±   |                           |     |                   Shift+§ |          shift+[IntlBackslash] |                      null |          shift+[IntlBackslash] |    NO   |
+|       Ctrl+Shift+IntlBackslash |   ±   |                           |     |              Ctrl+Shift+§ |     ctrl+shift+[IntlBackslash] |                      null |     ctrl+shift+[IntlBackslash] |    NO   |
+|              Alt+IntlBackslash |   §   |                           |     |                     Alt+§ |            alt+[IntlBackslash] |                      null |            alt+[IntlBackslash] |    NO   |
+|         Ctrl+Alt+IntlBackslash |  ---  |                           |     |                Ctrl+Alt+§ |       ctrl+alt+[IntlBackslash] |                      null |       ctrl+alt+[IntlBackslash] |    NO   |
+|        Shift+Alt+IntlBackslash |   ±   |                           |     |               Shift+Alt+§ |      shift+alt+[IntlBackslash] |                      null |      shift+alt+[IntlBackslash] |    NO   |
+|   Ctrl+Shift+Alt+IntlBackslash |  ---  |                           |     |          Ctrl+Shift+Alt+§ | ctrl+shift+alt+[IntlBackslash] |                      null | ctrl+shift+alt+[IntlBackslash] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                         IntlRo |  ---  |                           |     |                      null |                       [IntlRo] |                      null |                       [IntlRo] |    NO   |
+|                    Ctrl+IntlRo |  ---  |                           |     |                      null |                  ctrl+[IntlRo] |                      null |                  ctrl+[IntlRo] |    NO   |
+|                   Shift+IntlRo |  ---  |                           |     |                      null |                 shift+[IntlRo] |                      null |                 shift+[IntlRo] |    NO   |
+|              Ctrl+Shift+IntlRo |  ---  |                           |     |                      null |            ctrl+shift+[IntlRo] |                      null |            ctrl+shift+[IntlRo] |    NO   |
+|                     Alt+IntlRo |  ---  |                           |     |                      null |                   alt+[IntlRo] |                      null |                   alt+[IntlRo] |    NO   |
+|                Ctrl+Alt+IntlRo |  ---  |                           |     |                      null |              ctrl+alt+[IntlRo] |                      null |              ctrl+alt+[IntlRo] |    NO   |
+|               Shift+Alt+IntlRo |  ---  |                           |     |                      null |             shift+alt+[IntlRo] |                      null |             shift+alt+[IntlRo] |    NO   |
+|          Ctrl+Shift+Alt+IntlRo |  ---  |                           |     |                      null |        ctrl+shift+alt+[IntlRo] |                      null |        ctrl+shift+alt+[IntlRo] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    | Pri |          UI label         |         User settings          |    Electron accelerator   |       Dispatching string       | WYSIWYG |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|                        IntlYen |  ---  |                           |     |                      null |                      [IntlYen] |                      null |                      [IntlYen] |    NO   |
+|                   Ctrl+IntlYen |  ---  |                           |     |                      null |                 ctrl+[IntlYen] |                      null |                 ctrl+[IntlYen] |    NO   |
+|                  Shift+IntlYen |  ---  |                           |     |                      null |                shift+[IntlYen] |                      null |                shift+[IntlYen] |    NO   |
+|             Ctrl+Shift+IntlYen |  ---  |                           |     |                      null |           ctrl+shift+[IntlYen] |                      null |           ctrl+shift+[IntlYen] |    NO   |
+|                    Alt+IntlYen |  ---  |                           |     |                      null |                  alt+[IntlYen] |                      null |                  alt+[IntlYen] |    NO   |
+|               Ctrl+Alt+IntlYen |  ---  |                           |     |                      null |             ctrl+alt+[IntlYen] |                      null |             ctrl+alt+[IntlYen] |    NO   |
+|              Shift+Alt+IntlYen |  ---  |                           |     |                      null |            shift+alt+[IntlYen] |                      null |            shift+alt+[IntlYen] |    NO   |
+|         Ctrl+Shift+Alt+IntlYen |  ---  |                           |     |                      null |       ctrl+shift+alt+[IntlYen] |                      null |       ctrl+shift+alt+[IntlYen] |    NO   |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

lib/vscode/src/vs/workbench/services/keybinding/test/electron-browser/win_de_ch.txt

@@ -0,0 +1,284 @@
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyA |   a   |                         A |                         A |                          a |         |
+|                     Shift+KeyA |   A   |                   Shift+A |                   Shift+A |                    shift+a |         |
+|                  Ctrl+Alt+KeyA |  ---  |                Ctrl+Alt+A |                Ctrl+Alt+A |                 ctrl+alt+a |         |
+|            Ctrl+Shift+Alt+KeyA |  ---  |          Ctrl+Shift+Alt+A |          Ctrl+Shift+Alt+A |           ctrl+shift+alt+a |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyB |   b   |                         B |                         B |                          b |         |
+|                     Shift+KeyB |   B   |                   Shift+B |                   Shift+B |                    shift+b |         |
+|                  Ctrl+Alt+KeyB |  ---  |                Ctrl+Alt+B |                Ctrl+Alt+B |                 ctrl+alt+b |         |
+|            Ctrl+Shift+Alt+KeyB |  ---  |          Ctrl+Shift+Alt+B |          Ctrl+Shift+Alt+B |           ctrl+shift+alt+b |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyC |   c   |                         C |                         C |                          c |         |
+|                     Shift+KeyC |   C   |                   Shift+C |                   Shift+C |                    shift+c |         |
+|                  Ctrl+Alt+KeyC |  ---  |                Ctrl+Alt+C |                Ctrl+Alt+C |                 ctrl+alt+c |         |
+|            Ctrl+Shift+Alt+KeyC |  ---  |          Ctrl+Shift+Alt+C |          Ctrl+Shift+Alt+C |           ctrl+shift+alt+c |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyD |   d   |                         D |                         D |                          d |         |
+|                     Shift+KeyD |   D   |                   Shift+D |                   Shift+D |                    shift+d |         |
+|                  Ctrl+Alt+KeyD |  ---  |                Ctrl+Alt+D |                Ctrl+Alt+D |                 ctrl+alt+d |         |
+|            Ctrl+Shift+Alt+KeyD |  ---  |          Ctrl+Shift+Alt+D |          Ctrl+Shift+Alt+D |           ctrl+shift+alt+d |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyE |   e   |                         E |                         E |                          e |         |
+|                     Shift+KeyE |   E   |                   Shift+E |                   Shift+E |                    shift+e |         |
+|                  Ctrl+Alt+KeyE |   €   |                Ctrl+Alt+E |                Ctrl+Alt+E |                 ctrl+alt+e |         |
+|            Ctrl+Shift+Alt+KeyE |  ---  |          Ctrl+Shift+Alt+E |          Ctrl+Shift+Alt+E |           ctrl+shift+alt+e |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyF |   f   |                         F |                         F |                          f |         |
+|                     Shift+KeyF |   F   |                   Shift+F |                   Shift+F |                    shift+f |         |
+|                  Ctrl+Alt+KeyF |  ---  |                Ctrl+Alt+F |                Ctrl+Alt+F |                 ctrl+alt+f |         |
+|            Ctrl+Shift+Alt+KeyF |  ---  |          Ctrl+Shift+Alt+F |          Ctrl+Shift+Alt+F |           ctrl+shift+alt+f |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyG |   g   |                         G |                         G |                          g |         |
+|                     Shift+KeyG |   G   |                   Shift+G |                   Shift+G |                    shift+g |         |
+|                  Ctrl+Alt+KeyG |  ---  |                Ctrl+Alt+G |                Ctrl+Alt+G |                 ctrl+alt+g |         |
+|            Ctrl+Shift+Alt+KeyG |  ---  |          Ctrl+Shift+Alt+G |          Ctrl+Shift+Alt+G |           ctrl+shift+alt+g |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyH |   h   |                         H |                         H |                          h |         |
+|                     Shift+KeyH |   H   |                   Shift+H |                   Shift+H |                    shift+h |         |
+|                  Ctrl+Alt+KeyH |  ---  |                Ctrl+Alt+H |                Ctrl+Alt+H |                 ctrl+alt+h |         |
+|            Ctrl+Shift+Alt+KeyH |  ---  |          Ctrl+Shift+Alt+H |          Ctrl+Shift+Alt+H |           ctrl+shift+alt+h |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyI |   i   |                         I |                         I |                          i |         |
+|                     Shift+KeyI |   I   |                   Shift+I |                   Shift+I |                    shift+i |         |
+|                  Ctrl+Alt+KeyI |  ---  |                Ctrl+Alt+I |                Ctrl+Alt+I |                 ctrl+alt+i |         |
+|            Ctrl+Shift+Alt+KeyI |  ---  |          Ctrl+Shift+Alt+I |          Ctrl+Shift+Alt+I |           ctrl+shift+alt+i |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyJ |   j   |                         J |                         J |                          j |         |
+|                     Shift+KeyJ |   J   |                   Shift+J |                   Shift+J |                    shift+j |         |
+|                  Ctrl+Alt+KeyJ |  ---  |                Ctrl+Alt+J |                Ctrl+Alt+J |                 ctrl+alt+j |         |
+|            Ctrl+Shift+Alt+KeyJ |  ---  |          Ctrl+Shift+Alt+J |          Ctrl+Shift+Alt+J |           ctrl+shift+alt+j |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyK |   k   |                         K |                         K |                          k |         |
+|                     Shift+KeyK |   K   |                   Shift+K |                   Shift+K |                    shift+k |         |
+|                  Ctrl+Alt+KeyK |  ---  |                Ctrl+Alt+K |                Ctrl+Alt+K |                 ctrl+alt+k |         |
+|            Ctrl+Shift+Alt+KeyK |  ---  |          Ctrl+Shift+Alt+K |          Ctrl+Shift+Alt+K |           ctrl+shift+alt+k |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyL |   l   |                         L |                         L |                          l |         |
+|                     Shift+KeyL |   L   |                   Shift+L |                   Shift+L |                    shift+l |         |
+|                  Ctrl+Alt+KeyL |  ---  |                Ctrl+Alt+L |                Ctrl+Alt+L |                 ctrl+alt+l |         |
+|            Ctrl+Shift+Alt+KeyL |  ---  |          Ctrl+Shift+Alt+L |          Ctrl+Shift+Alt+L |           ctrl+shift+alt+l |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyM |   m   |                         M |                         M |                          m |         |
+|                     Shift+KeyM |   M   |                   Shift+M |                   Shift+M |                    shift+m |         |
+|                  Ctrl+Alt+KeyM |  ---  |                Ctrl+Alt+M |                Ctrl+Alt+M |                 ctrl+alt+m |         |
+|            Ctrl+Shift+Alt+KeyM |  ---  |          Ctrl+Shift+Alt+M |          Ctrl+Shift+Alt+M |           ctrl+shift+alt+m |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyN |   n   |                         N |                         N |                          n |         |
+|                     Shift+KeyN |   N   |                   Shift+N |                   Shift+N |                    shift+n |         |
+|                  Ctrl+Alt+KeyN |  ---  |                Ctrl+Alt+N |                Ctrl+Alt+N |                 ctrl+alt+n |         |
+|            Ctrl+Shift+Alt+KeyN |  ---  |          Ctrl+Shift+Alt+N |          Ctrl+Shift+Alt+N |           ctrl+shift+alt+n |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyO |   o   |                         O |                         O |                          o |         |
+|                     Shift+KeyO |   O   |                   Shift+O |                   Shift+O |                    shift+o |         |
+|                  Ctrl+Alt+KeyO |  ---  |                Ctrl+Alt+O |                Ctrl+Alt+O |                 ctrl+alt+o |         |
+|            Ctrl+Shift+Alt+KeyO |  ---  |          Ctrl+Shift+Alt+O |          Ctrl+Shift+Alt+O |           ctrl+shift+alt+o |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyP |   p   |                         P |                         P |                          p |         |
+|                     Shift+KeyP |   P   |                   Shift+P |                   Shift+P |                    shift+p |         |
+|                  Ctrl+Alt+KeyP |  ---  |                Ctrl+Alt+P |                Ctrl+Alt+P |                 ctrl+alt+p |         |
+|            Ctrl+Shift+Alt+KeyP |  ---  |          Ctrl+Shift+Alt+P |          Ctrl+Shift+Alt+P |           ctrl+shift+alt+p |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyQ |   q   |                         Q |                         Q |                          q |         |
+|                     Shift+KeyQ |   Q   |                   Shift+Q |                   Shift+Q |                    shift+q |         |
+|                  Ctrl+Alt+KeyQ |  ---  |                Ctrl+Alt+Q |                Ctrl+Alt+Q |                 ctrl+alt+q |         |
+|            Ctrl+Shift+Alt+KeyQ |  ---  |          Ctrl+Shift+Alt+Q |          Ctrl+Shift+Alt+Q |           ctrl+shift+alt+q |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyR |   r   |                         R |                         R |                          r |         |
+|                     Shift+KeyR |   R   |                   Shift+R |                   Shift+R |                    shift+r |         |
+|                  Ctrl+Alt+KeyR |  ---  |                Ctrl+Alt+R |                Ctrl+Alt+R |                 ctrl+alt+r |         |
+|            Ctrl+Shift+Alt+KeyR |  ---  |          Ctrl+Shift+Alt+R |          Ctrl+Shift+Alt+R |           ctrl+shift+alt+r |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyS |   s   |                         S |                         S |                          s |         |
+|                     Shift+KeyS |   S   |                   Shift+S |                   Shift+S |                    shift+s |         |
+|                  Ctrl+Alt+KeyS |  ---  |                Ctrl+Alt+S |                Ctrl+Alt+S |                 ctrl+alt+s |         |
+|            Ctrl+Shift+Alt+KeyS |  ---  |          Ctrl+Shift+Alt+S |          Ctrl+Shift+Alt+S |           ctrl+shift+alt+s |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyT |   t   |                         T |                         T |                          t |         |
+|                     Shift+KeyT |   T   |                   Shift+T |                   Shift+T |                    shift+t |         |
+|                  Ctrl+Alt+KeyT |  ---  |                Ctrl+Alt+T |                Ctrl+Alt+T |                 ctrl+alt+t |         |
+|            Ctrl+Shift+Alt+KeyT |  ---  |          Ctrl+Shift+Alt+T |          Ctrl+Shift+Alt+T |           ctrl+shift+alt+t |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyU |   u   |                         U |                         U |                          u |         |
+|                     Shift+KeyU |   U   |                   Shift+U |                   Shift+U |                    shift+u |         |
+|                  Ctrl+Alt+KeyU |  ---  |                Ctrl+Alt+U |                Ctrl+Alt+U |                 ctrl+alt+u |         |
+|            Ctrl+Shift+Alt+KeyU |  ---  |          Ctrl+Shift+Alt+U |          Ctrl+Shift+Alt+U |           ctrl+shift+alt+u |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyV |   v   |                         V |                         V |                          v |         |
+|                     Shift+KeyV |   V   |                   Shift+V |                   Shift+V |                    shift+v |         |
+|                  Ctrl+Alt+KeyV |  ---  |                Ctrl+Alt+V |                Ctrl+Alt+V |                 ctrl+alt+v |         |
+|            Ctrl+Shift+Alt+KeyV |  ---  |          Ctrl+Shift+Alt+V |          Ctrl+Shift+Alt+V |           ctrl+shift+alt+v |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyW |   w   |                         W |                         W |                          w |         |
+|                     Shift+KeyW |   W   |                   Shift+W |                   Shift+W |                    shift+w |         |
+|                  Ctrl+Alt+KeyW |  ---  |                Ctrl+Alt+W |                Ctrl+Alt+W |                 ctrl+alt+w |         |
+|            Ctrl+Shift+Alt+KeyW |  ---  |          Ctrl+Shift+Alt+W |          Ctrl+Shift+Alt+W |           ctrl+shift+alt+w |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyX |   x   |                         X |                         X |                          x |         |
+|                     Shift+KeyX |   X   |                   Shift+X |                   Shift+X |                    shift+x |         |
+|                  Ctrl+Alt+KeyX |  ---  |                Ctrl+Alt+X |                Ctrl+Alt+X |                 ctrl+alt+x |         |
+|            Ctrl+Shift+Alt+KeyX |  ---  |          Ctrl+Shift+Alt+X |          Ctrl+Shift+Alt+X |           ctrl+shift+alt+x |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyY |   z   |                         Z |                         Z |                          z |         |
+|                     Shift+KeyY |   Z   |                   Shift+Z |                   Shift+Z |                    shift+z |         |
+|                  Ctrl+Alt+KeyY |  ---  |                Ctrl+Alt+Z |                Ctrl+Alt+Z |                 ctrl+alt+z |         |
+|            Ctrl+Shift+Alt+KeyY |  ---  |          Ctrl+Shift+Alt+Z |          Ctrl+Shift+Alt+Z |           ctrl+shift+alt+z |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyZ |   y   |                         Y |                         Y |                          y |         |
+|                     Shift+KeyZ |   Y   |                   Shift+Y |                   Shift+Y |                    shift+y |         |
+|                  Ctrl+Alt+KeyZ |  ---  |                Ctrl+Alt+Y |                Ctrl+Alt+Y |                 ctrl+alt+y |         |
+|            Ctrl+Shift+Alt+KeyZ |  ---  |          Ctrl+Shift+Alt+Y |          Ctrl+Shift+Alt+Y |           ctrl+shift+alt+y |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit1 |   1   |                         1 |                         1 |                          1 |         |
+|                   Shift+Digit1 |   +   |                   Shift+1 |                   Shift+1 |                    shift+1 |         |
+|                Ctrl+Alt+Digit1 |   ¦   |                Ctrl+Alt+1 |                Ctrl+Alt+1 |                 ctrl+alt+1 |         |
+|          Ctrl+Shift+Alt+Digit1 |  ---  |          Ctrl+Shift+Alt+1 |          Ctrl+Shift+Alt+1 |           ctrl+shift+alt+1 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit2 |   2   |                         2 |                         2 |                          2 |         |
+|                   Shift+Digit2 |   "   |                   Shift+2 |                   Shift+2 |                    shift+2 |         |
+|                Ctrl+Alt+Digit2 |   @   |                Ctrl+Alt+2 |                Ctrl+Alt+2 |                 ctrl+alt+2 |         |
+|          Ctrl+Shift+Alt+Digit2 |  ---  |          Ctrl+Shift+Alt+2 |          Ctrl+Shift+Alt+2 |           ctrl+shift+alt+2 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit3 |   3   |                         3 |                         3 |                          3 |         |
+|                   Shift+Digit3 |   *   |                   Shift+3 |                   Shift+3 |                    shift+3 |         |
+|                Ctrl+Alt+Digit3 |   #   |                Ctrl+Alt+3 |                Ctrl+Alt+3 |                 ctrl+alt+3 |         |
+|          Ctrl+Shift+Alt+Digit3 |  ---  |          Ctrl+Shift+Alt+3 |          Ctrl+Shift+Alt+3 |           ctrl+shift+alt+3 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit4 |   4   |                         4 |                         4 |                          4 |         |
+|                   Shift+Digit4 |   ç   |                   Shift+4 |                   Shift+4 |                    shift+4 |         |
+|                Ctrl+Alt+Digit4 |   °   |                Ctrl+Alt+4 |                Ctrl+Alt+4 |                 ctrl+alt+4 |         |
+|          Ctrl+Shift+Alt+Digit4 |  ---  |          Ctrl+Shift+Alt+4 |          Ctrl+Shift+Alt+4 |           ctrl+shift+alt+4 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit5 |   5   |                         5 |                         5 |                          5 |         |
+|                   Shift+Digit5 |   %   |                   Shift+5 |                   Shift+5 |                    shift+5 |         |
+|                Ctrl+Alt+Digit5 |   §   |                Ctrl+Alt+5 |                Ctrl+Alt+5 |                 ctrl+alt+5 |         |
+|          Ctrl+Shift+Alt+Digit5 |  ---  |          Ctrl+Shift+Alt+5 |          Ctrl+Shift+Alt+5 |           ctrl+shift+alt+5 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit6 |   6   |                         6 |                         6 |                          6 |         |
+|                   Shift+Digit6 |   &   |                   Shift+6 |                   Shift+6 |                    shift+6 |         |
+|                Ctrl+Alt+Digit6 |   ¬   |                Ctrl+Alt+6 |                Ctrl+Alt+6 |                 ctrl+alt+6 |         |
+|          Ctrl+Shift+Alt+Digit6 |  ---  |          Ctrl+Shift+Alt+6 |          Ctrl+Shift+Alt+6 |           ctrl+shift+alt+6 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit7 |   7   |                         7 |                         7 |                          7 |         |
+|                   Shift+Digit7 |   /   |                   Shift+7 |                   Shift+7 |                    shift+7 |         |
+|                Ctrl+Alt+Digit7 |   |   |                Ctrl+Alt+7 |                Ctrl+Alt+7 |                 ctrl+alt+7 |         |
+|          Ctrl+Shift+Alt+Digit7 |  ---  |          Ctrl+Shift+Alt+7 |          Ctrl+Shift+Alt+7 |           ctrl+shift+alt+7 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit8 |   8   |                         8 |                         8 |                          8 |         |
+|                   Shift+Digit8 |   (   |                   Shift+8 |                   Shift+8 |                    shift+8 |         |
+|                Ctrl+Alt+Digit8 |   ¢   |                Ctrl+Alt+8 |                Ctrl+Alt+8 |                 ctrl+alt+8 |         |
+|          Ctrl+Shift+Alt+Digit8 |  ---  |          Ctrl+Shift+Alt+8 |          Ctrl+Shift+Alt+8 |           ctrl+shift+alt+8 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit9 |   9   |                         9 |                         9 |                          9 |         |
+|                   Shift+Digit9 |   )   |                   Shift+9 |                   Shift+9 |                    shift+9 |         |
+|                Ctrl+Alt+Digit9 |  ---  |                Ctrl+Alt+9 |                Ctrl+Alt+9 |                 ctrl+alt+9 |         |
+|          Ctrl+Shift+Alt+Digit9 |  ---  |          Ctrl+Shift+Alt+9 |          Ctrl+Shift+Alt+9 |           ctrl+shift+alt+9 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit0 |   0   |                         0 |                         0 |                          0 |         |
+|                   Shift+Digit0 |   =   |                   Shift+0 |                   Shift+0 |                    shift+0 |         |
+|                Ctrl+Alt+Digit0 |  ---  |                Ctrl+Alt+0 |                Ctrl+Alt+0 |                 ctrl+alt+0 |         |
+|          Ctrl+Shift+Alt+Digit0 |  ---  |          Ctrl+Shift+Alt+0 |          Ctrl+Shift+Alt+0 |           ctrl+shift+alt+0 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                          Minus |   '   |                         [ |                         ' |                      oem_4 |    NO   |
+|                    Shift+Minus |   ?   |                   Shift+[ |                   Shift+' |                shift+oem_4 |    NO   |
+|                 Ctrl+Alt+Minus |   ´   |                Ctrl+Alt+[ |                Ctrl+Alt+' |             ctrl+alt+oem_4 |    NO   |
+|           Ctrl+Shift+Alt+Minus |  ---  |          Ctrl+Shift+Alt+[ |          Ctrl+Shift+Alt+' |       ctrl+shift+alt+oem_4 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                          Equal |   ^   |                         ] |                         ^ |                      oem_6 |    NO   |
+|                    Shift+Equal |   `   |                   Shift+] |                   Shift+^ |                shift+oem_6 |    NO   |
+|                 Ctrl+Alt+Equal |   ~   |                Ctrl+Alt+] |                Ctrl+Alt+^ |             ctrl+alt+oem_6 |    NO   |
+|           Ctrl+Shift+Alt+Equal |  ---  |          Ctrl+Shift+Alt+] |          Ctrl+Shift+Alt+^ |       ctrl+shift+alt+oem_6 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                    BracketLeft |   ü   |                         ; |                         ü |                      oem_1 |    NO   |
+|              Shift+BracketLeft |   è   |                   Shift+; |                   Shift+ü |                shift+oem_1 |    NO   |
+|           Ctrl+Alt+BracketLeft |   [   |                Ctrl+Alt+; |                Ctrl+Alt+ü |             ctrl+alt+oem_1 |    NO   |
+|     Ctrl+Shift+Alt+BracketLeft |  ---  |          Ctrl+Shift+Alt+; |          Ctrl+Shift+Alt+ü |       ctrl+shift+alt+oem_1 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                   BracketRight |   ¨   |                         ` |                         ¨ |                      oem_3 |    NO   |
+|             Shift+BracketRight |   !   |                   Shift+` |                   Shift+¨ |                shift+oem_3 |    NO   |
+|          Ctrl+Alt+BracketRight |   ]   |                Ctrl+Alt+` |                Ctrl+Alt+¨ |             ctrl+alt+oem_3 |    NO   |
+|    Ctrl+Shift+Alt+BracketRight |  ---  |          Ctrl+Shift+Alt+` |          Ctrl+Shift+Alt+¨ |       ctrl+shift+alt+oem_3 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                      Backslash |   $   |                     OEM_8 |                         $ |                      oem_8 |    NO   |
+|                Shift+Backslash |   £   |               Shift+OEM_8 |                   Shift+$ |                shift+oem_8 |    NO   |
+|             Ctrl+Alt+Backslash |   }   |            Ctrl+Alt+OEM_8 |                Ctrl+Alt+$ |             ctrl+alt+oem_8 |    NO   |
+|       Ctrl+Shift+Alt+Backslash |  ---  |      Ctrl+Shift+Alt+OEM_8 |          Ctrl+Shift+Alt+$ |       ctrl+shift+alt+oem_8 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                       IntlHash |  ---  |                      null |                      null |                       null |    NO   |
+|                 Shift+IntlHash |  ---  |                      null |                      null |                       null |    NO   |
+|              Ctrl+Alt+IntlHash |  ---  |                      null |                      null |                       null |    NO   |
+|        Ctrl+Shift+Alt+IntlHash |  ---  |                      null |                      null |                       null |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                      Semicolon |   ö   |                         ' |                         ö |                      oem_7 |    NO   |
+|                Shift+Semicolon |   é   |                   Shift+' |                   Shift+ö |                shift+oem_7 |    NO   |
+|             Ctrl+Alt+Semicolon |  ---  |                Ctrl+Alt+' |                Ctrl+Alt+ö |             ctrl+alt+oem_7 |    NO   |
+|       Ctrl+Shift+Alt+Semicolon |  ---  |          Ctrl+Shift+Alt+' |          Ctrl+Shift+Alt+ö |       ctrl+shift+alt+oem_7 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                          Quote |   ä   |                         \ |                         ä |                      oem_5 |    NO   |
+|                    Shift+Quote |   à   |                   Shift+\ |                   Shift+ä |                shift+oem_5 |    NO   |
+|                 Ctrl+Alt+Quote |   {   |                Ctrl+Alt+\ |                Ctrl+Alt+ä |             ctrl+alt+oem_5 |    NO   |
+|           Ctrl+Shift+Alt+Quote |  ---  |          Ctrl+Shift+Alt+\ |          Ctrl+Shift+Alt+ä |       ctrl+shift+alt+oem_5 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                      Backquote |   §   |                         / |                         § |                      oem_2 |    NO   |
+|                Shift+Backquote |   °   |                   Shift+/ |                   Shift+§ |                shift+oem_2 |    NO   |
+|             Ctrl+Alt+Backquote |  ---  |                Ctrl+Alt+/ |                Ctrl+Alt+§ |             ctrl+alt+oem_2 |    NO   |
+|       Ctrl+Shift+Alt+Backquote |  ---  |          Ctrl+Shift+Alt+/ |          Ctrl+Shift+Alt+§ |       ctrl+shift+alt+oem_2 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                          Comma |   ,   |                         , |                         , |                  oem_comma |    NO   |
+|                    Shift+Comma |   ;   |                   Shift+, |                   Shift+, |            shift+oem_comma |    NO   |
+|                 Ctrl+Alt+Comma |  ---  |                Ctrl+Alt+, |                Ctrl+Alt+, |         ctrl+alt+oem_comma |    NO   |
+|           Ctrl+Shift+Alt+Comma |  ---  |          Ctrl+Shift+Alt+, |          Ctrl+Shift+Alt+, |   ctrl+shift+alt+oem_comma |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Period |   .   |                         . |                         . |                 oem_period |    NO   |
+|                   Shift+Period |   :   |                   Shift+. |                   Shift+. |           shift+oem_period |    NO   |
+|                Ctrl+Alt+Period |  ---  |                Ctrl+Alt+. |                Ctrl+Alt+. |        ctrl+alt+oem_period |    NO   |
+|          Ctrl+Shift+Alt+Period |  ---  |          Ctrl+Shift+Alt+. |          Ctrl+Shift+Alt+. |  ctrl+shift+alt+oem_period |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                          Slash |   -   |                         - |                         - |                  oem_minus |    NO   |
+|                    Shift+Slash |   _   |                   Shift+- |                   Shift+- |            shift+oem_minus |    NO   |
+|                 Ctrl+Alt+Slash |  ---  |                Ctrl+Alt+- |                Ctrl+Alt+- |         ctrl+alt+oem_minus |    NO   |
+|           Ctrl+Shift+Alt+Slash |  ---  |          Ctrl+Shift+Alt+- |          Ctrl+Shift+Alt+- |   ctrl+shift+alt+oem_minus |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                        ArrowUp |  ---  |                   UpArrow |                   UpArrow |                         up |         |
+|                  Shift+ArrowUp |  ---  |             Shift+UpArrow |             Shift+UpArrow |                   shift+up |         |
+|               Ctrl+Alt+ArrowUp |  ---  |          Ctrl+Alt+UpArrow |          Ctrl+Alt+UpArrow |                ctrl+alt+up |         |
+|         Ctrl+Shift+Alt+ArrowUp |  ---  |    Ctrl+Shift+Alt+UpArrow |    Ctrl+Shift+Alt+UpArrow |          ctrl+shift+alt+up |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                        Numpad0 |  ---  |                   NumPad0 |                   NumPad0 |                    numpad0 |         |
+|                  Shift+Numpad0 |  ---  |             Shift+NumPad0 |             Shift+NumPad0 |              shift+numpad0 |         |
+|               Ctrl+Alt+Numpad0 |  ---  |          Ctrl+Alt+NumPad0 |          Ctrl+Alt+NumPad0 |           ctrl+alt+numpad0 |         |
+|         Ctrl+Shift+Alt+Numpad0 |  ---  |    Ctrl+Shift+Alt+NumPad0 |    Ctrl+Shift+Alt+NumPad0 |     ctrl+shift+alt+numpad0 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                  IntlBackslash |   <   |                   OEM_102 |                         < |                    oem_102 |    NO   |
+|            Shift+IntlBackslash |   >   |             Shift+OEM_102 |                   Shift+< |              shift+oem_102 |    NO   |
+|         Ctrl+Alt+IntlBackslash |   \   |          Ctrl+Alt+OEM_102 |                Ctrl+Alt+< |           ctrl+alt+oem_102 |    NO   |
+|   Ctrl+Shift+Alt+IntlBackslash |  ---  |    Ctrl+Shift+Alt+OEM_102 |          Ctrl+Shift+Alt+< |     ctrl+shift+alt+oem_102 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         IntlRo |  ---  |                      null |                      null |                       null |    NO   |
+|                   Shift+IntlRo |  ---  |                      null |                      null |                       null |    NO   |
+|                Ctrl+Alt+IntlRo |  ---  |                      null |                      null |                       null |    NO   |
+|          Ctrl+Shift+Alt+IntlRo |  ---  |                      null |                      null |                       null |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                        IntlYen |  ---  |                      null |                      null |                       null |    NO   |
+|                  Shift+IntlYen |  ---  |                      null |                      null |                       null |    NO   |
+|               Ctrl+Alt+IntlYen |  ---  |                      null |                      null |                       null |    NO   |
+|         Ctrl+Shift+Alt+IntlYen |  ---  |                      null |                      null |                       null |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------

lib/vscode/src/vs/workbench/services/keybinding/test/electron-browser/win_en_us.txt

@@ -0,0 +1,284 @@
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyA |   a   |                         A |                         A |                          a |         |
+|                     Shift+KeyA |   A   |                   Shift+A |                   Shift+A |                    shift+a |         |
+|                  Ctrl+Alt+KeyA |  ---  |                Ctrl+Alt+A |                Ctrl+Alt+A |                 ctrl+alt+a |         |
+|            Ctrl+Shift+Alt+KeyA |  ---  |          Ctrl+Shift+Alt+A |          Ctrl+Shift+Alt+A |           ctrl+shift+alt+a |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyB |   b   |                         B |                         B |                          b |         |
+|                     Shift+KeyB |   B   |                   Shift+B |                   Shift+B |                    shift+b |         |
+|                  Ctrl+Alt+KeyB |  ---  |                Ctrl+Alt+B |                Ctrl+Alt+B |                 ctrl+alt+b |         |
+|            Ctrl+Shift+Alt+KeyB |  ---  |          Ctrl+Shift+Alt+B |          Ctrl+Shift+Alt+B |           ctrl+shift+alt+b |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyC |   c   |                         C |                         C |                          c |         |
+|                     Shift+KeyC |   C   |                   Shift+C |                   Shift+C |                    shift+c |         |
+|                  Ctrl+Alt+KeyC |  ---  |                Ctrl+Alt+C |                Ctrl+Alt+C |                 ctrl+alt+c |         |
+|            Ctrl+Shift+Alt+KeyC |  ---  |          Ctrl+Shift+Alt+C |          Ctrl+Shift+Alt+C |           ctrl+shift+alt+c |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyD |   d   |                         D |                         D |                          d |         |
+|                     Shift+KeyD |   D   |                   Shift+D |                   Shift+D |                    shift+d |         |
+|                  Ctrl+Alt+KeyD |  ---  |                Ctrl+Alt+D |                Ctrl+Alt+D |                 ctrl+alt+d |         |
+|            Ctrl+Shift+Alt+KeyD |  ---  |          Ctrl+Shift+Alt+D |          Ctrl+Shift+Alt+D |           ctrl+shift+alt+d |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyE |   e   |                         E |                         E |                          e |         |
+|                     Shift+KeyE |   E   |                   Shift+E |                   Shift+E |                    shift+e |         |
+|                  Ctrl+Alt+KeyE |  ---  |                Ctrl+Alt+E |                Ctrl+Alt+E |                 ctrl+alt+e |         |
+|            Ctrl+Shift+Alt+KeyE |  ---  |          Ctrl+Shift+Alt+E |          Ctrl+Shift+Alt+E |           ctrl+shift+alt+e |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyF |   f   |                         F |                         F |                          f |         |
+|                     Shift+KeyF |   F   |                   Shift+F |                   Shift+F |                    shift+f |         |
+|                  Ctrl+Alt+KeyF |  ---  |                Ctrl+Alt+F |                Ctrl+Alt+F |                 ctrl+alt+f |         |
+|            Ctrl+Shift+Alt+KeyF |  ---  |          Ctrl+Shift+Alt+F |          Ctrl+Shift+Alt+F |           ctrl+shift+alt+f |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyG |   g   |                         G |                         G |                          g |         |
+|                     Shift+KeyG |   G   |                   Shift+G |                   Shift+G |                    shift+g |         |
+|                  Ctrl+Alt+KeyG |  ---  |                Ctrl+Alt+G |                Ctrl+Alt+G |                 ctrl+alt+g |         |
+|            Ctrl+Shift+Alt+KeyG |  ---  |          Ctrl+Shift+Alt+G |          Ctrl+Shift+Alt+G |           ctrl+shift+alt+g |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyH |   h   |                         H |                         H |                          h |         |
+|                     Shift+KeyH |   H   |                   Shift+H |                   Shift+H |                    shift+h |         |
+|                  Ctrl+Alt+KeyH |  ---  |                Ctrl+Alt+H |                Ctrl+Alt+H |                 ctrl+alt+h |         |
+|            Ctrl+Shift+Alt+KeyH |  ---  |          Ctrl+Shift+Alt+H |          Ctrl+Shift+Alt+H |           ctrl+shift+alt+h |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyI |   i   |                         I |                         I |                          i |         |
+|                     Shift+KeyI |   I   |                   Shift+I |                   Shift+I |                    shift+i |         |
+|                  Ctrl+Alt+KeyI |  ---  |                Ctrl+Alt+I |                Ctrl+Alt+I |                 ctrl+alt+i |         |
+|            Ctrl+Shift+Alt+KeyI |  ---  |          Ctrl+Shift+Alt+I |          Ctrl+Shift+Alt+I |           ctrl+shift+alt+i |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyJ |   j   |                         J |                         J |                          j |         |
+|                     Shift+KeyJ |   J   |                   Shift+J |                   Shift+J |                    shift+j |         |
+|                  Ctrl+Alt+KeyJ |  ---  |                Ctrl+Alt+J |                Ctrl+Alt+J |                 ctrl+alt+j |         |
+|            Ctrl+Shift+Alt+KeyJ |  ---  |          Ctrl+Shift+Alt+J |          Ctrl+Shift+Alt+J |           ctrl+shift+alt+j |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyK |   k   |                         K |                         K |                          k |         |
+|                     Shift+KeyK |   K   |                   Shift+K |                   Shift+K |                    shift+k |         |
+|                  Ctrl+Alt+KeyK |  ---  |                Ctrl+Alt+K |                Ctrl+Alt+K |                 ctrl+alt+k |         |
+|            Ctrl+Shift+Alt+KeyK |  ---  |          Ctrl+Shift+Alt+K |          Ctrl+Shift+Alt+K |           ctrl+shift+alt+k |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyL |   l   |                         L |                         L |                          l |         |
+|                     Shift+KeyL |   L   |                   Shift+L |                   Shift+L |                    shift+l |         |
+|                  Ctrl+Alt+KeyL |  ---  |                Ctrl+Alt+L |                Ctrl+Alt+L |                 ctrl+alt+l |         |
+|            Ctrl+Shift+Alt+KeyL |  ---  |          Ctrl+Shift+Alt+L |          Ctrl+Shift+Alt+L |           ctrl+shift+alt+l |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyM |   m   |                         M |                         M |                          m |         |
+|                     Shift+KeyM |   M   |                   Shift+M |                   Shift+M |                    shift+m |         |
+|                  Ctrl+Alt+KeyM |  ---  |                Ctrl+Alt+M |                Ctrl+Alt+M |                 ctrl+alt+m |         |
+|            Ctrl+Shift+Alt+KeyM |  ---  |          Ctrl+Shift+Alt+M |          Ctrl+Shift+Alt+M |           ctrl+shift+alt+m |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyN |   n   |                         N |                         N |                          n |         |
+|                     Shift+KeyN |   N   |                   Shift+N |                   Shift+N |                    shift+n |         |
+|                  Ctrl+Alt+KeyN |  ---  |                Ctrl+Alt+N |                Ctrl+Alt+N |                 ctrl+alt+n |         |
+|            Ctrl+Shift+Alt+KeyN |  ---  |          Ctrl+Shift+Alt+N |          Ctrl+Shift+Alt+N |           ctrl+shift+alt+n |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyO |   o   |                         O |                         O |                          o |         |
+|                     Shift+KeyO |   O   |                   Shift+O |                   Shift+O |                    shift+o |         |
+|                  Ctrl+Alt+KeyO |  ---  |                Ctrl+Alt+O |                Ctrl+Alt+O |                 ctrl+alt+o |         |
+|            Ctrl+Shift+Alt+KeyO |  ---  |          Ctrl+Shift+Alt+O |          Ctrl+Shift+Alt+O |           ctrl+shift+alt+o |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyP |   p   |                         P |                         P |                          p |         |
+|                     Shift+KeyP |   P   |                   Shift+P |                   Shift+P |                    shift+p |         |
+|                  Ctrl+Alt+KeyP |  ---  |                Ctrl+Alt+P |                Ctrl+Alt+P |                 ctrl+alt+p |         |
+|            Ctrl+Shift+Alt+KeyP |  ---  |          Ctrl+Shift+Alt+P |          Ctrl+Shift+Alt+P |           ctrl+shift+alt+p |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyQ |   q   |                         Q |                         Q |                          q |         |
+|                     Shift+KeyQ |   Q   |                   Shift+Q |                   Shift+Q |                    shift+q |         |
+|                  Ctrl+Alt+KeyQ |  ---  |                Ctrl+Alt+Q |                Ctrl+Alt+Q |                 ctrl+alt+q |         |
+|            Ctrl+Shift+Alt+KeyQ |  ---  |          Ctrl+Shift+Alt+Q |          Ctrl+Shift+Alt+Q |           ctrl+shift+alt+q |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyR |   r   |                         R |                         R |                          r |         |
+|                     Shift+KeyR |   R   |                   Shift+R |                   Shift+R |                    shift+r |         |
+|                  Ctrl+Alt+KeyR |  ---  |                Ctrl+Alt+R |                Ctrl+Alt+R |                 ctrl+alt+r |         |
+|            Ctrl+Shift+Alt+KeyR |  ---  |          Ctrl+Shift+Alt+R |          Ctrl+Shift+Alt+R |           ctrl+shift+alt+r |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyS |   s   |                         S |                         S |                          s |         |
+|                     Shift+KeyS |   S   |                   Shift+S |                   Shift+S |                    shift+s |         |
+|                  Ctrl+Alt+KeyS |  ---  |                Ctrl+Alt+S |                Ctrl+Alt+S |                 ctrl+alt+s |         |
+|            Ctrl+Shift+Alt+KeyS |  ---  |          Ctrl+Shift+Alt+S |          Ctrl+Shift+Alt+S |           ctrl+shift+alt+s |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyT |   t   |                         T |                         T |                          t |         |
+|                     Shift+KeyT |   T   |                   Shift+T |                   Shift+T |                    shift+t |         |
+|                  Ctrl+Alt+KeyT |  ---  |                Ctrl+Alt+T |                Ctrl+Alt+T |                 ctrl+alt+t |         |
+|            Ctrl+Shift+Alt+KeyT |  ---  |          Ctrl+Shift+Alt+T |          Ctrl+Shift+Alt+T |           ctrl+shift+alt+t |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyU |   u   |                         U |                         U |                          u |         |
+|                     Shift+KeyU |   U   |                   Shift+U |                   Shift+U |                    shift+u |         |
+|                  Ctrl+Alt+KeyU |  ---  |                Ctrl+Alt+U |                Ctrl+Alt+U |                 ctrl+alt+u |         |
+|            Ctrl+Shift+Alt+KeyU |  ---  |          Ctrl+Shift+Alt+U |          Ctrl+Shift+Alt+U |           ctrl+shift+alt+u |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyV |   v   |                         V |                         V |                          v |         |
+|                     Shift+KeyV |   V   |                   Shift+V |                   Shift+V |                    shift+v |         |
+|                  Ctrl+Alt+KeyV |  ---  |                Ctrl+Alt+V |                Ctrl+Alt+V |                 ctrl+alt+v |         |
+|            Ctrl+Shift+Alt+KeyV |  ---  |          Ctrl+Shift+Alt+V |          Ctrl+Shift+Alt+V |           ctrl+shift+alt+v |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyW |   w   |                         W |                         W |                          w |         |
+|                     Shift+KeyW |   W   |                   Shift+W |                   Shift+W |                    shift+w |         |
+|                  Ctrl+Alt+KeyW |  ---  |                Ctrl+Alt+W |                Ctrl+Alt+W |                 ctrl+alt+w |         |
+|            Ctrl+Shift+Alt+KeyW |  ---  |          Ctrl+Shift+Alt+W |          Ctrl+Shift+Alt+W |           ctrl+shift+alt+w |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyX |   x   |                         X |                         X |                          x |         |
+|                     Shift+KeyX |   X   |                   Shift+X |                   Shift+X |                    shift+x |         |
+|                  Ctrl+Alt+KeyX |  ---  |                Ctrl+Alt+X |                Ctrl+Alt+X |                 ctrl+alt+x |         |
+|            Ctrl+Shift+Alt+KeyX |  ---  |          Ctrl+Shift+Alt+X |          Ctrl+Shift+Alt+X |           ctrl+shift+alt+x |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyY |   y   |                         Y |                         Y |                          y |         |
+|                     Shift+KeyY |   Y   |                   Shift+Y |                   Shift+Y |                    shift+y |         |
+|                  Ctrl+Alt+KeyY |  ---  |                Ctrl+Alt+Y |                Ctrl+Alt+Y |                 ctrl+alt+y |         |
+|            Ctrl+Shift+Alt+KeyY |  ---  |          Ctrl+Shift+Alt+Y |          Ctrl+Shift+Alt+Y |           ctrl+shift+alt+y |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyZ |   z   |                         Z |                         Z |                          z |         |
+|                     Shift+KeyZ |   Z   |                   Shift+Z |                   Shift+Z |                    shift+z |         |
+|                  Ctrl+Alt+KeyZ |  ---  |                Ctrl+Alt+Z |                Ctrl+Alt+Z |                 ctrl+alt+z |         |
+|            Ctrl+Shift+Alt+KeyZ |  ---  |          Ctrl+Shift+Alt+Z |          Ctrl+Shift+Alt+Z |           ctrl+shift+alt+z |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit1 |   1   |                         1 |                         1 |                          1 |         |
+|                   Shift+Digit1 |   !   |                   Shift+1 |                   Shift+1 |                    shift+1 |         |
+|                Ctrl+Alt+Digit1 |  ---  |                Ctrl+Alt+1 |                Ctrl+Alt+1 |                 ctrl+alt+1 |         |
+|          Ctrl+Shift+Alt+Digit1 |  ---  |          Ctrl+Shift+Alt+1 |          Ctrl+Shift+Alt+1 |           ctrl+shift+alt+1 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit2 |   2   |                         2 |                         2 |                          2 |         |
+|                   Shift+Digit2 |   @   |                   Shift+2 |                   Shift+2 |                    shift+2 |         |
+|                Ctrl+Alt+Digit2 |  ---  |                Ctrl+Alt+2 |                Ctrl+Alt+2 |                 ctrl+alt+2 |         |
+|          Ctrl+Shift+Alt+Digit2 |  ---  |          Ctrl+Shift+Alt+2 |          Ctrl+Shift+Alt+2 |           ctrl+shift+alt+2 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit3 |   3   |                         3 |                         3 |                          3 |         |
+|                   Shift+Digit3 |   #   |                   Shift+3 |                   Shift+3 |                    shift+3 |         |
+|                Ctrl+Alt+Digit3 |  ---  |                Ctrl+Alt+3 |                Ctrl+Alt+3 |                 ctrl+alt+3 |         |
+|          Ctrl+Shift+Alt+Digit3 |  ---  |          Ctrl+Shift+Alt+3 |          Ctrl+Shift+Alt+3 |           ctrl+shift+alt+3 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit4 |   4   |                         4 |                         4 |                          4 |         |
+|                   Shift+Digit4 |   $   |                   Shift+4 |                   Shift+4 |                    shift+4 |         |
+|                Ctrl+Alt+Digit4 |  ---  |                Ctrl+Alt+4 |                Ctrl+Alt+4 |                 ctrl+alt+4 |         |
+|          Ctrl+Shift+Alt+Digit4 |  ---  |          Ctrl+Shift+Alt+4 |          Ctrl+Shift+Alt+4 |           ctrl+shift+alt+4 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit5 |   5   |                         5 |                         5 |                          5 |         |
+|                   Shift+Digit5 |   %   |                   Shift+5 |                   Shift+5 |                    shift+5 |         |
+|                Ctrl+Alt+Digit5 |  ---  |                Ctrl+Alt+5 |                Ctrl+Alt+5 |                 ctrl+alt+5 |         |
+|          Ctrl+Shift+Alt+Digit5 |  ---  |          Ctrl+Shift+Alt+5 |          Ctrl+Shift+Alt+5 |           ctrl+shift+alt+5 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit6 |   6   |                         6 |                         6 |                          6 |         |
+|                   Shift+Digit6 |   ^   |                   Shift+6 |                   Shift+6 |                    shift+6 |         |
+|                Ctrl+Alt+Digit6 |  ---  |                Ctrl+Alt+6 |                Ctrl+Alt+6 |                 ctrl+alt+6 |         |
+|          Ctrl+Shift+Alt+Digit6 |  ---  |          Ctrl+Shift+Alt+6 |          Ctrl+Shift+Alt+6 |           ctrl+shift+alt+6 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit7 |   7   |                         7 |                         7 |                          7 |         |
+|                   Shift+Digit7 |   &   |                   Shift+7 |                   Shift+7 |                    shift+7 |         |
+|                Ctrl+Alt+Digit7 |  ---  |                Ctrl+Alt+7 |                Ctrl+Alt+7 |                 ctrl+alt+7 |         |
+|          Ctrl+Shift+Alt+Digit7 |  ---  |          Ctrl+Shift+Alt+7 |          Ctrl+Shift+Alt+7 |           ctrl+shift+alt+7 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit8 |   8   |                         8 |                         8 |                          8 |         |
+|                   Shift+Digit8 |   *   |                   Shift+8 |                   Shift+8 |                    shift+8 |         |
+|                Ctrl+Alt+Digit8 |  ---  |                Ctrl+Alt+8 |                Ctrl+Alt+8 |                 ctrl+alt+8 |         |
+|          Ctrl+Shift+Alt+Digit8 |  ---  |          Ctrl+Shift+Alt+8 |          Ctrl+Shift+Alt+8 |           ctrl+shift+alt+8 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit9 |   9   |                         9 |                         9 |                          9 |         |
+|                   Shift+Digit9 |   (   |                   Shift+9 |                   Shift+9 |                    shift+9 |         |
+|                Ctrl+Alt+Digit9 |  ---  |                Ctrl+Alt+9 |                Ctrl+Alt+9 |                 ctrl+alt+9 |         |
+|          Ctrl+Shift+Alt+Digit9 |  ---  |          Ctrl+Shift+Alt+9 |          Ctrl+Shift+Alt+9 |           ctrl+shift+alt+9 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit0 |   0   |                         0 |                         0 |                          0 |         |
+|                   Shift+Digit0 |   )   |                   Shift+0 |                   Shift+0 |                    shift+0 |         |
+|                Ctrl+Alt+Digit0 |  ---  |                Ctrl+Alt+0 |                Ctrl+Alt+0 |                 ctrl+alt+0 |         |
+|          Ctrl+Shift+Alt+Digit0 |  ---  |          Ctrl+Shift+Alt+0 |          Ctrl+Shift+Alt+0 |           ctrl+shift+alt+0 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                          Minus |   -   |                         - |                         - |                          - |         |
+|                    Shift+Minus |   _   |                   Shift+- |                   Shift+- |                    shift+- |         |
+|                 Ctrl+Alt+Minus |  ---  |                Ctrl+Alt+- |                Ctrl+Alt+- |                 ctrl+alt+- |         |
+|           Ctrl+Shift+Alt+Minus |  ---  |          Ctrl+Shift+Alt+- |          Ctrl+Shift+Alt+- |           ctrl+shift+alt+- |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                          Equal |   =   |                         = |                         = |                          = |         |
+|                    Shift+Equal |   +   |                   Shift+= |                   Shift+= |                    shift+= |         |
+|                 Ctrl+Alt+Equal |  ---  |                Ctrl+Alt+= |                Ctrl+Alt+= |                 ctrl+alt+= |         |
+|           Ctrl+Shift+Alt+Equal |  ---  |          Ctrl+Shift+Alt+= |          Ctrl+Shift+Alt+= |           ctrl+shift+alt+= |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                    BracketLeft |   [   |                         [ |                         [ |                          [ |         |
+|              Shift+BracketLeft |   {   |                   Shift+[ |                   Shift+[ |                    shift+[ |         |
+|           Ctrl+Alt+BracketLeft |  ---  |                Ctrl+Alt+[ |                Ctrl+Alt+[ |                 ctrl+alt+[ |         |
+|     Ctrl+Shift+Alt+BracketLeft |  ---  |          Ctrl+Shift+Alt+[ |          Ctrl+Shift+Alt+[ |           ctrl+shift+alt+[ |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                   BracketRight |   ]   |                         ] |                         ] |                          ] |         |
+|             Shift+BracketRight |   }   |                   Shift+] |                   Shift+] |                    shift+] |         |
+|          Ctrl+Alt+BracketRight |  ---  |                Ctrl+Alt+] |                Ctrl+Alt+] |                 ctrl+alt+] |         |
+|    Ctrl+Shift+Alt+BracketRight |  ---  |          Ctrl+Shift+Alt+] |          Ctrl+Shift+Alt+] |           ctrl+shift+alt+] |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                      Backslash |   \   |                         \ |                         \ |                          \ |         |
+|                Shift+Backslash |   |   |                   Shift+\ |                   Shift+\ |                    shift+\ |         |
+|             Ctrl+Alt+Backslash |  ---  |                Ctrl+Alt+\ |                Ctrl+Alt+\ |                 ctrl+alt+\ |         |
+|       Ctrl+Shift+Alt+Backslash |  ---  |          Ctrl+Shift+Alt+\ |          Ctrl+Shift+Alt+\ |           ctrl+shift+alt+\ |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                       IntlHash |  ---  |                      null |                      null |                       null |    NO   |
+|                 Shift+IntlHash |  ---  |                      null |                      null |                       null |    NO   |
+|              Ctrl+Alt+IntlHash |  ---  |                      null |                      null |                       null |    NO   |
+|        Ctrl+Shift+Alt+IntlHash |  ---  |                      null |                      null |                       null |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                      Semicolon |   ;   |                         ; |                         ; |                          ; |         |
+|                Shift+Semicolon |   :   |                   Shift+; |                   Shift+; |                    shift+; |         |
+|             Ctrl+Alt+Semicolon |  ---  |                Ctrl+Alt+; |                Ctrl+Alt+; |                 ctrl+alt+; |         |
+|       Ctrl+Shift+Alt+Semicolon |  ---  |          Ctrl+Shift+Alt+; |          Ctrl+Shift+Alt+; |           ctrl+shift+alt+; |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                          Quote |   '   |                         ' |                         ' |                          ' |         |
+|                    Shift+Quote |   "   |                   Shift+' |                   Shift+' |                    shift+' |         |
+|                 Ctrl+Alt+Quote |  ---  |                Ctrl+Alt+' |                Ctrl+Alt+' |                 ctrl+alt+' |         |
+|           Ctrl+Shift+Alt+Quote |  ---  |          Ctrl+Shift+Alt+' |          Ctrl+Shift+Alt+' |           ctrl+shift+alt+' |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                      Backquote |   `   |                         ` |                         ` |                          ` |         |
+|                Shift+Backquote |   ~   |                   Shift+` |                   Shift+` |                    shift+` |         |
+|             Ctrl+Alt+Backquote |  ---  |                Ctrl+Alt+` |                Ctrl+Alt+` |                 ctrl+alt+` |         |
+|       Ctrl+Shift+Alt+Backquote |  ---  |          Ctrl+Shift+Alt+` |          Ctrl+Shift+Alt+` |           ctrl+shift+alt+` |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                          Comma |   ,   |                         , |                         , |                          , |         |
+|                    Shift+Comma |   <   |                   Shift+, |                   Shift+, |                    shift+, |         |
+|                 Ctrl+Alt+Comma |  ---  |                Ctrl+Alt+, |                Ctrl+Alt+, |                 ctrl+alt+, |         |
+|           Ctrl+Shift+Alt+Comma |  ---  |          Ctrl+Shift+Alt+, |          Ctrl+Shift+Alt+, |           ctrl+shift+alt+, |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Period |   .   |                         . |                         . |                          . |         |
+|                   Shift+Period |   >   |                   Shift+. |                   Shift+. |                    shift+. |         |
+|                Ctrl+Alt+Period |  ---  |                Ctrl+Alt+. |                Ctrl+Alt+. |                 ctrl+alt+. |         |
+|          Ctrl+Shift+Alt+Period |  ---  |          Ctrl+Shift+Alt+. |          Ctrl+Shift+Alt+. |           ctrl+shift+alt+. |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                          Slash |   /   |                         / |                         / |                          / |         |
+|                    Shift+Slash |   ?   |                   Shift+/ |                   Shift+/ |                    shift+/ |         |
+|                 Ctrl+Alt+Slash |  ---  |                Ctrl+Alt+/ |                Ctrl+Alt+/ |                 ctrl+alt+/ |         |
+|           Ctrl+Shift+Alt+Slash |  ---  |          Ctrl+Shift+Alt+/ |          Ctrl+Shift+Alt+/ |           ctrl+shift+alt+/ |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                        ArrowUp |  ---  |                   UpArrow |                   UpArrow |                         up |         |
+|                  Shift+ArrowUp |  ---  |             Shift+UpArrow |             Shift+UpArrow |                   shift+up |         |
+|               Ctrl+Alt+ArrowUp |  ---  |          Ctrl+Alt+UpArrow |          Ctrl+Alt+UpArrow |                ctrl+alt+up |         |
+|         Ctrl+Shift+Alt+ArrowUp |  ---  |    Ctrl+Shift+Alt+UpArrow |    Ctrl+Shift+Alt+UpArrow |          ctrl+shift+alt+up |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                        Numpad0 |  ---  |                   NumPad0 |                   NumPad0 |                    numpad0 |         |
+|                  Shift+Numpad0 |  ---  |             Shift+NumPad0 |             Shift+NumPad0 |              shift+numpad0 |         |
+|               Ctrl+Alt+Numpad0 |  ---  |          Ctrl+Alt+NumPad0 |          Ctrl+Alt+NumPad0 |           ctrl+alt+numpad0 |         |
+|         Ctrl+Shift+Alt+Numpad0 |  ---  |    Ctrl+Shift+Alt+NumPad0 |    Ctrl+Shift+Alt+NumPad0 |     ctrl+shift+alt+numpad0 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                  IntlBackslash |   \   |                   OEM_102 |                         \ |                    oem_102 |    NO   |
+|            Shift+IntlBackslash |   |   |             Shift+OEM_102 |                   Shift+\ |              shift+oem_102 |    NO   |
+|         Ctrl+Alt+IntlBackslash |  ---  |          Ctrl+Alt+OEM_102 |                Ctrl+Alt+\ |           ctrl+alt+oem_102 |    NO   |
+|   Ctrl+Shift+Alt+IntlBackslash |  ---  |    Ctrl+Shift+Alt+OEM_102 |          Ctrl+Shift+Alt+\ |     ctrl+shift+alt+oem_102 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         IntlRo |  ---  |                      null |                      null |                       null |    NO   |
+|                   Shift+IntlRo |  ---  |                      null |                      null |                       null |    NO   |
+|                Ctrl+Alt+IntlRo |  ---  |                      null |                      null |                       null |    NO   |
+|          Ctrl+Shift+Alt+IntlRo |  ---  |                      null |                      null |                       null |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                        IntlYen |  ---  |                      null |                      null |                       null |    NO   |
+|                  Shift+IntlYen |  ---  |                      null |                      null |                       null |    NO   |
+|               Ctrl+Alt+IntlYen |  ---  |                      null |                      null |                       null |    NO   |
+|         Ctrl+Shift+Alt+IntlYen |  ---  |                      null |                      null |                       null |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------

lib/vscode/src/vs/workbench/services/keybinding/test/electron-browser/win_por_ptb.txt

@@ -0,0 +1,284 @@
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyA |   a   |                         A |                         A |                          a |         |
+|                     Shift+KeyA |   A   |                   Shift+A |                   Shift+A |                    shift+a |         |
+|                  Ctrl+Alt+KeyA |  ---  |                Ctrl+Alt+A |                Ctrl+Alt+A |                 ctrl+alt+a |         |
+|            Ctrl+Shift+Alt+KeyA |  ---  |          Ctrl+Shift+Alt+A |          Ctrl+Shift+Alt+A |           ctrl+shift+alt+a |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyB |   b   |                         B |                         B |                          b |         |
+|                     Shift+KeyB |   B   |                   Shift+B |                   Shift+B |                    shift+b |         |
+|                  Ctrl+Alt+KeyB |  ---  |                Ctrl+Alt+B |                Ctrl+Alt+B |                 ctrl+alt+b |         |
+|            Ctrl+Shift+Alt+KeyB |  ---  |          Ctrl+Shift+Alt+B |          Ctrl+Shift+Alt+B |           ctrl+shift+alt+b |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyC |   c   |                         C |                         C |                          c |         |
+|                     Shift+KeyC |   C   |                   Shift+C |                   Shift+C |                    shift+c |         |
+|                  Ctrl+Alt+KeyC |   ₢   |                Ctrl+Alt+C |                Ctrl+Alt+C |                 ctrl+alt+c |         |
+|            Ctrl+Shift+Alt+KeyC |  ---  |          Ctrl+Shift+Alt+C |          Ctrl+Shift+Alt+C |           ctrl+shift+alt+c |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyD |   d   |                         D |                         D |                          d |         |
+|                     Shift+KeyD |   D   |                   Shift+D |                   Shift+D |                    shift+d |         |
+|                  Ctrl+Alt+KeyD |  ---  |                Ctrl+Alt+D |                Ctrl+Alt+D |                 ctrl+alt+d |         |
+|            Ctrl+Shift+Alt+KeyD |  ---  |          Ctrl+Shift+Alt+D |          Ctrl+Shift+Alt+D |           ctrl+shift+alt+d |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyE |   e   |                         E |                         E |                          e |         |
+|                     Shift+KeyE |   E   |                   Shift+E |                   Shift+E |                    shift+e |         |
+|                  Ctrl+Alt+KeyE |   °   |                Ctrl+Alt+E |                Ctrl+Alt+E |                 ctrl+alt+e |         |
+|            Ctrl+Shift+Alt+KeyE |  ---  |          Ctrl+Shift+Alt+E |          Ctrl+Shift+Alt+E |           ctrl+shift+alt+e |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyF |   f   |                         F |                         F |                          f |         |
+|                     Shift+KeyF |   F   |                   Shift+F |                   Shift+F |                    shift+f |         |
+|                  Ctrl+Alt+KeyF |  ---  |                Ctrl+Alt+F |                Ctrl+Alt+F |                 ctrl+alt+f |         |
+|            Ctrl+Shift+Alt+KeyF |  ---  |          Ctrl+Shift+Alt+F |          Ctrl+Shift+Alt+F |           ctrl+shift+alt+f |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyG |   g   |                         G |                         G |                          g |         |
+|                     Shift+KeyG |   G   |                   Shift+G |                   Shift+G |                    shift+g |         |
+|                  Ctrl+Alt+KeyG |  ---  |                Ctrl+Alt+G |                Ctrl+Alt+G |                 ctrl+alt+g |         |
+|            Ctrl+Shift+Alt+KeyG |  ---  |          Ctrl+Shift+Alt+G |          Ctrl+Shift+Alt+G |           ctrl+shift+alt+g |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyH |   h   |                         H |                         H |                          h |         |
+|                     Shift+KeyH |   H   |                   Shift+H |                   Shift+H |                    shift+h |         |
+|                  Ctrl+Alt+KeyH |  ---  |                Ctrl+Alt+H |                Ctrl+Alt+H |                 ctrl+alt+h |         |
+|            Ctrl+Shift+Alt+KeyH |  ---  |          Ctrl+Shift+Alt+H |          Ctrl+Shift+Alt+H |           ctrl+shift+alt+h |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyI |   i   |                         I |                         I |                          i |         |
+|                     Shift+KeyI |   I   |                   Shift+I |                   Shift+I |                    shift+i |         |
+|                  Ctrl+Alt+KeyI |  ---  |                Ctrl+Alt+I |                Ctrl+Alt+I |                 ctrl+alt+i |         |
+|            Ctrl+Shift+Alt+KeyI |  ---  |          Ctrl+Shift+Alt+I |          Ctrl+Shift+Alt+I |           ctrl+shift+alt+i |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyJ |   j   |                         J |                         J |                          j |         |
+|                     Shift+KeyJ |   J   |                   Shift+J |                   Shift+J |                    shift+j |         |
+|                  Ctrl+Alt+KeyJ |  ---  |                Ctrl+Alt+J |                Ctrl+Alt+J |                 ctrl+alt+j |         |
+|            Ctrl+Shift+Alt+KeyJ |  ---  |          Ctrl+Shift+Alt+J |          Ctrl+Shift+Alt+J |           ctrl+shift+alt+j |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyK |   k   |                         K |                         K |                          k |         |
+|                     Shift+KeyK |   K   |                   Shift+K |                   Shift+K |                    shift+k |         |
+|                  Ctrl+Alt+KeyK |  ---  |                Ctrl+Alt+K |                Ctrl+Alt+K |                 ctrl+alt+k |         |
+|            Ctrl+Shift+Alt+KeyK |  ---  |          Ctrl+Shift+Alt+K |          Ctrl+Shift+Alt+K |           ctrl+shift+alt+k |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyL |   l   |                         L |                         L |                          l |         |
+|                     Shift+KeyL |   L   |                   Shift+L |                   Shift+L |                    shift+l |         |
+|                  Ctrl+Alt+KeyL |  ---  |                Ctrl+Alt+L |                Ctrl+Alt+L |                 ctrl+alt+l |         |
+|            Ctrl+Shift+Alt+KeyL |  ---  |          Ctrl+Shift+Alt+L |          Ctrl+Shift+Alt+L |           ctrl+shift+alt+l |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyM |   m   |                         M |                         M |                          m |         |
+|                     Shift+KeyM |   M   |                   Shift+M |                   Shift+M |                    shift+m |         |
+|                  Ctrl+Alt+KeyM |  ---  |                Ctrl+Alt+M |                Ctrl+Alt+M |                 ctrl+alt+m |         |
+|            Ctrl+Shift+Alt+KeyM |  ---  |          Ctrl+Shift+Alt+M |          Ctrl+Shift+Alt+M |           ctrl+shift+alt+m |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyN |   n   |                         N |                         N |                          n |         |
+|                     Shift+KeyN |   N   |                   Shift+N |                   Shift+N |                    shift+n |         |
+|                  Ctrl+Alt+KeyN |  ---  |                Ctrl+Alt+N |                Ctrl+Alt+N |                 ctrl+alt+n |         |
+|            Ctrl+Shift+Alt+KeyN |  ---  |          Ctrl+Shift+Alt+N |          Ctrl+Shift+Alt+N |           ctrl+shift+alt+n |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyO |   o   |                         O |                         O |                          o |         |
+|                     Shift+KeyO |   O   |                   Shift+O |                   Shift+O |                    shift+o |         |
+|                  Ctrl+Alt+KeyO |  ---  |                Ctrl+Alt+O |                Ctrl+Alt+O |                 ctrl+alt+o |         |
+|            Ctrl+Shift+Alt+KeyO |  ---  |          Ctrl+Shift+Alt+O |          Ctrl+Shift+Alt+O |           ctrl+shift+alt+o |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyP |   p   |                         P |                         P |                          p |         |
+|                     Shift+KeyP |   P   |                   Shift+P |                   Shift+P |                    shift+p |         |
+|                  Ctrl+Alt+KeyP |  ---  |                Ctrl+Alt+P |                Ctrl+Alt+P |                 ctrl+alt+p |         |
+|            Ctrl+Shift+Alt+KeyP |  ---  |          Ctrl+Shift+Alt+P |          Ctrl+Shift+Alt+P |           ctrl+shift+alt+p |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyQ |   q   |                         Q |                         Q |                          q |         |
+|                     Shift+KeyQ |   Q   |                   Shift+Q |                   Shift+Q |                    shift+q |         |
+|                  Ctrl+Alt+KeyQ |   /   |                Ctrl+Alt+Q |                Ctrl+Alt+Q |                 ctrl+alt+q |         |
+|            Ctrl+Shift+Alt+KeyQ |  ---  |          Ctrl+Shift+Alt+Q |          Ctrl+Shift+Alt+Q |           ctrl+shift+alt+q |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyR |   r   |                         R |                         R |                          r |         |
+|                     Shift+KeyR |   R   |                   Shift+R |                   Shift+R |                    shift+r |         |
+|                  Ctrl+Alt+KeyR |  ---  |                Ctrl+Alt+R |                Ctrl+Alt+R |                 ctrl+alt+r |         |
+|            Ctrl+Shift+Alt+KeyR |  ---  |          Ctrl+Shift+Alt+R |          Ctrl+Shift+Alt+R |           ctrl+shift+alt+r |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyS |   s   |                         S |                         S |                          s |         |
+|                     Shift+KeyS |   S   |                   Shift+S |                   Shift+S |                    shift+s |         |
+|                  Ctrl+Alt+KeyS |  ---  |                Ctrl+Alt+S |                Ctrl+Alt+S |                 ctrl+alt+s |         |
+|            Ctrl+Shift+Alt+KeyS |  ---  |          Ctrl+Shift+Alt+S |          Ctrl+Shift+Alt+S |           ctrl+shift+alt+s |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyT |   t   |                         T |                         T |                          t |         |
+|                     Shift+KeyT |   T   |                   Shift+T |                   Shift+T |                    shift+t |         |
+|                  Ctrl+Alt+KeyT |  ---  |                Ctrl+Alt+T |                Ctrl+Alt+T |                 ctrl+alt+t |         |
+|            Ctrl+Shift+Alt+KeyT |  ---  |          Ctrl+Shift+Alt+T |          Ctrl+Shift+Alt+T |           ctrl+shift+alt+t |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyU |   u   |                         U |                         U |                          u |         |
+|                     Shift+KeyU |   U   |                   Shift+U |                   Shift+U |                    shift+u |         |
+|                  Ctrl+Alt+KeyU |  ---  |                Ctrl+Alt+U |                Ctrl+Alt+U |                 ctrl+alt+u |         |
+|            Ctrl+Shift+Alt+KeyU |  ---  |          Ctrl+Shift+Alt+U |          Ctrl+Shift+Alt+U |           ctrl+shift+alt+u |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyV |   v   |                         V |                         V |                          v |         |
+|                     Shift+KeyV |   V   |                   Shift+V |                   Shift+V |                    shift+v |         |
+|                  Ctrl+Alt+KeyV |  ---  |                Ctrl+Alt+V |                Ctrl+Alt+V |                 ctrl+alt+v |         |
+|            Ctrl+Shift+Alt+KeyV |  ---  |          Ctrl+Shift+Alt+V |          Ctrl+Shift+Alt+V |           ctrl+shift+alt+v |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyW |   w   |                         W |                         W |                          w |         |
+|                     Shift+KeyW |   W   |                   Shift+W |                   Shift+W |                    shift+w |         |
+|                  Ctrl+Alt+KeyW |   ?   |                Ctrl+Alt+W |                Ctrl+Alt+W |                 ctrl+alt+w |         |
+|            Ctrl+Shift+Alt+KeyW |  ---  |          Ctrl+Shift+Alt+W |          Ctrl+Shift+Alt+W |           ctrl+shift+alt+w |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyX |   x   |                         X |                         X |                          x |         |
+|                     Shift+KeyX |   X   |                   Shift+X |                   Shift+X |                    shift+x |         |
+|                  Ctrl+Alt+KeyX |  ---  |                Ctrl+Alt+X |                Ctrl+Alt+X |                 ctrl+alt+x |         |
+|            Ctrl+Shift+Alt+KeyX |  ---  |          Ctrl+Shift+Alt+X |          Ctrl+Shift+Alt+X |           ctrl+shift+alt+x |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyY |   y   |                         Y |                         Y |                          y |         |
+|                     Shift+KeyY |   Y   |                   Shift+Y |                   Shift+Y |                    shift+y |         |
+|                  Ctrl+Alt+KeyY |  ---  |                Ctrl+Alt+Y |                Ctrl+Alt+Y |                 ctrl+alt+y |         |
+|            Ctrl+Shift+Alt+KeyY |  ---  |          Ctrl+Shift+Alt+Y |          Ctrl+Shift+Alt+Y |           ctrl+shift+alt+y |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyZ |   z   |                         Z |                         Z |                          z |         |
+|                     Shift+KeyZ |   Z   |                   Shift+Z |                   Shift+Z |                    shift+z |         |
+|                  Ctrl+Alt+KeyZ |  ---  |                Ctrl+Alt+Z |                Ctrl+Alt+Z |                 ctrl+alt+z |         |
+|            Ctrl+Shift+Alt+KeyZ |  ---  |          Ctrl+Shift+Alt+Z |          Ctrl+Shift+Alt+Z |           ctrl+shift+alt+z |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit1 |   1   |                         1 |                         1 |                          1 |         |
+|                   Shift+Digit1 |   !   |                   Shift+1 |                   Shift+1 |                    shift+1 |         |
+|                Ctrl+Alt+Digit1 |   ¹   |                Ctrl+Alt+1 |                Ctrl+Alt+1 |                 ctrl+alt+1 |         |
+|          Ctrl+Shift+Alt+Digit1 |  ---  |          Ctrl+Shift+Alt+1 |          Ctrl+Shift+Alt+1 |           ctrl+shift+alt+1 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit2 |   2   |                         2 |                         2 |                          2 |         |
+|                   Shift+Digit2 |   @   |                   Shift+2 |                   Shift+2 |                    shift+2 |         |
+|                Ctrl+Alt+Digit2 |   ²   |                Ctrl+Alt+2 |                Ctrl+Alt+2 |                 ctrl+alt+2 |         |
+|          Ctrl+Shift+Alt+Digit2 |  ---  |          Ctrl+Shift+Alt+2 |          Ctrl+Shift+Alt+2 |           ctrl+shift+alt+2 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit3 |   3   |                         3 |                         3 |                          3 |         |
+|                   Shift+Digit3 |   #   |                   Shift+3 |                   Shift+3 |                    shift+3 |         |
+|                Ctrl+Alt+Digit3 |   ³   |                Ctrl+Alt+3 |                Ctrl+Alt+3 |                 ctrl+alt+3 |         |
+|          Ctrl+Shift+Alt+Digit3 |  ---  |          Ctrl+Shift+Alt+3 |          Ctrl+Shift+Alt+3 |           ctrl+shift+alt+3 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit4 |   4   |                         4 |                         4 |                          4 |         |
+|                   Shift+Digit4 |   $   |                   Shift+4 |                   Shift+4 |                    shift+4 |         |
+|                Ctrl+Alt+Digit4 |   £   |                Ctrl+Alt+4 |                Ctrl+Alt+4 |                 ctrl+alt+4 |         |
+|          Ctrl+Shift+Alt+Digit4 |  ---  |          Ctrl+Shift+Alt+4 |          Ctrl+Shift+Alt+4 |           ctrl+shift+alt+4 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit5 |   5   |                         5 |                         5 |                          5 |         |
+|                   Shift+Digit5 |   %   |                   Shift+5 |                   Shift+5 |                    shift+5 |         |
+|                Ctrl+Alt+Digit5 |   ¢   |                Ctrl+Alt+5 |                Ctrl+Alt+5 |                 ctrl+alt+5 |         |
+|          Ctrl+Shift+Alt+Digit5 |  ---  |          Ctrl+Shift+Alt+5 |          Ctrl+Shift+Alt+5 |           ctrl+shift+alt+5 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit6 |   6   |                         6 |                         6 |                          6 |         |
+|                   Shift+Digit6 |   ¨   |                   Shift+6 |                   Shift+6 |                    shift+6 |         |
+|                Ctrl+Alt+Digit6 |   ¬   |                Ctrl+Alt+6 |                Ctrl+Alt+6 |                 ctrl+alt+6 |         |
+|          Ctrl+Shift+Alt+Digit6 |  ---  |          Ctrl+Shift+Alt+6 |          Ctrl+Shift+Alt+6 |           ctrl+shift+alt+6 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit7 |   7   |                         7 |                         7 |                          7 |         |
+|                   Shift+Digit7 |   &   |                   Shift+7 |                   Shift+7 |                    shift+7 |         |
+|                Ctrl+Alt+Digit7 |  ---  |                Ctrl+Alt+7 |                Ctrl+Alt+7 |                 ctrl+alt+7 |         |
+|          Ctrl+Shift+Alt+Digit7 |  ---  |          Ctrl+Shift+Alt+7 |          Ctrl+Shift+Alt+7 |           ctrl+shift+alt+7 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit8 |   8   |                         8 |                         8 |                          8 |         |
+|                   Shift+Digit8 |   *   |                   Shift+8 |                   Shift+8 |                    shift+8 |         |
+|                Ctrl+Alt+Digit8 |  ---  |                Ctrl+Alt+8 |                Ctrl+Alt+8 |                 ctrl+alt+8 |         |
+|          Ctrl+Shift+Alt+Digit8 |  ---  |          Ctrl+Shift+Alt+8 |          Ctrl+Shift+Alt+8 |           ctrl+shift+alt+8 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit9 |   9   |                         9 |                         9 |                          9 |         |
+|                   Shift+Digit9 |   (   |                   Shift+9 |                   Shift+9 |                    shift+9 |         |
+|                Ctrl+Alt+Digit9 |  ---  |                Ctrl+Alt+9 |                Ctrl+Alt+9 |                 ctrl+alt+9 |         |
+|          Ctrl+Shift+Alt+Digit9 |  ---  |          Ctrl+Shift+Alt+9 |          Ctrl+Shift+Alt+9 |           ctrl+shift+alt+9 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit0 |   0   |                         0 |                         0 |                          0 |         |
+|                   Shift+Digit0 |   )   |                   Shift+0 |                   Shift+0 |                    shift+0 |         |
+|                Ctrl+Alt+Digit0 |  ---  |                Ctrl+Alt+0 |                Ctrl+Alt+0 |                 ctrl+alt+0 |         |
+|          Ctrl+Shift+Alt+Digit0 |  ---  |          Ctrl+Shift+Alt+0 |          Ctrl+Shift+Alt+0 |           ctrl+shift+alt+0 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                          Minus |   -   |                         - |                         - |                  oem_minus |    NO   |
+|                    Shift+Minus |   _   |                   Shift+- |                   Shift+- |            shift+oem_minus |    NO   |
+|                 Ctrl+Alt+Minus |  ---  |                Ctrl+Alt+- |                Ctrl+Alt+- |         ctrl+alt+oem_minus |    NO   |
+|           Ctrl+Shift+Alt+Minus |  ---  |          Ctrl+Shift+Alt+- |          Ctrl+Shift+Alt+- |   ctrl+shift+alt+oem_minus |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                          Equal |   =   |                         = |                         = |                   oem_plus |    NO   |
+|                    Shift+Equal |   +   |                   Shift+= |                   Shift+= |             shift+oem_plus |    NO   |
+|                 Ctrl+Alt+Equal |   §   |                Ctrl+Alt+= |                Ctrl+Alt+= |          ctrl+alt+oem_plus |    NO   |
+|           Ctrl+Shift+Alt+Equal |  ---  |          Ctrl+Shift+Alt+= |          Ctrl+Shift+Alt+= |    ctrl+shift+alt+oem_plus |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                    BracketLeft |   ´   |                         [ |                         ´ |                      oem_4 |    NO   |
+|              Shift+BracketLeft |   `   |                   Shift+[ |                   Shift+´ |                shift+oem_4 |    NO   |
+|           Ctrl+Alt+BracketLeft |  ---  |                Ctrl+Alt+[ |                Ctrl+Alt+´ |             ctrl+alt+oem_4 |    NO   |
+|     Ctrl+Shift+Alt+BracketLeft |  ---  |          Ctrl+Shift+Alt+[ |          Ctrl+Shift+Alt+´ |       ctrl+shift+alt+oem_4 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                   BracketRight |   [   |                         ] |                         [ |                      oem_6 |    NO   |
+|             Shift+BracketRight |   {   |                   Shift+] |                   Shift+[ |                shift+oem_6 |    NO   |
+|          Ctrl+Alt+BracketRight |   ª   |                Ctrl+Alt+] |                Ctrl+Alt+[ |             ctrl+alt+oem_6 |    NO   |
+|    Ctrl+Shift+Alt+BracketRight |  ---  |          Ctrl+Shift+Alt+] |          Ctrl+Shift+Alt+[ |       ctrl+shift+alt+oem_6 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                      Backslash |   ]   |                         \ |                         ] |                      oem_5 |    NO   |
+|                Shift+Backslash |   }   |                   Shift+\ |                   Shift+] |                shift+oem_5 |    NO   |
+|             Ctrl+Alt+Backslash |   º   |                Ctrl+Alt+\ |                Ctrl+Alt+] |             ctrl+alt+oem_5 |    NO   |
+|       Ctrl+Shift+Alt+Backslash |  ---  |          Ctrl+Shift+Alt+\ |          Ctrl+Shift+Alt+] |       ctrl+shift+alt+oem_5 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                       IntlHash |  ---  |                      null |                      null |                       null |    NO   |
+|                 Shift+IntlHash |  ---  |                      null |                      null |                       null |    NO   |
+|              Ctrl+Alt+IntlHash |  ---  |                      null |                      null |                       null |    NO   |
+|        Ctrl+Shift+Alt+IntlHash |  ---  |                      null |                      null |                       null |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                      Semicolon |   ç   |                         ; |                         ç |                      oem_1 |    NO   |
+|                Shift+Semicolon |   Ç   |                   Shift+; |                   Shift+ç |                shift+oem_1 |    NO   |
+|             Ctrl+Alt+Semicolon |  ---  |                Ctrl+Alt+; |                Ctrl+Alt+ç |             ctrl+alt+oem_1 |    NO   |
+|       Ctrl+Shift+Alt+Semicolon |  ---  |          Ctrl+Shift+Alt+; |          Ctrl+Shift+Alt+ç |       ctrl+shift+alt+oem_1 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                          Quote |   ~   |                         ' |                         ~ |                      oem_7 |    NO   |
+|                    Shift+Quote |   ^   |                   Shift+' |                   Shift+~ |                shift+oem_7 |    NO   |
+|                 Ctrl+Alt+Quote |  ---  |                Ctrl+Alt+' |                Ctrl+Alt+~ |             ctrl+alt+oem_7 |    NO   |
+|           Ctrl+Shift+Alt+Quote |  ---  |          Ctrl+Shift+Alt+' |          Ctrl+Shift+Alt+~ |       ctrl+shift+alt+oem_7 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                      Backquote |   '   |                         ` |                         ' |                      oem_3 |    NO   |
+|                Shift+Backquote |   "   |                   Shift+` |                   Shift+' |                shift+oem_3 |    NO   |
+|             Ctrl+Alt+Backquote |  ---  |                Ctrl+Alt+` |                Ctrl+Alt+' |             ctrl+alt+oem_3 |    NO   |
+|       Ctrl+Shift+Alt+Backquote |  ---  |          Ctrl+Shift+Alt+` |          Ctrl+Shift+Alt+' |       ctrl+shift+alt+oem_3 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                          Comma |   ,   |                         , |                         , |                  oem_comma |    NO   |
+|                    Shift+Comma |   <   |                   Shift+, |                   Shift+, |            shift+oem_comma |    NO   |
+|                 Ctrl+Alt+Comma |  ---  |                Ctrl+Alt+, |                Ctrl+Alt+, |         ctrl+alt+oem_comma |    NO   |
+|           Ctrl+Shift+Alt+Comma |  ---  |          Ctrl+Shift+Alt+, |          Ctrl+Shift+Alt+, |   ctrl+shift+alt+oem_comma |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Period |   .   |                         . |                         . |                 oem_period |    NO   |
+|                   Shift+Period |   >   |                   Shift+. |                   Shift+. |           shift+oem_period |    NO   |
+|                Ctrl+Alt+Period |  ---  |                Ctrl+Alt+. |                Ctrl+Alt+. |        ctrl+alt+oem_period |    NO   |
+|          Ctrl+Shift+Alt+Period |  ---  |          Ctrl+Shift+Alt+. |          Ctrl+Shift+Alt+. |  ctrl+shift+alt+oem_period |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                          Slash |   ;   |                         / |                         ; |                      oem_2 |    NO   |
+|                    Shift+Slash |   :   |                   Shift+/ |                   Shift+; |                shift+oem_2 |    NO   |
+|                 Ctrl+Alt+Slash |  ---  |                Ctrl+Alt+/ |                Ctrl+Alt+; |             ctrl+alt+oem_2 |    NO   |
+|           Ctrl+Shift+Alt+Slash |  ---  |          Ctrl+Shift+Alt+/ |          Ctrl+Shift+Alt+; |       ctrl+shift+alt+oem_2 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                        ArrowUp |  ---  |                   UpArrow |                   UpArrow |                         up |         |
+|                  Shift+ArrowUp |  ---  |             Shift+UpArrow |             Shift+UpArrow |                   shift+up |         |
+|               Ctrl+Alt+ArrowUp |  ---  |          Ctrl+Alt+UpArrow |          Ctrl+Alt+UpArrow |                ctrl+alt+up |         |
+|         Ctrl+Shift+Alt+ArrowUp |  ---  |    Ctrl+Shift+Alt+UpArrow |    Ctrl+Shift+Alt+UpArrow |          ctrl+shift+alt+up |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                        Numpad0 |  ---  |                   NumPad0 |                   NumPad0 |                    numpad0 |         |
+|                  Shift+Numpad0 |  ---  |             Shift+NumPad0 |             Shift+NumPad0 |              shift+numpad0 |         |
+|               Ctrl+Alt+Numpad0 |  ---  |          Ctrl+Alt+NumPad0 |          Ctrl+Alt+NumPad0 |           ctrl+alt+numpad0 |         |
+|         Ctrl+Shift+Alt+Numpad0 |  ---  |    Ctrl+Shift+Alt+NumPad0 |    Ctrl+Shift+Alt+NumPad0 |     ctrl+shift+alt+numpad0 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                  IntlBackslash |   \   |                   OEM_102 |                         \ |                    oem_102 |    NO   |
+|            Shift+IntlBackslash |   |   |             Shift+OEM_102 |                   Shift+\ |              shift+oem_102 |    NO   |
+|         Ctrl+Alt+IntlBackslash |  ---  |          Ctrl+Alt+OEM_102 |                Ctrl+Alt+\ |           ctrl+alt+oem_102 |    NO   |
+|   Ctrl+Shift+Alt+IntlBackslash |  ---  |    Ctrl+Shift+Alt+OEM_102 |          Ctrl+Shift+Alt+\ |     ctrl+shift+alt+oem_102 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         IntlRo |   /   |                   ABNT_C1 |                         / |                    abnt_c1 |    NO   |
+|                   Shift+IntlRo |   ?   |             Shift+ABNT_C1 |                   Shift+/ |              shift+abnt_c1 |    NO   |
+|                Ctrl+Alt+IntlRo |   °   |          Ctrl+Alt+ABNT_C1 |                Ctrl+Alt+/ |           ctrl+alt+abnt_c1 |    NO   |
+|          Ctrl+Shift+Alt+IntlRo |  ---  |    Ctrl+Shift+Alt+ABNT_C1 |          Ctrl+Shift+Alt+/ |     ctrl+shift+alt+abnt_c1 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                        IntlYen |  ---  |                      null |                      null |                       null |    NO   |
+|                  Shift+IntlYen |  ---  |                      null |                      null |                       null |    NO   |
+|               Ctrl+Alt+IntlYen |  ---  |                      null |                      null |                       null |    NO   |
+|         Ctrl+Shift+Alt+IntlYen |  ---  |                      null |                      null |                       null |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------

lib/vscode/src/vs/workbench/services/keybinding/test/electron-browser/win_ru.txt

@@ -0,0 +1,284 @@
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyA |   ф   |                         A |                         A |                          a |         |
+|                     Shift+KeyA |   Ф   |                   Shift+A |                   Shift+A |                    shift+a |         |
+|                  Ctrl+Alt+KeyA |  ---  |                Ctrl+Alt+A |                Ctrl+Alt+A |                 ctrl+alt+a |         |
+|            Ctrl+Shift+Alt+KeyA |  ---  |          Ctrl+Shift+Alt+A |          Ctrl+Shift+Alt+A |           ctrl+shift+alt+a |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyB |   и   |                         B |                         B |                          b |         |
+|                     Shift+KeyB |   И   |                   Shift+B |                   Shift+B |                    shift+b |         |
+|                  Ctrl+Alt+KeyB |  ---  |                Ctrl+Alt+B |                Ctrl+Alt+B |                 ctrl+alt+b |         |
+|            Ctrl+Shift+Alt+KeyB |  ---  |          Ctrl+Shift+Alt+B |          Ctrl+Shift+Alt+B |           ctrl+shift+alt+b |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyC |   с   |                         C |                         C |                          c |         |
+|                     Shift+KeyC |   С   |                   Shift+C |                   Shift+C |                    shift+c |         |
+|                  Ctrl+Alt+KeyC |  ---  |                Ctrl+Alt+C |                Ctrl+Alt+C |                 ctrl+alt+c |         |
+|            Ctrl+Shift+Alt+KeyC |  ---  |          Ctrl+Shift+Alt+C |          Ctrl+Shift+Alt+C |           ctrl+shift+alt+c |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyD |   в   |                         D |                         D |                          d |         |
+|                     Shift+KeyD |   В   |                   Shift+D |                   Shift+D |                    shift+d |         |
+|                  Ctrl+Alt+KeyD |  ---  |                Ctrl+Alt+D |                Ctrl+Alt+D |                 ctrl+alt+d |         |
+|            Ctrl+Shift+Alt+KeyD |  ---  |          Ctrl+Shift+Alt+D |          Ctrl+Shift+Alt+D |           ctrl+shift+alt+d |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyE |   у   |                         E |                         E |                          e |         |
+|                     Shift+KeyE |   У   |                   Shift+E |                   Shift+E |                    shift+e |         |
+|                  Ctrl+Alt+KeyE |  ---  |                Ctrl+Alt+E |                Ctrl+Alt+E |                 ctrl+alt+e |         |
+|            Ctrl+Shift+Alt+KeyE |  ---  |          Ctrl+Shift+Alt+E |          Ctrl+Shift+Alt+E |           ctrl+shift+alt+e |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyF |   а   |                         F |                         F |                          f |         |
+|                     Shift+KeyF |   А   |                   Shift+F |                   Shift+F |                    shift+f |         |
+|                  Ctrl+Alt+KeyF |  ---  |                Ctrl+Alt+F |                Ctrl+Alt+F |                 ctrl+alt+f |         |
+|            Ctrl+Shift+Alt+KeyF |  ---  |          Ctrl+Shift+Alt+F |          Ctrl+Shift+Alt+F |           ctrl+shift+alt+f |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyG |   п   |                         G |                         G |                          g |         |
+|                     Shift+KeyG |   П   |                   Shift+G |                   Shift+G |                    shift+g |         |
+|                  Ctrl+Alt+KeyG |  ---  |                Ctrl+Alt+G |                Ctrl+Alt+G |                 ctrl+alt+g |         |
+|            Ctrl+Shift+Alt+KeyG |  ---  |          Ctrl+Shift+Alt+G |          Ctrl+Shift+Alt+G |           ctrl+shift+alt+g |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyH |   р   |                         H |                         H |                          h |         |
+|                     Shift+KeyH |   Р   |                   Shift+H |                   Shift+H |                    shift+h |         |
+|                  Ctrl+Alt+KeyH |  ---  |                Ctrl+Alt+H |                Ctrl+Alt+H |                 ctrl+alt+h |         |
+|            Ctrl+Shift+Alt+KeyH |  ---  |          Ctrl+Shift+Alt+H |          Ctrl+Shift+Alt+H |           ctrl+shift+alt+h |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyI |   ш   |                         I |                         I |                          i |         |
+|                     Shift+KeyI |   Ш   |                   Shift+I |                   Shift+I |                    shift+i |         |
+|                  Ctrl+Alt+KeyI |  ---  |                Ctrl+Alt+I |                Ctrl+Alt+I |                 ctrl+alt+i |         |
+|            Ctrl+Shift+Alt+KeyI |  ---  |          Ctrl+Shift+Alt+I |          Ctrl+Shift+Alt+I |           ctrl+shift+alt+i |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyJ |   о   |                         J |                         J |                          j |         |
+|                     Shift+KeyJ |   О   |                   Shift+J |                   Shift+J |                    shift+j |         |
+|                  Ctrl+Alt+KeyJ |  ---  |                Ctrl+Alt+J |                Ctrl+Alt+J |                 ctrl+alt+j |         |
+|            Ctrl+Shift+Alt+KeyJ |  ---  |          Ctrl+Shift+Alt+J |          Ctrl+Shift+Alt+J |           ctrl+shift+alt+j |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyK |   л   |                         K |                         K |                          k |         |
+|                     Shift+KeyK |   Л   |                   Shift+K |                   Shift+K |                    shift+k |         |
+|                  Ctrl+Alt+KeyK |  ---  |                Ctrl+Alt+K |                Ctrl+Alt+K |                 ctrl+alt+k |         |
+|            Ctrl+Shift+Alt+KeyK |  ---  |          Ctrl+Shift+Alt+K |          Ctrl+Shift+Alt+K |           ctrl+shift+alt+k |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyL |   д   |                         L |                         L |                          l |         |
+|                     Shift+KeyL |   Д   |                   Shift+L |                   Shift+L |                    shift+l |         |
+|                  Ctrl+Alt+KeyL |  ---  |                Ctrl+Alt+L |                Ctrl+Alt+L |                 ctrl+alt+l |         |
+|            Ctrl+Shift+Alt+KeyL |  ---  |          Ctrl+Shift+Alt+L |          Ctrl+Shift+Alt+L |           ctrl+shift+alt+l |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyM |   ь   |                         M |                         M |                          m |         |
+|                     Shift+KeyM |   Ь   |                   Shift+M |                   Shift+M |                    shift+m |         |
+|                  Ctrl+Alt+KeyM |  ---  |                Ctrl+Alt+M |                Ctrl+Alt+M |                 ctrl+alt+m |         |
+|            Ctrl+Shift+Alt+KeyM |  ---  |          Ctrl+Shift+Alt+M |          Ctrl+Shift+Alt+M |           ctrl+shift+alt+m |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyN |   т   |                         N |                         N |                          n |         |
+|                     Shift+KeyN |   Т   |                   Shift+N |                   Shift+N |                    shift+n |         |
+|                  Ctrl+Alt+KeyN |  ---  |                Ctrl+Alt+N |                Ctrl+Alt+N |                 ctrl+alt+n |         |
+|            Ctrl+Shift+Alt+KeyN |  ---  |          Ctrl+Shift+Alt+N |          Ctrl+Shift+Alt+N |           ctrl+shift+alt+n |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyO |   щ   |                         O |                         O |                          o |         |
+|                     Shift+KeyO |   Щ   |                   Shift+O |                   Shift+O |                    shift+o |         |
+|                  Ctrl+Alt+KeyO |  ---  |                Ctrl+Alt+O |                Ctrl+Alt+O |                 ctrl+alt+o |         |
+|            Ctrl+Shift+Alt+KeyO |  ---  |          Ctrl+Shift+Alt+O |          Ctrl+Shift+Alt+O |           ctrl+shift+alt+o |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyP |   з   |                         P |                         P |                          p |         |
+|                     Shift+KeyP |   З   |                   Shift+P |                   Shift+P |                    shift+p |         |
+|                  Ctrl+Alt+KeyP |  ---  |                Ctrl+Alt+P |                Ctrl+Alt+P |                 ctrl+alt+p |         |
+|            Ctrl+Shift+Alt+KeyP |  ---  |          Ctrl+Shift+Alt+P |          Ctrl+Shift+Alt+P |           ctrl+shift+alt+p |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyQ |   й   |                         Q |                         Q |                          q |         |
+|                     Shift+KeyQ |   Й   |                   Shift+Q |                   Shift+Q |                    shift+q |         |
+|                  Ctrl+Alt+KeyQ |  ---  |                Ctrl+Alt+Q |                Ctrl+Alt+Q |                 ctrl+alt+q |         |
+|            Ctrl+Shift+Alt+KeyQ |  ---  |          Ctrl+Shift+Alt+Q |          Ctrl+Shift+Alt+Q |           ctrl+shift+alt+q |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyR |   к   |                         R |                         R |                          r |         |
+|                     Shift+KeyR |   К   |                   Shift+R |                   Shift+R |                    shift+r |         |
+|                  Ctrl+Alt+KeyR |  ---  |                Ctrl+Alt+R |                Ctrl+Alt+R |                 ctrl+alt+r |         |
+|            Ctrl+Shift+Alt+KeyR |  ---  |          Ctrl+Shift+Alt+R |          Ctrl+Shift+Alt+R |           ctrl+shift+alt+r |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyS |   ы   |                         S |                         S |                          s |         |
+|                     Shift+KeyS |   Ы   |                   Shift+S |                   Shift+S |                    shift+s |         |
+|                  Ctrl+Alt+KeyS |  ---  |                Ctrl+Alt+S |                Ctrl+Alt+S |                 ctrl+alt+s |         |
+|            Ctrl+Shift+Alt+KeyS |  ---  |          Ctrl+Shift+Alt+S |          Ctrl+Shift+Alt+S |           ctrl+shift+alt+s |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyT |   е   |                         T |                         T |                          t |         |
+|                     Shift+KeyT |   Е   |                   Shift+T |                   Shift+T |                    shift+t |         |
+|                  Ctrl+Alt+KeyT |  ---  |                Ctrl+Alt+T |                Ctrl+Alt+T |                 ctrl+alt+t |         |
+|            Ctrl+Shift+Alt+KeyT |  ---  |          Ctrl+Shift+Alt+T |          Ctrl+Shift+Alt+T |           ctrl+shift+alt+t |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyU |   г   |                         U |                         U |                          u |         |
+|                     Shift+KeyU |   Г   |                   Shift+U |                   Shift+U |                    shift+u |         |
+|                  Ctrl+Alt+KeyU |  ---  |                Ctrl+Alt+U |                Ctrl+Alt+U |                 ctrl+alt+u |         |
+|            Ctrl+Shift+Alt+KeyU |  ---  |          Ctrl+Shift+Alt+U |          Ctrl+Shift+Alt+U |           ctrl+shift+alt+u |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyV |   м   |                         V |                         V |                          v |         |
+|                     Shift+KeyV |   М   |                   Shift+V |                   Shift+V |                    shift+v |         |
+|                  Ctrl+Alt+KeyV |  ---  |                Ctrl+Alt+V |                Ctrl+Alt+V |                 ctrl+alt+v |         |
+|            Ctrl+Shift+Alt+KeyV |  ---  |          Ctrl+Shift+Alt+V |          Ctrl+Shift+Alt+V |           ctrl+shift+alt+v |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyW |   ц   |                         W |                         W |                          w |         |
+|                     Shift+KeyW |   Ц   |                   Shift+W |                   Shift+W |                    shift+w |         |
+|                  Ctrl+Alt+KeyW |  ---  |                Ctrl+Alt+W |                Ctrl+Alt+W |                 ctrl+alt+w |         |
+|            Ctrl+Shift+Alt+KeyW |  ---  |          Ctrl+Shift+Alt+W |          Ctrl+Shift+Alt+W |           ctrl+shift+alt+w |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyX |   ч   |                         X |                         X |                          x |         |
+|                     Shift+KeyX |   Ч   |                   Shift+X |                   Shift+X |                    shift+x |         |
+|                  Ctrl+Alt+KeyX |  ---  |                Ctrl+Alt+X |                Ctrl+Alt+X |                 ctrl+alt+x |         |
+|            Ctrl+Shift+Alt+KeyX |  ---  |          Ctrl+Shift+Alt+X |          Ctrl+Shift+Alt+X |           ctrl+shift+alt+x |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyY |   н   |                         Y |                         Y |                          y |         |
+|                     Shift+KeyY |   Н   |                   Shift+Y |                   Shift+Y |                    shift+y |         |
+|                  Ctrl+Alt+KeyY |  ---  |                Ctrl+Alt+Y |                Ctrl+Alt+Y |                 ctrl+alt+y |         |
+|            Ctrl+Shift+Alt+KeyY |  ---  |          Ctrl+Shift+Alt+Y |          Ctrl+Shift+Alt+Y |           ctrl+shift+alt+y |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                           KeyZ |   я   |                         Z |                         Z |                          z |         |
+|                     Shift+KeyZ |   Я   |                   Shift+Z |                   Shift+Z |                    shift+z |         |
+|                  Ctrl+Alt+KeyZ |  ---  |                Ctrl+Alt+Z |                Ctrl+Alt+Z |                 ctrl+alt+z |         |
+|            Ctrl+Shift+Alt+KeyZ |  ---  |          Ctrl+Shift+Alt+Z |          Ctrl+Shift+Alt+Z |           ctrl+shift+alt+z |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit1 |   1   |                         1 |                         1 |                          1 |         |
+|                   Shift+Digit1 |   !   |                   Shift+1 |                   Shift+1 |                    shift+1 |         |
+|                Ctrl+Alt+Digit1 |  ---  |                Ctrl+Alt+1 |                Ctrl+Alt+1 |                 ctrl+alt+1 |         |
+|          Ctrl+Shift+Alt+Digit1 |  ---  |          Ctrl+Shift+Alt+1 |          Ctrl+Shift+Alt+1 |           ctrl+shift+alt+1 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit2 |   2   |                         2 |                         2 |                          2 |         |
+|                   Shift+Digit2 |   "   |                   Shift+2 |                   Shift+2 |                    shift+2 |         |
+|                Ctrl+Alt+Digit2 |  ---  |                Ctrl+Alt+2 |                Ctrl+Alt+2 |                 ctrl+alt+2 |         |
+|          Ctrl+Shift+Alt+Digit2 |  ---  |          Ctrl+Shift+Alt+2 |          Ctrl+Shift+Alt+2 |           ctrl+shift+alt+2 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit3 |   3   |                         3 |                         3 |                          3 |         |
+|                   Shift+Digit3 |   №   |                   Shift+3 |                   Shift+3 |                    shift+3 |         |
+|                Ctrl+Alt+Digit3 |  ---  |                Ctrl+Alt+3 |                Ctrl+Alt+3 |                 ctrl+alt+3 |         |
+|          Ctrl+Shift+Alt+Digit3 |  ---  |          Ctrl+Shift+Alt+3 |          Ctrl+Shift+Alt+3 |           ctrl+shift+alt+3 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit4 |   4   |                         4 |                         4 |                          4 |         |
+|                   Shift+Digit4 |   ;   |                   Shift+4 |                   Shift+4 |                    shift+4 |         |
+|                Ctrl+Alt+Digit4 |  ---  |                Ctrl+Alt+4 |                Ctrl+Alt+4 |                 ctrl+alt+4 |         |
+|          Ctrl+Shift+Alt+Digit4 |  ---  |          Ctrl+Shift+Alt+4 |          Ctrl+Shift+Alt+4 |           ctrl+shift+alt+4 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit5 |   5   |                         5 |                         5 |                          5 |         |
+|                   Shift+Digit5 |   %   |                   Shift+5 |                   Shift+5 |                    shift+5 |         |
+|                Ctrl+Alt+Digit5 |  ---  |                Ctrl+Alt+5 |                Ctrl+Alt+5 |                 ctrl+alt+5 |         |
+|          Ctrl+Shift+Alt+Digit5 |  ---  |          Ctrl+Shift+Alt+5 |          Ctrl+Shift+Alt+5 |           ctrl+shift+alt+5 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit6 |   6   |                         6 |                         6 |                          6 |         |
+|                   Shift+Digit6 |   :   |                   Shift+6 |                   Shift+6 |                    shift+6 |         |
+|                Ctrl+Alt+Digit6 |  ---  |                Ctrl+Alt+6 |                Ctrl+Alt+6 |                 ctrl+alt+6 |         |
+|          Ctrl+Shift+Alt+Digit6 |  ---  |          Ctrl+Shift+Alt+6 |          Ctrl+Shift+Alt+6 |           ctrl+shift+alt+6 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit7 |   7   |                         7 |                         7 |                          7 |         |
+|                   Shift+Digit7 |   ?   |                   Shift+7 |                   Shift+7 |                    shift+7 |         |
+|                Ctrl+Alt+Digit7 |  ---  |                Ctrl+Alt+7 |                Ctrl+Alt+7 |                 ctrl+alt+7 |         |
+|          Ctrl+Shift+Alt+Digit7 |  ---  |          Ctrl+Shift+Alt+7 |          Ctrl+Shift+Alt+7 |           ctrl+shift+alt+7 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit8 |   8   |                         8 |                         8 |                          8 |         |
+|                   Shift+Digit8 |   *   |                   Shift+8 |                   Shift+8 |                    shift+8 |         |
+|                Ctrl+Alt+Digit8 |   ₽   |                Ctrl+Alt+8 |                Ctrl+Alt+8 |                 ctrl+alt+8 |         |
+|          Ctrl+Shift+Alt+Digit8 |  ---  |          Ctrl+Shift+Alt+8 |          Ctrl+Shift+Alt+8 |           ctrl+shift+alt+8 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit9 |   9   |                         9 |                         9 |                          9 |         |
+|                   Shift+Digit9 |   (   |                   Shift+9 |                   Shift+9 |                    shift+9 |         |
+|                Ctrl+Alt+Digit9 |  ---  |                Ctrl+Alt+9 |                Ctrl+Alt+9 |                 ctrl+alt+9 |         |
+|          Ctrl+Shift+Alt+Digit9 |  ---  |          Ctrl+Shift+Alt+9 |          Ctrl+Shift+Alt+9 |           ctrl+shift+alt+9 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Digit0 |   0   |                         0 |                         0 |                          0 |         |
+|                   Shift+Digit0 |   )   |                   Shift+0 |                   Shift+0 |                    shift+0 |         |
+|                Ctrl+Alt+Digit0 |  ---  |                Ctrl+Alt+0 |                Ctrl+Alt+0 |                 ctrl+alt+0 |         |
+|          Ctrl+Shift+Alt+Digit0 |  ---  |          Ctrl+Shift+Alt+0 |          Ctrl+Shift+Alt+0 |           ctrl+shift+alt+0 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                          Minus |   -   |                         - |                         - |                  oem_minus |    NO   |
+|                    Shift+Minus |   _   |                   Shift+- |                   Shift+- |            shift+oem_minus |    NO   |
+|                 Ctrl+Alt+Minus |  ---  |                Ctrl+Alt+- |                Ctrl+Alt+- |         ctrl+alt+oem_minus |    NO   |
+|           Ctrl+Shift+Alt+Minus |  ---  |          Ctrl+Shift+Alt+- |          Ctrl+Shift+Alt+- |   ctrl+shift+alt+oem_minus |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                          Equal |   =   |                         = |                         = |                   oem_plus |    NO   |
+|                    Shift+Equal |   +   |                   Shift+= |                   Shift+= |             shift+oem_plus |    NO   |
+|                 Ctrl+Alt+Equal |  ---  |                Ctrl+Alt+= |                Ctrl+Alt+= |          ctrl+alt+oem_plus |    NO   |
+|           Ctrl+Shift+Alt+Equal |  ---  |          Ctrl+Shift+Alt+= |          Ctrl+Shift+Alt+= |    ctrl+shift+alt+oem_plus |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                    BracketLeft |   х   |                         [ |                         [ |                      oem_4 |    NO   |
+|              Shift+BracketLeft |   Х   |                   Shift+[ |                   Shift+[ |                shift+oem_4 |    NO   |
+|           Ctrl+Alt+BracketLeft |  ---  |                Ctrl+Alt+[ |                Ctrl+Alt+[ |             ctrl+alt+oem_4 |    NO   |
+|     Ctrl+Shift+Alt+BracketLeft |  ---  |          Ctrl+Shift+Alt+[ |          Ctrl+Shift+Alt+[ |       ctrl+shift+alt+oem_4 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                   BracketRight |   ъ   |                         ] |                         ] |                      oem_6 |    NO   |
+|             Shift+BracketRight |   Ъ   |                   Shift+] |                   Shift+] |                shift+oem_6 |    NO   |
+|          Ctrl+Alt+BracketRight |  ---  |                Ctrl+Alt+] |                Ctrl+Alt+] |             ctrl+alt+oem_6 |    NO   |
+|    Ctrl+Shift+Alt+BracketRight |  ---  |          Ctrl+Shift+Alt+] |          Ctrl+Shift+Alt+] |       ctrl+shift+alt+oem_6 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                      Backslash |   \   |                         \ |                         \ |                      oem_5 |    NO   |
+|                Shift+Backslash |   /   |                   Shift+\ |                   Shift+\ |                shift+oem_5 |    NO   |
+|             Ctrl+Alt+Backslash |  ---  |                Ctrl+Alt+\ |                Ctrl+Alt+\ |             ctrl+alt+oem_5 |    NO   |
+|       Ctrl+Shift+Alt+Backslash |  ---  |          Ctrl+Shift+Alt+\ |          Ctrl+Shift+Alt+\ |       ctrl+shift+alt+oem_5 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                       IntlHash |  ---  |                      null |                      null |                       null |    NO   |
+|                 Shift+IntlHash |  ---  |                      null |                      null |                       null |    NO   |
+|              Ctrl+Alt+IntlHash |  ---  |                      null |                      null |                       null |    NO   |
+|        Ctrl+Shift+Alt+IntlHash |  ---  |                      null |                      null |                       null |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                      Semicolon |   ж   |                         ; |                         ; |                      oem_1 |    NO   |
+|                Shift+Semicolon |   Ж   |                   Shift+; |                   Shift+; |                shift+oem_1 |    NO   |
+|             Ctrl+Alt+Semicolon |  ---  |                Ctrl+Alt+; |                Ctrl+Alt+; |             ctrl+alt+oem_1 |    NO   |
+|       Ctrl+Shift+Alt+Semicolon |  ---  |          Ctrl+Shift+Alt+; |          Ctrl+Shift+Alt+; |       ctrl+shift+alt+oem_1 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                          Quote |   э   |                         ' |                         ' |                      oem_7 |    NO   |
+|                    Shift+Quote |   Э   |                   Shift+' |                   Shift+' |                shift+oem_7 |    NO   |
+|                 Ctrl+Alt+Quote |  ---  |                Ctrl+Alt+' |                Ctrl+Alt+' |             ctrl+alt+oem_7 |    NO   |
+|           Ctrl+Shift+Alt+Quote |  ---  |          Ctrl+Shift+Alt+' |          Ctrl+Shift+Alt+' |       ctrl+shift+alt+oem_7 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                      Backquote |   ё   |                         ` |                         ` |                      oem_3 |    NO   |
+|                Shift+Backquote |   Ё   |                   Shift+` |                   Shift+` |                shift+oem_3 |    NO   |
+|             Ctrl+Alt+Backquote |  ---  |                Ctrl+Alt+` |                Ctrl+Alt+` |             ctrl+alt+oem_3 |    NO   |
+|       Ctrl+Shift+Alt+Backquote |  ---  |          Ctrl+Shift+Alt+` |          Ctrl+Shift+Alt+` |       ctrl+shift+alt+oem_3 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                          Comma |   б   |                         , |                         , |                  oem_comma |    NO   |
+|                    Shift+Comma |   Б   |                   Shift+, |                   Shift+, |            shift+oem_comma |    NO   |
+|                 Ctrl+Alt+Comma |  ---  |                Ctrl+Alt+, |                Ctrl+Alt+, |         ctrl+alt+oem_comma |    NO   |
+|           Ctrl+Shift+Alt+Comma |  ---  |          Ctrl+Shift+Alt+, |          Ctrl+Shift+Alt+, |   ctrl+shift+alt+oem_comma |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         Period |   ю   |                         . |                         . |                 oem_period |    NO   |
+|                   Shift+Period |   Ю   |                   Shift+. |                   Shift+. |           shift+oem_period |    NO   |
+|                Ctrl+Alt+Period |  ---  |                Ctrl+Alt+. |                Ctrl+Alt+. |        ctrl+alt+oem_period |    NO   |
+|          Ctrl+Shift+Alt+Period |  ---  |          Ctrl+Shift+Alt+. |          Ctrl+Shift+Alt+. |  ctrl+shift+alt+oem_period |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                          Slash |   .   |                         / |                         / |                      oem_2 |    NO   |
+|                    Shift+Slash |   ,   |                   Shift+/ |                   Shift+/ |                shift+oem_2 |    NO   |
+|                 Ctrl+Alt+Slash |  ---  |                Ctrl+Alt+/ |                Ctrl+Alt+/ |             ctrl+alt+oem_2 |    NO   |
+|           Ctrl+Shift+Alt+Slash |  ---  |          Ctrl+Shift+Alt+/ |          Ctrl+Shift+Alt+/ |       ctrl+shift+alt+oem_2 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                        ArrowUp |  ---  |                   UpArrow |                   UpArrow |                         up |         |
+|                  Shift+ArrowUp |  ---  |             Shift+UpArrow |             Shift+UpArrow |                   shift+up |         |
+|               Ctrl+Alt+ArrowUp |  ---  |          Ctrl+Alt+UpArrow |          Ctrl+Alt+UpArrow |                ctrl+alt+up |         |
+|         Ctrl+Shift+Alt+ArrowUp |  ---  |    Ctrl+Shift+Alt+UpArrow |    Ctrl+Shift+Alt+UpArrow |          ctrl+shift+alt+up |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                        Numpad0 |  ---  |                   NumPad0 |                   NumPad0 |                    numpad0 |         |
+|                  Shift+Numpad0 |  ---  |             Shift+NumPad0 |             Shift+NumPad0 |              shift+numpad0 |         |
+|               Ctrl+Alt+Numpad0 |  ---  |          Ctrl+Alt+NumPad0 |          Ctrl+Alt+NumPad0 |           ctrl+alt+numpad0 |         |
+|         Ctrl+Shift+Alt+Numpad0 |  ---  |    Ctrl+Shift+Alt+NumPad0 |    Ctrl+Shift+Alt+NumPad0 |     ctrl+shift+alt+numpad0 |         |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                  IntlBackslash |   \   |                   OEM_102 |                         \ |                    oem_102 |    NO   |
+|            Shift+IntlBackslash |   /   |             Shift+OEM_102 |                   Shift+\ |              shift+oem_102 |    NO   |
+|         Ctrl+Alt+IntlBackslash |  ---  |          Ctrl+Alt+OEM_102 |                Ctrl+Alt+\ |           ctrl+alt+oem_102 |    NO   |
+|   Ctrl+Shift+Alt+IntlBackslash |  ---  |    Ctrl+Shift+Alt+OEM_102 |          Ctrl+Shift+Alt+\ |     ctrl+shift+alt+oem_102 |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                         IntlRo |  ---  |                      null |                      null |                       null |    NO   |
+|                   Shift+IntlRo |  ---  |                      null |                      null |                       null |    NO   |
+|                Ctrl+Alt+IntlRo |  ---  |                      null |                      null |                       null |    NO   |
+|          Ctrl+Shift+Alt+IntlRo |  ---  |                      null |                      null |                       null |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------
+|                        IntlYen |  ---  |                      null |                      null |                       null |    NO   |
+|                  Shift+IntlYen |  ---  |                      null |                      null |                       null |    NO   |
+|               Ctrl+Alt+IntlYen |  ---  |                      null |                      null |                       null |    NO   |
+|         Ctrl+Shift+Alt+IntlYen |  ---  |                      null |                      null |                       null |    NO   |
+-----------------------------------------------------------------------------------------------------------------------------------------

lib/vscode/src/vs/workbench/services/keybinding/test/electron-browser/windowsKeyboardMapper.test.ts

@@ -0,0 +1,534 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyChord, KeyCode, KeyMod, SimpleKeybinding, createKeybinding } from 'vs/base/common/keyCodes';
+import { OperatingSystem } from 'vs/base/common/platform';
+import { ScanCode, ScanCodeBinding } from 'vs/base/common/scanCode';
+import { IWindowsKeyboardMapping, WindowsKeyboardMapper } from 'vs/workbench/services/keybinding/common/windowsKeyboardMapper';
+import { IResolvedKeybinding, assertMapping, assertResolveKeybinding, assertResolveKeyboardEvent, assertResolveUserBinding, readRawMapping } from 'vs/workbench/services/keybinding/test/electron-browser/keyboardMapperTestUtils';
+
+const WRITE_FILE_IF_DIFFERENT = false;
+
+async function createKeyboardMapper(isUSStandard: boolean, file: string): Promise<WindowsKeyboardMapper> {
+	const rawMappings = await readRawMapping<IWindowsKeyboardMapping>(file);
+	return new WindowsKeyboardMapper(isUSStandard, rawMappings);
+}
+
+function _assertResolveKeybinding(mapper: WindowsKeyboardMapper, k: number, expected: IResolvedKeybinding[]): void {
+	const keyBinding = createKeybinding(k, OperatingSystem.Windows);
+	assertResolveKeybinding(mapper, keyBinding!, expected);
+}
+
+suite('keyboardMapper - WINDOWS de_ch', () => {
+
+	let mapper: WindowsKeyboardMapper;
+
+	suiteSetup(async () => {
+		mapper = await createKeyboardMapper(false, 'win_de_ch');
+	});
+
+	test('mapping', () => {
+		return assertMapping(WRITE_FILE_IF_DIFFERENT, mapper, 'win_de_ch.txt');
+	});
+
+	test('resolveKeybinding Ctrl+A', () => {
+		_assertResolveKeybinding(
+			mapper,
+			KeyMod.CtrlCmd | KeyCode.KEY_A,
+			[{
+				label: 'Ctrl+A',
+				ariaLabel: 'Control+A',
+				electronAccelerator: 'Ctrl+A',
+				userSettingsLabel: 'ctrl+a',
+				isWYSIWYG: true,
+				isChord: false,
+				dispatchParts: ['ctrl+A'],
+			}]
+		);
+	});
+
+	test('resolveKeybinding Ctrl+Z', () => {
+		_assertResolveKeybinding(
+			mapper,
+			KeyMod.CtrlCmd | KeyCode.KEY_Z,
+			[{
+				label: 'Ctrl+Z',
+				ariaLabel: 'Control+Z',
+				electronAccelerator: 'Ctrl+Z',
+				userSettingsLabel: 'ctrl+z',
+				isWYSIWYG: true,
+				isChord: false,
+				dispatchParts: ['ctrl+Z'],
+			}]
+		);
+	});
+
+	test('resolveKeyboardEvent Ctrl+Z', () => {
+		assertResolveKeyboardEvent(
+			mapper,
+			{
+				_standardKeyboardEventBrand: true,
+				ctrlKey: true,
+				shiftKey: false,
+				altKey: false,
+				metaKey: false,
+				keyCode: KeyCode.KEY_Z,
+				code: null!
+			},
+			{
+				label: 'Ctrl+Z',
+				ariaLabel: 'Control+Z',
+				electronAccelerator: 'Ctrl+Z',
+				userSettingsLabel: 'ctrl+z',
+				isWYSIWYG: true,
+				isChord: false,
+				dispatchParts: ['ctrl+Z'],
+			}
+		);
+	});
+
+	test('resolveKeybinding Ctrl+]', () => {
+		_assertResolveKeybinding(
+			mapper,
+			KeyMod.CtrlCmd | KeyCode.US_CLOSE_SQUARE_BRACKET,
+			[{
+				label: 'Ctrl+^',
+				ariaLabel: 'Control+^',
+				electronAccelerator: 'Ctrl+]',
+				userSettingsLabel: 'ctrl+oem_6',
+				isWYSIWYG: false,
+				isChord: false,
+				dispatchParts: ['ctrl+]'],
+			}]
+		);
+	});
+
+	test('resolveKeyboardEvent Ctrl+]', () => {
+		assertResolveKeyboardEvent(
+			mapper,
+			{
+				_standardKeyboardEventBrand: true,
+				ctrlKey: true,
+				shiftKey: false,
+				altKey: false,
+				metaKey: false,
+				keyCode: KeyCode.US_CLOSE_SQUARE_BRACKET,
+				code: null!
+			},
+			{
+				label: 'Ctrl+^',
+				ariaLabel: 'Control+^',
+				electronAccelerator: 'Ctrl+]',
+				userSettingsLabel: 'ctrl+oem_6',
+				isWYSIWYG: false,
+				isChord: false,
+				dispatchParts: ['ctrl+]'],
+			}
+		);
+	});
+
+	test('resolveKeybinding Shift+]', () => {
+		_assertResolveKeybinding(
+			mapper,
+			KeyMod.Shift | KeyCode.US_CLOSE_SQUARE_BRACKET,
+			[{
+				label: 'Shift+^',
+				ariaLabel: 'Shift+^',
+				electronAccelerator: 'Shift+]',
+				userSettingsLabel: 'shift+oem_6',
+				isWYSIWYG: false,
+				isChord: false,
+				dispatchParts: ['shift+]'],
+			}]
+		);
+	});
+
+	test('resolveKeybinding Ctrl+/', () => {
+		_assertResolveKeybinding(
+			mapper,
+			KeyMod.CtrlCmd | KeyCode.US_SLASH,
+			[{
+				label: 'Ctrl+§',
+				ariaLabel: 'Control+§',
+				electronAccelerator: 'Ctrl+/',
+				userSettingsLabel: 'ctrl+oem_2',
+				isWYSIWYG: false,
+				isChord: false,
+				dispatchParts: ['ctrl+/'],
+			}]
+		);
+	});
+
+	test('resolveKeybinding Ctrl+Shift+/', () => {
+		_assertResolveKeybinding(
+			mapper,
+			KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.US_SLASH,
+			[{
+				label: 'Ctrl+Shift+§',
+				ariaLabel: 'Control+Shift+§',
+				electronAccelerator: 'Ctrl+Shift+/',
+				userSettingsLabel: 'ctrl+shift+oem_2',
+				isWYSIWYG: false,
+				isChord: false,
+				dispatchParts: ['ctrl+shift+/'],
+			}]
+		);
+	});
+
+	test('resolveKeybinding Ctrl+K Ctrl+\\', () => {
+		_assertResolveKeybinding(
+			mapper,
+			KeyChord(KeyMod.CtrlCmd | KeyCode.KEY_K, KeyMod.CtrlCmd | KeyCode.US_BACKSLASH),
+			[{
+				label: 'Ctrl+K Ctrl+ä',
+				ariaLabel: 'Control+K Control+ä',
+				electronAccelerator: null,
+				userSettingsLabel: 'ctrl+k ctrl+oem_5',
+				isWYSIWYG: false,
+				isChord: true,
+				dispatchParts: ['ctrl+K', 'ctrl+\\'],
+			}]
+		);
+	});
+
+	test('resolveKeybinding Ctrl+K Ctrl+=', () => {
+		_assertResolveKeybinding(
+			mapper,
+			KeyChord(KeyMod.CtrlCmd | KeyCode.KEY_K, KeyMod.CtrlCmd | KeyCode.US_EQUAL),
+			[]
+		);
+	});
+
+	test('resolveKeybinding Ctrl+DownArrow', () => {
+		_assertResolveKeybinding(
+			mapper,
+			KeyMod.CtrlCmd | KeyCode.DownArrow,
+			[{
+				label: 'Ctrl+DownArrow',
+				ariaLabel: 'Control+DownArrow',
+				electronAccelerator: 'Ctrl+Down',
+				userSettingsLabel: 'ctrl+down',
+				isWYSIWYG: true,
+				isChord: false,
+				dispatchParts: ['ctrl+DownArrow'],
+			}]
+		);
+	});
+
+	test('resolveKeybinding Ctrl+NUMPAD_0', () => {
+		_assertResolveKeybinding(
+			mapper,
+			KeyMod.CtrlCmd | KeyCode.NUMPAD_0,
+			[{
+				label: 'Ctrl+NumPad0',
+				ariaLabel: 'Control+NumPad0',
+				electronAccelerator: null,
+				userSettingsLabel: 'ctrl+numpad0',
+				isWYSIWYG: true,
+				isChord: false,
+				dispatchParts: ['ctrl+NumPad0'],
+			}]
+		);
+	});
+
+	test('resolveKeybinding Ctrl+Home', () => {
+		_assertResolveKeybinding(
+			mapper,
+			KeyMod.CtrlCmd | KeyCode.Home,
+			[{
+				label: 'Ctrl+Home',
+				ariaLabel: 'Control+Home',
+				electronAccelerator: 'Ctrl+Home',
+				userSettingsLabel: 'ctrl+home',
+				isWYSIWYG: true,
+				isChord: false,
+				dispatchParts: ['ctrl+Home'],
+			}]
+		);
+	});
+
+	test('resolveKeyboardEvent Ctrl+Home', () => {
+		assertResolveKeyboardEvent(
+			mapper,
+			{
+				_standardKeyboardEventBrand: true,
+				ctrlKey: true,
+				shiftKey: false,
+				altKey: false,
+				metaKey: false,
+				keyCode: KeyCode.Home,
+				code: null!
+			},
+			{
+				label: 'Ctrl+Home',
+				ariaLabel: 'Control+Home',
+				electronAccelerator: 'Ctrl+Home',
+				userSettingsLabel: 'ctrl+home',
+				isWYSIWYG: true,
+				isChord: false,
+				dispatchParts: ['ctrl+Home'],
+			}
+		);
+	});
+
+	test('resolveUserBinding empty', () => {
+		assertResolveUserBinding(mapper, [], []);
+	});
+
+	test('resolveUserBinding Ctrl+[Comma] Ctrl+/', () => {
+		assertResolveUserBinding(
+			mapper, [
+			new ScanCodeBinding(true, false, false, false, ScanCode.Comma),
+			new SimpleKeybinding(true, false, false, false, KeyCode.US_SLASH),
+		],
+			[{
+				label: 'Ctrl+, Ctrl+§',
+				ariaLabel: 'Control+, Control+§',
+				electronAccelerator: null,
+				userSettingsLabel: 'ctrl+oem_comma ctrl+oem_2',
+				isWYSIWYG: false,
+				isChord: true,
+				dispatchParts: ['ctrl+,', 'ctrl+/'],
+			}]
+		);
+	});
+
+	test('resolveKeyboardEvent Modifier only Ctrl+', () => {
+		assertResolveKeyboardEvent(
+			mapper,
+			{
+				_standardKeyboardEventBrand: true,
+				ctrlKey: true,
+				shiftKey: false,
+				altKey: false,
+				metaKey: false,
+				keyCode: KeyCode.Ctrl,
+				code: null!
+			},
+			{
+				label: 'Ctrl',
+				ariaLabel: 'Control',
+				electronAccelerator: null,
+				userSettingsLabel: 'ctrl',
+				isWYSIWYG: true,
+				isChord: false,
+				dispatchParts: [null],
+			}
+		);
+	});
+});
+
+suite('keyboardMapper - WINDOWS en_us', () => {
+
+	let mapper: WindowsKeyboardMapper;
+
+	suiteSetup(async () => {
+		mapper = await createKeyboardMapper(true, 'win_en_us');
+	});
+
+	test('mapping', () => {
+		return assertMapping(WRITE_FILE_IF_DIFFERENT, mapper, 'win_en_us.txt');
+	});
+
+	test('resolveKeybinding Ctrl+K Ctrl+\\', () => {
+		_assertResolveKeybinding(
+			mapper,
+			KeyChord(KeyMod.CtrlCmd | KeyCode.KEY_K, KeyMod.CtrlCmd | KeyCode.US_BACKSLASH),
+			[{
+				label: 'Ctrl+K Ctrl+\\',
+				ariaLabel: 'Control+K Control+\\',
+				electronAccelerator: null,
+				userSettingsLabel: 'ctrl+k ctrl+\\',
+				isWYSIWYG: true,
+				isChord: true,
+				dispatchParts: ['ctrl+K', 'ctrl+\\'],
+			}]
+		);
+	});
+
+	test('resolveUserBinding Ctrl+[Comma] Ctrl+/', () => {
+		assertResolveUserBinding(
+			mapper, [
+			new ScanCodeBinding(true, false, false, false, ScanCode.Comma),
+			new SimpleKeybinding(true, false, false, false, KeyCode.US_SLASH),
+		],
+			[{
+				label: 'Ctrl+, Ctrl+/',
+				ariaLabel: 'Control+, Control+/',
+				electronAccelerator: null,
+				userSettingsLabel: 'ctrl+, ctrl+/',
+				isWYSIWYG: true,
+				isChord: true,
+				dispatchParts: ['ctrl+,', 'ctrl+/'],
+			}]
+		);
+	});
+
+	test('resolveUserBinding Ctrl+[Comma]', () => {
+		assertResolveUserBinding(
+			mapper, [
+			new ScanCodeBinding(true, false, false, false, ScanCode.Comma),
+		],
+			[{
+				label: 'Ctrl+,',
+				ariaLabel: 'Control+,',
+				electronAccelerator: 'Ctrl+,',
+				userSettingsLabel: 'ctrl+,',
+				isWYSIWYG: true,
+				isChord: false,
+				dispatchParts: ['ctrl+,'],
+			}]
+		);
+	});
+
+	test('resolveKeyboardEvent Modifier only Ctrl+', () => {
+		assertResolveKeyboardEvent(
+			mapper,
+			{
+				_standardKeyboardEventBrand: true,
+				ctrlKey: true,
+				shiftKey: false,
+				altKey: false,
+				metaKey: false,
+				keyCode: KeyCode.Ctrl,
+				code: null!
+			},
+			{
+				label: 'Ctrl',
+				ariaLabel: 'Control',
+				electronAccelerator: null,
+				userSettingsLabel: 'ctrl',
+				isWYSIWYG: true,
+				isChord: false,
+				dispatchParts: [null],
+			}
+		);
+	});
+});
+
+suite('keyboardMapper - WINDOWS por_ptb', () => {
+
+	let mapper: WindowsKeyboardMapper;
+
+	suiteSetup(async () => {
+		mapper = await createKeyboardMapper(false, 'win_por_ptb');
+	});
+
+	test('mapping', () => {
+		return assertMapping(WRITE_FILE_IF_DIFFERENT, mapper, 'win_por_ptb.txt');
+	});
+
+	test('resolveKeyboardEvent Ctrl+[IntlRo]', () => {
+		assertResolveKeyboardEvent(
+			mapper,
+			{
+				_standardKeyboardEventBrand: true,
+				ctrlKey: true,
+				shiftKey: false,
+				altKey: false,
+				metaKey: false,
+				keyCode: KeyCode.ABNT_C1,
+				code: null!
+			},
+			{
+				label: 'Ctrl+/',
+				ariaLabel: 'Control+/',
+				electronAccelerator: 'Ctrl+ABNT_C1',
+				userSettingsLabel: 'ctrl+abnt_c1',
+				isWYSIWYG: false,
+				isChord: false,
+				dispatchParts: ['ctrl+ABNT_C1'],
+			}
+		);
+	});
+
+	test('resolveKeyboardEvent Ctrl+[NumpadComma]', () => {
+		assertResolveKeyboardEvent(
+			mapper,
+			{
+				_standardKeyboardEventBrand: true,
+				ctrlKey: true,
+				shiftKey: false,
+				altKey: false,
+				metaKey: false,
+				keyCode: KeyCode.ABNT_C2,
+				code: null!
+			},
+			{
+				label: 'Ctrl+.',
+				ariaLabel: 'Control+.',
+				electronAccelerator: 'Ctrl+ABNT_C2',
+				userSettingsLabel: 'ctrl+abnt_c2',
+				isWYSIWYG: false,
+				isChord: false,
+				dispatchParts: ['ctrl+ABNT_C2'],
+			}
+		);
+	});
+});
+
+suite('keyboardMapper - WINDOWS ru', () => {
+
+	let mapper: WindowsKeyboardMapper;
+
+	suiteSetup(async () => {
+		mapper = await createKeyboardMapper(false, 'win_ru');
+	});
+
+	test('mapping', () => {
+		return assertMapping(WRITE_FILE_IF_DIFFERENT, mapper, 'win_ru.txt');
+	});
+
+	test('issue ##24361: resolveKeybinding Ctrl+K Ctrl+K', () => {
+		_assertResolveKeybinding(
+			mapper,
+			KeyChord(KeyMod.CtrlCmd | KeyCode.KEY_K, KeyMod.CtrlCmd | KeyCode.KEY_K),
+			[{
+				label: 'Ctrl+K Ctrl+K',
+				ariaLabel: 'Control+K Control+K',
+				electronAccelerator: null,
+				userSettingsLabel: 'ctrl+k ctrl+k',
+				isWYSIWYG: true,
+				isChord: true,
+				dispatchParts: ['ctrl+K', 'ctrl+K'],
+			}]
+		);
+	});
+});
+
+suite('keyboardMapper - misc', () => {
+	test('issue #23513: Toggle Sidebar Visibility and Go to Line display same key mapping in Arabic keyboard', () => {
+		const mapper = new WindowsKeyboardMapper(false, {
+			'KeyB': {
+				'vkey': 'VK_B',
+				'value': 'لا',
+				'withShift': 'لآ',
+				'withAltGr': '',
+				'withShiftAltGr': ''
+			},
+			'KeyG': {
+				'vkey': 'VK_G',
+				'value': 'ل',
+				'withShift': 'لأ',
+				'withAltGr': '',
+				'withShiftAltGr': ''
+			}
+		});
+
+		_assertResolveKeybinding(
+			mapper,
+			KeyMod.CtrlCmd | KeyCode.KEY_B,
+			[{
+				label: 'Ctrl+B',
+				ariaLabel: 'Control+B',
+				electronAccelerator: 'Ctrl+B',
+				userSettingsLabel: 'ctrl+b',
+				isWYSIWYG: true,
+				isChord: false,
+				dispatchParts: ['ctrl+B'],
+			}]
+		);
+	});
+});