@codingame/monaco-vscode-api 1.83.8 → 1.83.10-next.0

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

@@ -1,498 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-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 'monaco-editor/esm/vs/base/common/platform.js';
-import { WindowsKeyboardMapper } from '../common/windowsKeyboardMapper.js';
-import { FallbackKeyboardMapper } from '../common/fallbackKeyboardMapper.js';
-import { MacLinuxKeyboardMapper } from '../common/macLinuxKeyboardMapper.js';
-import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
-import { parse, getNodeType } from 'monaco-editor/esm/vs/base/common/json.js';
-import * as objects from 'monaco-editor/esm/vs/base/common/objects.js';
-import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { getKeyboardLayoutId } from '../../../../platform/keyboardLayout/common/keyboardLayout.js';
-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._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 (navigator.keyboard) {
-            try {
-                return navigator.keyboard.getLayoutMap().then((e) => {
-                    const ret = {};
-                    for (const key of e) {
-                        ret[key[0]] = {
-                            'value': key[1],
-                            'withShift': '',
-                            'withAltGr': '',
-                            'withShiftAltGr': ''
-                        };
-                    }
-                    return ret;
-                });
-            }
-            catch {
-            }
-        }
-        else 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 ? !objects.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': ( nls.localizeWithPath(
-        'vs/workbench/services/keybinding/browser/keyboardLayoutService',
-        'keyboardConfigurationTitle',
-        "Keyboard"
-    )),
-    'properties': {
-        'keyboard.layout': {
-            'type': 'string',
-            'default': 'autodetect',
-            'description': ( nls.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

@@ -1,13 +0,0 @@
-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

@@ -1,162 +0,0 @@
-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: []
-    }
-});