@codingame/monaco-vscode-keybindings-service-override 4.1.0 → 4.1.1

package/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayoutService.js

@@ -0,0 +1,502 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { KeymapInfo } from '../common/keymapInfo.js';
+import { readKeyboardConfig } from '../../../../platform/keyboardLayout/common/keyboardConfig.js';
+import { CachedKeyboardMapper } from '../../../../platform/keyboardLayout/common/keyboardMapper.js';
+import { OS, isWindows, isMacintosh } from 'vscode/vscode/vs/base/common/platform';
+import { WindowsKeyboardMapper } from '../common/windowsKeyboardMapper.js';
+import { FallbackKeyboardMapper } from 'vscode/vscode/vs/workbench/services/keybinding/common/fallbackKeyboardMapper';
+import { MacLinuxKeyboardMapper } from '../common/macLinuxKeyboardMapper.js';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
+import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
+import { parse, getNodeType } from 'vscode/vscode/vs/base/common/json';
+import { equals } from 'vscode/vscode/vs/base/common/objects';
+import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { Extensions } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { getKeyboardLayoutId } from 'vscode/vscode/vs/platform/keyboardLayout/common/keyboardLayout';
+
+function __variableDynamicImportRuntime0__(path) {
+  switch (path) {
+    case './keyboardLayouts/layout.contribution.darwin.js': return import('./keyboardLayouts/layout.contribution.darwin.js').then(module => module.default ?? module);
+    case './keyboardLayouts/layout.contribution.linux.js': return import('./keyboardLayouts/layout.contribution.linux.js').then(module => module.default ?? module);
+    case './keyboardLayouts/layout.contribution.win.js': return import('./keyboardLayouts/layout.contribution.win.js').then(module => module.default ?? module);
+    default: return new Promise(function(resolve, reject) {
+      (typeof queueMicrotask === 'function' ? queueMicrotask : setTimeout)(
+        reject.bind(null, new Error("Unknown variable dynamic import: " + path))
+      );
+    })
+   }
+ }
+class BrowserKeyboardMapperFactoryBase extends Disposable {
+    get activeKeymap() {
+        return this._activeKeymapInfo;
+    }
+    get keymapInfos() {
+        return this._keymapInfos;
+    }
+    get activeKeyboardLayout() {
+        if (!this._initialized) {
+            return null;
+        }
+        return this._activeKeymapInfo?.layout ?? null;
+    }
+    get activeKeyMapping() {
+        if (!this._initialized) {
+            return null;
+        }
+        return this._activeKeymapInfo?.mapping ?? null;
+    }
+    get keyboardLayouts() {
+        return ( this._keymapInfos.map(keymapInfo => keymapInfo.layout));
+    }
+    constructor(_configurationService) {
+        super();
+        this._configurationService = _configurationService;
+        this._onDidChangeKeyboardMapper = ( new Emitter());
+        this.onDidChangeKeyboardMapper = this._onDidChangeKeyboardMapper.event;
+        this.keyboardLayoutMapAllowed = navigator.keyboard !== undefined;
+        this._keyboardMapper = null;
+        this._initialized = false;
+        this._keymapInfos = [];
+        this._mru = [];
+        this._activeKeymapInfo = null;
+        if (navigator.keyboard && navigator.keyboard.addEventListener) {
+            navigator.keyboard.addEventListener('layoutchange', () => {
+                this._getBrowserKeyMapping().then((mapping) => {
+                    if (this.isKeyMappingActive(mapping)) {
+                        return;
+                    }
+                    this.setLayoutFromBrowserAPI();
+                });
+            });
+        }
+        this._register(this._configurationService.onDidChangeConfiguration((e) => {
+            if (e.affectsConfiguration('keyboard')) {
+                this._keyboardMapper = null;
+                this._onDidChangeKeyboardMapper.fire();
+            }
+        }));
+    }
+    registerKeyboardLayout(layout) {
+        this._keymapInfos.push(layout);
+        this._mru = this._keymapInfos;
+    }
+    removeKeyboardLayout(layout) {
+        let index = this._mru.indexOf(layout);
+        this._mru.splice(index, 1);
+        index = this._keymapInfos.indexOf(layout);
+        this._keymapInfos.splice(index, 1);
+    }
+    getMatchedKeymapInfo(keyMapping) {
+        if (!keyMapping) {
+            return null;
+        }
+        const 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++) {
+                const 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) {
+        return this._activeKeymapInfo && keymap && this._activeKeymapInfo.fuzzyEqual(keymap);
+    }
+    setUSKeyboardLayout() {
+        this._activeKeymapInfo = this.getUSStandardLayout();
+    }
+    setActiveKeyMapping(keymap) {
+        let keymapUpdated = false;
+        const matchedKeyboardLayout = this.getMatchedKeymapInfo(keymap);
+        if (matchedKeyboardLayout) {
+            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) {
+        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);
+    }
+    setLayoutFromBrowserAPI() {
+        this._updateKeyboardLayoutAsync(this._initialized);
+    }
+    _updateKeyboardLayoutAsync(initialized, keyboardEvent) {
+        if (!initialized) {
+            return;
+        }
+        this._getBrowserKeyMapping(keyboardEvent).then(keyMap => {
+            if (this.isKeyMappingActive(keyMap)) {
+                return;
+            }
+            this.setActiveKeyMapping(keyMap);
+        });
+    }
+    getKeyboardMapper() {
+        const config = readKeyboardConfig(this._configurationService);
+        if (config.dispatch === 1  || !this._initialized || !this._activeKeymapInfo) {
+            return ( new FallbackKeyboardMapper(config.mapAltGrToCtrlAlt, OS));
+        }
+        if (!this._keyboardMapper) {
+            this._keyboardMapper = ( new CachedKeyboardMapper(
+                BrowserKeyboardMapperFactory._createKeyboardMapper(this._activeKeymapInfo, config.mapAltGrToCtrlAlt)
+            ));
+        }
+        return this._keyboardMapper;
+    }
+    validateCurrentKeyboardMapping(keyboardEvent) {
+        if (!this._initialized) {
+            return;
+        }
+        const isCurrentKeyboard = this._validateCurrentKeyboardMapping(keyboardEvent);
+        if (isCurrentKeyboard) {
+            return;
+        }
+        this._updateKeyboardLayoutAsync(true, keyboardEvent);
+    }
+    setKeyboardLayout(layoutName) {
+        const matchedLayouts = this.keymapInfos.filter(keymapInfo => getKeyboardLayoutId(keymapInfo.layout) === layoutName);
+        if (matchedLayouts.length > 0) {
+            this.setActiveKeymapInfo(matchedLayouts[0]);
+        }
+    }
+    _setKeyboardData(keymapInfo) {
+        this._initialized = true;
+        this._keyboardMapper = null;
+        this._onDidChangeKeyboardMapper.fire();
+    }
+    static _createKeyboardMapper(keymapInfo, mapAltGrToCtrlAlt) {
+        const rawMapping = keymapInfo.mapping;
+        const isUSStandard = !!keymapInfo.layout.isUSStandard;
+        if (OS === 1 ) {
+            return ( new WindowsKeyboardMapper(isUSStandard, rawMapping, mapAltGrToCtrlAlt));
+        }
+        if (( Object.keys(rawMapping)).length === 0) {
+            return ( new FallbackKeyboardMapper(mapAltGrToCtrlAlt, OS));
+        }
+        return ( new MacLinuxKeyboardMapper(isUSStandard, rawMapping, mapAltGrToCtrlAlt, OS));
+    }
+    _validateCurrentKeyboardMapping(keyboardEvent) {
+        if (!this._initialized) {
+            return true;
+        }
+        const standardKeyboardEvent = keyboardEvent;
+        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 === '') {
+            if (keyboardEvent.ctrlKey || keyboardEvent.metaKey) {
+                setTimeout(() => {
+                    this._getBrowserKeyMapping().then((keymap) => {
+                        if (this.isKeyMappingActive(keymap)) {
+                            return;
+                        }
+                        this.setLayoutFromBrowserAPI();
+                    });
+                }, 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;
+        }
+        if (!isDead && standardKeyboardEvent.browserEvent.key !== expectedValue) {
+            return false;
+        }
+        return true;
+    }
+    async _getBrowserKeyMapping(keyboardEvent) {
+        if (this.keyboardLayoutMapAllowed) {
+            try {
+                return await navigator.keyboard.getLayoutMap().then((e) => {
+                    const ret = {};
+                    for (const key of e) {
+                        ret[key[0]] = {
+                            'value': key[1],
+                            'withShift': '',
+                            'withAltGr': '',
+                            'withShiftAltGr': ''
+                        };
+                    }
+                    return ret;
+                });
+            }
+            catch {
+                this.keyboardLayoutMapAllowed = false;
+            }
+        }
+        if (keyboardEvent && !keyboardEvent.shiftKey && !keyboardEvent.altKey && !keyboardEvent.metaKey && !keyboardEvent.metaKey) {
+            const ret = {};
+            const standardKeyboardEvent = keyboardEvent;
+            ret[standardKeyboardEvent.browserEvent.code] = {
+                'value': standardKeyboardEvent.browserEvent.key,
+                'withShift': '',
+                'withAltGr': '',
+                'withShiftAltGr': ''
+            };
+            const matchedKeyboardLayout = this.getMatchedKeymapInfo(ret);
+            if (matchedKeyboardLayout) {
+                return ret;
+            }
+            return null;
+        }
+        return null;
+    }
+}
+class BrowserKeyboardMapperFactory extends BrowserKeyboardMapperFactoryBase {
+    constructor(configurationService, notificationService, storageService, commandService) {
+        super(configurationService);
+        const platform = isWindows ? 'win' : isMacintosh ? 'darwin' : 'linux';
+        __variableDynamicImportRuntime0__('./keyboardLayouts/layout.contribution.' + platform + '.js').then((m) => {
+            const keymapInfos = m.KeyboardLayoutContribution.INSTANCE.layoutInfos;
+            this._keymapInfos.push(...( keymapInfos.map(info => (( new KeymapInfo(
+                info.layout,
+                info.secondaryLayouts,
+                info.mapping,
+                info.isUserKeyboardLayout
+            ))))));
+            this._mru = this._keymapInfos;
+            this._initialized = true;
+            this.setLayoutFromBrowserAPI();
+        });
+    }
+}
+class UserKeyboardLayout extends Disposable {
+    get keyboardLayout() { return this._keyboardLayout; }
+    constructor(keyboardLayoutResource, fileService) {
+        super();
+        this.keyboardLayoutResource = keyboardLayoutResource;
+        this.fileService = fileService;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        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() {
+        await this.reload();
+    }
+    async reload() {
+        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 ? !equals(existing, this._keyboardLayout) : true;
+    }
+}
+let BrowserKeyboardLayoutService = class BrowserKeyboardLayoutService extends Disposable {
+    constructor(environmentService, fileService, notificationService, storageService, commandService, configurationService) {
+        super();
+        this.configurationService = configurationService;
+        this._onDidChangeKeyboardLayout = ( new Emitter());
+        this.onDidChangeKeyboardLayout = this._onDidChangeKeyboardLayout.event;
+        const keyboardConfig = configurationService.getValue('keyboard');
+        const layout = keyboardConfig.layout;
+        this._keyboardLayoutMode = layout ?? 'autodetect';
+        this._factory = ( new BrowserKeyboardMapperFactory(configurationService, notificationService, storageService, commandService));
+        this._register(this._factory.onDidChangeKeyboardMapper(() => {
+            this._onDidChangeKeyboardLayout.fire();
+        }));
+        if (layout && layout !== 'autodetect') {
+            this._factory.setKeyboardLayout(layout);
+        }
+        this._register(configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('keyboard.layout')) {
+                const keyboardConfig = configurationService.getValue('keyboard');
+                const layout = keyboardConfig.layout;
+                this._keyboardLayoutMode = layout;
+                if (layout === 'autodetect') {
+                    this._factory.setLayoutFromBrowserAPI();
+                }
+                else {
+                    this._factory.setKeyboardLayout(layout);
+                }
+            }
+        }));
+        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(() => {
+            const 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('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);
+                }
+            }
+        }
+    }
+    getKeyboardMapper() {
+        return this._factory.getKeyboardMapper();
+    }
+    getCurrentKeyboardLayout() {
+        return this._factory.activeKeyboardLayout;
+    }
+    getAllKeyboardLayouts() {
+        return this._factory.keyboardLayouts;
+    }
+    getRawKeyboardMapping() {
+        return this._factory.activeKeyMapping;
+    }
+    validateCurrentKeyboardMapping(keyboardEvent) {
+        if (this._keyboardLayoutMode !== 'autodetect') {
+            return;
+        }
+        this._factory.validateCurrentKeyboardMapping(keyboardEvent);
+    }
+};
+BrowserKeyboardLayoutService = ( __decorate([
+    ( __param(0, IEnvironmentService)),
+    ( __param(1, IFileService)),
+    ( __param(2, INotificationService)),
+    ( __param(3, IStorageService)),
+    ( __param(4, ICommandService)),
+    ( __param(5, IConfigurationService))
+], BrowserKeyboardLayoutService));
+const configurationRegistry = ( Registry.as(Extensions.Configuration));
+const keyboardConfiguration = {
+    'id': 'keyboard',
+    'order': 15,
+    'type': 'object',
+    'title': ( localizeWithPath(
+        'vs/workbench/services/keybinding/browser/keyboardLayoutService',
+        'keyboardConfigurationTitle',
+        "Keyboard"
+    )),
+    'properties': {
+        'keyboard.layout': {
+            'type': 'string',
+            'default': 'autodetect',
+            'description': ( localizeWithPath(
+                'vs/workbench/services/keybinding/browser/keyboardLayoutService',
+                'keyboard.layout.config',
+                "Control the keyboard layout used in web."
+            ))
+        }
+    }
+};
+configurationRegistry.registerConfiguration(keyboardConfiguration);
+
+export { BrowserKeyboardLayoutService, BrowserKeyboardMapperFactory, BrowserKeyboardMapperFactoryBase };

package/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/_.contribution.js

@@ -0,0 +1,14 @@
+class KeyboardLayoutContribution {
+    static { this.INSTANCE = ( new KeyboardLayoutContribution()); }
+    get layoutInfos() {
+        return this._layoutInfos;
+    }
+    constructor() {
+        this._layoutInfos = [];
+    }
+    registerKeyboardLayout(layout) {
+        this._layoutInfos.push(layout);
+    }
+}
+
+export { KeyboardLayoutContribution };

package/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/cz.win.js

@@ -0,0 +1,163 @@
+import { KeyboardLayoutContribution } from './_.contribution.js';
+
+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: []
+    }
+});