From 0371a7dc4c578e5097aa9f042010ff4add0eaab5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Miroslav=20=C5=A0ediv=C3=BD?= <sedivy.miro@gmail.com>
Date: Tue, 4 Oct 2022 20:28:07 +0200
Subject: [PATCH] Add NoVnc keyboard (#13)

* novnc wip.

* remove blacklistKeys.

* eslint ignore all js files.

* ad common keyboard interface.

* upgrade novnc.

* fix novnc.

* fix novnc keyboard.

* fix keyboard remapping.

* conditionally include novnc at build time.
---
 .eslintrc                                     |    3 +-
 README.md                                     |   10 +
 src/component/overlay.vue                     |   12 +-
 src/component/utils/keyboard-remapping.ts     |   14 +-
 src/component/utils/keyboard.ts               |   17 +
 .../guacamole.js}                             | 3026 ++++++++---------
 .../guacamole.ts}                             |   16 +-
 src/component/utils/keyboards/novnc.js        |    2 +
 src/component/utils/keyboards/novnc.ts        |   50 +
 .../utils/keyboards/novnc/browser.js          |   42 +
 .../utils/keyboards/novnc/domkeytable.js      |  311 ++
 .../utils/keyboards/novnc/fixedkeys.js        |  129 +
 .../utils/keyboards/novnc/keyboard.js         |  293 ++
 src/component/utils/keyboards/novnc/keysym.js |  616 ++++
 .../utils/keyboards/novnc/keysymdef.js        |  688 ++++
 src/component/utils/keyboards/novnc/util.js   |  191 ++
 src/component/utils/keyboards/novnc/vkeys.js  |  116 +
 vue.config.js                                 |   10 +
 18 files changed, 4014 insertions(+), 1532 deletions(-)
 create mode 100644 src/component/utils/keyboard.ts
 rename src/component/utils/{guacamole-keyboard.js => keyboards/guacamole.js} (96%)
 rename src/component/utils/{guacamole-keyboard.ts => keyboards/guacamole.ts} (86%)
 create mode 100644 src/component/utils/keyboards/novnc.js
 create mode 100644 src/component/utils/keyboards/novnc.ts
 create mode 100644 src/component/utils/keyboards/novnc/browser.js
 create mode 100644 src/component/utils/keyboards/novnc/domkeytable.js
 create mode 100644 src/component/utils/keyboards/novnc/fixedkeys.js
 create mode 100644 src/component/utils/keyboards/novnc/keyboard.js
 create mode 100644 src/component/utils/keyboards/novnc/keysym.js
 create mode 100644 src/component/utils/keyboards/novnc/keysymdef.js
 create mode 100644 src/component/utils/keyboards/novnc/util.js
 create mode 100644 src/component/utils/keyboards/novnc/vkeys.js

diff --git a/.eslintrc b/.eslintrc
index 34b791bd..654c3bf4 100644
--- a/.eslintrc
+++ b/.eslintrc
@@ -14,5 +14,6 @@
     "no-dupe-class-members": "off",
     "no-console": "off",
     "no-empty": "off"
-  }
+  },
+  "ignorePatterns": ["**/*.js"]
 }
diff --git a/README.md b/README.md
index b9acd68e..5c6fb19f 100644
--- a/README.md
+++ b/README.md
@@ -21,6 +21,16 @@ echo @demodesk:registry=https://npm.pkg.github.com >> .npmrc
 # yarn command
 echo \"@demodesk:registry\" \"https://npm.pkg.github.com\" >> .yarnrc
 ```
+### Build
+
+You can set keyboard provider at build time, either `novnc` or the default `guacamole`.
+
+```bash
+# by default uses guacamole keybaord
+npm run build
+# uses novnc keybaord
+KEYBOARD=novnc npm run build
+```
 
 ### Example
 API consists of accessing Vue reactive state, calling various methods and subscribing to events. Simple usage:
diff --git a/src/component/overlay.vue b/src/component/overlay.vue
index 54cc6579..077ed168 100644
--- a/src/component/overlay.vue
+++ b/src/component/overlay.vue
@@ -45,7 +45,7 @@
 <script lang="ts">
   import { Vue, Component, Ref, Prop, Watch } from 'vue-property-decorator'
 
-  import GuacamoleKeyboard from './utils/guacamole-keyboard'
+  import { KeyboardInterface, NewKeyboard } from './utils/keyboard'
   import { KeyTable, keySymsRemap } from './utils/keyboard-remapping'
   import { getFilesFromDataTansfer } from './utils/file-upload'
   import { NekoControl } from './internal/control'
@@ -69,8 +69,9 @@
     @Ref('textarea') readonly _textarea!: HTMLTextAreaElement
     private _ctx!: CanvasRenderingContext2D
 
+    private keyboard!: KeyboardInterface
     private textInput = ''
-    private keyboard = GuacamoleKeyboard()
+
     private focused = false
 
     @Prop()
@@ -132,7 +133,8 @@
       let ctrlKey = 0
       let noKeyUp = {} as Record<number, boolean>
 
-      // Initialize Guacamole Keyboard
+      // Initialize Keyboard
+      this.keyboard = NewKeyboard()
       this.keyboard.onkeydown = (key: number) => {
         key = keySymsRemap(key)
 
@@ -188,7 +190,9 @@
     beforeDestroy() {
       window.removeEventListener('mouseup', this.onMouseUp, true)
 
-      // Guacamole Keyboard does not provide destroy functions
+      if (this.keyboard) {
+        this.keyboard.removeListener()
+      }
 
       this.webrtc.removeListener('cursor-position', this.onCursorPosition)
       this.webrtc.removeListener('cursor-image', this.onCursorImage)
diff --git a/src/component/utils/keyboard-remapping.ts b/src/component/utils/keyboard-remapping.ts
index f3a4392b..b22b7a32 100644
--- a/src/component/utils/keyboard-remapping.ts
+++ b/src/component/utils/keyboard-remapping.ts
@@ -12,26 +12,22 @@ export const KeyTable = {
   XK_Super_R: 0xffec, // Right super
 
   XK_ISO_Level3_Shift: 0xfe03, // AltGr
-  XK_Mode_switch: 0xff7e, // Character set switch
 }
 
 export const keySymsRemap = function (key: number) {
   const isMac = navigator && navigator.platform.match(/^mac/i)
   const isiOS = navigator && navigator.platform.match(/ipad|iphone|ipod/i)
 
-  // switch command with ctrl on mac and ios
+  // switch command with ctrl and option with altgr on mac and ios
   if (isMac || isiOS) {
     switch (key) {
-      case KeyTable.XK_Meta_L:
+      case KeyTable.XK_Meta_L: // meta is used by guacamole for CMD key
+      case KeyTable.XK_Super_L: // super is used by novnc for CMD key
         return KeyTable.XK_Control_L
       case KeyTable.XK_Meta_R:
-        return KeyTable.XK_Control_R
-      case KeyTable.XK_Super_L:
-        return KeyTable.XK_Alt_L
       case KeyTable.XK_Super_R:
-        return KeyTable.XK_Super_L
-      case KeyTable.XK_Alt_L:
-        return KeyTable.XK_Mode_switch
+        return KeyTable.XK_Control_R
+      case KeyTable.XK_Alt_L: // alt (option key on mac) behaves like altgr
       case KeyTable.XK_Alt_R:
         return KeyTable.XK_ISO_Level3_Shift
     }
diff --git a/src/component/utils/keyboard.ts b/src/component/utils/keyboard.ts
new file mode 100644
index 00000000..0c753647
--- /dev/null
+++ b/src/component/utils/keyboard.ts
@@ -0,0 +1,17 @@
+//@ts-ignore
+import Keyboard from './keyboards/__KEYBOARD__'
+
+// conditional import at build time:
+// __KEYBOARD__ is replaced by the value of the env variable KEYBOARD
+
+export interface KeyboardInterface {
+  onkeydown?: (keysym: number) => boolean
+  onkeyup?: (keysym: number) => void
+  release: (keysym: number) => void
+  listenTo: (element: Element | Document) => void
+  removeListener: () => void
+}
+
+export function NewKeyboard(element?: Element): KeyboardInterface {
+  return Keyboard(element)
+}
diff --git a/src/component/utils/guacamole-keyboard.js b/src/component/utils/keyboards/guacamole.js
similarity index 96%
rename from src/component/utils/guacamole-keyboard.js
rename to src/component/utils/keyboards/guacamole.js
index c28bb597..a93f8d00 100644
--- a/src/component/utils/guacamole-keyboard.js
+++ b/src/component/utils/keyboards/guacamole.js
@@ -1,1514 +1,1512 @@
-/* eslint-disable */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-var Guacamole = Guacamole || {};
-
-/**
- * Provides cross-browser and cross-keyboard keyboard for a specific element.
- * Browser and keyboard layout variation is abstracted away, providing events
- * which represent keys as their corresponding X11 keysym.
- * 
- * @constructor
- * @param {Element|Document} [element]
- *    The Element to use to provide keyboard events. If omitted, at least one
- *    Element must be manually provided through the listenTo() function for
- *    the Guacamole.Keyboard instance to have any effect.
- */
-Guacamole.Keyboard = function Keyboard(element) {
-
-    /**
-     * Reference to this Guacamole.Keyboard.
-     *
-     * @private
-     * @type {!Guacamole.Keyboard}
-     */
-    var guac_keyboard = this;
-
-    /**
-     * An integer value which uniquely identifies this Guacamole.Keyboard
-     * instance with respect to other Guacamole.Keyboard instances.
-     *
-     * @private
-     * @type {!number}
-     */
-    var guacKeyboardID = Guacamole.Keyboard._nextID++;
-
-    /**
-     * The name of the property which is added to event objects via markEvent()
-     * to note that they have already been handled by this Guacamole.Keyboard.
-     *
-     * @private
-     * @constant
-     * @type {!string}
-     */
-    var EVENT_MARKER = '_GUAC_KEYBOARD_HANDLED_BY_' + guacKeyboardID;
-
-    /**
-     * Fired whenever the user presses a key with the element associated
-     * with this Guacamole.Keyboard in focus.
-     * 
-     * @event
-     * @param {!number} keysym
-     *     The keysym of the key being pressed.
-     *
-     * @return {!boolean}
-     *     true if the key event should be allowed through to the browser,
-     *     false otherwise.
-     */
-    this.onkeydown = null;
-
-    /**
-     * Fired whenever the user releases a key with the element associated
-     * with this Guacamole.Keyboard in focus.
-     * 
-     * @event
-     * @param {!number} keysym
-     *     The keysym of the key being released.
-     */
-    this.onkeyup = null;
-
-    /**
-     * Set of known platform-specific or browser-specific quirks which must be
-     * accounted for to properly interpret key events, even if the only way to
-     * reliably detect that quirk is to platform/browser-sniff.
-     *
-     * @private
-     * @type {!Object.<string, boolean>}
-     */
-    var quirks = {
-
-        /**
-         * Whether keyup events are universally unreliable.
-         *
-         * @type {!boolean}
-         */
-        keyupUnreliable: false,
-
-        /**
-         * Whether the Alt key is actually a modifier for typable keys and is
-         * thus never used for keyboard shortcuts.
-         *
-         * @type {!boolean}
-         */
-        altIsTypableOnly: false,
-
-        /**
-         * Whether we can rely on receiving a keyup event for the Caps Lock
-         * key.
-         *
-         * @type {!boolean}
-         */
-        capsLockKeyupUnreliable: false
-
-    };
-
-    // Set quirk flags depending on platform/browser, if such information is
-    // available
-    if (navigator && navigator.platform) {
-
-        // All keyup events are unreliable on iOS (sadly)
-        if (navigator.platform.match(/ipad|iphone|ipod/i))
-            quirks.keyupUnreliable = true;
-
-        // The Alt key on Mac is never used for keyboard shortcuts, and the
-        // Caps Lock key never dispatches keyup events
-        else if (navigator.platform.match(/^mac/i)) {
-            quirks.altIsTypableOnly = true;
-            quirks.capsLockKeyupUnreliable = true;
-        }
-
-    }
-
-    /**
-     * A key event having a corresponding timestamp. This event is non-specific.
-     * Its subclasses should be used instead when recording specific key
-     * events.
-     *
-     * @private
-     * @constructor
-     * @param {KeyboardEvent} [orig]
-     *     The relevant DOM keyboard event.
-     */
-    var KeyEvent = function KeyEvent(orig) {
-
-        /**
-         * Reference to this key event.
-         *
-         * @private
-         * @type {!KeyEvent}
-         */
-        var key_event = this;
-
-        /**
-         * The JavaScript key code of the key pressed. For most events (keydown
-         * and keyup), this is a scancode-like value related to the position of
-         * the key on the US English "Qwerty" keyboard. For keypress events, 
-         * this is the Unicode codepoint of the character that would be typed
-         * by the key pressed.
-         *
-         * @type {!number}
-         */
-        this.keyCode = orig ? (orig.which || orig.keyCode) : 0;
-
-        /**
-         * The legacy DOM3 "keyIdentifier" of the key pressed, as defined at:
-         * http://www.w3.org/TR/2009/WD-DOM-Level-3-Events-20090908/#events-Events-KeyboardEvent
-         *
-         * @type {!string}
-         */
-        this.keyIdentifier = orig && orig.keyIdentifier;
-
-        /**
-         * The standard name of the key pressed, as defined at:
-         * http://www.w3.org/TR/DOM-Level-3-Events/#events-KeyboardEvent
-         * 
-         * @type {!string}
-         */
-        this.key = orig && orig.key;
-
-        /**
-         * The location on the keyboard corresponding to the key pressed, as
-         * defined at:
-         * http://www.w3.org/TR/DOM-Level-3-Events/#events-KeyboardEvent
-         * 
-         * @type {!number}
-         */
-        this.location = orig ? getEventLocation(orig) : 0;
-
-        /**
-         * The state of all local keyboard modifiers at the time this event was
-         * received.
-         *
-         * @type {!Guacamole.Keyboard.ModifierState}
-         */
-        this.modifiers = orig ? Guacamole.Keyboard.ModifierState.fromKeyboardEvent(orig) : new Guacamole.Keyboard.ModifierState();
-
-        /**
-         * An arbitrary timestamp in milliseconds, indicating this event's
-         * position in time relative to other events.
-         *
-         * @type {!number}
-         */
-        this.timestamp = new Date().getTime();
-
-        /**
-         * Whether the default action of this key event should be prevented.
-         *
-         * @type {!boolean}
-         */
-        this.defaultPrevented = false;
-
-        /**
-         * The keysym of the key associated with this key event, as determined
-         * by a best-effort guess using available event properties and keyboard
-         * state.
-         *
-         * @type {number}
-         */
-        this.keysym = null;
-
-        /**
-         * Whether the keysym value of this key event is known to be reliable.
-         * If false, the keysym may still be valid, but it's only a best guess,
-         * and future key events may be a better source of information.
-         *
-         * @type {!boolean}
-         */
-        this.reliable = false;
-
-        /**
-         * Returns the number of milliseconds elapsed since this event was
-         * received.
-         *
-         * @return {!number}
-         *     The number of milliseconds elapsed since this event was
-         *     received.
-         */
-        this.getAge = function() {
-            return new Date().getTime() - key_event.timestamp;
-        };
-
-    };
-
-    /**
-     * Information related to the pressing of a key, which need not be a key
-     * associated with a printable character. The presence or absence of any
-     * information within this object is browser-dependent.
-     *
-     * @private
-     * @constructor
-     * @augments Guacamole.Keyboard.KeyEvent
-     * @param {!KeyboardEvent} orig
-     *     The relevant DOM "keydown" event.
-     */
-    var KeydownEvent = function KeydownEvent(orig) {
-
-        // We extend KeyEvent
-        KeyEvent.call(this, orig);
-
-        // If key is known from keyCode or DOM3 alone, use that
-        this.keysym =  keysym_from_key_identifier(this.key, this.location)
-                    || keysym_from_keycode(this.keyCode, this.location);
-
-        /**
-         * Whether the keyup following this keydown event is known to be
-         * reliable. If false, we cannot rely on the keyup event to occur.
-         *
-         * @type {!boolean}
-         */
-        this.keyupReliable = !quirks.keyupUnreliable;
-
-        // DOM3 and keyCode are reliable sources if the corresponding key is
-        // not a printable key
-        if (this.keysym && !isPrintable(this.keysym))
-            this.reliable = true;
-
-        // Use legacy keyIdentifier as a last resort, if it looks sane
-        if (!this.keysym && key_identifier_sane(this.keyCode, this.keyIdentifier))
-            this.keysym = keysym_from_key_identifier(this.keyIdentifier, this.location, this.modifiers.shift);
-
-        // If a key is pressed while meta is held down, the keyup will
-        // never be sent in Chrome (bug #108404)
-        if (this.modifiers.meta && this.keysym !== 0xFFE7 && this.keysym !== 0xFFE8)
-            this.keyupReliable = false;
-
-        // We cannot rely on receiving keyup for Caps Lock on certain platforms
-        else if (this.keysym === 0xFFE5 && quirks.capsLockKeyupUnreliable)
-            this.keyupReliable = false;
-
-        // Determine whether default action for Alt+combinations must be prevented
-        var prevent_alt = !this.modifiers.ctrl && !quirks.altIsTypableOnly;
-
-        // Determine whether default action for Ctrl+combinations must be prevented
-        var prevent_ctrl = !this.modifiers.alt;
-
-        // We must rely on the (potentially buggy) keyIdentifier if preventing
-        // the default action is important
-        if ((prevent_ctrl && this.modifiers.ctrl)
-         || (prevent_alt  && this.modifiers.alt)
-         || this.modifiers.meta
-         || this.modifiers.hyper)
-            this.reliable = true;
-
-        // Record most recently known keysym by associated key code
-        recentKeysym[this.keyCode] = this.keysym;
-
-    };
-
-    KeydownEvent.prototype = new KeyEvent();
-
-    /**
-     * Information related to the pressing of a key, which MUST be
-     * associated with a printable character. The presence or absence of any
-     * information within this object is browser-dependent.
-     *
-     * @private
-     * @constructor
-     * @augments Guacamole.Keyboard.KeyEvent
-     * @param {!KeyboardEvent} orig
-     *     The relevant DOM "keypress" event.
-     */
-    var KeypressEvent = function KeypressEvent(orig) {
-
-        // We extend KeyEvent
-        KeyEvent.call(this, orig);
-
-        // Pull keysym from char code
-        this.keysym = keysym_from_charcode(this.keyCode);
-
-        // Keypress is always reliable
-        this.reliable = true;
-
-    };
-
-    KeypressEvent.prototype = new KeyEvent();
-
-    /**
-     * Information related to the releasing of a key, which need not be a key
-     * associated with a printable character. The presence or absence of any
-     * information within this object is browser-dependent.
-     *
-     * @private
-     * @constructor
-     * @augments Guacamole.Keyboard.KeyEvent
-     * @param {!KeyboardEvent} orig
-     *     The relevant DOM "keyup" event.
-     */
-    var KeyupEvent = function KeyupEvent(orig) {
-
-        // We extend KeyEvent
-        KeyEvent.call(this, orig);
-
-        // If key is known from keyCode or DOM3 alone, use that (keyCode is
-        // still more reliable for keyup when dead keys are in use)
-        this.keysym =  keysym_from_keycode(this.keyCode, this.location)
-                    || keysym_from_key_identifier(this.key, this.location);
-
-        // Fall back to the most recently pressed keysym associated with the
-        // keyCode if the inferred key doesn't seem to actually be pressed
-        if (!guac_keyboard.pressed[this.keysym])
-            this.keysym = recentKeysym[this.keyCode] || this.keysym;
-
-        // Keyup is as reliable as it will ever be
-        this.reliable = true;
-
-    };
-
-    KeyupEvent.prototype = new KeyEvent();
-
-    /**
-     * An array of recorded events, which can be instances of the private
-     * KeydownEvent, KeypressEvent, and KeyupEvent classes.
-     *
-     * @private
-     * @type {!KeyEvent[]}
-     */
-    var eventLog = [];
-
-    /**
-     * Map of known JavaScript keycodes which do not map to typable characters
-     * to their X11 keysym equivalents.
-     *
-     * @private
-     * @type {!Object.<number, number[]>}
-     */
-    var keycodeKeysyms = {
-        8:   [0xFF08], // backspace
-        9:   [0xFF09], // tab
-        12:  [0xFF0B, 0xFF0B, 0xFF0B, 0xFFB5], // clear       / KP 5
-        13:  [0xFF0D], // enter
-        16:  [0xFFE1, 0xFFE1, 0xFFE2], // shift
-        17:  [0xFFE3, 0xFFE3, 0xFFE4], // ctrl
-        18:  [0xFFE9, 0xFFE9, 0xFE03], // alt
-        19:  [0xFF13], // pause/break
-        20:  [0xFFE5], // caps lock
-        27:  [0xFF1B], // escape
-        32:  [0x0020], // space
-        33:  [0xFF55, 0xFF55, 0xFF55, 0xFFB9], // page up     / KP 9
-        34:  [0xFF56, 0xFF56, 0xFF56, 0xFFB3], // page down   / KP 3
-        35:  [0xFF57, 0xFF57, 0xFF57, 0xFFB1], // end         / KP 1
-        36:  [0xFF50, 0xFF50, 0xFF50, 0xFFB7], // home        / KP 7
-        37:  [0xFF51, 0xFF51, 0xFF51, 0xFFB4], // left arrow  / KP 4
-        38:  [0xFF52, 0xFF52, 0xFF52, 0xFFB8], // up arrow    / KP 8
-        39:  [0xFF53, 0xFF53, 0xFF53, 0xFFB6], // right arrow / KP 6
-        40:  [0xFF54, 0xFF54, 0xFF54, 0xFFB2], // down arrow  / KP 2
-        45:  [0xFF63, 0xFF63, 0xFF63, 0xFFB0], // insert      / KP 0
-        46:  [0xFFFF, 0xFFFF, 0xFFFF, 0xFFAE], // delete      / KP decimal
-        91:  [0xFFE7], // left windows/command key (meta_l)
-        92:  [0xFFE8], // right window/command key (meta_r)
-        93:  [0xFF67], // menu key
-        96:  [0xFFB0], // KP 0
-        97:  [0xFFB1], // KP 1
-        98:  [0xFFB2], // KP 2
-        99:  [0xFFB3], // KP 3
-        100: [0xFFB4], // KP 4
-        101: [0xFFB5], // KP 5
-        102: [0xFFB6], // KP 6
-        103: [0xFFB7], // KP 7
-        104: [0xFFB8], // KP 8
-        105: [0xFFB9], // KP 9
-        106: [0xFFAA], // KP multiply
-        107: [0xFFAB], // KP add
-        109: [0xFFAD], // KP subtract
-        110: [0xFFAE], // KP decimal
-        111: [0xFFAF], // KP divide
-        112: [0xFFBE], // f1
-        113: [0xFFBF], // f2
-        114: [0xFFC0], // f3
-        115: [0xFFC1], // f4
-        116: [0xFFC2], // f5
-        117: [0xFFC3], // f6
-        118: [0xFFC4], // f7
-        119: [0xFFC5], // f8
-        120: [0xFFC6], // f9
-        121: [0xFFC7], // f10
-        122: [0xFFC8], // f11
-        123: [0xFFC9], // f12
-        144: [0xFF7F], // num lock
-        145: [0xFF14], // scroll lock
-        225: [0xFE03]  // altgraph (iso_level3_shift)
-    };
-
-    /**
-     * Map of known JavaScript keyidentifiers which do not map to typable
-     * characters to their unshifted X11 keysym equivalents.
-     *
-     * @private
-     * @type {!Object.<string, number[]>}
-     */
-    var keyidentifier_keysym = {
-        "Again": [0xFF66],
-        "AllCandidates": [0xFF3D],
-        "Alphanumeric": [0xFF30],
-        "Alt": [0xFFE9, 0xFFE9, 0xFE03],
-        "Attn": [0xFD0E],
-        "AltGraph": [0xFE03],
-        "ArrowDown": [0xFF54],
-        "ArrowLeft": [0xFF51],
-        "ArrowRight": [0xFF53],
-        "ArrowUp": [0xFF52],
-        "Backspace": [0xFF08],
-        "CapsLock": [0xFFE5],
-        "Cancel": [0xFF69],
-        "Clear": [0xFF0B],
-        "Convert": [0xFF21],
-        "Copy": [0xFD15],
-        "Crsel": [0xFD1C],
-        "CrSel": [0xFD1C],
-        "CodeInput": [0xFF37],
-        "Compose": [0xFF20],
-        "Control": [0xFFE3, 0xFFE3, 0xFFE4],
-        "ContextMenu": [0xFF67],
-        "Delete": [0xFFFF],
-        "Down": [0xFF54],
-        "End": [0xFF57],
-        "Enter": [0xFF0D],
-        "EraseEof": [0xFD06],
-        "Escape": [0xFF1B],
-        "Execute": [0xFF62],
-        "Exsel": [0xFD1D],
-        "ExSel": [0xFD1D],
-        "F1": [0xFFBE],
-        "F2": [0xFFBF],
-        "F3": [0xFFC0],
-        "F4": [0xFFC1],
-        "F5": [0xFFC2],
-        "F6": [0xFFC3],
-        "F7": [0xFFC4],
-        "F8": [0xFFC5],
-        "F9": [0xFFC6],
-        "F10": [0xFFC7],
-        "F11": [0xFFC8],
-        "F12": [0xFFC9],
-        "F13": [0xFFCA],
-        "F14": [0xFFCB],
-        "F15": [0xFFCC],
-        "F16": [0xFFCD],
-        "F17": [0xFFCE],
-        "F18": [0xFFCF],
-        "F19": [0xFFD0],
-        "F20": [0xFFD1],
-        "F21": [0xFFD2],
-        "F22": [0xFFD3],
-        "F23": [0xFFD4],
-        "F24": [0xFFD5],
-        "Find": [0xFF68],
-        "GroupFirst": [0xFE0C],
-        "GroupLast": [0xFE0E],
-        "GroupNext": [0xFE08],
-        "GroupPrevious": [0xFE0A],
-        "FullWidth": null,
-        "HalfWidth": null,
-        "HangulMode": [0xFF31],
-        "Hankaku": [0xFF29],
-        "HanjaMode": [0xFF34],
-        "Help": [0xFF6A],
-        "Hiragana": [0xFF25],
-        "HiraganaKatakana": [0xFF27],
-        "Home": [0xFF50],
-        "Hyper": [0xFFED, 0xFFED, 0xFFEE],
-        "Insert": [0xFF63],
-        "JapaneseHiragana": [0xFF25],
-        "JapaneseKatakana": [0xFF26],
-        "JapaneseRomaji": [0xFF24],
-        "JunjaMode": [0xFF38],
-        "KanaMode": [0xFF2D],
-        "KanjiMode": [0xFF21],
-        "Katakana": [0xFF26],
-        "Left": [0xFF51],
-        "Meta": [0xFFE7, 0xFFE7, 0xFFE8],
-        "ModeChange": [0xFF7E],
-        "NumLock": [0xFF7F],
-        "PageDown": [0xFF56],
-        "PageUp": [0xFF55],
-        "Pause": [0xFF13],
-        "Play": [0xFD16],
-        "PreviousCandidate": [0xFF3E],
-        "PrintScreen": [0xFF61],
-        "Redo": [0xFF66],
-        "Right": [0xFF53],
-        "RomanCharacters": null,
-        "Scroll": [0xFF14],
-        "Select": [0xFF60],
-        "Separator": [0xFFAC],
-        "Shift": [0xFFE1, 0xFFE1, 0xFFE2],
-        "SingleCandidate": [0xFF3C],
-        "Super": [0xFFEB, 0xFFEB, 0xFFEC],
-        "Tab": [0xFF09],
-        "UIKeyInputDownArrow": [0xFF54],
-        "UIKeyInputEscape": [0xFF1B],
-        "UIKeyInputLeftArrow": [0xFF51],
-        "UIKeyInputRightArrow": [0xFF53],
-        "UIKeyInputUpArrow": [0xFF52],
-        "Up": [0xFF52],
-        "Undo": [0xFF65],
-        "Win": [0xFFE7, 0xFFE7, 0xFFE8],
-        "Zenkaku": [0xFF28],
-        "ZenkakuHankaku": [0xFF2A]
-    };
-
-    /**
-     * All keysyms which should not repeat when held down.
-     *
-     * @private
-     * @type {!Object.<number, boolean>}
-     */
-    var no_repeat = {
-        0xFE03: true, // ISO Level 3 Shift (AltGr)
-        0xFFE1: true, // Left shift
-        0xFFE2: true, // Right shift
-        0xFFE3: true, // Left ctrl 
-        0xFFE4: true, // Right ctrl 
-        0xFFE5: true, // Caps Lock
-        0xFFE7: true, // Left meta 
-        0xFFE8: true, // Right meta 
-        0xFFE9: true, // Left alt
-        0xFFEA: true, // Right alt
-        0xFFEB: true, // Left super/hyper
-        0xFFEC: true  // Right super/hyper
-    };
-
-    /**
-     * All modifiers and their states.
-     *
-     * @type {!Guacamole.Keyboard.ModifierState}
-     */
-    this.modifiers = new Guacamole.Keyboard.ModifierState();
-        
-    /**
-     * The state of every key, indexed by keysym. If a particular key is
-     * pressed, the value of pressed for that keysym will be true. If a key
-     * is not currently pressed, it will not be defined. 
-     *
-     * @type {!Object.<number, boolean>}
-     */
-    this.pressed = {};
-
-    /**
-     * The state of every key, indexed by keysym, for strictly those keys whose
-     * status has been indirectly determined thorugh observation of other key
-     * events. If a particular key is implicitly pressed, the value of
-     * implicitlyPressed for that keysym will be true. If a key
-     * is not currently implicitly pressed (the key is not pressed OR the state
-     * of the key is explicitly known), it will not be defined.
-     *
-     * @private
-     * @type {!Object.<number, boolean>}
-     */
-    var implicitlyPressed = {};
-
-    /**
-     * The last result of calling the onkeydown handler for each key, indexed
-     * by keysym. This is used to prevent/allow default actions for key events,
-     * even when the onkeydown handler cannot be called again because the key
-     * is (theoretically) still pressed.
-     *
-     * @private
-     * @type {!Object.<number, boolean>}
-     */
-    var last_keydown_result = {};
-
-    /**
-     * The keysym most recently associated with a given keycode when keydown
-     * fired. This object maps keycodes to keysyms.
-     *
-     * @private
-     * @type {!Object.<number, number>}
-     */
-    var recentKeysym = {};
-
-    /**
-     * Timeout before key repeat starts.
-     *
-     * @private
-     * @type {number}
-     */
-    var key_repeat_timeout = null;
-
-    /**
-     * Interval which presses and releases the last key pressed while that
-     * key is still being held down.
-     *
-     * @private
-     * @type {number}
-     */
-    var key_repeat_interval = null;
-
-    /**
-     * Given an array of keysyms indexed by location, returns the keysym
-     * for the given location, or the keysym for the standard location if
-     * undefined.
-     * 
-     * @private
-     * @param {number[]} keysyms
-     *     An array of keysyms, where the index of the keysym in the array is
-     *     the location value.
-     *
-     * @param {!number} location
-     *     The location on the keyboard corresponding to the key pressed, as
-     *     defined at: http://www.w3.org/TR/DOM-Level-3-Events/#events-KeyboardEvent
-     */
-    var get_keysym = function get_keysym(keysyms, location) {
-
-        if (!keysyms)
-            return null;
-
-        return keysyms[location] || keysyms[0];
-    };
-
-    /**
-     * Returns true if the given keysym corresponds to a printable character,
-     * false otherwise.
-     *
-     * @param {!number} keysym
-     *     The keysym to check.
-     *
-     * @returns {!boolean}
-     *     true if the given keysym corresponds to a printable character,
-     *     false otherwise.
-     */
-    var isPrintable = function isPrintable(keysym) {
-
-        // Keysyms with Unicode equivalents are printable
-        return (keysym >= 0x00 && keysym <= 0xFF)
-            || (keysym & 0xFFFF0000) === 0x01000000;
-
-    };
-
-    function keysym_from_key_identifier(identifier, location, shifted) {
-
-        if (!identifier)
-            return null;
-
-        var typedCharacter;
-
-        // If identifier is U+xxxx, decode Unicode character 
-        var unicodePrefixLocation = identifier.indexOf("U+");
-        if (unicodePrefixLocation >= 0) {
-            var hex = identifier.substring(unicodePrefixLocation+2);
-            typedCharacter = String.fromCharCode(parseInt(hex, 16));
-        }
-
-        // If single character and not keypad, use that as typed character
-        else if (identifier.length === 1 && location !== 3)
-            typedCharacter = identifier;
-
-        // Otherwise, look up corresponding keysym
-        else
-            return get_keysym(keyidentifier_keysym[identifier], location);
-
-        // Alter case if necessary
-        if (shifted === true)
-            typedCharacter = typedCharacter.toUpperCase();
-        else if (shifted === false)
-            typedCharacter = typedCharacter.toLowerCase();
-
-        // Get codepoint
-        var codepoint = typedCharacter.charCodeAt(0);
-        return keysym_from_charcode(codepoint);
-
-    }
-
-    function isControlCharacter(codepoint) {
-        return codepoint <= 0x1F || (codepoint >= 0x7F && codepoint <= 0x9F);
-    }
-
-    function keysym_from_charcode(codepoint) {
-
-        // Keysyms for control characters
-        if (isControlCharacter(codepoint)) return 0xFF00 | codepoint;
-
-        // Keysyms for ASCII chars
-        if (codepoint >= 0x0000 && codepoint <= 0x00FF)
-            return codepoint;
-
-        // Keysyms for Unicode
-        if (codepoint >= 0x0100 && codepoint <= 0x10FFFF)
-            return 0x01000000 | codepoint;
-
-        return null;
-
-    }
-
-    function keysym_from_keycode(keyCode, location) {
-        return get_keysym(keycodeKeysyms[keyCode], location);
-    }
-
-    /**
-     * Heuristically detects if the legacy keyIdentifier property of
-     * a keydown/keyup event looks incorrectly derived. Chrome, and
-     * presumably others, will produce the keyIdentifier by assuming
-     * the keyCode is the Unicode codepoint for that key. This is not
-     * correct in all cases.
-     *
-     * @private
-     * @param {!number} keyCode
-     *     The keyCode from a browser keydown/keyup event.
-     *
-     * @param {string} keyIdentifier
-     *     The legacy keyIdentifier from a browser keydown/keyup event.
-     *
-     * @returns {!boolean}
-     *     true if the keyIdentifier looks sane, false if the keyIdentifier
-     *     appears incorrectly derived or is missing entirely.
-     */
-    var key_identifier_sane = function key_identifier_sane(keyCode, keyIdentifier) {
-
-        // Missing identifier is not sane
-        if (!keyIdentifier)
-            return false;
-
-        // Assume non-Unicode keyIdentifier values are sane
-        var unicodePrefixLocation = keyIdentifier.indexOf("U+");
-        if (unicodePrefixLocation === -1)
-            return true;
-
-        // If the Unicode codepoint isn't identical to the keyCode,
-        // then the identifier is likely correct
-        var codepoint = parseInt(keyIdentifier.substring(unicodePrefixLocation+2), 16);
-        if (keyCode !== codepoint)
-            return true;
-
-        // The keyCodes for A-Z and 0-9 are actually identical to their
-        // Unicode codepoints
-        if ((keyCode >= 65 && keyCode <= 90) || (keyCode >= 48 && keyCode <= 57))
-            return true;
-
-        // The keyIdentifier does NOT appear sane
-        return false;
-
-    };
-
-    /**
-     * Marks a key as pressed, firing the keydown event if registered. Key
-     * repeat for the pressed key will start after a delay if that key is
-     * not a modifier. The return value of this function depends on the
-     * return value of the keydown event handler, if any.
-     * 
-     * @param {number} keysym
-     *     The keysym of the key to press.
-     *
-     * @return {boolean}
-     *     true if event should NOT be canceled, false otherwise.
-     */
-    this.press = function(keysym) {
-
-        // Don't bother with pressing the key if the key is unknown
-        if (keysym === null) return;
-
-        // Only press if released
-        if (!guac_keyboard.pressed[keysym]) {
-
-            // Mark key as pressed
-            guac_keyboard.pressed[keysym] = true;
-
-            // Send key event
-            if (guac_keyboard.onkeydown) {
-                var result = guac_keyboard.onkeydown(keysym);
-                last_keydown_result[keysym] = result;
-
-                // Stop any current repeat
-                window.clearTimeout(key_repeat_timeout);
-                window.clearInterval(key_repeat_interval);
-
-                // Repeat after a delay as long as pressed
-                if (!no_repeat[keysym])
-                    key_repeat_timeout = window.setTimeout(function() {
-                        key_repeat_interval = window.setInterval(function() {
-                            guac_keyboard.onkeyup(keysym);
-                            guac_keyboard.onkeydown(keysym);
-                        }, 50);
-                    }, 500);
-
-                return result;
-            }
-        }
-
-        // Return the last keydown result by default, resort to false if unknown
-        return last_keydown_result[keysym] || false;
-
-    };
-
-    /**
-     * Marks a key as released, firing the keyup event if registered.
-     * 
-     * @param {number} keysym
-     *     The keysym of the key to release.
-     */
-    this.release = function(keysym) {
-
-        // Only release if pressed
-        if (guac_keyboard.pressed[keysym]) {
-            
-            // Mark key as released
-            delete guac_keyboard.pressed[keysym];
-            delete implicitlyPressed[keysym];
-
-            // Stop repeat
-            window.clearTimeout(key_repeat_timeout);
-            window.clearInterval(key_repeat_interval);
-
-            // Send key event
-            if (keysym !== null && guac_keyboard.onkeyup)
-                guac_keyboard.onkeyup(keysym);
-
-        }
-
-    };
-
-    /**
-     * Presses and releases the keys necessary to type the given string of
-     * text.
-     *
-     * @param {!string} str
-     *     The string to type.
-     */
-    this.type = function type(str) {
-
-        // Press/release the key corresponding to each character in the string
-        for (var i = 0; i < str.length; i++) {
-
-            // Determine keysym of current character
-            var codepoint = str.codePointAt ? str.codePointAt(i) : str.charCodeAt(i);
-            var keysym = keysym_from_charcode(codepoint);
-
-            // Press and release key for current character
-            guac_keyboard.press(keysym);
-            guac_keyboard.release(keysym);
-
-        }
-
-    };
-
-    /**
-     * Resets the state of this keyboard, releasing all keys, and firing keyup
-     * events for each released key.
-     */
-    this.reset = function() {
-
-        // Release all pressed keys
-        for (var keysym in guac_keyboard.pressed)
-            guac_keyboard.release(parseInt(keysym));
-
-        // Clear event log
-        eventLog = [];
-
-    };
-
-    /**
-     * Resynchronizes the remote state of the given modifier with its
-     * corresponding local modifier state, as dictated by
-     * {@link KeyEvent#modifiers} within the given key event, by pressing or
-     * releasing keysyms.
-     *
-     * @private
-     * @param {!string} modifier
-     *     The name of the {@link Guacamole.Keyboard.ModifierState} property
-     *     being updated.
-     *
-     * @param {!number[]} keysyms
-     *     The keysyms which represent the modifier being updated.
-     *
-     * @param {!KeyEvent} keyEvent
-     *     Guacamole's current best interpretation of the key event being
-     *     processed.
-     */
-    var updateModifierState = function updateModifierState(modifier,
-        keysyms, keyEvent) {
-
-        var localState = keyEvent.modifiers[modifier];
-        var remoteState = guac_keyboard.modifiers[modifier];
-
-        var i;
-
-        // Do not trust changes in modifier state for events directly involving
-        // that modifier: (1) the flag may erroneously be cleared despite
-        // another version of the same key still being held and (2) the change
-        // in flag may be due to the current event being processed, thus
-        // updating things here is at best redundant and at worst incorrect
-        if (keysyms.indexOf(keyEvent.keysym) !== -1)
-            return;
-
-        // Release all related keys if modifier is implicitly released
-        if (remoteState && localState === false) {
-            for (i = 0; i < keysyms.length; i++) {
-                guac_keyboard.release(keysyms[i]);
-            }
-        }
-
-        // Press if modifier is implicitly pressed
-        else if (!remoteState && localState) {
-
-            // Verify that modifier flag isn't already pressed or already set
-            // due to another version of the same key being held down
-            for (i = 0; i < keysyms.length; i++) {
-                if (guac_keyboard.pressed[keysyms[i]])
-                    return;
-            }
-
-            // Mark as implicitly pressed only if there is other information
-            // within the key event relating to a different key. Some
-            // platforms, such as iOS, will send essentially empty key events
-            // for modifier keys, using only the modifier flags to signal the
-            // identity of the key.
-            var keysym = keysyms[0];
-            if (keyEvent.keysym)
-                implicitlyPressed[keysym] = true;
-
-            guac_keyboard.press(keysym);
-
-        }
-
-    };
-
-    /**
-     * Given a keyboard event, updates the remote key state to match the local
-     * modifier state and remote based on the modifier flags within the event.
-     * This function pays no attention to keycodes.
-     *
-     * @private
-     * @param {!KeyEvent} keyEvent
-     *     Guacamole's current best interpretation of the key event being
-     *     processed.
-     */
-    var syncModifierStates = function syncModifierStates(keyEvent) {
-
-        // Resync state of alt
-        updateModifierState('alt', [
-            0xFFE9, // Left alt
-            0xFFEA, // Right alt
-            0xFE03  // AltGr
-        ], keyEvent);
-
-        // Resync state of shift
-        updateModifierState('shift', [
-            0xFFE1, // Left shift
-            0xFFE2  // Right shift
-        ], keyEvent);
-
-        // Resync state of ctrl
-        updateModifierState('ctrl', [
-            0xFFE3, // Left ctrl
-            0xFFE4  // Right ctrl
-        ], keyEvent);
-
-        // Resync state of meta
-        updateModifierState('meta', [
-            0xFFE7, // Left meta
-            0xFFE8  // Right meta
-        ], keyEvent);
-
-        // Resync state of hyper
-        updateModifierState('hyper', [
-            0xFFEB, // Left super/hyper
-            0xFFEC  // Right super/hyper
-        ], keyEvent);
-
-        // Update state
-        guac_keyboard.modifiers = keyEvent.modifiers;
-
-    };
-
-    /**
-     * Returns whether all currently pressed keys were implicitly pressed. A
-     * key is implicitly pressed if its status was inferred indirectly from
-     * inspection of other key events.
-     *
-     * @private
-     * @returns {!boolean}
-     *     true if all currently pressed keys were implicitly pressed, false
-     *     otherwise.
-     */
-    var isStateImplicit = function isStateImplicit() {
-
-        for (var keysym in guac_keyboard.pressed) {
-            if (!implicitlyPressed[keysym])
-                return false;
-        }
-
-        return true;
-
-    };
-
-    /**
-     * Reads through the event log, removing events from the head of the log
-     * when the corresponding true key presses are known (or as known as they
-     * can be).
-     * 
-     * @private
-     * @return {boolean}
-     *     Whether the default action of the latest event should be prevented.
-     */
-    function interpret_events() {
-
-        // Do not prevent default if no event could be interpreted
-        var handled_event = interpret_event();
-        if (!handled_event)
-            return false;
-
-        // Interpret as much as possible
-        var last_event;
-        do {
-            last_event = handled_event;
-            handled_event = interpret_event();
-        } while (handled_event !== null);
-
-        // Reset keyboard state if we cannot expect to receive any further
-        // keyup events
-        if (isStateImplicit())
-            guac_keyboard.reset();
-
-        return last_event.defaultPrevented;
-
-    }
-
-    /**
-     * Releases Ctrl+Alt, if both are currently pressed and the given keysym
-     * looks like a key that may require AltGr.
-     *
-     * @private
-     * @param {!number} keysym
-     *     The key that was just pressed.
-     */
-    var release_simulated_altgr = function release_simulated_altgr(keysym) {
-
-        // Both Ctrl+Alt must be pressed if simulated AltGr is in use
-        if (!guac_keyboard.modifiers.ctrl || !guac_keyboard.modifiers.alt)
-            return;
-
-        // Assume [A-Z] never require AltGr
-        if (keysym >= 0x0041 && keysym <= 0x005A)
-            return;
-
-        // Assume [a-z] never require AltGr
-        if (keysym >= 0x0061 && keysym <= 0x007A)
-            return;
-
-        // Release Ctrl+Alt if the keysym is printable
-        if (keysym <= 0xFF || (keysym & 0xFF000000) === 0x01000000) {
-            guac_keyboard.release(0xFFE3); // Left ctrl 
-            guac_keyboard.release(0xFFE4); // Right ctrl 
-            guac_keyboard.release(0xFFE9); // Left alt
-            guac_keyboard.release(0xFFEA); // Right alt
-        }
-
-    };
-
-    /**
-     * Reads through the event log, interpreting the first event, if possible,
-     * and returning that event. If no events can be interpreted, due to a
-     * total lack of events or the need for more events, null is returned. Any
-     * interpreted events are automatically removed from the log.
-     * 
-     * @private
-     * @return {KeyEvent}
-     *     The first key event in the log, if it can be interpreted, or null
-     *     otherwise.
-     */
-    var interpret_event = function interpret_event() {
-
-        // Peek at first event in log
-        var first = eventLog[0];
-        if (!first)
-            return null;
-
-        // Keydown event
-        if (first instanceof KeydownEvent) {
-
-            var keysym = null;
-            var accepted_events = [];
-
-            // Defer handling of Meta until it is known to be functioning as a
-            // modifier (it may otherwise actually be an alternative method for
-            // pressing a single key, such as Meta+Left for Home on ChromeOS)
-            if (first.keysym === 0xFFE7 || first.keysym === 0xFFE8) {
-
-                // Defer handling until further events exist to provide context
-                if (eventLog.length === 1)
-                    return null;
-
-                // Drop keydown if it turns out Meta does not actually apply
-                if (eventLog[1].keysym !== first.keysym) {
-                    if (!eventLog[1].modifiers.meta)
-                        return eventLog.shift();
-                }
-
-                // Drop duplicate keydown events while waiting to determine
-                // whether to acknowledge Meta (browser may repeat keydown
-                // while the key is held)
-                else if (eventLog[1] instanceof KeydownEvent)
-                    return eventLog.shift();
-
-            }
-
-            // If event itself is reliable, no need to wait for other events
-            if (first.reliable) {
-                keysym = first.keysym;
-                accepted_events = eventLog.splice(0, 1);
-            }
-
-            // If keydown is immediately followed by a keypress, use the indicated character
-            else if (eventLog[1] instanceof KeypressEvent) {
-                keysym = eventLog[1].keysym;
-                accepted_events = eventLog.splice(0, 2);
-            }
-
-            // If keydown is immediately followed by anything else, then no
-            // keypress can possibly occur to clarify this event, and we must
-            // handle it now
-            else if (eventLog[1]) {
-                keysym = first.keysym;
-                accepted_events = eventLog.splice(0, 1);
-            }
-
-            // Fire a key press if valid events were found
-            if (accepted_events.length > 0) {
-
-                syncModifierStates(first);
-
-                if (keysym) {
-
-                    // Fire event
-                    release_simulated_altgr(keysym);
-                    var defaultPrevented = !guac_keyboard.press(keysym);
-                    recentKeysym[first.keyCode] = keysym;
-
-                    // Release the key now if we cannot rely on the associated
-                    // keyup event
-                    if (!first.keyupReliable)
-                        guac_keyboard.release(keysym);
-
-                    // Record whether default was prevented
-                    for (var i=0; i<accepted_events.length; i++)
-                        accepted_events[i].defaultPrevented = defaultPrevented;
-
-                }
-
-                return first;
-
-            }
-
-        } // end if keydown
-
-        // Keyup event
-        else if (first instanceof KeyupEvent && !quirks.keyupUnreliable) {
-
-            // Release specific key if known
-            var keysym = first.keysym;
-            if (keysym) {
-                guac_keyboard.release(keysym);
-                delete recentKeysym[first.keyCode];
-                first.defaultPrevented = true;
-            }
-
-            // Otherwise, fall back to releasing all keys
-            else {
-                guac_keyboard.reset();
-                return first;
-            }
-
-            syncModifierStates(first);
-            return eventLog.shift();
-
-        } // end if keyup
-
-        // Ignore any other type of event (keypress by itself is invalid, and
-        // unreliable keyup events should simply be dumped)
-        else
-            return eventLog.shift();
-
-        // No event interpreted
-        return null;
-
-    };
-
-    /**
-     * Returns the keyboard location of the key associated with the given
-     * keyboard event. The location differentiates key events which otherwise
-     * have the same keycode, such as left shift vs. right shift.
-     *
-     * @private
-     * @param {!KeyboardEvent} e
-     *     A JavaScript keyboard event, as received through the DOM via a
-     *     "keydown", "keyup", or "keypress" handler.
-     *
-     * @returns {!number}
-     *     The location of the key event on the keyboard, as defined at:
-     *     http://www.w3.org/TR/DOM-Level-3-Events/#events-KeyboardEvent
-     */
-    var getEventLocation = function getEventLocation(e) {
-
-        // Use standard location, if possible
-        if ('location' in e)
-            return e.location;
-
-        // Failing that, attempt to use deprecated keyLocation
-        if ('keyLocation' in e)
-            return e.keyLocation;
-
-        // If no location is available, assume left side
-        return 0;
-
-    };
-
-    /**
-     * Attempts to mark the given Event as having been handled by this
-     * Guacamole.Keyboard. If the Event has already been marked as handled,
-     * false is returned.
-     *
-     * @param {!Event} e
-     *     The Event to mark.
-     *
-     * @returns {!boolean}
-     *     true if the given Event was successfully marked, false if the given
-     *     Event was already marked.
-     */
-    var markEvent = function markEvent(e) {
-
-        // Fail if event is already marked
-        if (e[EVENT_MARKER])
-            return false;
-
-        // Mark event otherwise
-        e[EVENT_MARKER] = true;
-        return true;
-
-    };
-
-    /**
-     * Attaches event listeners to the given Element, automatically translating
-     * received key, input, and composition events into simple keydown/keyup
-     * events signalled through this Guacamole.Keyboard's onkeydown and
-     * onkeyup handlers.
-     *
-     * @param {!(Element|Document)} element
-     *     The Element to attach event listeners to for the sake of handling
-     *     key or input events.
-     */
-    this.listenTo = function listenTo(element) {
-
-        // When key pressed
-        element.addEventListener("keydown", function(e) {
-
-            // Only intercept if handler set
-            if (!guac_keyboard.onkeydown) return;
-
-            // Ignore events which have already been handled
-            if (!markEvent(e)) return;
-
-            var keydownEvent = new KeydownEvent(e);
-
-            // Ignore (but do not prevent) the "composition" keycode sent by some
-            // browsers when an IME is in use (see: http://lists.w3.org/Archives/Public/www-dom/2010JulSep/att-0182/keyCode-spec.html)
-            if (keydownEvent.keyCode === 229)
-                return;
-
-            // Log event
-            eventLog.push(keydownEvent);
-
-            // Interpret as many events as possible, prevent default if indicated
-            if (interpret_events())
-                e.preventDefault();
-
-        }, true);
-
-        // When key pressed
-        element.addEventListener("keypress", function(e) {
-
-            // Only intercept if handler set
-            if (!guac_keyboard.onkeydown && !guac_keyboard.onkeyup) return;
-
-            // Ignore events which have already been handled
-            if (!markEvent(e)) return;
-
-            // Log event
-            eventLog.push(new KeypressEvent(e));
-
-            // Interpret as many events as possible, prevent default if indicated
-            if (interpret_events())
-                e.preventDefault();
-
-        }, true);
-
-        // When key released
-        element.addEventListener("keyup", function(e) {
-
-            // Only intercept if handler set
-            if (!guac_keyboard.onkeyup) return;
-
-            // Ignore events which have already been handled
-            if (!markEvent(e)) return;
-
-            e.preventDefault();
-
-            // Log event, call for interpretation
-            eventLog.push(new KeyupEvent(e));
-            interpret_events();
-
-        }, true);
-
-        /**
-         * Handles the given "input" event, typing the data within the input text.
-         * If the event is complete (text is provided), handling of "compositionend"
-         * events is suspended, as such events may conflict with input events.
-         *
-         * @private
-         * @param {!InputEvent} e
-         *     The "input" event to handle.
-         */
-        var handleInput = function handleInput(e) {
-
-            // Only intercept if handler set
-            if (!guac_keyboard.onkeydown && !guac_keyboard.onkeyup) return;
-
-            // Ignore events which have already been handled
-            if (!markEvent(e)) return;
-
-            // Type all content written
-            if (e.data && !e.isComposing) {
-                element.removeEventListener("compositionend", handleComposition, false);
-                guac_keyboard.type(e.data);
-            }
-
-        };
-
-        /**
-         * Handles the given "compositionend" event, typing the data within the
-         * composed text. If the event is complete (composed text is provided),
-         * handling of "input" events is suspended, as such events may conflict
-         * with composition events.
-         *
-         * @private
-         * @param {!CompositionEvent} e
-         *     The "compositionend" event to handle.
-         */
-        var handleComposition = function handleComposition(e) {
-
-            // Only intercept if handler set
-            if (!guac_keyboard.onkeydown && !guac_keyboard.onkeyup) return;
-
-            // Ignore events which have already been handled
-            if (!markEvent(e)) return;
-
-            // Type all content written
-            if (e.data) {
-                element.removeEventListener("input", handleInput, false);
-                guac_keyboard.type(e.data);
-            }
-
-        };
-
-        // Automatically type text entered into the wrapped field
-        //20220428: NEKO: Removed because of clipboard handling.
-        //element.addEventListener("input", handleInput, false);
-        //element.addEventListener("compositionend", handleComposition, false);
-    };
-
-    // Listen to given element, if any
-    if (element)
-        guac_keyboard.listenTo(element);
-
-};
-
-/**
- * The unique numerical identifier to assign to the next Guacamole.Keyboard
- * instance.
- *
- * @private
- * @type {!number}
- */
-Guacamole.Keyboard._nextID = 0;
-
-/**
- * The state of all supported keyboard modifiers.
- * @constructor
- */
-Guacamole.Keyboard.ModifierState = function() {
-    
-    /**
-     * Whether shift is currently pressed.
-     *
-     * @type {!boolean}
-     */
-    this.shift = false;
-    
-    /**
-     * Whether ctrl is currently pressed.
-     *
-     * @type {!boolean}
-     */
-    this.ctrl = false;
-    
-    /**
-     * Whether alt is currently pressed.
-     *
-     * @type {!boolean}
-     */
-    this.alt = false;
-    
-    /**
-     * Whether meta (apple key) is currently pressed.
-     *
-     * @type {!boolean}
-     */
-    this.meta = false;
-
-    /**
-     * Whether hyper (windows key) is currently pressed.
-     *
-     * @type {!boolean}
-     */
-    this.hyper = false;
-
-};
-
-/**
- * Returns the modifier state applicable to the keyboard event given.
- * 
- * @param {!KeyboardEvent} e
- *     The keyboard event to read.
- *
- * @returns {!Guacamole.Keyboard.ModifierState}
- *     The current state of keyboard modifiers.
- */
-Guacamole.Keyboard.ModifierState.fromKeyboardEvent = function(e) {
-    
-    var state = new Guacamole.Keyboard.ModifierState();
-
-    // Assign states from old flags
-    state.shift = e.shiftKey;
-    state.ctrl  = e.ctrlKey;
-    state.alt   = e.altKey;
-    state.meta  = e.metaKey;
-
-    // Use DOM3 getModifierState() for others
-    if (e.getModifierState) {
-        state.hyper = e.getModifierState("OS")
-                   || e.getModifierState("Super")
-                   || e.getModifierState("Hyper")
-                   || e.getModifierState("Win");
-    }
-
-    return state;
-    
-};
-
-export default Guacamole.Keyboard;
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+var Guacamole = Guacamole || {};
+
+/**
+ * Provides cross-browser and cross-keyboard keyboard for a specific element.
+ * Browser and keyboard layout variation is abstracted away, providing events
+ * which represent keys as their corresponding X11 keysym.
+ * 
+ * @constructor
+ * @param {Element|Document} [element]
+ *    The Element to use to provide keyboard events. If omitted, at least one
+ *    Element must be manually provided through the listenTo() function for
+ *    the Guacamole.Keyboard instance to have any effect.
+ */
+Guacamole.Keyboard = function Keyboard(element) {
+
+    /**
+     * Reference to this Guacamole.Keyboard.
+     *
+     * @private
+     * @type {!Guacamole.Keyboard}
+     */
+    var guac_keyboard = this;
+
+    /**
+     * An integer value which uniquely identifies this Guacamole.Keyboard
+     * instance with respect to other Guacamole.Keyboard instances.
+     *
+     * @private
+     * @type {!number}
+     */
+    var guacKeyboardID = Guacamole.Keyboard._nextID++;
+
+    /**
+     * The name of the property which is added to event objects via markEvent()
+     * to note that they have already been handled by this Guacamole.Keyboard.
+     *
+     * @private
+     * @constant
+     * @type {!string}
+     */
+    var EVENT_MARKER = '_GUAC_KEYBOARD_HANDLED_BY_' + guacKeyboardID;
+
+    /**
+     * Fired whenever the user presses a key with the element associated
+     * with this Guacamole.Keyboard in focus.
+     * 
+     * @event
+     * @param {!number} keysym
+     *     The keysym of the key being pressed.
+     *
+     * @return {!boolean}
+     *     true if the key event should be allowed through to the browser,
+     *     false otherwise.
+     */
+    this.onkeydown = null;
+
+    /**
+     * Fired whenever the user releases a key with the element associated
+     * with this Guacamole.Keyboard in focus.
+     * 
+     * @event
+     * @param {!number} keysym
+     *     The keysym of the key being released.
+     */
+    this.onkeyup = null;
+
+    /**
+     * Set of known platform-specific or browser-specific quirks which must be
+     * accounted for to properly interpret key events, even if the only way to
+     * reliably detect that quirk is to platform/browser-sniff.
+     *
+     * @private
+     * @type {!Object.<string, boolean>}
+     */
+    var quirks = {
+
+        /**
+         * Whether keyup events are universally unreliable.
+         *
+         * @type {!boolean}
+         */
+        keyupUnreliable: false,
+
+        /**
+         * Whether the Alt key is actually a modifier for typable keys and is
+         * thus never used for keyboard shortcuts.
+         *
+         * @type {!boolean}
+         */
+        altIsTypableOnly: false,
+
+        /**
+         * Whether we can rely on receiving a keyup event for the Caps Lock
+         * key.
+         *
+         * @type {!boolean}
+         */
+        capsLockKeyupUnreliable: false
+
+    };
+
+    // Set quirk flags depending on platform/browser, if such information is
+    // available
+    if (navigator && navigator.platform) {
+
+        // All keyup events are unreliable on iOS (sadly)
+        if (navigator.platform.match(/ipad|iphone|ipod/i))
+            quirks.keyupUnreliable = true;
+
+        // The Alt key on Mac is never used for keyboard shortcuts, and the
+        // Caps Lock key never dispatches keyup events
+        else if (navigator.platform.match(/^mac/i)) {
+            quirks.altIsTypableOnly = true;
+            quirks.capsLockKeyupUnreliable = true;
+        }
+
+    }
+
+    /**
+     * A key event having a corresponding timestamp. This event is non-specific.
+     * Its subclasses should be used instead when recording specific key
+     * events.
+     *
+     * @private
+     * @constructor
+     * @param {KeyboardEvent} [orig]
+     *     The relevant DOM keyboard event.
+     */
+    var KeyEvent = function KeyEvent(orig) {
+
+        /**
+         * Reference to this key event.
+         *
+         * @private
+         * @type {!KeyEvent}
+         */
+        var key_event = this;
+
+        /**
+         * The JavaScript key code of the key pressed. For most events (keydown
+         * and keyup), this is a scancode-like value related to the position of
+         * the key on the US English "Qwerty" keyboard. For keypress events, 
+         * this is the Unicode codepoint of the character that would be typed
+         * by the key pressed.
+         *
+         * @type {!number}
+         */
+        this.keyCode = orig ? (orig.which || orig.keyCode) : 0;
+
+        /**
+         * The legacy DOM3 "keyIdentifier" of the key pressed, as defined at:
+         * http://www.w3.org/TR/2009/WD-DOM-Level-3-Events-20090908/#events-Events-KeyboardEvent
+         *
+         * @type {!string}
+         */
+        this.keyIdentifier = orig && orig.keyIdentifier;
+
+        /**
+         * The standard name of the key pressed, as defined at:
+         * http://www.w3.org/TR/DOM-Level-3-Events/#events-KeyboardEvent
+         * 
+         * @type {!string}
+         */
+        this.key = orig && orig.key;
+
+        /**
+         * The location on the keyboard corresponding to the key pressed, as
+         * defined at:
+         * http://www.w3.org/TR/DOM-Level-3-Events/#events-KeyboardEvent
+         * 
+         * @type {!number}
+         */
+        this.location = orig ? getEventLocation(orig) : 0;
+
+        /**
+         * The state of all local keyboard modifiers at the time this event was
+         * received.
+         *
+         * @type {!Guacamole.Keyboard.ModifierState}
+         */
+        this.modifiers = orig ? Guacamole.Keyboard.ModifierState.fromKeyboardEvent(orig) : new Guacamole.Keyboard.ModifierState();
+
+        /**
+         * An arbitrary timestamp in milliseconds, indicating this event's
+         * position in time relative to other events.
+         *
+         * @type {!number}
+         */
+        this.timestamp = new Date().getTime();
+
+        /**
+         * Whether the default action of this key event should be prevented.
+         *
+         * @type {!boolean}
+         */
+        this.defaultPrevented = false;
+
+        /**
+         * The keysym of the key associated with this key event, as determined
+         * by a best-effort guess using available event properties and keyboard
+         * state.
+         *
+         * @type {number}
+         */
+        this.keysym = null;
+
+        /**
+         * Whether the keysym value of this key event is known to be reliable.
+         * If false, the keysym may still be valid, but it's only a best guess,
+         * and future key events may be a better source of information.
+         *
+         * @type {!boolean}
+         */
+        this.reliable = false;
+
+        /**
+         * Returns the number of milliseconds elapsed since this event was
+         * received.
+         *
+         * @return {!number}
+         *     The number of milliseconds elapsed since this event was
+         *     received.
+         */
+        this.getAge = function() {
+            return new Date().getTime() - key_event.timestamp;
+        };
+
+    };
+
+    /**
+     * Information related to the pressing of a key, which need not be a key
+     * associated with a printable character. The presence or absence of any
+     * information within this object is browser-dependent.
+     *
+     * @private
+     * @constructor
+     * @augments Guacamole.Keyboard.KeyEvent
+     * @param {!KeyboardEvent} orig
+     *     The relevant DOM "keydown" event.
+     */
+    var KeydownEvent = function KeydownEvent(orig) {
+
+        // We extend KeyEvent
+        KeyEvent.call(this, orig);
+
+        // If key is known from keyCode or DOM3 alone, use that
+        this.keysym =  keysym_from_key_identifier(this.key, this.location)
+                    || keysym_from_keycode(this.keyCode, this.location);
+
+        /**
+         * Whether the keyup following this keydown event is known to be
+         * reliable. If false, we cannot rely on the keyup event to occur.
+         *
+         * @type {!boolean}
+         */
+        this.keyupReliable = !quirks.keyupUnreliable;
+
+        // DOM3 and keyCode are reliable sources if the corresponding key is
+        // not a printable key
+        if (this.keysym && !isPrintable(this.keysym))
+            this.reliable = true;
+
+        // Use legacy keyIdentifier as a last resort, if it looks sane
+        if (!this.keysym && key_identifier_sane(this.keyCode, this.keyIdentifier))
+            this.keysym = keysym_from_key_identifier(this.keyIdentifier, this.location, this.modifiers.shift);
+
+        // If a key is pressed while meta is held down, the keyup will
+        // never be sent in Chrome (bug #108404)
+        if (this.modifiers.meta && this.keysym !== 0xFFE7 && this.keysym !== 0xFFE8)
+            this.keyupReliable = false;
+
+        // We cannot rely on receiving keyup for Caps Lock on certain platforms
+        else if (this.keysym === 0xFFE5 && quirks.capsLockKeyupUnreliable)
+            this.keyupReliable = false;
+
+        // Determine whether default action for Alt+combinations must be prevented
+        var prevent_alt = !this.modifiers.ctrl && !quirks.altIsTypableOnly;
+
+        // Determine whether default action for Ctrl+combinations must be prevented
+        var prevent_ctrl = !this.modifiers.alt;
+
+        // We must rely on the (potentially buggy) keyIdentifier if preventing
+        // the default action is important
+        if ((prevent_ctrl && this.modifiers.ctrl)
+         || (prevent_alt  && this.modifiers.alt)
+         || this.modifiers.meta
+         || this.modifiers.hyper)
+            this.reliable = true;
+
+        // Record most recently known keysym by associated key code
+        recentKeysym[this.keyCode] = this.keysym;
+
+    };
+
+    KeydownEvent.prototype = new KeyEvent();
+
+    /**
+     * Information related to the pressing of a key, which MUST be
+     * associated with a printable character. The presence or absence of any
+     * information within this object is browser-dependent.
+     *
+     * @private
+     * @constructor
+     * @augments Guacamole.Keyboard.KeyEvent
+     * @param {!KeyboardEvent} orig
+     *     The relevant DOM "keypress" event.
+     */
+    var KeypressEvent = function KeypressEvent(orig) {
+
+        // We extend KeyEvent
+        KeyEvent.call(this, orig);
+
+        // Pull keysym from char code
+        this.keysym = keysym_from_charcode(this.keyCode);
+
+        // Keypress is always reliable
+        this.reliable = true;
+
+    };
+
+    KeypressEvent.prototype = new KeyEvent();
+
+    /**
+     * Information related to the releasing of a key, which need not be a key
+     * associated with a printable character. The presence or absence of any
+     * information within this object is browser-dependent.
+     *
+     * @private
+     * @constructor
+     * @augments Guacamole.Keyboard.KeyEvent
+     * @param {!KeyboardEvent} orig
+     *     The relevant DOM "keyup" event.
+     */
+    var KeyupEvent = function KeyupEvent(orig) {
+
+        // We extend KeyEvent
+        KeyEvent.call(this, orig);
+
+        // If key is known from keyCode or DOM3 alone, use that (keyCode is
+        // still more reliable for keyup when dead keys are in use)
+        this.keysym =  keysym_from_keycode(this.keyCode, this.location)
+                    || keysym_from_key_identifier(this.key, this.location);
+
+        // Fall back to the most recently pressed keysym associated with the
+        // keyCode if the inferred key doesn't seem to actually be pressed
+        if (!guac_keyboard.pressed[this.keysym])
+            this.keysym = recentKeysym[this.keyCode] || this.keysym;
+
+        // Keyup is as reliable as it will ever be
+        this.reliable = true;
+
+    };
+
+    KeyupEvent.prototype = new KeyEvent();
+
+    /**
+     * An array of recorded events, which can be instances of the private
+     * KeydownEvent, KeypressEvent, and KeyupEvent classes.
+     *
+     * @private
+     * @type {!KeyEvent[]}
+     */
+    var eventLog = [];
+
+    /**
+     * Map of known JavaScript keycodes which do not map to typable characters
+     * to their X11 keysym equivalents.
+     *
+     * @private
+     * @type {!Object.<number, number[]>}
+     */
+    var keycodeKeysyms = {
+        8:   [0xFF08], // backspace
+        9:   [0xFF09], // tab
+        12:  [0xFF0B, 0xFF0B, 0xFF0B, 0xFFB5], // clear       / KP 5
+        13:  [0xFF0D], // enter
+        16:  [0xFFE1, 0xFFE1, 0xFFE2], // shift
+        17:  [0xFFE3, 0xFFE3, 0xFFE4], // ctrl
+        18:  [0xFFE9, 0xFFE9, 0xFE03], // alt
+        19:  [0xFF13], // pause/break
+        20:  [0xFFE5], // caps lock
+        27:  [0xFF1B], // escape
+        32:  [0x0020], // space
+        33:  [0xFF55, 0xFF55, 0xFF55, 0xFFB9], // page up     / KP 9
+        34:  [0xFF56, 0xFF56, 0xFF56, 0xFFB3], // page down   / KP 3
+        35:  [0xFF57, 0xFF57, 0xFF57, 0xFFB1], // end         / KP 1
+        36:  [0xFF50, 0xFF50, 0xFF50, 0xFFB7], // home        / KP 7
+        37:  [0xFF51, 0xFF51, 0xFF51, 0xFFB4], // left arrow  / KP 4
+        38:  [0xFF52, 0xFF52, 0xFF52, 0xFFB8], // up arrow    / KP 8
+        39:  [0xFF53, 0xFF53, 0xFF53, 0xFFB6], // right arrow / KP 6
+        40:  [0xFF54, 0xFF54, 0xFF54, 0xFFB2], // down arrow  / KP 2
+        45:  [0xFF63, 0xFF63, 0xFF63, 0xFFB0], // insert      / KP 0
+        46:  [0xFFFF, 0xFFFF, 0xFFFF, 0xFFAE], // delete      / KP decimal
+        91:  [0xFFE7], // left windows/command key (meta_l)
+        92:  [0xFFE8], // right window/command key (meta_r)
+        93:  [0xFF67], // menu key
+        96:  [0xFFB0], // KP 0
+        97:  [0xFFB1], // KP 1
+        98:  [0xFFB2], // KP 2
+        99:  [0xFFB3], // KP 3
+        100: [0xFFB4], // KP 4
+        101: [0xFFB5], // KP 5
+        102: [0xFFB6], // KP 6
+        103: [0xFFB7], // KP 7
+        104: [0xFFB8], // KP 8
+        105: [0xFFB9], // KP 9
+        106: [0xFFAA], // KP multiply
+        107: [0xFFAB], // KP add
+        109: [0xFFAD], // KP subtract
+        110: [0xFFAE], // KP decimal
+        111: [0xFFAF], // KP divide
+        112: [0xFFBE], // f1
+        113: [0xFFBF], // f2
+        114: [0xFFC0], // f3
+        115: [0xFFC1], // f4
+        116: [0xFFC2], // f5
+        117: [0xFFC3], // f6
+        118: [0xFFC4], // f7
+        119: [0xFFC5], // f8
+        120: [0xFFC6], // f9
+        121: [0xFFC7], // f10
+        122: [0xFFC8], // f11
+        123: [0xFFC9], // f12
+        144: [0xFF7F], // num lock
+        145: [0xFF14], // scroll lock
+        225: [0xFE03]  // altgraph (iso_level3_shift)
+    };
+
+    /**
+     * Map of known JavaScript keyidentifiers which do not map to typable
+     * characters to their unshifted X11 keysym equivalents.
+     *
+     * @private
+     * @type {!Object.<string, number[]>}
+     */
+    var keyidentifier_keysym = {
+        "Again": [0xFF66],
+        "AllCandidates": [0xFF3D],
+        "Alphanumeric": [0xFF30],
+        "Alt": [0xFFE9, 0xFFE9, 0xFE03],
+        "Attn": [0xFD0E],
+        "AltGraph": [0xFE03],
+        "ArrowDown": [0xFF54],
+        "ArrowLeft": [0xFF51],
+        "ArrowRight": [0xFF53],
+        "ArrowUp": [0xFF52],
+        "Backspace": [0xFF08],
+        "CapsLock": [0xFFE5],
+        "Cancel": [0xFF69],
+        "Clear": [0xFF0B],
+        "Convert": [0xFF21],
+        "Copy": [0xFD15],
+        "Crsel": [0xFD1C],
+        "CrSel": [0xFD1C],
+        "CodeInput": [0xFF37],
+        "Compose": [0xFF20],
+        "Control": [0xFFE3, 0xFFE3, 0xFFE4],
+        "ContextMenu": [0xFF67],
+        "Delete": [0xFFFF],
+        "Down": [0xFF54],
+        "End": [0xFF57],
+        "Enter": [0xFF0D],
+        "EraseEof": [0xFD06],
+        "Escape": [0xFF1B],
+        "Execute": [0xFF62],
+        "Exsel": [0xFD1D],
+        "ExSel": [0xFD1D],
+        "F1": [0xFFBE],
+        "F2": [0xFFBF],
+        "F3": [0xFFC0],
+        "F4": [0xFFC1],
+        "F5": [0xFFC2],
+        "F6": [0xFFC3],
+        "F7": [0xFFC4],
+        "F8": [0xFFC5],
+        "F9": [0xFFC6],
+        "F10": [0xFFC7],
+        "F11": [0xFFC8],
+        "F12": [0xFFC9],
+        "F13": [0xFFCA],
+        "F14": [0xFFCB],
+        "F15": [0xFFCC],
+        "F16": [0xFFCD],
+        "F17": [0xFFCE],
+        "F18": [0xFFCF],
+        "F19": [0xFFD0],
+        "F20": [0xFFD1],
+        "F21": [0xFFD2],
+        "F22": [0xFFD3],
+        "F23": [0xFFD4],
+        "F24": [0xFFD5],
+        "Find": [0xFF68],
+        "GroupFirst": [0xFE0C],
+        "GroupLast": [0xFE0E],
+        "GroupNext": [0xFE08],
+        "GroupPrevious": [0xFE0A],
+        "FullWidth": null,
+        "HalfWidth": null,
+        "HangulMode": [0xFF31],
+        "Hankaku": [0xFF29],
+        "HanjaMode": [0xFF34],
+        "Help": [0xFF6A],
+        "Hiragana": [0xFF25],
+        "HiraganaKatakana": [0xFF27],
+        "Home": [0xFF50],
+        "Hyper": [0xFFED, 0xFFED, 0xFFEE],
+        "Insert": [0xFF63],
+        "JapaneseHiragana": [0xFF25],
+        "JapaneseKatakana": [0xFF26],
+        "JapaneseRomaji": [0xFF24],
+        "JunjaMode": [0xFF38],
+        "KanaMode": [0xFF2D],
+        "KanjiMode": [0xFF21],
+        "Katakana": [0xFF26],
+        "Left": [0xFF51],
+        "Meta": [0xFFE7, 0xFFE7, 0xFFE8],
+        "ModeChange": [0xFF7E],
+        "NumLock": [0xFF7F],
+        "PageDown": [0xFF56],
+        "PageUp": [0xFF55],
+        "Pause": [0xFF13],
+        "Play": [0xFD16],
+        "PreviousCandidate": [0xFF3E],
+        "PrintScreen": [0xFF61],
+        "Redo": [0xFF66],
+        "Right": [0xFF53],
+        "RomanCharacters": null,
+        "Scroll": [0xFF14],
+        "Select": [0xFF60],
+        "Separator": [0xFFAC],
+        "Shift": [0xFFE1, 0xFFE1, 0xFFE2],
+        "SingleCandidate": [0xFF3C],
+        "Super": [0xFFEB, 0xFFEB, 0xFFEC],
+        "Tab": [0xFF09],
+        "UIKeyInputDownArrow": [0xFF54],
+        "UIKeyInputEscape": [0xFF1B],
+        "UIKeyInputLeftArrow": [0xFF51],
+        "UIKeyInputRightArrow": [0xFF53],
+        "UIKeyInputUpArrow": [0xFF52],
+        "Up": [0xFF52],
+        "Undo": [0xFF65],
+        "Win": [0xFFE7, 0xFFE7, 0xFFE8],
+        "Zenkaku": [0xFF28],
+        "ZenkakuHankaku": [0xFF2A]
+    };
+
+    /**
+     * All keysyms which should not repeat when held down.
+     *
+     * @private
+     * @type {!Object.<number, boolean>}
+     */
+    var no_repeat = {
+        0xFE03: true, // ISO Level 3 Shift (AltGr)
+        0xFFE1: true, // Left shift
+        0xFFE2: true, // Right shift
+        0xFFE3: true, // Left ctrl 
+        0xFFE4: true, // Right ctrl 
+        0xFFE5: true, // Caps Lock
+        0xFFE7: true, // Left meta 
+        0xFFE8: true, // Right meta 
+        0xFFE9: true, // Left alt
+        0xFFEA: true, // Right alt
+        0xFFEB: true, // Left super/hyper
+        0xFFEC: true  // Right super/hyper
+    };
+
+    /**
+     * All modifiers and their states.
+     *
+     * @type {!Guacamole.Keyboard.ModifierState}
+     */
+    this.modifiers = new Guacamole.Keyboard.ModifierState();
+        
+    /**
+     * The state of every key, indexed by keysym. If a particular key is
+     * pressed, the value of pressed for that keysym will be true. If a key
+     * is not currently pressed, it will not be defined. 
+     *
+     * @type {!Object.<number, boolean>}
+     */
+    this.pressed = {};
+
+    /**
+     * The state of every key, indexed by keysym, for strictly those keys whose
+     * status has been indirectly determined thorugh observation of other key
+     * events. If a particular key is implicitly pressed, the value of
+     * implicitlyPressed for that keysym will be true. If a key
+     * is not currently implicitly pressed (the key is not pressed OR the state
+     * of the key is explicitly known), it will not be defined.
+     *
+     * @private
+     * @type {!Object.<number, boolean>}
+     */
+    var implicitlyPressed = {};
+
+    /**
+     * The last result of calling the onkeydown handler for each key, indexed
+     * by keysym. This is used to prevent/allow default actions for key events,
+     * even when the onkeydown handler cannot be called again because the key
+     * is (theoretically) still pressed.
+     *
+     * @private
+     * @type {!Object.<number, boolean>}
+     */
+    var last_keydown_result = {};
+
+    /**
+     * The keysym most recently associated with a given keycode when keydown
+     * fired. This object maps keycodes to keysyms.
+     *
+     * @private
+     * @type {!Object.<number, number>}
+     */
+    var recentKeysym = {};
+
+    /**
+     * Timeout before key repeat starts.
+     *
+     * @private
+     * @type {number}
+     */
+    var key_repeat_timeout = null;
+
+    /**
+     * Interval which presses and releases the last key pressed while that
+     * key is still being held down.
+     *
+     * @private
+     * @type {number}
+     */
+    var key_repeat_interval = null;
+
+    /**
+     * Given an array of keysyms indexed by location, returns the keysym
+     * for the given location, or the keysym for the standard location if
+     * undefined.
+     * 
+     * @private
+     * @param {number[]} keysyms
+     *     An array of keysyms, where the index of the keysym in the array is
+     *     the location value.
+     *
+     * @param {!number} location
+     *     The location on the keyboard corresponding to the key pressed, as
+     *     defined at: http://www.w3.org/TR/DOM-Level-3-Events/#events-KeyboardEvent
+     */
+    var get_keysym = function get_keysym(keysyms, location) {
+
+        if (!keysyms)
+            return null;
+
+        return keysyms[location] || keysyms[0];
+    };
+
+    /**
+     * Returns true if the given keysym corresponds to a printable character,
+     * false otherwise.
+     *
+     * @param {!number} keysym
+     *     The keysym to check.
+     *
+     * @returns {!boolean}
+     *     true if the given keysym corresponds to a printable character,
+     *     false otherwise.
+     */
+    var isPrintable = function isPrintable(keysym) {
+
+        // Keysyms with Unicode equivalents are printable
+        return (keysym >= 0x00 && keysym <= 0xFF)
+            || (keysym & 0xFFFF0000) === 0x01000000;
+
+    };
+
+    function keysym_from_key_identifier(identifier, location, shifted) {
+
+        if (!identifier)
+            return null;
+
+        var typedCharacter;
+
+        // If identifier is U+xxxx, decode Unicode character 
+        var unicodePrefixLocation = identifier.indexOf("U+");
+        if (unicodePrefixLocation >= 0) {
+            var hex = identifier.substring(unicodePrefixLocation+2);
+            typedCharacter = String.fromCharCode(parseInt(hex, 16));
+        }
+
+        // If single character and not keypad, use that as typed character
+        else if (identifier.length === 1 && location !== 3)
+            typedCharacter = identifier;
+
+        // Otherwise, look up corresponding keysym
+        else
+            return get_keysym(keyidentifier_keysym[identifier], location);
+
+        // Alter case if necessary
+        if (shifted === true)
+            typedCharacter = typedCharacter.toUpperCase();
+        else if (shifted === false)
+            typedCharacter = typedCharacter.toLowerCase();
+
+        // Get codepoint
+        var codepoint = typedCharacter.charCodeAt(0);
+        return keysym_from_charcode(codepoint);
+
+    }
+
+    function isControlCharacter(codepoint) {
+        return codepoint <= 0x1F || (codepoint >= 0x7F && codepoint <= 0x9F);
+    }
+
+    function keysym_from_charcode(codepoint) {
+
+        // Keysyms for control characters
+        if (isControlCharacter(codepoint)) return 0xFF00 | codepoint;
+
+        // Keysyms for ASCII chars
+        if (codepoint >= 0x0000 && codepoint <= 0x00FF)
+            return codepoint;
+
+        // Keysyms for Unicode
+        if (codepoint >= 0x0100 && codepoint <= 0x10FFFF)
+            return 0x01000000 | codepoint;
+
+        return null;
+
+    }
+
+    function keysym_from_keycode(keyCode, location) {
+        return get_keysym(keycodeKeysyms[keyCode], location);
+    }
+
+    /**
+     * Heuristically detects if the legacy keyIdentifier property of
+     * a keydown/keyup event looks incorrectly derived. Chrome, and
+     * presumably others, will produce the keyIdentifier by assuming
+     * the keyCode is the Unicode codepoint for that key. This is not
+     * correct in all cases.
+     *
+     * @private
+     * @param {!number} keyCode
+     *     The keyCode from a browser keydown/keyup event.
+     *
+     * @param {string} keyIdentifier
+     *     The legacy keyIdentifier from a browser keydown/keyup event.
+     *
+     * @returns {!boolean}
+     *     true if the keyIdentifier looks sane, false if the keyIdentifier
+     *     appears incorrectly derived or is missing entirely.
+     */
+    var key_identifier_sane = function key_identifier_sane(keyCode, keyIdentifier) {
+
+        // Missing identifier is not sane
+        if (!keyIdentifier)
+            return false;
+
+        // Assume non-Unicode keyIdentifier values are sane
+        var unicodePrefixLocation = keyIdentifier.indexOf("U+");
+        if (unicodePrefixLocation === -1)
+            return true;
+
+        // If the Unicode codepoint isn't identical to the keyCode,
+        // then the identifier is likely correct
+        var codepoint = parseInt(keyIdentifier.substring(unicodePrefixLocation+2), 16);
+        if (keyCode !== codepoint)
+            return true;
+
+        // The keyCodes for A-Z and 0-9 are actually identical to their
+        // Unicode codepoints
+        if ((keyCode >= 65 && keyCode <= 90) || (keyCode >= 48 && keyCode <= 57))
+            return true;
+
+        // The keyIdentifier does NOT appear sane
+        return false;
+
+    };
+
+    /**
+     * Marks a key as pressed, firing the keydown event if registered. Key
+     * repeat for the pressed key will start after a delay if that key is
+     * not a modifier. The return value of this function depends on the
+     * return value of the keydown event handler, if any.
+     * 
+     * @param {number} keysym
+     *     The keysym of the key to press.
+     *
+     * @return {boolean}
+     *     true if event should NOT be canceled, false otherwise.
+     */
+    this.press = function(keysym) {
+
+        // Don't bother with pressing the key if the key is unknown
+        if (keysym === null) return;
+
+        // Only press if released
+        if (!guac_keyboard.pressed[keysym]) {
+
+            // Mark key as pressed
+            guac_keyboard.pressed[keysym] = true;
+
+            // Send key event
+            if (guac_keyboard.onkeydown) {
+                var result = guac_keyboard.onkeydown(keysym);
+                last_keydown_result[keysym] = result;
+
+                // Stop any current repeat
+                window.clearTimeout(key_repeat_timeout);
+                window.clearInterval(key_repeat_interval);
+
+                // Repeat after a delay as long as pressed
+                if (!no_repeat[keysym])
+                    key_repeat_timeout = window.setTimeout(function() {
+                        key_repeat_interval = window.setInterval(function() {
+                            guac_keyboard.onkeyup(keysym);
+                            guac_keyboard.onkeydown(keysym);
+                        }, 50);
+                    }, 500);
+
+                return result;
+            }
+        }
+
+        // Return the last keydown result by default, resort to false if unknown
+        return last_keydown_result[keysym] || false;
+
+    };
+
+    /**
+     * Marks a key as released, firing the keyup event if registered.
+     * 
+     * @param {number} keysym
+     *     The keysym of the key to release.
+     */
+    this.release = function(keysym) {
+
+        // Only release if pressed
+        if (guac_keyboard.pressed[keysym]) {
+            
+            // Mark key as released
+            delete guac_keyboard.pressed[keysym];
+            delete implicitlyPressed[keysym];
+
+            // Stop repeat
+            window.clearTimeout(key_repeat_timeout);
+            window.clearInterval(key_repeat_interval);
+
+            // Send key event
+            if (keysym !== null && guac_keyboard.onkeyup)
+                guac_keyboard.onkeyup(keysym);
+
+        }
+
+    };
+
+    /**
+     * Presses and releases the keys necessary to type the given string of
+     * text.
+     *
+     * @param {!string} str
+     *     The string to type.
+     */
+    this.type = function type(str) {
+
+        // Press/release the key corresponding to each character in the string
+        for (var i = 0; i < str.length; i++) {
+
+            // Determine keysym of current character
+            var codepoint = str.codePointAt ? str.codePointAt(i) : str.charCodeAt(i);
+            var keysym = keysym_from_charcode(codepoint);
+
+            // Press and release key for current character
+            guac_keyboard.press(keysym);
+            guac_keyboard.release(keysym);
+
+        }
+
+    };
+
+    /**
+     * Resets the state of this keyboard, releasing all keys, and firing keyup
+     * events for each released key.
+     */
+    this.reset = function() {
+
+        // Release all pressed keys
+        for (var keysym in guac_keyboard.pressed)
+            guac_keyboard.release(parseInt(keysym));
+
+        // Clear event log
+        eventLog = [];
+
+    };
+
+    /**
+     * Resynchronizes the remote state of the given modifier with its
+     * corresponding local modifier state, as dictated by
+     * {@link KeyEvent#modifiers} within the given key event, by pressing or
+     * releasing keysyms.
+     *
+     * @private
+     * @param {!string} modifier
+     *     The name of the {@link Guacamole.Keyboard.ModifierState} property
+     *     being updated.
+     *
+     * @param {!number[]} keysyms
+     *     The keysyms which represent the modifier being updated.
+     *
+     * @param {!KeyEvent} keyEvent
+     *     Guacamole's current best interpretation of the key event being
+     *     processed.
+     */
+    var updateModifierState = function updateModifierState(modifier,
+        keysyms, keyEvent) {
+
+        var localState = keyEvent.modifiers[modifier];
+        var remoteState = guac_keyboard.modifiers[modifier];
+
+        var i;
+
+        // Do not trust changes in modifier state for events directly involving
+        // that modifier: (1) the flag may erroneously be cleared despite
+        // another version of the same key still being held and (2) the change
+        // in flag may be due to the current event being processed, thus
+        // updating things here is at best redundant and at worst incorrect
+        if (keysyms.indexOf(keyEvent.keysym) !== -1)
+            return;
+
+        // Release all related keys if modifier is implicitly released
+        if (remoteState && localState === false) {
+            for (i = 0; i < keysyms.length; i++) {
+                guac_keyboard.release(keysyms[i]);
+            }
+        }
+
+        // Press if modifier is implicitly pressed
+        else if (!remoteState && localState) {
+
+            // Verify that modifier flag isn't already pressed or already set
+            // due to another version of the same key being held down
+            for (i = 0; i < keysyms.length; i++) {
+                if (guac_keyboard.pressed[keysyms[i]])
+                    return;
+            }
+
+            // Mark as implicitly pressed only if there is other information
+            // within the key event relating to a different key. Some
+            // platforms, such as iOS, will send essentially empty key events
+            // for modifier keys, using only the modifier flags to signal the
+            // identity of the key.
+            var keysym = keysyms[0];
+            if (keyEvent.keysym)
+                implicitlyPressed[keysym] = true;
+
+            guac_keyboard.press(keysym);
+
+        }
+
+    };
+
+    /**
+     * Given a keyboard event, updates the remote key state to match the local
+     * modifier state and remote based on the modifier flags within the event.
+     * This function pays no attention to keycodes.
+     *
+     * @private
+     * @param {!KeyEvent} keyEvent
+     *     Guacamole's current best interpretation of the key event being
+     *     processed.
+     */
+    var syncModifierStates = function syncModifierStates(keyEvent) {
+
+        // Resync state of alt
+        updateModifierState('alt', [
+            0xFFE9, // Left alt
+            0xFFEA, // Right alt
+            0xFE03  // AltGr
+        ], keyEvent);
+
+        // Resync state of shift
+        updateModifierState('shift', [
+            0xFFE1, // Left shift
+            0xFFE2  // Right shift
+        ], keyEvent);
+
+        // Resync state of ctrl
+        updateModifierState('ctrl', [
+            0xFFE3, // Left ctrl
+            0xFFE4  // Right ctrl
+        ], keyEvent);
+
+        // Resync state of meta
+        updateModifierState('meta', [
+            0xFFE7, // Left meta
+            0xFFE8  // Right meta
+        ], keyEvent);
+
+        // Resync state of hyper
+        updateModifierState('hyper', [
+            0xFFEB, // Left super/hyper
+            0xFFEC  // Right super/hyper
+        ], keyEvent);
+
+        // Update state
+        guac_keyboard.modifiers = keyEvent.modifiers;
+
+    };
+
+    /**
+     * Returns whether all currently pressed keys were implicitly pressed. A
+     * key is implicitly pressed if its status was inferred indirectly from
+     * inspection of other key events.
+     *
+     * @private
+     * @returns {!boolean}
+     *     true if all currently pressed keys were implicitly pressed, false
+     *     otherwise.
+     */
+    var isStateImplicit = function isStateImplicit() {
+
+        for (var keysym in guac_keyboard.pressed) {
+            if (!implicitlyPressed[keysym])
+                return false;
+        }
+
+        return true;
+
+    };
+
+    /**
+     * Reads through the event log, removing events from the head of the log
+     * when the corresponding true key presses are known (or as known as they
+     * can be).
+     * 
+     * @private
+     * @return {boolean}
+     *     Whether the default action of the latest event should be prevented.
+     */
+    function interpret_events() {
+
+        // Do not prevent default if no event could be interpreted
+        var handled_event = interpret_event();
+        if (!handled_event)
+            return false;
+
+        // Interpret as much as possible
+        var last_event;
+        do {
+            last_event = handled_event;
+            handled_event = interpret_event();
+        } while (handled_event !== null);
+
+        // Reset keyboard state if we cannot expect to receive any further
+        // keyup events
+        if (isStateImplicit())
+            guac_keyboard.reset();
+
+        return last_event.defaultPrevented;
+
+    }
+
+    /**
+     * Releases Ctrl+Alt, if both are currently pressed and the given keysym
+     * looks like a key that may require AltGr.
+     *
+     * @private
+     * @param {!number} keysym
+     *     The key that was just pressed.
+     */
+    var release_simulated_altgr = function release_simulated_altgr(keysym) {
+
+        // Both Ctrl+Alt must be pressed if simulated AltGr is in use
+        if (!guac_keyboard.modifiers.ctrl || !guac_keyboard.modifiers.alt)
+            return;
+
+        // Assume [A-Z] never require AltGr
+        if (keysym >= 0x0041 && keysym <= 0x005A)
+            return;
+
+        // Assume [a-z] never require AltGr
+        if (keysym >= 0x0061 && keysym <= 0x007A)
+            return;
+
+        // Release Ctrl+Alt if the keysym is printable
+        if (keysym <= 0xFF || (keysym & 0xFF000000) === 0x01000000) {
+            guac_keyboard.release(0xFFE3); // Left ctrl 
+            guac_keyboard.release(0xFFE4); // Right ctrl 
+            guac_keyboard.release(0xFFE9); // Left alt
+            guac_keyboard.release(0xFFEA); // Right alt
+        }
+
+    };
+
+    /**
+     * Reads through the event log, interpreting the first event, if possible,
+     * and returning that event. If no events can be interpreted, due to a
+     * total lack of events or the need for more events, null is returned. Any
+     * interpreted events are automatically removed from the log.
+     * 
+     * @private
+     * @return {KeyEvent}
+     *     The first key event in the log, if it can be interpreted, or null
+     *     otherwise.
+     */
+    var interpret_event = function interpret_event() {
+
+        // Peek at first event in log
+        var first = eventLog[0];
+        if (!first)
+            return null;
+
+        // Keydown event
+        if (first instanceof KeydownEvent) {
+
+            var keysym = null;
+            var accepted_events = [];
+
+            // Defer handling of Meta until it is known to be functioning as a
+            // modifier (it may otherwise actually be an alternative method for
+            // pressing a single key, such as Meta+Left for Home on ChromeOS)
+            if (first.keysym === 0xFFE7 || first.keysym === 0xFFE8) {
+
+                // Defer handling until further events exist to provide context
+                if (eventLog.length === 1)
+                    return null;
+
+                // Drop keydown if it turns out Meta does not actually apply
+                if (eventLog[1].keysym !== first.keysym) {
+                    if (!eventLog[1].modifiers.meta)
+                        return eventLog.shift();
+                }
+
+                // Drop duplicate keydown events while waiting to determine
+                // whether to acknowledge Meta (browser may repeat keydown
+                // while the key is held)
+                else if (eventLog[1] instanceof KeydownEvent)
+                    return eventLog.shift();
+
+            }
+
+            // If event itself is reliable, no need to wait for other events
+            if (first.reliable) {
+                keysym = first.keysym;
+                accepted_events = eventLog.splice(0, 1);
+            }
+
+            // If keydown is immediately followed by a keypress, use the indicated character
+            else if (eventLog[1] instanceof KeypressEvent) {
+                keysym = eventLog[1].keysym;
+                accepted_events = eventLog.splice(0, 2);
+            }
+
+            // If keydown is immediately followed by anything else, then no
+            // keypress can possibly occur to clarify this event, and we must
+            // handle it now
+            else if (eventLog[1]) {
+                keysym = first.keysym;
+                accepted_events = eventLog.splice(0, 1);
+            }
+
+            // Fire a key press if valid events were found
+            if (accepted_events.length > 0) {
+
+                syncModifierStates(first);
+
+                if (keysym) {
+
+                    // Fire event
+                    release_simulated_altgr(keysym);
+                    var defaultPrevented = !guac_keyboard.press(keysym);
+                    recentKeysym[first.keyCode] = keysym;
+
+                    // Release the key now if we cannot rely on the associated
+                    // keyup event
+                    if (!first.keyupReliable)
+                        guac_keyboard.release(keysym);
+
+                    // Record whether default was prevented
+                    for (var i=0; i<accepted_events.length; i++)
+                        accepted_events[i].defaultPrevented = defaultPrevented;
+
+                }
+
+                return first;
+
+            }
+
+        } // end if keydown
+
+        // Keyup event
+        else if (first instanceof KeyupEvent && !quirks.keyupUnreliable) {
+
+            // Release specific key if known
+            var keysym = first.keysym;
+            if (keysym) {
+                guac_keyboard.release(keysym);
+                delete recentKeysym[first.keyCode];
+                first.defaultPrevented = true;
+            }
+
+            // Otherwise, fall back to releasing all keys
+            else {
+                guac_keyboard.reset();
+                return first;
+            }
+
+            syncModifierStates(first);
+            return eventLog.shift();
+
+        } // end if keyup
+
+        // Ignore any other type of event (keypress by itself is invalid, and
+        // unreliable keyup events should simply be dumped)
+        else
+            return eventLog.shift();
+
+        // No event interpreted
+        return null;
+
+    };
+
+    /**
+     * Returns the keyboard location of the key associated with the given
+     * keyboard event. The location differentiates key events which otherwise
+     * have the same keycode, such as left shift vs. right shift.
+     *
+     * @private
+     * @param {!KeyboardEvent} e
+     *     A JavaScript keyboard event, as received through the DOM via a
+     *     "keydown", "keyup", or "keypress" handler.
+     *
+     * @returns {!number}
+     *     The location of the key event on the keyboard, as defined at:
+     *     http://www.w3.org/TR/DOM-Level-3-Events/#events-KeyboardEvent
+     */
+    var getEventLocation = function getEventLocation(e) {
+
+        // Use standard location, if possible
+        if ('location' in e)
+            return e.location;
+
+        // Failing that, attempt to use deprecated keyLocation
+        if ('keyLocation' in e)
+            return e.keyLocation;
+
+        // If no location is available, assume left side
+        return 0;
+
+    };
+
+    /**
+     * Attempts to mark the given Event as having been handled by this
+     * Guacamole.Keyboard. If the Event has already been marked as handled,
+     * false is returned.
+     *
+     * @param {!Event} e
+     *     The Event to mark.
+     *
+     * @returns {!boolean}
+     *     true if the given Event was successfully marked, false if the given
+     *     Event was already marked.
+     */
+    var markEvent = function markEvent(e) {
+
+        // Fail if event is already marked
+        if (e[EVENT_MARKER])
+            return false;
+
+        // Mark event otherwise
+        e[EVENT_MARKER] = true;
+        return true;
+
+    };
+
+    /**
+     * Attaches event listeners to the given Element, automatically translating
+     * received key, input, and composition events into simple keydown/keyup
+     * events signalled through this Guacamole.Keyboard's onkeydown and
+     * onkeyup handlers.
+     *
+     * @param {!(Element|Document)} element
+     *     The Element to attach event listeners to for the sake of handling
+     *     key or input events.
+     */
+    this.listenTo = function listenTo(element) {
+
+        // When key pressed
+        element.addEventListener("keydown", function(e) {
+
+            // Only intercept if handler set
+            if (!guac_keyboard.onkeydown) return;
+
+            // Ignore events which have already been handled
+            if (!markEvent(e)) return;
+
+            var keydownEvent = new KeydownEvent(e);
+
+            // Ignore (but do not prevent) the "composition" keycode sent by some
+            // browsers when an IME is in use (see: http://lists.w3.org/Archives/Public/www-dom/2010JulSep/att-0182/keyCode-spec.html)
+            if (keydownEvent.keyCode === 229)
+                return;
+
+            // Log event
+            eventLog.push(keydownEvent);
+
+            // Interpret as many events as possible, prevent default if indicated
+            if (interpret_events())
+                e.preventDefault();
+
+        }, true);
+
+        // When key pressed
+        element.addEventListener("keypress", function(e) {
+
+            // Only intercept if handler set
+            if (!guac_keyboard.onkeydown && !guac_keyboard.onkeyup) return;
+
+            // Ignore events which have already been handled
+            if (!markEvent(e)) return;
+
+            // Log event
+            eventLog.push(new KeypressEvent(e));
+
+            // Interpret as many events as possible, prevent default if indicated
+            if (interpret_events())
+                e.preventDefault();
+
+        }, true);
+
+        // When key released
+        element.addEventListener("keyup", function(e) {
+
+            // Only intercept if handler set
+            if (!guac_keyboard.onkeyup) return;
+
+            // Ignore events which have already been handled
+            if (!markEvent(e)) return;
+
+            e.preventDefault();
+
+            // Log event, call for interpretation
+            eventLog.push(new KeyupEvent(e));
+            interpret_events();
+
+        }, true);
+
+        /**
+         * Handles the given "input" event, typing the data within the input text.
+         * If the event is complete (text is provided), handling of "compositionend"
+         * events is suspended, as such events may conflict with input events.
+         *
+         * @private
+         * @param {!InputEvent} e
+         *     The "input" event to handle.
+         */
+        var handleInput = function handleInput(e) {
+
+            // Only intercept if handler set
+            if (!guac_keyboard.onkeydown && !guac_keyboard.onkeyup) return;
+
+            // Ignore events which have already been handled
+            if (!markEvent(e)) return;
+
+            // Type all content written
+            if (e.data && !e.isComposing) {
+                element.removeEventListener("compositionend", handleComposition, false);
+                guac_keyboard.type(e.data);
+            }
+
+        };
+
+        /**
+         * Handles the given "compositionend" event, typing the data within the
+         * composed text. If the event is complete (composed text is provided),
+         * handling of "input" events is suspended, as such events may conflict
+         * with composition events.
+         *
+         * @private
+         * @param {!CompositionEvent} e
+         *     The "compositionend" event to handle.
+         */
+        var handleComposition = function handleComposition(e) {
+
+            // Only intercept if handler set
+            if (!guac_keyboard.onkeydown && !guac_keyboard.onkeyup) return;
+
+            // Ignore events which have already been handled
+            if (!markEvent(e)) return;
+
+            // Type all content written
+            if (e.data) {
+                element.removeEventListener("input", handleInput, false);
+                guac_keyboard.type(e.data);
+            }
+
+        };
+
+        // Automatically type text entered into the wrapped field
+        //20220428: NEKO: Removed because of clipboard handling.
+        //element.addEventListener("input", handleInput, false);
+        //element.addEventListener("compositionend", handleComposition, false);
+    };
+
+    // Listen to given element, if any
+    if (element)
+        guac_keyboard.listenTo(element);
+
+};
+
+/**
+ * The unique numerical identifier to assign to the next Guacamole.Keyboard
+ * instance.
+ *
+ * @private
+ * @type {!number}
+ */
+Guacamole.Keyboard._nextID = 0;
+
+/**
+ * The state of all supported keyboard modifiers.
+ * @constructor
+ */
+Guacamole.Keyboard.ModifierState = function() {
+    
+    /**
+     * Whether shift is currently pressed.
+     *
+     * @type {!boolean}
+     */
+    this.shift = false;
+    
+    /**
+     * Whether ctrl is currently pressed.
+     *
+     * @type {!boolean}
+     */
+    this.ctrl = false;
+    
+    /**
+     * Whether alt is currently pressed.
+     *
+     * @type {!boolean}
+     */
+    this.alt = false;
+    
+    /**
+     * Whether meta (apple key) is currently pressed.
+     *
+     * @type {!boolean}
+     */
+    this.meta = false;
+
+    /**
+     * Whether hyper (windows key) is currently pressed.
+     *
+     * @type {!boolean}
+     */
+    this.hyper = false;
+
+};
+
+/**
+ * Returns the modifier state applicable to the keyboard event given.
+ * 
+ * @param {!KeyboardEvent} e
+ *     The keyboard event to read.
+ *
+ * @returns {!Guacamole.Keyboard.ModifierState}
+ *     The current state of keyboard modifiers.
+ */
+Guacamole.Keyboard.ModifierState.fromKeyboardEvent = function(e) {
+    
+    var state = new Guacamole.Keyboard.ModifierState();
+
+    // Assign states from old flags
+    state.shift = e.shiftKey;
+    state.ctrl  = e.ctrlKey;
+    state.alt   = e.altKey;
+    state.meta  = e.metaKey;
+
+    // Use DOM3 getModifierState() for others
+    if (e.getModifierState) {
+        state.hyper = e.getModifierState("OS")
+                   || e.getModifierState("Super")
+                   || e.getModifierState("Hyper")
+                   || e.getModifierState("Win");
+    }
+
+    return state;
+    
+};
+
+export default Guacamole.Keyboard;
diff --git a/src/component/utils/guacamole-keyboard.ts b/src/component/utils/keyboards/guacamole.ts
similarity index 86%
rename from src/component/utils/guacamole-keyboard.ts
rename to src/component/utils/keyboards/guacamole.ts
index 784d63d3..ed89b89a 100644
--- a/src/component/utils/guacamole-keyboard.ts
+++ b/src/component/utils/keyboards/guacamole.ts
@@ -1,4 +1,4 @@
-import GuacamoleKeyboard from './guacamole-keyboard.js'
+import GuacamoleKeyboard from './guacamole.js'
 
 export interface GuacamoleKeyboardInterface {
   /**
@@ -65,12 +65,20 @@ export interface GuacamoleKeyboardInterface {
    *     key or input events.
    */
   listenTo: (element: Element | Document) => void
+
+  // custom functions
+  removeListener: () => void
 }
 
 export default function (element?: Element): GuacamoleKeyboardInterface {
-  const Keyboard = {}
+  const keyboard = {} as GuacamoleKeyboardInterface
 
-  GuacamoleKeyboard.bind(Keyboard, element)()
+  GuacamoleKeyboard.bind(keyboard, element)()
 
-  return Keyboard as GuacamoleKeyboardInterface
+  // add removeListener function
+  keyboard.removeListener = function () {
+    // Guacamole Keyboard does not provide destroy functions
+  }
+
+  return keyboard
 }
diff --git a/src/component/utils/keyboards/novnc.js b/src/component/utils/keyboards/novnc.js
new file mode 100644
index 00000000..b8b7d5c1
--- /dev/null
+++ b/src/component/utils/keyboards/novnc.js
@@ -0,0 +1,2 @@
+import Keyboard from './novnc/keyboard.js'
+export default Keyboard
diff --git a/src/component/utils/keyboards/novnc.ts b/src/component/utils/keyboards/novnc.ts
new file mode 100644
index 00000000..f5756c20
--- /dev/null
+++ b/src/component/utils/keyboards/novnc.ts
@@ -0,0 +1,50 @@
+import Keyboard from './novnc.js'
+
+export interface NoVncKeyboardInterface {
+  // original functions
+  onkeyevent: (keysym: number | null, code: string, down: boolean) => boolean
+  grab: () => void
+  ungrab: () => void
+
+  // custom functions
+  onkeydown?: (keysym: number) => boolean
+  onkeyup?: (keysym: number) => void
+  release: (keysym: number) => void
+  listenTo: (element: Element | Document) => void
+  removeListener: () => void
+}
+
+export default function (element?: Element): NoVncKeyboardInterface {
+  // @ts-ignore
+  const keyboard = new Keyboard(element)
+
+  // map on key event to onkeydown and onkeyup
+  keyboard.onkeyevent = function (keysym: number | null, code: string, down: boolean) {
+    if (keysym === null) return false
+    if (down) return this.onkeydown(keysym, code)
+    this.onkeyup(keysym, code)
+  }
+
+  // add release function
+  keyboard.release = function (keysym: number) {
+    for (const code in this._keyDownList) {
+      if (this._keyDownList[code] === keysym) {
+        this._sendKeyEvent(keysym, code, false)
+        break
+      }
+    }
+  }
+
+  // add listenTo function
+  keyboard.listenTo = function (element: Element | Document) {
+    if (element) this._target = element
+    this.grab()
+  }
+
+  // add removeListener function
+  keyboard.removeListener = function () {
+    this.ungrab()
+  }
+
+  return keyboard
+}
diff --git a/src/component/utils/keyboards/novnc/browser.js b/src/component/utils/keyboards/novnc/browser.js
new file mode 100644
index 00000000..64b0fedd
--- /dev/null
+++ b/src/component/utils/keyboards/novnc/browser.js
@@ -0,0 +1,42 @@
+/*
+ * noVNC: HTML5 VNC client
+ * Copyright (C) 2019 The noVNC Authors
+ * Licensed under MPL 2.0 (see LICENSE.txt)
+ *
+ * See README.md for usage and integration instructions.
+ *
+ * Browser feature support detection
+ */
+
+export function isMac() {
+    return navigator && !!(/mac/i).exec(navigator.platform);
+}
+
+export function isWindows() {
+    return navigator && !!(/win/i).exec(navigator.platform);
+}
+
+export function isIOS() {
+    return navigator &&
+           (!!(/ipad/i).exec(navigator.platform) ||
+            !!(/iphone/i).exec(navigator.platform) ||
+            !!(/ipod/i).exec(navigator.platform));
+}
+
+export function isSafari() {
+    return navigator && (navigator.userAgent.indexOf('Safari') !== -1 &&
+                         navigator.userAgent.indexOf('Chrome') === -1);
+}
+
+export function isIE() {
+    return navigator && !!(/trident/i).exec(navigator.userAgent);
+}
+
+export function isEdge() {
+    return navigator && !!(/edge/i).exec(navigator.userAgent);
+}
+
+export function isFirefox() {
+    return navigator && !!(/firefox/i).exec(navigator.userAgent);
+}
+
diff --git a/src/component/utils/keyboards/novnc/domkeytable.js b/src/component/utils/keyboards/novnc/domkeytable.js
new file mode 100644
index 00000000..f79aeadf
--- /dev/null
+++ b/src/component/utils/keyboards/novnc/domkeytable.js
@@ -0,0 +1,311 @@
+/*
+ * noVNC: HTML5 VNC client
+ * Copyright (C) 2018 The noVNC Authors
+ * Licensed under MPL 2.0 or any later version (see LICENSE.txt)
+ */
+
+import KeyTable from "./keysym.js";
+
+/*
+ * Mapping between HTML key values and VNC/X11 keysyms for "special"
+ * keys that cannot be handled via their Unicode codepoint.
+ *
+ * See https://www.w3.org/TR/uievents-key/ for possible values.
+ */
+
+const DOMKeyTable = {};
+
+function addStandard(key, standard) {
+    if (standard === undefined) throw new Error("Undefined keysym for key \"" + key + "\"");
+    if (key in DOMKeyTable) throw new Error("Duplicate entry for key \"" + key + "\"");
+    DOMKeyTable[key] = [standard, standard, standard, standard];
+}
+
+function addLeftRight(key, left, right) {
+    if (left === undefined) throw new Error("Undefined keysym for key \"" + key + "\"");
+    if (right === undefined) throw new Error("Undefined keysym for key \"" + key + "\"");
+    if (key in DOMKeyTable) throw new Error("Duplicate entry for key \"" + key + "\"");
+    DOMKeyTable[key] = [left, left, right, left];
+}
+
+function addNumpad(key, standard, numpad) {
+    if (standard === undefined) throw new Error("Undefined keysym for key \"" + key + "\"");
+    if (numpad === undefined) throw new Error("Undefined keysym for key \"" + key + "\"");
+    if (key in DOMKeyTable) throw new Error("Duplicate entry for key \"" + key + "\"");
+    DOMKeyTable[key] = [standard, standard, standard, numpad];
+}
+
+// 3.2. Modifier Keys
+
+addLeftRight("Alt", KeyTable.XK_Alt_L, KeyTable.XK_Alt_R);
+addStandard("AltGraph", KeyTable.XK_ISO_Level3_Shift);
+addStandard("CapsLock", KeyTable.XK_Caps_Lock);
+addLeftRight("Control", KeyTable.XK_Control_L, KeyTable.XK_Control_R);
+// - Fn
+// - FnLock
+addLeftRight("Meta", KeyTable.XK_Super_L, KeyTable.XK_Super_R);
+addStandard("NumLock", KeyTable.XK_Num_Lock);
+addStandard("ScrollLock", KeyTable.XK_Scroll_Lock);
+addLeftRight("Shift", KeyTable.XK_Shift_L, KeyTable.XK_Shift_R);
+// - Symbol
+// - SymbolLock
+// - Hyper
+// - Super
+
+// 3.3. Whitespace Keys
+
+addNumpad("Enter", KeyTable.XK_Return, KeyTable.XK_KP_Enter);
+addStandard("Tab", KeyTable.XK_Tab);
+addNumpad(" ", KeyTable.XK_space, KeyTable.XK_KP_Space);
+
+// 3.4. Navigation Keys
+
+addNumpad("ArrowDown", KeyTable.XK_Down, KeyTable.XK_KP_Down);
+addNumpad("ArrowLeft", KeyTable.XK_Left, KeyTable.XK_KP_Left);
+addNumpad("ArrowRight", KeyTable.XK_Right, KeyTable.XK_KP_Right);
+addNumpad("ArrowUp", KeyTable.XK_Up, KeyTable.XK_KP_Up);
+addNumpad("End", KeyTable.XK_End, KeyTable.XK_KP_End);
+addNumpad("Home", KeyTable.XK_Home, KeyTable.XK_KP_Home);
+addNumpad("PageDown", KeyTable.XK_Next, KeyTable.XK_KP_Next);
+addNumpad("PageUp", KeyTable.XK_Prior, KeyTable.XK_KP_Prior);
+
+// 3.5. Editing Keys
+
+addStandard("Backspace", KeyTable.XK_BackSpace);
+// Browsers send "Clear" for the numpad 5 without NumLock because
+// Windows uses VK_Clear for that key. But Unix expects KP_Begin for
+// that scenario.
+addNumpad("Clear", KeyTable.XK_Clear, KeyTable.XK_KP_Begin);
+addStandard("Copy", KeyTable.XF86XK_Copy);
+// - CrSel
+addStandard("Cut", KeyTable.XF86XK_Cut);
+addNumpad("Delete", KeyTable.XK_Delete, KeyTable.XK_KP_Delete);
+// - EraseEof
+// - ExSel
+addNumpad("Insert", KeyTable.XK_Insert, KeyTable.XK_KP_Insert);
+addStandard("Paste", KeyTable.XF86XK_Paste);
+addStandard("Redo", KeyTable.XK_Redo);
+addStandard("Undo", KeyTable.XK_Undo);
+
+// 3.6. UI Keys
+
+// - Accept
+// - Again (could just be XK_Redo)
+// - Attn
+addStandard("Cancel", KeyTable.XK_Cancel);
+addStandard("ContextMenu", KeyTable.XK_Menu);
+addStandard("Escape", KeyTable.XK_Escape);
+addStandard("Execute", KeyTable.XK_Execute);
+addStandard("Find", KeyTable.XK_Find);
+addStandard("Help", KeyTable.XK_Help);
+addStandard("Pause", KeyTable.XK_Pause);
+// - Play
+// - Props
+addStandard("Select", KeyTable.XK_Select);
+addStandard("ZoomIn", KeyTable.XF86XK_ZoomIn);
+addStandard("ZoomOut", KeyTable.XF86XK_ZoomOut);
+
+// 3.7. Device Keys
+
+addStandard("BrightnessDown", KeyTable.XF86XK_MonBrightnessDown);
+addStandard("BrightnessUp", KeyTable.XF86XK_MonBrightnessUp);
+addStandard("Eject", KeyTable.XF86XK_Eject);
+addStandard("LogOff", KeyTable.XF86XK_LogOff);
+addStandard("Power", KeyTable.XF86XK_PowerOff);
+addStandard("PowerOff", KeyTable.XF86XK_PowerDown);
+addStandard("PrintScreen", KeyTable.XK_Print);
+addStandard("Hibernate", KeyTable.XF86XK_Hibernate);
+addStandard("Standby", KeyTable.XF86XK_Standby);
+addStandard("WakeUp", KeyTable.XF86XK_WakeUp);
+
+// 3.8. IME and Composition Keys
+
+addStandard("AllCandidates", KeyTable.XK_MultipleCandidate);
+addStandard("Alphanumeric", KeyTable.XK_Eisu_toggle);
+addStandard("CodeInput", KeyTable.XK_Codeinput);
+addStandard("Compose", KeyTable.XK_Multi_key);
+addStandard("Convert", KeyTable.XK_Henkan);
+// - Dead
+// - FinalMode
+addStandard("GroupFirst", KeyTable.XK_ISO_First_Group);
+addStandard("GroupLast", KeyTable.XK_ISO_Last_Group);
+addStandard("GroupNext", KeyTable.XK_ISO_Next_Group);
+addStandard("GroupPrevious", KeyTable.XK_ISO_Prev_Group);
+// - ModeChange (XK_Mode_switch is often used for AltGr)
+// - NextCandidate
+addStandard("NonConvert", KeyTable.XK_Muhenkan);
+addStandard("PreviousCandidate", KeyTable.XK_PreviousCandidate);
+// - Process
+addStandard("SingleCandidate", KeyTable.XK_SingleCandidate);
+addStandard("HangulMode", KeyTable.XK_Hangul);
+addStandard("HanjaMode", KeyTable.XK_Hangul_Hanja);
+addStandard("JunjaMode", KeyTable.XK_Hangul_Jeonja);
+addStandard("Eisu", KeyTable.XK_Eisu_toggle);
+addStandard("Hankaku", KeyTable.XK_Hankaku);
+addStandard("Hiragana", KeyTable.XK_Hiragana);
+addStandard("HiraganaKatakana", KeyTable.XK_Hiragana_Katakana);
+addStandard("KanaMode", KeyTable.XK_Kana_Shift); // could also be _Kana_Lock
+addStandard("KanjiMode", KeyTable.XK_Kanji);
+addStandard("Katakana", KeyTable.XK_Katakana);
+addStandard("Romaji", KeyTable.XK_Romaji);
+addStandard("Zenkaku", KeyTable.XK_Zenkaku);
+addStandard("ZenkakuHankaku", KeyTable.XK_Zenkaku_Hankaku);
+
+// 3.9. General-Purpose Function Keys
+
+addStandard("F1", KeyTable.XK_F1);
+addStandard("F2", KeyTable.XK_F2);
+addStandard("F3", KeyTable.XK_F3);
+addStandard("F4", KeyTable.XK_F4);
+addStandard("F5", KeyTable.XK_F5);
+addStandard("F6", KeyTable.XK_F6);
+addStandard("F7", KeyTable.XK_F7);
+addStandard("F8", KeyTable.XK_F8);
+addStandard("F9", KeyTable.XK_F9);
+addStandard("F10", KeyTable.XK_F10);
+addStandard("F11", KeyTable.XK_F11);
+addStandard("F12", KeyTable.XK_F12);
+addStandard("F13", KeyTable.XK_F13);
+addStandard("F14", KeyTable.XK_F14);
+addStandard("F15", KeyTable.XK_F15);
+addStandard("F16", KeyTable.XK_F16);
+addStandard("F17", KeyTable.XK_F17);
+addStandard("F18", KeyTable.XK_F18);
+addStandard("F19", KeyTable.XK_F19);
+addStandard("F20", KeyTable.XK_F20);
+addStandard("F21", KeyTable.XK_F21);
+addStandard("F22", KeyTable.XK_F22);
+addStandard("F23", KeyTable.XK_F23);
+addStandard("F24", KeyTable.XK_F24);
+addStandard("F25", KeyTable.XK_F25);
+addStandard("F26", KeyTable.XK_F26);
+addStandard("F27", KeyTable.XK_F27);
+addStandard("F28", KeyTable.XK_F28);
+addStandard("F29", KeyTable.XK_F29);
+addStandard("F30", KeyTable.XK_F30);
+addStandard("F31", KeyTable.XK_F31);
+addStandard("F32", KeyTable.XK_F32);
+addStandard("F33", KeyTable.XK_F33);
+addStandard("F34", KeyTable.XK_F34);
+addStandard("F35", KeyTable.XK_F35);
+// - Soft1...
+
+// 3.10. Multimedia Keys
+
+// - ChannelDown
+// - ChannelUp
+addStandard("Close", KeyTable.XF86XK_Close);
+addStandard("MailForward", KeyTable.XF86XK_MailForward);
+addStandard("MailReply", KeyTable.XF86XK_Reply);
+addStandard("MailSend", KeyTable.XF86XK_Send);
+// - MediaClose
+addStandard("MediaFastForward", KeyTable.XF86XK_AudioForward);
+addStandard("MediaPause", KeyTable.XF86XK_AudioPause);
+addStandard("MediaPlay", KeyTable.XF86XK_AudioPlay);
+// - MediaPlayPause
+addStandard("MediaRecord", KeyTable.XF86XK_AudioRecord);
+addStandard("MediaRewind", KeyTable.XF86XK_AudioRewind);
+addStandard("MediaStop", KeyTable.XF86XK_AudioStop);
+addStandard("MediaTrackNext", KeyTable.XF86XK_AudioNext);
+addStandard("MediaTrackPrevious", KeyTable.XF86XK_AudioPrev);
+addStandard("New", KeyTable.XF86XK_New);
+addStandard("Open", KeyTable.XF86XK_Open);
+addStandard("Print", KeyTable.XK_Print);
+addStandard("Save", KeyTable.XF86XK_Save);
+addStandard("SpellCheck", KeyTable.XF86XK_Spell);
+
+// 3.11. Multimedia Numpad Keys
+
+// - Key11
+// - Key12
+
+// 3.12. Audio Keys
+
+// - AudioBalanceLeft
+// - AudioBalanceRight
+// - AudioBassBoostDown
+// - AudioBassBoostToggle
+// - AudioBassBoostUp
+// - AudioFaderFront
+// - AudioFaderRear
+// - AudioSurroundModeNext
+// - AudioTrebleDown
+// - AudioTrebleUp
+addStandard("AudioVolumeDown", KeyTable.XF86XK_AudioLowerVolume);
+addStandard("AudioVolumeUp", KeyTable.XF86XK_AudioRaiseVolume);
+addStandard("AudioVolumeMute", KeyTable.XF86XK_AudioMute);
+// - MicrophoneToggle
+// - MicrophoneVolumeDown
+// - MicrophoneVolumeUp
+addStandard("MicrophoneVolumeMute", KeyTable.XF86XK_AudioMicMute);
+
+// 3.13. Speech Keys
+
+// - SpeechCorrectionList
+// - SpeechInputToggle
+
+// 3.14. Application Keys
+
+addStandard("LaunchApplication1", KeyTable.XF86XK_MyComputer);
+addStandard("LaunchApplication2", KeyTable.XF86XK_Calculator);
+addStandard("LaunchCalendar", KeyTable.XF86XK_Calendar);
+// - LaunchContacts
+addStandard("LaunchMail", KeyTable.XF86XK_Mail);
+addStandard("LaunchMediaPlayer", KeyTable.XF86XK_AudioMedia);
+addStandard("LaunchMusicPlayer", KeyTable.XF86XK_Music);
+addStandard("LaunchPhone", KeyTable.XF86XK_Phone);
+addStandard("LaunchScreenSaver", KeyTable.XF86XK_ScreenSaver);
+addStandard("LaunchSpreadsheet", KeyTable.XF86XK_Excel);
+addStandard("LaunchWebBrowser", KeyTable.XF86XK_WWW);
+addStandard("LaunchWebCam", KeyTable.XF86XK_WebCam);
+addStandard("LaunchWordProcessor", KeyTable.XF86XK_Word);
+
+// 3.15. Browser Keys
+
+addStandard("BrowserBack", KeyTable.XF86XK_Back);
+addStandard("BrowserFavorites", KeyTable.XF86XK_Favorites);
+addStandard("BrowserForward", KeyTable.XF86XK_Forward);
+addStandard("BrowserHome", KeyTable.XF86XK_HomePage);
+addStandard("BrowserRefresh", KeyTable.XF86XK_Refresh);
+addStandard("BrowserSearch", KeyTable.XF86XK_Search);
+addStandard("BrowserStop", KeyTable.XF86XK_Stop);
+
+// 3.16. Mobile Phone Keys
+
+// - A whole bunch...
+
+// 3.17. TV Keys
+
+// - A whole bunch...
+
+// 3.18. Media Controller Keys
+
+// - A whole bunch...
+addStandard("Dimmer", KeyTable.XF86XK_BrightnessAdjust);
+addStandard("MediaAudioTrack", KeyTable.XF86XK_AudioCycleTrack);
+addStandard("RandomToggle", KeyTable.XF86XK_AudioRandomPlay);
+addStandard("SplitScreenToggle", KeyTable.XF86XK_SplitScreen);
+addStandard("Subtitle", KeyTable.XF86XK_Subtitle);
+addStandard("VideoModeNext", KeyTable.XF86XK_Next_VMode);
+
+// Extra: Numpad
+
+addNumpad("=", KeyTable.XK_equal, KeyTable.XK_KP_Equal);
+addNumpad("+", KeyTable.XK_plus, KeyTable.XK_KP_Add);
+addNumpad("-", KeyTable.XK_minus, KeyTable.XK_KP_Subtract);
+addNumpad("*", KeyTable.XK_asterisk, KeyTable.XK_KP_Multiply);
+addNumpad("/", KeyTable.XK_slash, KeyTable.XK_KP_Divide);
+addNumpad(".", KeyTable.XK_period, KeyTable.XK_KP_Decimal);
+addNumpad(",", KeyTable.XK_comma, KeyTable.XK_KP_Separator);
+addNumpad("0", KeyTable.XK_0, KeyTable.XK_KP_0);
+addNumpad("1", KeyTable.XK_1, KeyTable.XK_KP_1);
+addNumpad("2", KeyTable.XK_2, KeyTable.XK_KP_2);
+addNumpad("3", KeyTable.XK_3, KeyTable.XK_KP_3);
+addNumpad("4", KeyTable.XK_4, KeyTable.XK_KP_4);
+addNumpad("5", KeyTable.XK_5, KeyTable.XK_KP_5);
+addNumpad("6", KeyTable.XK_6, KeyTable.XK_KP_6);
+addNumpad("7", KeyTable.XK_7, KeyTable.XK_KP_7);
+addNumpad("8", KeyTable.XK_8, KeyTable.XK_KP_8);
+addNumpad("9", KeyTable.XK_9, KeyTable.XK_KP_9);
+
+export default DOMKeyTable;
diff --git a/src/component/utils/keyboards/novnc/fixedkeys.js b/src/component/utils/keyboards/novnc/fixedkeys.js
new file mode 100644
index 00000000..4d09f2f7
--- /dev/null
+++ b/src/component/utils/keyboards/novnc/fixedkeys.js
@@ -0,0 +1,129 @@
+/*
+ * noVNC: HTML5 VNC client
+ * Copyright (C) 2018 The noVNC Authors
+ * Licensed under MPL 2.0 or any later version (see LICENSE.txt)
+ */
+
+/*
+ * Fallback mapping between HTML key codes (physical keys) and
+ * HTML key values. This only works for keys that don't vary
+ * between layouts. We also omit those who manage fine by mapping the
+ * Unicode representation.
+ *
+ * See https://www.w3.org/TR/uievents-code/ for possible codes.
+ * See https://www.w3.org/TR/uievents-key/ for possible values.
+ */
+
+/* eslint-disable key-spacing */
+
+export default {
+
+// 3.1.1.1. Writing System Keys
+
+    'Backspace':        'Backspace',
+
+// 3.1.1.2. Functional Keys
+
+    'AltLeft':          'Alt',
+    'AltRight':         'Alt', // This could also be 'AltGraph'
+    'CapsLock':         'CapsLock',
+    'ContextMenu':      'ContextMenu',
+    'ControlLeft':      'Control',
+    'ControlRight':     'Control',
+    'Enter':            'Enter',
+    'MetaLeft':         'Meta',
+    'MetaRight':        'Meta',
+    'ShiftLeft':        'Shift',
+    'ShiftRight':       'Shift',
+    'Tab':              'Tab',
+    // FIXME: Japanese/Korean keys
+
+// 3.1.2. Control Pad Section
+
+    'Delete':           'Delete',
+    'End':              'End',
+    'Help':             'Help',
+    'Home':             'Home',
+    'Insert':           'Insert',
+    'PageDown':         'PageDown',
+    'PageUp':           'PageUp',
+
+// 3.1.3. Arrow Pad Section
+
+    'ArrowDown':        'ArrowDown',
+    'ArrowLeft':        'ArrowLeft',
+    'ArrowRight':       'ArrowRight',
+    'ArrowUp':          'ArrowUp',
+
+// 3.1.4. Numpad Section
+
+    'NumLock':          'NumLock',
+    'NumpadBackspace':  'Backspace',
+    'NumpadClear':      'Clear',
+
+// 3.1.5. Function Section
+
+    'Escape':           'Escape',
+    'F1':               'F1',
+    'F2':               'F2',
+    'F3':               'F3',
+    'F4':               'F4',
+    'F5':               'F5',
+    'F6':               'F6',
+    'F7':               'F7',
+    'F8':               'F8',
+    'F9':               'F9',
+    'F10':              'F10',
+    'F11':              'F11',
+    'F12':              'F12',
+    'F13':              'F13',
+    'F14':              'F14',
+    'F15':              'F15',
+    'F16':              'F16',
+    'F17':              'F17',
+    'F18':              'F18',
+    'F19':              'F19',
+    'F20':              'F20',
+    'F21':              'F21',
+    'F22':              'F22',
+    'F23':              'F23',
+    'F24':              'F24',
+    'F25':              'F25',
+    'F26':              'F26',
+    'F27':              'F27',
+    'F28':              'F28',
+    'F29':              'F29',
+    'F30':              'F30',
+    'F31':              'F31',
+    'F32':              'F32',
+    'F33':              'F33',
+    'F34':              'F34',
+    'F35':              'F35',
+    'PrintScreen':      'PrintScreen',
+    'ScrollLock':       'ScrollLock',
+    'Pause':            'Pause',
+
+// 3.1.6. Media Keys
+
+    'BrowserBack':      'BrowserBack',
+    'BrowserFavorites': 'BrowserFavorites',
+    'BrowserForward':   'BrowserForward',
+    'BrowserHome':      'BrowserHome',
+    'BrowserRefresh':   'BrowserRefresh',
+    'BrowserSearch':    'BrowserSearch',
+    'BrowserStop':      'BrowserStop',
+    'Eject':            'Eject',
+    'LaunchApp1':       'LaunchMyComputer',
+    'LaunchApp2':       'LaunchCalendar',
+    'LaunchMail':       'LaunchMail',
+    'MediaPlayPause':   'MediaPlay',
+    'MediaStop':        'MediaStop',
+    'MediaTrackNext':   'MediaTrackNext',
+    'MediaTrackPrevious': 'MediaTrackPrevious',
+    'Power':            'Power',
+    'Sleep':            'Sleep',
+    'AudioVolumeDown':  'AudioVolumeDown',
+    'AudioVolumeMute':  'AudioVolumeMute',
+    'AudioVolumeUp':    'AudioVolumeUp',
+    'WakeUp':           'WakeUp',
+};
diff --git a/src/component/utils/keyboards/novnc/keyboard.js b/src/component/utils/keyboards/novnc/keyboard.js
new file mode 100644
index 00000000..64ff3110
--- /dev/null
+++ b/src/component/utils/keyboards/novnc/keyboard.js
@@ -0,0 +1,293 @@
+/*
+ * noVNC: HTML5 VNC client
+ * Copyright (C) 2019 The noVNC Authors
+ * Licensed under MPL 2.0 or any later version (see LICENSE.txt)
+ */
+
+import * as KeyboardUtil from "./util.js";
+import KeyTable from "./keysym.js";
+import * as browser from "./browser.js";
+
+//
+// Keyboard event handler
+//
+
+function stopEvent(e) {
+  e.stopPropagation();
+  e.preventDefault();
+}
+
+export default class Keyboard {
+    constructor(target) {
+        this._target = target || null;
+
+        this._keyDownList = {};         // List of depressed keys
+                                        // (even if they are happy)
+        this._altGrArmed = false;       // Windows AltGr detection
+
+        // keep these here so we can refer to them later
+        this._eventHandlers = {
+            'keyup': this._handleKeyUp.bind(this),
+            'keydown': this._handleKeyDown.bind(this),
+            'blur': this._allKeysUp.bind(this),
+        };
+
+        // ===== EVENT HANDLERS =====
+
+        this.onkeyevent = () => {}; // Handler for key press/release
+    }
+
+    // ===== PRIVATE METHODS =====
+
+    _sendKeyEvent(keysym, code, down) {
+        if (down) {
+            this._keyDownList[code] = keysym;
+        } else {
+            // Do we really think this key is down?
+            if (!(code in this._keyDownList)) {
+                return;
+            }
+            delete this._keyDownList[code];
+        }
+
+        //console.debug("onkeyevent " + (down ? "down" : "up") +
+        //          ", keysym: " + keysym, ", code: " + code);
+        //20220924: NEKO: Return a value.
+        return this.onkeyevent(keysym, code, down);
+    }
+
+    _getKeyCode(e) {
+        const code = KeyboardUtil.getKeycode(e);
+        if (code !== 'Unidentified') {
+            return code;
+        }
+
+        // Unstable, but we don't have anything else to go on
+        if (e.keyCode) {
+            // 229 is used for composition events
+            if (e.keyCode !== 229) {
+                return 'Platform' + e.keyCode;
+            }
+        }
+
+        // A precursor to the final DOM3 standard. Unfortunately it
+        // is not layout independent, so it is as bad as using keyCode
+        if (e.keyIdentifier) {
+            // Non-character key?
+            if (e.keyIdentifier.substr(0, 2) !== 'U+') {
+                return e.keyIdentifier;
+            }
+
+            const codepoint = parseInt(e.keyIdentifier.substr(2), 16);
+            const char = String.fromCharCode(codepoint).toUpperCase();
+
+            return 'Platform' + char.charCodeAt();
+        }
+
+        return 'Unidentified';
+    }
+
+    _handleKeyDown(e) {
+        const code = this._getKeyCode(e);
+        let keysym = KeyboardUtil.getKeysym(e);
+
+        // Windows doesn't have a proper AltGr, but handles it using
+        // fake Ctrl+Alt. However the remote end might not be Windows,
+        // so we need to merge those in to a single AltGr event. We
+        // detect this case by seeing the two key events directly after
+        // each other with a very short time between them (<50ms).
+        if (this._altGrArmed) {
+            this._altGrArmed = false;
+            clearTimeout(this._altGrTimeout);
+
+            if ((code === "AltRight") &&
+                ((e.timeStamp - this._altGrCtrlTime) < 50)) {
+                // FIXME: We fail to detect this if either Ctrl key is
+                //        first manually pressed as Windows then no
+                //        longer sends the fake Ctrl down event. It
+                //        does however happily send real Ctrl events
+                //        even when AltGr is already down. Some
+                //        browsers detect this for us though and set the
+                //        key to "AltGraph".
+                keysym = KeyTable.XK_ISO_Level3_Shift;
+            } else {
+                this._sendKeyEvent(KeyTable.XK_Control_L, "ControlLeft", true);
+            }
+        }
+
+        // We cannot handle keys we cannot track, but we also need
+        // to deal with virtual keyboards which omit key info
+        if (code === 'Unidentified') {
+            if (keysym) {
+                // If it's a virtual keyboard then it should be
+                // sufficient to just send press and release right
+                // after each other
+                this._sendKeyEvent(keysym, code, true);
+                this._sendKeyEvent(keysym, code, false);
+            }
+
+            stopEvent(e);
+            return;
+        }
+
+        if (browser.isMac() || browser.isIOS()) {
+          // If a key is pressed while meta is held down, the keyup will
+          // never be sent in Chrome (bug #108404) and possibly others
+          if (e.metaKey && keysym !== KeyTable.XK_Super_L && keysym !== KeyTable.XK_Super_R) {
+              //20220927: NEKO: Stop propagation only if wanted.
+              let propagation = this._sendKeyEvent(keysym, code, true);
+              this._sendKeyEvent(keysym, code, false);
+              //20220927: NEKO: Stop propagation only if wanted.
+              if (!propagation) stopEvent(e);
+              return;
+          }
+
+          // Alt behaves more like AltGraph on macOS, so shuffle the
+          // keys around a bit to make things more sane for the remote
+          // server. This method is used by RealVNC and TigerVNC (and
+          // possibly others).
+          switch (keysym) {
+              //20220927: NEKO: Do not hijack CMD keys.
+              //case KeyTable.XK_Super_L:
+              //    keysym = KeyTable.XK_Alt_L;
+              //    break;
+              //case KeyTable.XK_Super_R:
+              //    keysym = KeyTable.XK_Super_L;
+              //    break;
+              case KeyTable.XK_Alt_L:
+                  keysym = KeyTable.XK_Mode_switch;
+                  break;
+              case KeyTable.XK_Alt_R:
+                  keysym = KeyTable.XK_ISO_Level3_Shift;
+                  break;
+          }
+        }
+
+        // Is this key already pressed? If so, then we must use the
+        // same keysym or we'll confuse the server
+        if (code in this._keyDownList) {
+            keysym = this._keyDownList[code];
+        }
+
+        // macOS doesn't send proper key events for modifiers, only
+        // state change events. That gets extra confusing for CapsLock
+        // which toggles on each press, but not on release. So pretend
+        // it was a quick press and release of the button.
+        if ((browser.isMac() || browser.isIOS()) && (code === 'CapsLock')) {
+            this._sendKeyEvent(KeyTable.XK_Caps_Lock, 'CapsLock', true);
+            this._sendKeyEvent(KeyTable.XK_Caps_Lock, 'CapsLock', false);
+            stopEvent(e);
+            return;
+        }
+
+        // Windows doesn't send proper key releases for a bunch of
+        // Japanese IM keys so we have to fake the release right away
+        const jpBadKeys = [ KeyTable.XK_Zenkaku_Hankaku,
+                            KeyTable.XK_Eisu_toggle,
+                            KeyTable.XK_Katakana,
+                            KeyTable.XK_Hiragana,
+                            KeyTable.XK_Romaji ];
+        if (browser.isWindows() && jpBadKeys.includes(keysym)) {
+            this._sendKeyEvent(keysym, code, true);
+            this._sendKeyEvent(keysym, code, false);
+            stopEvent(e);
+            return;
+        }
+
+        //20220924: NEKO: Do not stop propagation.
+        //stopEvent(e);
+
+        // Possible start of AltGr sequence? (see above)
+        if ((code === "ControlLeft") && browser.isWindows() &&
+            !("ControlLeft" in this._keyDownList)) {
+            this._altGrArmed = true;
+            this._altGrTimeout = setTimeout(this._handleAltGrTimeout.bind(this), 100);
+            this._altGrCtrlTime = e.timeStamp;
+            return;
+        }
+
+        //20220924: NEKO: Stop propagation only if wanted.
+        if(!this._sendKeyEvent(keysym, code, true)) {
+          stopEvent(e);
+        }
+    }
+
+    _handleKeyUp(e) {
+        stopEvent(e);
+
+        const code = this._getKeyCode(e);
+
+        // We can't get a release in the middle of an AltGr sequence, so
+        // abort that detection
+        if (this._altGrArmed) {
+            this._altGrArmed = false;
+            clearTimeout(this._altGrTimeout);
+            this._sendKeyEvent(KeyTable.XK_Control_L, "ControlLeft", true);
+        }
+
+        // See comment in _handleKeyDown()
+        if ((browser.isMac() || browser.isIOS()) && (code === 'CapsLock')) {
+            this._sendKeyEvent(KeyTable.XK_Caps_Lock, 'CapsLock', true);
+            this._sendKeyEvent(KeyTable.XK_Caps_Lock, 'CapsLock', false);
+            return;
+        }
+
+        this._sendKeyEvent(this._keyDownList[code], code, false);
+
+        // Windows has a rather nasty bug where it won't send key
+        // release events for a Shift button if the other Shift is still
+        // pressed
+        if (browser.isWindows() && ((code === 'ShiftLeft') ||
+                                    (code === 'ShiftRight'))) {
+            if ('ShiftRight' in this._keyDownList) {
+                this._sendKeyEvent(this._keyDownList['ShiftRight'],
+                                   'ShiftRight', false);
+            }
+            if ('ShiftLeft' in this._keyDownList) {
+                this._sendKeyEvent(this._keyDownList['ShiftLeft'],
+                                   'ShiftLeft', false);
+            }
+        }
+    }
+
+    _handleAltGrTimeout() {
+        this._altGrArmed = false;
+        clearTimeout(this._altGrTimeout);
+        this._sendKeyEvent(KeyTable.XK_Control_L, "ControlLeft", true);
+    }
+
+    _allKeysUp() {
+        //console.debug(">> Keyboard.allKeysUp");
+        for (let code in this._keyDownList) {
+            this._sendKeyEvent(this._keyDownList[code], code, false);
+        }
+        //console.debug("<< Keyboard.allKeysUp");
+    }
+
+    // ===== PUBLIC METHODS =====
+
+    grab() {
+        //console.debug(">> Keyboard.grab");
+
+        this._target.addEventListener('keydown', this._eventHandlers.keydown);
+        this._target.addEventListener('keyup', this._eventHandlers.keyup);
+
+        // Release (key up) if window loses focus
+        window.addEventListener('blur', this._eventHandlers.blur);
+
+        //console.debug("<< Keyboard.grab");
+    }
+
+    ungrab() {
+        //console.debug(">> Keyboard.ungrab");
+
+        this._target.removeEventListener('keydown', this._eventHandlers.keydown);
+        this._target.removeEventListener('keyup', this._eventHandlers.keyup);
+        window.removeEventListener('blur', this._eventHandlers.blur);
+
+        // Release (key up) all keys that are in a down state
+        this._allKeysUp();
+
+        //console.debug(">> Keyboard.ungrab");
+    }
+}
diff --git a/src/component/utils/keyboards/novnc/keysym.js b/src/component/utils/keyboards/novnc/keysym.js
new file mode 100644
index 00000000..22ba0584
--- /dev/null
+++ b/src/component/utils/keyboards/novnc/keysym.js
@@ -0,0 +1,616 @@
+/* eslint-disable key-spacing */
+
+export default {
+    XK_VoidSymbol:                  0xffffff, /* Void symbol */
+
+    XK_BackSpace:                   0xff08, /* Back space, back char */
+    XK_Tab:                         0xff09,
+    XK_Linefeed:                    0xff0a, /* Linefeed, LF */
+    XK_Clear:                       0xff0b,
+    XK_Return:                      0xff0d, /* Return, enter */
+    XK_Pause:                       0xff13, /* Pause, hold */
+    XK_Scroll_Lock:                 0xff14,
+    XK_Sys_Req:                     0xff15,
+    XK_Escape:                      0xff1b,
+    XK_Delete:                      0xffff, /* Delete, rubout */
+
+    /* International & multi-key character composition */
+
+    XK_Multi_key:                   0xff20, /* Multi-key character compose */
+    XK_Codeinput:                   0xff37,
+    XK_SingleCandidate:             0xff3c,
+    XK_MultipleCandidate:           0xff3d,
+    XK_PreviousCandidate:           0xff3e,
+
+    /* Japanese keyboard support */
+
+    XK_Kanji:                       0xff21, /* Kanji, Kanji convert */
+    XK_Muhenkan:                    0xff22, /* Cancel Conversion */
+    XK_Henkan_Mode:                 0xff23, /* Start/Stop Conversion */
+    XK_Henkan:                      0xff23, /* Alias for Henkan_Mode */
+    XK_Romaji:                      0xff24, /* to Romaji */
+    XK_Hiragana:                    0xff25, /* to Hiragana */
+    XK_Katakana:                    0xff26, /* to Katakana */
+    XK_Hiragana_Katakana:           0xff27, /* Hiragana/Katakana toggle */
+    XK_Zenkaku:                     0xff28, /* to Zenkaku */
+    XK_Hankaku:                     0xff29, /* to Hankaku */
+    XK_Zenkaku_Hankaku:             0xff2a, /* Zenkaku/Hankaku toggle */
+    XK_Touroku:                     0xff2b, /* Add to Dictionary */
+    XK_Massyo:                      0xff2c, /* Delete from Dictionary */
+    XK_Kana_Lock:                   0xff2d, /* Kana Lock */
+    XK_Kana_Shift:                  0xff2e, /* Kana Shift */
+    XK_Eisu_Shift:                  0xff2f, /* Alphanumeric Shift */
+    XK_Eisu_toggle:                 0xff30, /* Alphanumeric toggle */
+    XK_Kanji_Bangou:                0xff37, /* Codeinput */
+    XK_Zen_Koho:                    0xff3d, /* Multiple/All Candidate(s) */
+    XK_Mae_Koho:                    0xff3e, /* Previous Candidate */
+
+    /* Cursor control & motion */
+
+    XK_Home:                        0xff50,
+    XK_Left:                        0xff51, /* Move left, left arrow */
+    XK_Up:                          0xff52, /* Move up, up arrow */
+    XK_Right:                       0xff53, /* Move right, right arrow */
+    XK_Down:                        0xff54, /* Move down, down arrow */
+    XK_Prior:                       0xff55, /* Prior, previous */
+    XK_Page_Up:                     0xff55,
+    XK_Next:                        0xff56, /* Next */
+    XK_Page_Down:                   0xff56,
+    XK_End:                         0xff57, /* EOL */
+    XK_Begin:                       0xff58, /* BOL */
+
+
+    /* Misc functions */
+
+    XK_Select:                      0xff60, /* Select, mark */
+    XK_Print:                       0xff61,
+    XK_Execute:                     0xff62, /* Execute, run, do */
+    XK_Insert:                      0xff63, /* Insert, insert here */
+    XK_Undo:                        0xff65,
+    XK_Redo:                        0xff66, /* Redo, again */
+    XK_Menu:                        0xff67,
+    XK_Find:                        0xff68, /* Find, search */
+    XK_Cancel:                      0xff69, /* Cancel, stop, abort, exit */
+    XK_Help:                        0xff6a, /* Help */
+    XK_Break:                       0xff6b,
+    XK_Mode_switch:                 0xff7e, /* Character set switch */
+    XK_script_switch:               0xff7e, /* Alias for mode_switch */
+    XK_Num_Lock:                    0xff7f,
+
+    /* Keypad functions, keypad numbers cleverly chosen to map to ASCII */
+
+    XK_KP_Space:                    0xff80, /* Space */
+    XK_KP_Tab:                      0xff89,
+    XK_KP_Enter:                    0xff8d, /* Enter */
+    XK_KP_F1:                       0xff91, /* PF1, KP_A, ... */
+    XK_KP_F2:                       0xff92,
+    XK_KP_F3:                       0xff93,
+    XK_KP_F4:                       0xff94,
+    XK_KP_Home:                     0xff95,
+    XK_KP_Left:                     0xff96,
+    XK_KP_Up:                       0xff97,
+    XK_KP_Right:                    0xff98,
+    XK_KP_Down:                     0xff99,
+    XK_KP_Prior:                    0xff9a,
+    XK_KP_Page_Up:                  0xff9a,
+    XK_KP_Next:                     0xff9b,
+    XK_KP_Page_Down:                0xff9b,
+    XK_KP_End:                      0xff9c,
+    XK_KP_Begin:                    0xff9d,
+    XK_KP_Insert:                   0xff9e,
+    XK_KP_Delete:                   0xff9f,
+    XK_KP_Equal:                    0xffbd, /* Equals */
+    XK_KP_Multiply:                 0xffaa,
+    XK_KP_Add:                      0xffab,
+    XK_KP_Separator:                0xffac, /* Separator, often comma */
+    XK_KP_Subtract:                 0xffad,
+    XK_KP_Decimal:                  0xffae,
+    XK_KP_Divide:                   0xffaf,
+
+    XK_KP_0:                        0xffb0,
+    XK_KP_1:                        0xffb1,
+    XK_KP_2:                        0xffb2,
+    XK_KP_3:                        0xffb3,
+    XK_KP_4:                        0xffb4,
+    XK_KP_5:                        0xffb5,
+    XK_KP_6:                        0xffb6,
+    XK_KP_7:                        0xffb7,
+    XK_KP_8:                        0xffb8,
+    XK_KP_9:                        0xffb9,
+
+    /*
+     * Auxiliary functions; note the duplicate definitions for left and right
+     * function keys;  Sun keyboards and a few other manufacturers have such
+     * function key groups on the left and/or right sides of the keyboard.
+     * We've not found a keyboard with more than 35 function keys total.
+     */
+
+    XK_F1:                          0xffbe,
+    XK_F2:                          0xffbf,
+    XK_F3:                          0xffc0,
+    XK_F4:                          0xffc1,
+    XK_F5:                          0xffc2,
+    XK_F6:                          0xffc3,
+    XK_F7:                          0xffc4,
+    XK_F8:                          0xffc5,
+    XK_F9:                          0xffc6,
+    XK_F10:                         0xffc7,
+    XK_F11:                         0xffc8,
+    XK_L1:                          0xffc8,
+    XK_F12:                         0xffc9,
+    XK_L2:                          0xffc9,
+    XK_F13:                         0xffca,
+    XK_L3:                          0xffca,
+    XK_F14:                         0xffcb,
+    XK_L4:                          0xffcb,
+    XK_F15:                         0xffcc,
+    XK_L5:                          0xffcc,
+    XK_F16:                         0xffcd,
+    XK_L6:                          0xffcd,
+    XK_F17:                         0xffce,
+    XK_L7:                          0xffce,
+    XK_F18:                         0xffcf,
+    XK_L8:                          0xffcf,
+    XK_F19:                         0xffd0,
+    XK_L9:                          0xffd0,
+    XK_F20:                         0xffd1,
+    XK_L10:                         0xffd1,
+    XK_F21:                         0xffd2,
+    XK_R1:                          0xffd2,
+    XK_F22:                         0xffd3,
+    XK_R2:                          0xffd3,
+    XK_F23:                         0xffd4,
+    XK_R3:                          0xffd4,
+    XK_F24:                         0xffd5,
+    XK_R4:                          0xffd5,
+    XK_F25:                         0xffd6,
+    XK_R5:                          0xffd6,
+    XK_F26:                         0xffd7,
+    XK_R6:                          0xffd7,
+    XK_F27:                         0xffd8,
+    XK_R7:                          0xffd8,
+    XK_F28:                         0xffd9,
+    XK_R8:                          0xffd9,
+    XK_F29:                         0xffda,
+    XK_R9:                          0xffda,
+    XK_F30:                         0xffdb,
+    XK_R10:                         0xffdb,
+    XK_F31:                         0xffdc,
+    XK_R11:                         0xffdc,
+    XK_F32:                         0xffdd,
+    XK_R12:                         0xffdd,
+    XK_F33:                         0xffde,
+    XK_R13:                         0xffde,
+    XK_F34:                         0xffdf,
+    XK_R14:                         0xffdf,
+    XK_F35:                         0xffe0,
+    XK_R15:                         0xffe0,
+
+    /* Modifiers */
+
+    XK_Shift_L:                     0xffe1, /* Left shift */
+    XK_Shift_R:                     0xffe2, /* Right shift */
+    XK_Control_L:                   0xffe3, /* Left control */
+    XK_Control_R:                   0xffe4, /* Right control */
+    XK_Caps_Lock:                   0xffe5, /* Caps lock */
+    XK_Shift_Lock:                  0xffe6, /* Shift lock */
+
+    XK_Meta_L:                      0xffe7, /* Left meta */
+    XK_Meta_R:                      0xffe8, /* Right meta */
+    XK_Alt_L:                       0xffe9, /* Left alt */
+    XK_Alt_R:                       0xffea, /* Right alt */
+    XK_Super_L:                     0xffeb, /* Left super */
+    XK_Super_R:                     0xffec, /* Right super */
+    XK_Hyper_L:                     0xffed, /* Left hyper */
+    XK_Hyper_R:                     0xffee, /* Right hyper */
+
+    /*
+     * Keyboard (XKB) Extension function and modifier keys
+     * (from Appendix C of "The X Keyboard Extension: Protocol Specification")
+     * Byte 3 = 0xfe
+     */
+
+    XK_ISO_Level3_Shift:            0xfe03, /* AltGr */
+    XK_ISO_Next_Group:              0xfe08,
+    XK_ISO_Prev_Group:              0xfe0a,
+    XK_ISO_First_Group:             0xfe0c,
+    XK_ISO_Last_Group:              0xfe0e,
+
+    /*
+     * Latin 1
+     * (ISO/IEC 8859-1: Unicode U+0020..U+00FF)
+     * Byte 3: 0
+     */
+
+    XK_space:                       0x0020, /* U+0020 SPACE */
+    XK_exclam:                      0x0021, /* U+0021 EXCLAMATION MARK */
+    XK_quotedbl:                    0x0022, /* U+0022 QUOTATION MARK */
+    XK_numbersign:                  0x0023, /* U+0023 NUMBER SIGN */
+    XK_dollar:                      0x0024, /* U+0024 DOLLAR SIGN */
+    XK_percent:                     0x0025, /* U+0025 PERCENT SIGN */
+    XK_ampersand:                   0x0026, /* U+0026 AMPERSAND */
+    XK_apostrophe:                  0x0027, /* U+0027 APOSTROPHE */
+    XK_quoteright:                  0x0027, /* deprecated */
+    XK_parenleft:                   0x0028, /* U+0028 LEFT PARENTHESIS */
+    XK_parenright:                  0x0029, /* U+0029 RIGHT PARENTHESIS */
+    XK_asterisk:                    0x002a, /* U+002A ASTERISK */
+    XK_plus:                        0x002b, /* U+002B PLUS SIGN */
+    XK_comma:                       0x002c, /* U+002C COMMA */
+    XK_minus:                       0x002d, /* U+002D HYPHEN-MINUS */
+    XK_period:                      0x002e, /* U+002E FULL STOP */
+    XK_slash:                       0x002f, /* U+002F SOLIDUS */
+    XK_0:                           0x0030, /* U+0030 DIGIT ZERO */
+    XK_1:                           0x0031, /* U+0031 DIGIT ONE */
+    XK_2:                           0x0032, /* U+0032 DIGIT TWO */
+    XK_3:                           0x0033, /* U+0033 DIGIT THREE */
+    XK_4:                           0x0034, /* U+0034 DIGIT FOUR */
+    XK_5:                           0x0035, /* U+0035 DIGIT FIVE */
+    XK_6:                           0x0036, /* U+0036 DIGIT SIX */
+    XK_7:                           0x0037, /* U+0037 DIGIT SEVEN */
+    XK_8:                           0x0038, /* U+0038 DIGIT EIGHT */
+    XK_9:                           0x0039, /* U+0039 DIGIT NINE */
+    XK_colon:                       0x003a, /* U+003A COLON */
+    XK_semicolon:                   0x003b, /* U+003B SEMICOLON */
+    XK_less:                        0x003c, /* U+003C LESS-THAN SIGN */
+    XK_equal:                       0x003d, /* U+003D EQUALS SIGN */
+    XK_greater:                     0x003e, /* U+003E GREATER-THAN SIGN */
+    XK_question:                    0x003f, /* U+003F QUESTION MARK */
+    XK_at:                          0x0040, /* U+0040 COMMERCIAL AT */
+    XK_A:                           0x0041, /* U+0041 LATIN CAPITAL LETTER A */
+    XK_B:                           0x0042, /* U+0042 LATIN CAPITAL LETTER B */
+    XK_C:                           0x0043, /* U+0043 LATIN CAPITAL LETTER C */
+    XK_D:                           0x0044, /* U+0044 LATIN CAPITAL LETTER D */
+    XK_E:                           0x0045, /* U+0045 LATIN CAPITAL LETTER E */
+    XK_F:                           0x0046, /* U+0046 LATIN CAPITAL LETTER F */
+    XK_G:                           0x0047, /* U+0047 LATIN CAPITAL LETTER G */
+    XK_H:                           0x0048, /* U+0048 LATIN CAPITAL LETTER H */
+    XK_I:                           0x0049, /* U+0049 LATIN CAPITAL LETTER I */
+    XK_J:                           0x004a, /* U+004A LATIN CAPITAL LETTER J */
+    XK_K:                           0x004b, /* U+004B LATIN CAPITAL LETTER K */
+    XK_L:                           0x004c, /* U+004C LATIN CAPITAL LETTER L */
+    XK_M:                           0x004d, /* U+004D LATIN CAPITAL LETTER M */
+    XK_N:                           0x004e, /* U+004E LATIN CAPITAL LETTER N */
+    XK_O:                           0x004f, /* U+004F LATIN CAPITAL LETTER O */
+    XK_P:                           0x0050, /* U+0050 LATIN CAPITAL LETTER P */
+    XK_Q:                           0x0051, /* U+0051 LATIN CAPITAL LETTER Q */
+    XK_R:                           0x0052, /* U+0052 LATIN CAPITAL LETTER R */
+    XK_S:                           0x0053, /* U+0053 LATIN CAPITAL LETTER S */
+    XK_T:                           0x0054, /* U+0054 LATIN CAPITAL LETTER T */
+    XK_U:                           0x0055, /* U+0055 LATIN CAPITAL LETTER U */
+    XK_V:                           0x0056, /* U+0056 LATIN CAPITAL LETTER V */
+    XK_W:                           0x0057, /* U+0057 LATIN CAPITAL LETTER W */
+    XK_X:                           0x0058, /* U+0058 LATIN CAPITAL LETTER X */
+    XK_Y:                           0x0059, /* U+0059 LATIN CAPITAL LETTER Y */
+    XK_Z:                           0x005a, /* U+005A LATIN CAPITAL LETTER Z */
+    XK_bracketleft:                 0x005b, /* U+005B LEFT SQUARE BRACKET */
+    XK_backslash:                   0x005c, /* U+005C REVERSE SOLIDUS */
+    XK_bracketright:                0x005d, /* U+005D RIGHT SQUARE BRACKET */
+    XK_asciicircum:                 0x005e, /* U+005E CIRCUMFLEX ACCENT */
+    XK_underscore:                  0x005f, /* U+005F LOW LINE */
+    XK_grave:                       0x0060, /* U+0060 GRAVE ACCENT */
+    XK_quoteleft:                   0x0060, /* deprecated */
+    XK_a:                           0x0061, /* U+0061 LATIN SMALL LETTER A */
+    XK_b:                           0x0062, /* U+0062 LATIN SMALL LETTER B */
+    XK_c:                           0x0063, /* U+0063 LATIN SMALL LETTER C */
+    XK_d:                           0x0064, /* U+0064 LATIN SMALL LETTER D */
+    XK_e:                           0x0065, /* U+0065 LATIN SMALL LETTER E */
+    XK_f:                           0x0066, /* U+0066 LATIN SMALL LETTER F */
+    XK_g:                           0x0067, /* U+0067 LATIN SMALL LETTER G */
+    XK_h:                           0x0068, /* U+0068 LATIN SMALL LETTER H */
+    XK_i:                           0x0069, /* U+0069 LATIN SMALL LETTER I */
+    XK_j:                           0x006a, /* U+006A LATIN SMALL LETTER J */
+    XK_k:                           0x006b, /* U+006B LATIN SMALL LETTER K */
+    XK_l:                           0x006c, /* U+006C LATIN SMALL LETTER L */
+    XK_m:                           0x006d, /* U+006D LATIN SMALL LETTER M */
+    XK_n:                           0x006e, /* U+006E LATIN SMALL LETTER N */
+    XK_o:                           0x006f, /* U+006F LATIN SMALL LETTER O */
+    XK_p:                           0x0070, /* U+0070 LATIN SMALL LETTER P */
+    XK_q:                           0x0071, /* U+0071 LATIN SMALL LETTER Q */
+    XK_r:                           0x0072, /* U+0072 LATIN SMALL LETTER R */
+    XK_s:                           0x0073, /* U+0073 LATIN SMALL LETTER S */
+    XK_t:                           0x0074, /* U+0074 LATIN SMALL LETTER T */
+    XK_u:                           0x0075, /* U+0075 LATIN SMALL LETTER U */
+    XK_v:                           0x0076, /* U+0076 LATIN SMALL LETTER V */
+    XK_w:                           0x0077, /* U+0077 LATIN SMALL LETTER W */
+    XK_x:                           0x0078, /* U+0078 LATIN SMALL LETTER X */
+    XK_y:                           0x0079, /* U+0079 LATIN SMALL LETTER Y */
+    XK_z:                           0x007a, /* U+007A LATIN SMALL LETTER Z */
+    XK_braceleft:                   0x007b, /* U+007B LEFT CURLY BRACKET */
+    XK_bar:                         0x007c, /* U+007C VERTICAL LINE */
+    XK_braceright:                  0x007d, /* U+007D RIGHT CURLY BRACKET */
+    XK_asciitilde:                  0x007e, /* U+007E TILDE */
+
+    XK_nobreakspace:                0x00a0, /* U+00A0 NO-BREAK SPACE */
+    XK_exclamdown:                  0x00a1, /* U+00A1 INVERTED EXCLAMATION MARK */
+    XK_cent:                        0x00a2, /* U+00A2 CENT SIGN */
+    XK_sterling:                    0x00a3, /* U+00A3 POUND SIGN */
+    XK_currency:                    0x00a4, /* U+00A4 CURRENCY SIGN */
+    XK_yen:                         0x00a5, /* U+00A5 YEN SIGN */
+    XK_brokenbar:                   0x00a6, /* U+00A6 BROKEN BAR */
+    XK_section:                     0x00a7, /* U+00A7 SECTION SIGN */
+    XK_diaeresis:                   0x00a8, /* U+00A8 DIAERESIS */
+    XK_copyright:                   0x00a9, /* U+00A9 COPYRIGHT SIGN */
+    XK_ordfeminine:                 0x00aa, /* U+00AA FEMININE ORDINAL INDICATOR */
+    XK_guillemotleft:               0x00ab, /* U+00AB LEFT-POINTING DOUBLE ANGLE QUOTATION MARK */
+    XK_notsign:                     0x00ac, /* U+00AC NOT SIGN */
+    XK_hyphen:                      0x00ad, /* U+00AD SOFT HYPHEN */
+    XK_registered:                  0x00ae, /* U+00AE REGISTERED SIGN */
+    XK_macron:                      0x00af, /* U+00AF MACRON */
+    XK_degree:                      0x00b0, /* U+00B0 DEGREE SIGN */
+    XK_plusminus:                   0x00b1, /* U+00B1 PLUS-MINUS SIGN */
+    XK_twosuperior:                 0x00b2, /* U+00B2 SUPERSCRIPT TWO */
+    XK_threesuperior:               0x00b3, /* U+00B3 SUPERSCRIPT THREE */
+    XK_acute:                       0x00b4, /* U+00B4 ACUTE ACCENT */
+    XK_mu:                          0x00b5, /* U+00B5 MICRO SIGN */
+    XK_paragraph:                   0x00b6, /* U+00B6 PILCROW SIGN */
+    XK_periodcentered:              0x00b7, /* U+00B7 MIDDLE DOT */
+    XK_cedilla:                     0x00b8, /* U+00B8 CEDILLA */
+    XK_onesuperior:                 0x00b9, /* U+00B9 SUPERSCRIPT ONE */
+    XK_masculine:                   0x00ba, /* U+00BA MASCULINE ORDINAL INDICATOR */
+    XK_guillemotright:              0x00bb, /* U+00BB RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK */
+    XK_onequarter:                  0x00bc, /* U+00BC VULGAR FRACTION ONE QUARTER */
+    XK_onehalf:                     0x00bd, /* U+00BD VULGAR FRACTION ONE HALF */
+    XK_threequarters:               0x00be, /* U+00BE VULGAR FRACTION THREE QUARTERS */
+    XK_questiondown:                0x00bf, /* U+00BF INVERTED QUESTION MARK */
+    XK_Agrave:                      0x00c0, /* U+00C0 LATIN CAPITAL LETTER A WITH GRAVE */
+    XK_Aacute:                      0x00c1, /* U+00C1 LATIN CAPITAL LETTER A WITH ACUTE */
+    XK_Acircumflex:                 0x00c2, /* U+00C2 LATIN CAPITAL LETTER A WITH CIRCUMFLEX */
+    XK_Atilde:                      0x00c3, /* U+00C3 LATIN CAPITAL LETTER A WITH TILDE */
+    XK_Adiaeresis:                  0x00c4, /* U+00C4 LATIN CAPITAL LETTER A WITH DIAERESIS */
+    XK_Aring:                       0x00c5, /* U+00C5 LATIN CAPITAL LETTER A WITH RING ABOVE */
+    XK_AE:                          0x00c6, /* U+00C6 LATIN CAPITAL LETTER AE */
+    XK_Ccedilla:                    0x00c7, /* U+00C7 LATIN CAPITAL LETTER C WITH CEDILLA */
+    XK_Egrave:                      0x00c8, /* U+00C8 LATIN CAPITAL LETTER E WITH GRAVE */
+    XK_Eacute:                      0x00c9, /* U+00C9 LATIN CAPITAL LETTER E WITH ACUTE */
+    XK_Ecircumflex:                 0x00ca, /* U+00CA LATIN CAPITAL LETTER E WITH CIRCUMFLEX */
+    XK_Ediaeresis:                  0x00cb, /* U+00CB LATIN CAPITAL LETTER E WITH DIAERESIS */
+    XK_Igrave:                      0x00cc, /* U+00CC LATIN CAPITAL LETTER I WITH GRAVE */
+    XK_Iacute:                      0x00cd, /* U+00CD LATIN CAPITAL LETTER I WITH ACUTE */
+    XK_Icircumflex:                 0x00ce, /* U+00CE LATIN CAPITAL LETTER I WITH CIRCUMFLEX */
+    XK_Idiaeresis:                  0x00cf, /* U+00CF LATIN CAPITAL LETTER I WITH DIAERESIS */
+    XK_ETH:                         0x00d0, /* U+00D0 LATIN CAPITAL LETTER ETH */
+    XK_Eth:                         0x00d0, /* deprecated */
+    XK_Ntilde:                      0x00d1, /* U+00D1 LATIN CAPITAL LETTER N WITH TILDE */
+    XK_Ograve:                      0x00d2, /* U+00D2 LATIN CAPITAL LETTER O WITH GRAVE */
+    XK_Oacute:                      0x00d3, /* U+00D3 LATIN CAPITAL LETTER O WITH ACUTE */
+    XK_Ocircumflex:                 0x00d4, /* U+00D4 LATIN CAPITAL LETTER O WITH CIRCUMFLEX */
+    XK_Otilde:                      0x00d5, /* U+00D5 LATIN CAPITAL LETTER O WITH TILDE */
+    XK_Odiaeresis:                  0x00d6, /* U+00D6 LATIN CAPITAL LETTER O WITH DIAERESIS */
+    XK_multiply:                    0x00d7, /* U+00D7 MULTIPLICATION SIGN */
+    XK_Oslash:                      0x00d8, /* U+00D8 LATIN CAPITAL LETTER O WITH STROKE */
+    XK_Ooblique:                    0x00d8, /* U+00D8 LATIN CAPITAL LETTER O WITH STROKE */
+    XK_Ugrave:                      0x00d9, /* U+00D9 LATIN CAPITAL LETTER U WITH GRAVE */
+    XK_Uacute:                      0x00da, /* U+00DA LATIN CAPITAL LETTER U WITH ACUTE */
+    XK_Ucircumflex:                 0x00db, /* U+00DB LATIN CAPITAL LETTER U WITH CIRCUMFLEX */
+    XK_Udiaeresis:                  0x00dc, /* U+00DC LATIN CAPITAL LETTER U WITH DIAERESIS */
+    XK_Yacute:                      0x00dd, /* U+00DD LATIN CAPITAL LETTER Y WITH ACUTE */
+    XK_THORN:                       0x00de, /* U+00DE LATIN CAPITAL LETTER THORN */
+    XK_Thorn:                       0x00de, /* deprecated */
+    XK_ssharp:                      0x00df, /* U+00DF LATIN SMALL LETTER SHARP S */
+    XK_agrave:                      0x00e0, /* U+00E0 LATIN SMALL LETTER A WITH GRAVE */
+    XK_aacute:                      0x00e1, /* U+00E1 LATIN SMALL LETTER A WITH ACUTE */
+    XK_acircumflex:                 0x00e2, /* U+00E2 LATIN SMALL LETTER A WITH CIRCUMFLEX */
+    XK_atilde:                      0x00e3, /* U+00E3 LATIN SMALL LETTER A WITH TILDE */
+    XK_adiaeresis:                  0x00e4, /* U+00E4 LATIN SMALL LETTER A WITH DIAERESIS */
+    XK_aring:                       0x00e5, /* U+00E5 LATIN SMALL LETTER A WITH RING ABOVE */
+    XK_ae:                          0x00e6, /* U+00E6 LATIN SMALL LETTER AE */
+    XK_ccedilla:                    0x00e7, /* U+00E7 LATIN SMALL LETTER C WITH CEDILLA */
+    XK_egrave:                      0x00e8, /* U+00E8 LATIN SMALL LETTER E WITH GRAVE */
+    XK_eacute:                      0x00e9, /* U+00E9 LATIN SMALL LETTER E WITH ACUTE */
+    XK_ecircumflex:                 0x00ea, /* U+00EA LATIN SMALL LETTER E WITH CIRCUMFLEX */
+    XK_ediaeresis:                  0x00eb, /* U+00EB LATIN SMALL LETTER E WITH DIAERESIS */
+    XK_igrave:                      0x00ec, /* U+00EC LATIN SMALL LETTER I WITH GRAVE */
+    XK_iacute:                      0x00ed, /* U+00ED LATIN SMALL LETTER I WITH ACUTE */
+    XK_icircumflex:                 0x00ee, /* U+00EE LATIN SMALL LETTER I WITH CIRCUMFLEX */
+    XK_idiaeresis:                  0x00ef, /* U+00EF LATIN SMALL LETTER I WITH DIAERESIS */
+    XK_eth:                         0x00f0, /* U+00F0 LATIN SMALL LETTER ETH */
+    XK_ntilde:                      0x00f1, /* U+00F1 LATIN SMALL LETTER N WITH TILDE */
+    XK_ograve:                      0x00f2, /* U+00F2 LATIN SMALL LETTER O WITH GRAVE */
+    XK_oacute:                      0x00f3, /* U+00F3 LATIN SMALL LETTER O WITH ACUTE */
+    XK_ocircumflex:                 0x00f4, /* U+00F4 LATIN SMALL LETTER O WITH CIRCUMFLEX */
+    XK_otilde:                      0x00f5, /* U+00F5 LATIN SMALL LETTER O WITH TILDE */
+    XK_odiaeresis:                  0x00f6, /* U+00F6 LATIN SMALL LETTER O WITH DIAERESIS */
+    XK_division:                    0x00f7, /* U+00F7 DIVISION SIGN */
+    XK_oslash:                      0x00f8, /* U+00F8 LATIN SMALL LETTER O WITH STROKE */
+    XK_ooblique:                    0x00f8, /* U+00F8 LATIN SMALL LETTER O WITH STROKE */
+    XK_ugrave:                      0x00f9, /* U+00F9 LATIN SMALL LETTER U WITH GRAVE */
+    XK_uacute:                      0x00fa, /* U+00FA LATIN SMALL LETTER U WITH ACUTE */
+    XK_ucircumflex:                 0x00fb, /* U+00FB LATIN SMALL LETTER U WITH CIRCUMFLEX */
+    XK_udiaeresis:                  0x00fc, /* U+00FC LATIN SMALL LETTER U WITH DIAERESIS */
+    XK_yacute:                      0x00fd, /* U+00FD LATIN SMALL LETTER Y WITH ACUTE */
+    XK_thorn:                       0x00fe, /* U+00FE LATIN SMALL LETTER THORN */
+    XK_ydiaeresis:                  0x00ff, /* U+00FF LATIN SMALL LETTER Y WITH DIAERESIS */
+
+    /*
+     * Korean
+     * Byte 3 = 0x0e
+     */
+
+    XK_Hangul:                      0xff31, /* Hangul start/stop(toggle) */
+    XK_Hangul_Hanja:                0xff34, /* Start Hangul->Hanja Conversion */
+    XK_Hangul_Jeonja:               0xff38, /* Jeonja mode */
+
+    /*
+     * XFree86 vendor specific keysyms.
+     *
+     * The XFree86 keysym range is 0x10080001 - 0x1008FFFF.
+     */
+
+    XF86XK_ModeLock:                0x1008FF01,
+    XF86XK_MonBrightnessUp:         0x1008FF02,
+    XF86XK_MonBrightnessDown:       0x1008FF03,
+    XF86XK_KbdLightOnOff:           0x1008FF04,
+    XF86XK_KbdBrightnessUp:         0x1008FF05,
+    XF86XK_KbdBrightnessDown:       0x1008FF06,
+    XF86XK_Standby:                 0x1008FF10,
+    XF86XK_AudioLowerVolume:        0x1008FF11,
+    XF86XK_AudioMute:               0x1008FF12,
+    XF86XK_AudioRaiseVolume:        0x1008FF13,
+    XF86XK_AudioPlay:               0x1008FF14,
+    XF86XK_AudioStop:               0x1008FF15,
+    XF86XK_AudioPrev:               0x1008FF16,
+    XF86XK_AudioNext:               0x1008FF17,
+    XF86XK_HomePage:                0x1008FF18,
+    XF86XK_Mail:                    0x1008FF19,
+    XF86XK_Start:                   0x1008FF1A,
+    XF86XK_Search:                  0x1008FF1B,
+    XF86XK_AudioRecord:             0x1008FF1C,
+    XF86XK_Calculator:              0x1008FF1D,
+    XF86XK_Memo:                    0x1008FF1E,
+    XF86XK_ToDoList:                0x1008FF1F,
+    XF86XK_Calendar:                0x1008FF20,
+    XF86XK_PowerDown:               0x1008FF21,
+    XF86XK_ContrastAdjust:          0x1008FF22,
+    XF86XK_RockerUp:                0x1008FF23,
+    XF86XK_RockerDown:              0x1008FF24,
+    XF86XK_RockerEnter:             0x1008FF25,
+    XF86XK_Back:                    0x1008FF26,
+    XF86XK_Forward:                 0x1008FF27,
+    XF86XK_Stop:                    0x1008FF28,
+    XF86XK_Refresh:                 0x1008FF29,
+    XF86XK_PowerOff:                0x1008FF2A,
+    XF86XK_WakeUp:                  0x1008FF2B,
+    XF86XK_Eject:                   0x1008FF2C,
+    XF86XK_ScreenSaver:             0x1008FF2D,
+    XF86XK_WWW:                     0x1008FF2E,
+    XF86XK_Sleep:                   0x1008FF2F,
+    XF86XK_Favorites:               0x1008FF30,
+    XF86XK_AudioPause:              0x1008FF31,
+    XF86XK_AudioMedia:              0x1008FF32,
+    XF86XK_MyComputer:              0x1008FF33,
+    XF86XK_VendorHome:              0x1008FF34,
+    XF86XK_LightBulb:               0x1008FF35,
+    XF86XK_Shop:                    0x1008FF36,
+    XF86XK_History:                 0x1008FF37,
+    XF86XK_OpenURL:                 0x1008FF38,
+    XF86XK_AddFavorite:             0x1008FF39,
+    XF86XK_HotLinks:                0x1008FF3A,
+    XF86XK_BrightnessAdjust:        0x1008FF3B,
+    XF86XK_Finance:                 0x1008FF3C,
+    XF86XK_Community:               0x1008FF3D,
+    XF86XK_AudioRewind:             0x1008FF3E,
+    XF86XK_BackForward:             0x1008FF3F,
+    XF86XK_Launch0:                 0x1008FF40,
+    XF86XK_Launch1:                 0x1008FF41,
+    XF86XK_Launch2:                 0x1008FF42,
+    XF86XK_Launch3:                 0x1008FF43,
+    XF86XK_Launch4:                 0x1008FF44,
+    XF86XK_Launch5:                 0x1008FF45,
+    XF86XK_Launch6:                 0x1008FF46,
+    XF86XK_Launch7:                 0x1008FF47,
+    XF86XK_Launch8:                 0x1008FF48,
+    XF86XK_Launch9:                 0x1008FF49,
+    XF86XK_LaunchA:                 0x1008FF4A,
+    XF86XK_LaunchB:                 0x1008FF4B,
+    XF86XK_LaunchC:                 0x1008FF4C,
+    XF86XK_LaunchD:                 0x1008FF4D,
+    XF86XK_LaunchE:                 0x1008FF4E,
+    XF86XK_LaunchF:                 0x1008FF4F,
+    XF86XK_ApplicationLeft:         0x1008FF50,
+    XF86XK_ApplicationRight:        0x1008FF51,
+    XF86XK_Book:                    0x1008FF52,
+    XF86XK_CD:                      0x1008FF53,
+    XF86XK_Calculater:              0x1008FF54,
+    XF86XK_Clear:                   0x1008FF55,
+    XF86XK_Close:                   0x1008FF56,
+    XF86XK_Copy:                    0x1008FF57,
+    XF86XK_Cut:                     0x1008FF58,
+    XF86XK_Display:                 0x1008FF59,
+    XF86XK_DOS:                     0x1008FF5A,
+    XF86XK_Documents:               0x1008FF5B,
+    XF86XK_Excel:                   0x1008FF5C,
+    XF86XK_Explorer:                0x1008FF5D,
+    XF86XK_Game:                    0x1008FF5E,
+    XF86XK_Go:                      0x1008FF5F,
+    XF86XK_iTouch:                  0x1008FF60,
+    XF86XK_LogOff:                  0x1008FF61,
+    XF86XK_Market:                  0x1008FF62,
+    XF86XK_Meeting:                 0x1008FF63,
+    XF86XK_MenuKB:                  0x1008FF65,
+    XF86XK_MenuPB:                  0x1008FF66,
+    XF86XK_MySites:                 0x1008FF67,
+    XF86XK_New:                     0x1008FF68,
+    XF86XK_News:                    0x1008FF69,
+    XF86XK_OfficeHome:              0x1008FF6A,
+    XF86XK_Open:                    0x1008FF6B,
+    XF86XK_Option:                  0x1008FF6C,
+    XF86XK_Paste:                   0x1008FF6D,
+    XF86XK_Phone:                   0x1008FF6E,
+    XF86XK_Q:                       0x1008FF70,
+    XF86XK_Reply:                   0x1008FF72,
+    XF86XK_Reload:                  0x1008FF73,
+    XF86XK_RotateWindows:           0x1008FF74,
+    XF86XK_RotationPB:              0x1008FF75,
+    XF86XK_RotationKB:              0x1008FF76,
+    XF86XK_Save:                    0x1008FF77,
+    XF86XK_ScrollUp:                0x1008FF78,
+    XF86XK_ScrollDown:              0x1008FF79,
+    XF86XK_ScrollClick:             0x1008FF7A,
+    XF86XK_Send:                    0x1008FF7B,
+    XF86XK_Spell:                   0x1008FF7C,
+    XF86XK_SplitScreen:             0x1008FF7D,
+    XF86XK_Support:                 0x1008FF7E,
+    XF86XK_TaskPane:                0x1008FF7F,
+    XF86XK_Terminal:                0x1008FF80,
+    XF86XK_Tools:                   0x1008FF81,
+    XF86XK_Travel:                  0x1008FF82,
+    XF86XK_UserPB:                  0x1008FF84,
+    XF86XK_User1KB:                 0x1008FF85,
+    XF86XK_User2KB:                 0x1008FF86,
+    XF86XK_Video:                   0x1008FF87,
+    XF86XK_WheelButton:             0x1008FF88,
+    XF86XK_Word:                    0x1008FF89,
+    XF86XK_Xfer:                    0x1008FF8A,
+    XF86XK_ZoomIn:                  0x1008FF8B,
+    XF86XK_ZoomOut:                 0x1008FF8C,
+    XF86XK_Away:                    0x1008FF8D,
+    XF86XK_Messenger:               0x1008FF8E,
+    XF86XK_WebCam:                  0x1008FF8F,
+    XF86XK_MailForward:             0x1008FF90,
+    XF86XK_Pictures:                0x1008FF91,
+    XF86XK_Music:                   0x1008FF92,
+    XF86XK_Battery:                 0x1008FF93,
+    XF86XK_Bluetooth:               0x1008FF94,
+    XF86XK_WLAN:                    0x1008FF95,
+    XF86XK_UWB:                     0x1008FF96,
+    XF86XK_AudioForward:            0x1008FF97,
+    XF86XK_AudioRepeat:             0x1008FF98,
+    XF86XK_AudioRandomPlay:         0x1008FF99,
+    XF86XK_Subtitle:                0x1008FF9A,
+    XF86XK_AudioCycleTrack:         0x1008FF9B,
+    XF86XK_CycleAngle:              0x1008FF9C,
+    XF86XK_FrameBack:               0x1008FF9D,
+    XF86XK_FrameForward:            0x1008FF9E,
+    XF86XK_Time:                    0x1008FF9F,
+    XF86XK_Select:                  0x1008FFA0,
+    XF86XK_View:                    0x1008FFA1,
+    XF86XK_TopMenu:                 0x1008FFA2,
+    XF86XK_Red:                     0x1008FFA3,
+    XF86XK_Green:                   0x1008FFA4,
+    XF86XK_Yellow:                  0x1008FFA5,
+    XF86XK_Blue:                    0x1008FFA6,
+    XF86XK_Suspend:                 0x1008FFA7,
+    XF86XK_Hibernate:               0x1008FFA8,
+    XF86XK_TouchpadToggle:          0x1008FFA9,
+    XF86XK_TouchpadOn:              0x1008FFB0,
+    XF86XK_TouchpadOff:             0x1008FFB1,
+    XF86XK_AudioMicMute:            0x1008FFB2,
+    XF86XK_Switch_VT_1:             0x1008FE01,
+    XF86XK_Switch_VT_2:             0x1008FE02,
+    XF86XK_Switch_VT_3:             0x1008FE03,
+    XF86XK_Switch_VT_4:             0x1008FE04,
+    XF86XK_Switch_VT_5:             0x1008FE05,
+    XF86XK_Switch_VT_6:             0x1008FE06,
+    XF86XK_Switch_VT_7:             0x1008FE07,
+    XF86XK_Switch_VT_8:             0x1008FE08,
+    XF86XK_Switch_VT_9:             0x1008FE09,
+    XF86XK_Switch_VT_10:            0x1008FE0A,
+    XF86XK_Switch_VT_11:            0x1008FE0B,
+    XF86XK_Switch_VT_12:            0x1008FE0C,
+    XF86XK_Ungrab:                  0x1008FE20,
+    XF86XK_ClearGrab:               0x1008FE21,
+    XF86XK_Next_VMode:              0x1008FE22,
+    XF86XK_Prev_VMode:              0x1008FE23,
+    XF86XK_LogWindowTree:           0x1008FE24,
+    XF86XK_LogGrabInfo:             0x1008FE25,
+};
diff --git a/src/component/utils/keyboards/novnc/keysymdef.js b/src/component/utils/keyboards/novnc/keysymdef.js
new file mode 100644
index 00000000..951cacab
--- /dev/null
+++ b/src/component/utils/keyboards/novnc/keysymdef.js
@@ -0,0 +1,688 @@
+/*
+ * Mapping from Unicode codepoints to X11/RFB keysyms
+ *
+ * This file was automatically generated from keysymdef.h
+ * DO NOT EDIT!
+ */
+
+/* Functions at the bottom */
+
+const codepoints = {
+    0x0100: 0x03c0, // XK_Amacron
+    0x0101: 0x03e0, // XK_amacron
+    0x0102: 0x01c3, // XK_Abreve
+    0x0103: 0x01e3, // XK_abreve
+    0x0104: 0x01a1, // XK_Aogonek
+    0x0105: 0x01b1, // XK_aogonek
+    0x0106: 0x01c6, // XK_Cacute
+    0x0107: 0x01e6, // XK_cacute
+    0x0108: 0x02c6, // XK_Ccircumflex
+    0x0109: 0x02e6, // XK_ccircumflex
+    0x010a: 0x02c5, // XK_Cabovedot
+    0x010b: 0x02e5, // XK_cabovedot
+    0x010c: 0x01c8, // XK_Ccaron
+    0x010d: 0x01e8, // XK_ccaron
+    0x010e: 0x01cf, // XK_Dcaron
+    0x010f: 0x01ef, // XK_dcaron
+    0x0110: 0x01d0, // XK_Dstroke
+    0x0111: 0x01f0, // XK_dstroke
+    0x0112: 0x03aa, // XK_Emacron
+    0x0113: 0x03ba, // XK_emacron
+    0x0116: 0x03cc, // XK_Eabovedot
+    0x0117: 0x03ec, // XK_eabovedot
+    0x0118: 0x01ca, // XK_Eogonek
+    0x0119: 0x01ea, // XK_eogonek
+    0x011a: 0x01cc, // XK_Ecaron
+    0x011b: 0x01ec, // XK_ecaron
+    0x011c: 0x02d8, // XK_Gcircumflex
+    0x011d: 0x02f8, // XK_gcircumflex
+    0x011e: 0x02ab, // XK_Gbreve
+    0x011f: 0x02bb, // XK_gbreve
+    0x0120: 0x02d5, // XK_Gabovedot
+    0x0121: 0x02f5, // XK_gabovedot
+    0x0122: 0x03ab, // XK_Gcedilla
+    0x0123: 0x03bb, // XK_gcedilla
+    0x0124: 0x02a6, // XK_Hcircumflex
+    0x0125: 0x02b6, // XK_hcircumflex
+    0x0126: 0x02a1, // XK_Hstroke
+    0x0127: 0x02b1, // XK_hstroke
+    0x0128: 0x03a5, // XK_Itilde
+    0x0129: 0x03b5, // XK_itilde
+    0x012a: 0x03cf, // XK_Imacron
+    0x012b: 0x03ef, // XK_imacron
+    0x012e: 0x03c7, // XK_Iogonek
+    0x012f: 0x03e7, // XK_iogonek
+    0x0130: 0x02a9, // XK_Iabovedot
+    0x0131: 0x02b9, // XK_idotless
+    0x0134: 0x02ac, // XK_Jcircumflex
+    0x0135: 0x02bc, // XK_jcircumflex
+    0x0136: 0x03d3, // XK_Kcedilla
+    0x0137: 0x03f3, // XK_kcedilla
+    0x0138: 0x03a2, // XK_kra
+    0x0139: 0x01c5, // XK_Lacute
+    0x013a: 0x01e5, // XK_lacute
+    0x013b: 0x03a6, // XK_Lcedilla
+    0x013c: 0x03b6, // XK_lcedilla
+    0x013d: 0x01a5, // XK_Lcaron
+    0x013e: 0x01b5, // XK_lcaron
+    0x0141: 0x01a3, // XK_Lstroke
+    0x0142: 0x01b3, // XK_lstroke
+    0x0143: 0x01d1, // XK_Nacute
+    0x0144: 0x01f1, // XK_nacute
+    0x0145: 0x03d1, // XK_Ncedilla
+    0x0146: 0x03f1, // XK_ncedilla
+    0x0147: 0x01d2, // XK_Ncaron
+    0x0148: 0x01f2, // XK_ncaron
+    0x014a: 0x03bd, // XK_ENG
+    0x014b: 0x03bf, // XK_eng
+    0x014c: 0x03d2, // XK_Omacron
+    0x014d: 0x03f2, // XK_omacron
+    0x0150: 0x01d5, // XK_Odoubleacute
+    0x0151: 0x01f5, // XK_odoubleacute
+    0x0152: 0x13bc, // XK_OE
+    0x0153: 0x13bd, // XK_oe
+    0x0154: 0x01c0, // XK_Racute
+    0x0155: 0x01e0, // XK_racute
+    0x0156: 0x03a3, // XK_Rcedilla
+    0x0157: 0x03b3, // XK_rcedilla
+    0x0158: 0x01d8, // XK_Rcaron
+    0x0159: 0x01f8, // XK_rcaron
+    0x015a: 0x01a6, // XK_Sacute
+    0x015b: 0x01b6, // XK_sacute
+    0x015c: 0x02de, // XK_Scircumflex
+    0x015d: 0x02fe, // XK_scircumflex
+    0x015e: 0x01aa, // XK_Scedilla
+    0x015f: 0x01ba, // XK_scedilla
+    0x0160: 0x01a9, // XK_Scaron
+    0x0161: 0x01b9, // XK_scaron
+    0x0162: 0x01de, // XK_Tcedilla
+    0x0163: 0x01fe, // XK_tcedilla
+    0x0164: 0x01ab, // XK_Tcaron
+    0x0165: 0x01bb, // XK_tcaron
+    0x0166: 0x03ac, // XK_Tslash
+    0x0167: 0x03bc, // XK_tslash
+    0x0168: 0x03dd, // XK_Utilde
+    0x0169: 0x03fd, // XK_utilde
+    0x016a: 0x03de, // XK_Umacron
+    0x016b: 0x03fe, // XK_umacron
+    0x016c: 0x02dd, // XK_Ubreve
+    0x016d: 0x02fd, // XK_ubreve
+    0x016e: 0x01d9, // XK_Uring
+    0x016f: 0x01f9, // XK_uring
+    0x0170: 0x01db, // XK_Udoubleacute
+    0x0171: 0x01fb, // XK_udoubleacute
+    0x0172: 0x03d9, // XK_Uogonek
+    0x0173: 0x03f9, // XK_uogonek
+    0x0178: 0x13be, // XK_Ydiaeresis
+    0x0179: 0x01ac, // XK_Zacute
+    0x017a: 0x01bc, // XK_zacute
+    0x017b: 0x01af, // XK_Zabovedot
+    0x017c: 0x01bf, // XK_zabovedot
+    0x017d: 0x01ae, // XK_Zcaron
+    0x017e: 0x01be, // XK_zcaron
+    0x0192: 0x08f6, // XK_function
+    0x01d2: 0x10001d1, // XK_Ocaron
+    0x02c7: 0x01b7, // XK_caron
+    0x02d8: 0x01a2, // XK_breve
+    0x02d9: 0x01ff, // XK_abovedot
+    0x02db: 0x01b2, // XK_ogonek
+    0x02dd: 0x01bd, // XK_doubleacute
+    0x0385: 0x07ae, // XK_Greek_accentdieresis
+    0x0386: 0x07a1, // XK_Greek_ALPHAaccent
+    0x0388: 0x07a2, // XK_Greek_EPSILONaccent
+    0x0389: 0x07a3, // XK_Greek_ETAaccent
+    0x038a: 0x07a4, // XK_Greek_IOTAaccent
+    0x038c: 0x07a7, // XK_Greek_OMICRONaccent
+    0x038e: 0x07a8, // XK_Greek_UPSILONaccent
+    0x038f: 0x07ab, // XK_Greek_OMEGAaccent
+    0x0390: 0x07b6, // XK_Greek_iotaaccentdieresis
+    0x0391: 0x07c1, // XK_Greek_ALPHA
+    0x0392: 0x07c2, // XK_Greek_BETA
+    0x0393: 0x07c3, // XK_Greek_GAMMA
+    0x0394: 0x07c4, // XK_Greek_DELTA
+    0x0395: 0x07c5, // XK_Greek_EPSILON
+    0x0396: 0x07c6, // XK_Greek_ZETA
+    0x0397: 0x07c7, // XK_Greek_ETA
+    0x0398: 0x07c8, // XK_Greek_THETA
+    0x0399: 0x07c9, // XK_Greek_IOTA
+    0x039a: 0x07ca, // XK_Greek_KAPPA
+    0x039b: 0x07cb, // XK_Greek_LAMDA
+    0x039c: 0x07cc, // XK_Greek_MU
+    0x039d: 0x07cd, // XK_Greek_NU
+    0x039e: 0x07ce, // XK_Greek_XI
+    0x039f: 0x07cf, // XK_Greek_OMICRON
+    0x03a0: 0x07d0, // XK_Greek_PI
+    0x03a1: 0x07d1, // XK_Greek_RHO
+    0x03a3: 0x07d2, // XK_Greek_SIGMA
+    0x03a4: 0x07d4, // XK_Greek_TAU
+    0x03a5: 0x07d5, // XK_Greek_UPSILON
+    0x03a6: 0x07d6, // XK_Greek_PHI
+    0x03a7: 0x07d7, // XK_Greek_CHI
+    0x03a8: 0x07d8, // XK_Greek_PSI
+    0x03a9: 0x07d9, // XK_Greek_OMEGA
+    0x03aa: 0x07a5, // XK_Greek_IOTAdieresis
+    0x03ab: 0x07a9, // XK_Greek_UPSILONdieresis
+    0x03ac: 0x07b1, // XK_Greek_alphaaccent
+    0x03ad: 0x07b2, // XK_Greek_epsilonaccent
+    0x03ae: 0x07b3, // XK_Greek_etaaccent
+    0x03af: 0x07b4, // XK_Greek_iotaaccent
+    0x03b0: 0x07ba, // XK_Greek_upsilonaccentdieresis
+    0x03b1: 0x07e1, // XK_Greek_alpha
+    0x03b2: 0x07e2, // XK_Greek_beta
+    0x03b3: 0x07e3, // XK_Greek_gamma
+    0x03b4: 0x07e4, // XK_Greek_delta
+    0x03b5: 0x07e5, // XK_Greek_epsilon
+    0x03b6: 0x07e6, // XK_Greek_zeta
+    0x03b7: 0x07e7, // XK_Greek_eta
+    0x03b8: 0x07e8, // XK_Greek_theta
+    0x03b9: 0x07e9, // XK_Greek_iota
+    0x03ba: 0x07ea, // XK_Greek_kappa
+    0x03bb: 0x07eb, // XK_Greek_lamda
+    0x03bc: 0x07ec, // XK_Greek_mu
+    0x03bd: 0x07ed, // XK_Greek_nu
+    0x03be: 0x07ee, // XK_Greek_xi
+    0x03bf: 0x07ef, // XK_Greek_omicron
+    0x03c0: 0x07f0, // XK_Greek_pi
+    0x03c1: 0x07f1, // XK_Greek_rho
+    0x03c2: 0x07f3, // XK_Greek_finalsmallsigma
+    0x03c3: 0x07f2, // XK_Greek_sigma
+    0x03c4: 0x07f4, // XK_Greek_tau
+    0x03c5: 0x07f5, // XK_Greek_upsilon
+    0x03c6: 0x07f6, // XK_Greek_phi
+    0x03c7: 0x07f7, // XK_Greek_chi
+    0x03c8: 0x07f8, // XK_Greek_psi
+    0x03c9: 0x07f9, // XK_Greek_omega
+    0x03ca: 0x07b5, // XK_Greek_iotadieresis
+    0x03cb: 0x07b9, // XK_Greek_upsilondieresis
+    0x03cc: 0x07b7, // XK_Greek_omicronaccent
+    0x03cd: 0x07b8, // XK_Greek_upsilonaccent
+    0x03ce: 0x07bb, // XK_Greek_omegaaccent
+    0x0401: 0x06b3, // XK_Cyrillic_IO
+    0x0402: 0x06b1, // XK_Serbian_DJE
+    0x0403: 0x06b2, // XK_Macedonia_GJE
+    0x0404: 0x06b4, // XK_Ukrainian_IE
+    0x0405: 0x06b5, // XK_Macedonia_DSE
+    0x0406: 0x06b6, // XK_Ukrainian_I
+    0x0407: 0x06b7, // XK_Ukrainian_YI
+    0x0408: 0x06b8, // XK_Cyrillic_JE
+    0x0409: 0x06b9, // XK_Cyrillic_LJE
+    0x040a: 0x06ba, // XK_Cyrillic_NJE
+    0x040b: 0x06bb, // XK_Serbian_TSHE
+    0x040c: 0x06bc, // XK_Macedonia_KJE
+    0x040e: 0x06be, // XK_Byelorussian_SHORTU
+    0x040f: 0x06bf, // XK_Cyrillic_DZHE
+    0x0410: 0x06e1, // XK_Cyrillic_A
+    0x0411: 0x06e2, // XK_Cyrillic_BE
+    0x0412: 0x06f7, // XK_Cyrillic_VE
+    0x0413: 0x06e7, // XK_Cyrillic_GHE
+    0x0414: 0x06e4, // XK_Cyrillic_DE
+    0x0415: 0x06e5, // XK_Cyrillic_IE
+    0x0416: 0x06f6, // XK_Cyrillic_ZHE
+    0x0417: 0x06fa, // XK_Cyrillic_ZE
+    0x0418: 0x06e9, // XK_Cyrillic_I
+    0x0419: 0x06ea, // XK_Cyrillic_SHORTI
+    0x041a: 0x06eb, // XK_Cyrillic_KA
+    0x041b: 0x06ec, // XK_Cyrillic_EL
+    0x041c: 0x06ed, // XK_Cyrillic_EM
+    0x041d: 0x06ee, // XK_Cyrillic_EN
+    0x041e: 0x06ef, // XK_Cyrillic_O
+    0x041f: 0x06f0, // XK_Cyrillic_PE
+    0x0420: 0x06f2, // XK_Cyrillic_ER
+    0x0421: 0x06f3, // XK_Cyrillic_ES
+    0x0422: 0x06f4, // XK_Cyrillic_TE
+    0x0423: 0x06f5, // XK_Cyrillic_U
+    0x0424: 0x06e6, // XK_Cyrillic_EF
+    0x0425: 0x06e8, // XK_Cyrillic_HA
+    0x0426: 0x06e3, // XK_Cyrillic_TSE
+    0x0427: 0x06fe, // XK_Cyrillic_CHE
+    0x0428: 0x06fb, // XK_Cyrillic_SHA
+    0x0429: 0x06fd, // XK_Cyrillic_SHCHA
+    0x042a: 0x06ff, // XK_Cyrillic_HARDSIGN
+    0x042b: 0x06f9, // XK_Cyrillic_YERU
+    0x042c: 0x06f8, // XK_Cyrillic_SOFTSIGN
+    0x042d: 0x06fc, // XK_Cyrillic_E
+    0x042e: 0x06e0, // XK_Cyrillic_YU
+    0x042f: 0x06f1, // XK_Cyrillic_YA
+    0x0430: 0x06c1, // XK_Cyrillic_a
+    0x0431: 0x06c2, // XK_Cyrillic_be
+    0x0432: 0x06d7, // XK_Cyrillic_ve
+    0x0433: 0x06c7, // XK_Cyrillic_ghe
+    0x0434: 0x06c4, // XK_Cyrillic_de
+    0x0435: 0x06c5, // XK_Cyrillic_ie
+    0x0436: 0x06d6, // XK_Cyrillic_zhe
+    0x0437: 0x06da, // XK_Cyrillic_ze
+    0x0438: 0x06c9, // XK_Cyrillic_i
+    0x0439: 0x06ca, // XK_Cyrillic_shorti
+    0x043a: 0x06cb, // XK_Cyrillic_ka
+    0x043b: 0x06cc, // XK_Cyrillic_el
+    0x043c: 0x06cd, // XK_Cyrillic_em
+    0x043d: 0x06ce, // XK_Cyrillic_en
+    0x043e: 0x06cf, // XK_Cyrillic_o
+    0x043f: 0x06d0, // XK_Cyrillic_pe
+    0x0440: 0x06d2, // XK_Cyrillic_er
+    0x0441: 0x06d3, // XK_Cyrillic_es
+    0x0442: 0x06d4, // XK_Cyrillic_te
+    0x0443: 0x06d5, // XK_Cyrillic_u
+    0x0444: 0x06c6, // XK_Cyrillic_ef
+    0x0445: 0x06c8, // XK_Cyrillic_ha
+    0x0446: 0x06c3, // XK_Cyrillic_tse
+    0x0447: 0x06de, // XK_Cyrillic_che
+    0x0448: 0x06db, // XK_Cyrillic_sha
+    0x0449: 0x06dd, // XK_Cyrillic_shcha
+    0x044a: 0x06df, // XK_Cyrillic_hardsign
+    0x044b: 0x06d9, // XK_Cyrillic_yeru
+    0x044c: 0x06d8, // XK_Cyrillic_softsign
+    0x044d: 0x06dc, // XK_Cyrillic_e
+    0x044e: 0x06c0, // XK_Cyrillic_yu
+    0x044f: 0x06d1, // XK_Cyrillic_ya
+    0x0451: 0x06a3, // XK_Cyrillic_io
+    0x0452: 0x06a1, // XK_Serbian_dje
+    0x0453: 0x06a2, // XK_Macedonia_gje
+    0x0454: 0x06a4, // XK_Ukrainian_ie
+    0x0455: 0x06a5, // XK_Macedonia_dse
+    0x0456: 0x06a6, // XK_Ukrainian_i
+    0x0457: 0x06a7, // XK_Ukrainian_yi
+    0x0458: 0x06a8, // XK_Cyrillic_je
+    0x0459: 0x06a9, // XK_Cyrillic_lje
+    0x045a: 0x06aa, // XK_Cyrillic_nje
+    0x045b: 0x06ab, // XK_Serbian_tshe
+    0x045c: 0x06ac, // XK_Macedonia_kje
+    0x045e: 0x06ae, // XK_Byelorussian_shortu
+    0x045f: 0x06af, // XK_Cyrillic_dzhe
+    0x0490: 0x06bd, // XK_Ukrainian_GHE_WITH_UPTURN
+    0x0491: 0x06ad, // XK_Ukrainian_ghe_with_upturn
+    0x05d0: 0x0ce0, // XK_hebrew_aleph
+    0x05d1: 0x0ce1, // XK_hebrew_bet
+    0x05d2: 0x0ce2, // XK_hebrew_gimel
+    0x05d3: 0x0ce3, // XK_hebrew_dalet
+    0x05d4: 0x0ce4, // XK_hebrew_he
+    0x05d5: 0x0ce5, // XK_hebrew_waw
+    0x05d6: 0x0ce6, // XK_hebrew_zain
+    0x05d7: 0x0ce7, // XK_hebrew_chet
+    0x05d8: 0x0ce8, // XK_hebrew_tet
+    0x05d9: 0x0ce9, // XK_hebrew_yod
+    0x05da: 0x0cea, // XK_hebrew_finalkaph
+    0x05db: 0x0ceb, // XK_hebrew_kaph
+    0x05dc: 0x0cec, // XK_hebrew_lamed
+    0x05dd: 0x0ced, // XK_hebrew_finalmem
+    0x05de: 0x0cee, // XK_hebrew_mem
+    0x05df: 0x0cef, // XK_hebrew_finalnun
+    0x05e0: 0x0cf0, // XK_hebrew_nun
+    0x05e1: 0x0cf1, // XK_hebrew_samech
+    0x05e2: 0x0cf2, // XK_hebrew_ayin
+    0x05e3: 0x0cf3, // XK_hebrew_finalpe
+    0x05e4: 0x0cf4, // XK_hebrew_pe
+    0x05e5: 0x0cf5, // XK_hebrew_finalzade
+    0x05e6: 0x0cf6, // XK_hebrew_zade
+    0x05e7: 0x0cf7, // XK_hebrew_qoph
+    0x05e8: 0x0cf8, // XK_hebrew_resh
+    0x05e9: 0x0cf9, // XK_hebrew_shin
+    0x05ea: 0x0cfa, // XK_hebrew_taw
+    0x060c: 0x05ac, // XK_Arabic_comma
+    0x061b: 0x05bb, // XK_Arabic_semicolon
+    0x061f: 0x05bf, // XK_Arabic_question_mark
+    0x0621: 0x05c1, // XK_Arabic_hamza
+    0x0622: 0x05c2, // XK_Arabic_maddaonalef
+    0x0623: 0x05c3, // XK_Arabic_hamzaonalef
+    0x0624: 0x05c4, // XK_Arabic_hamzaonwaw
+    0x0625: 0x05c5, // XK_Arabic_hamzaunderalef
+    0x0626: 0x05c6, // XK_Arabic_hamzaonyeh
+    0x0627: 0x05c7, // XK_Arabic_alef
+    0x0628: 0x05c8, // XK_Arabic_beh
+    0x0629: 0x05c9, // XK_Arabic_tehmarbuta
+    0x062a: 0x05ca, // XK_Arabic_teh
+    0x062b: 0x05cb, // XK_Arabic_theh
+    0x062c: 0x05cc, // XK_Arabic_jeem
+    0x062d: 0x05cd, // XK_Arabic_hah
+    0x062e: 0x05ce, // XK_Arabic_khah
+    0x062f: 0x05cf, // XK_Arabic_dal
+    0x0630: 0x05d0, // XK_Arabic_thal
+    0x0631: 0x05d1, // XK_Arabic_ra
+    0x0632: 0x05d2, // XK_Arabic_zain
+    0x0633: 0x05d3, // XK_Arabic_seen
+    0x0634: 0x05d4, // XK_Arabic_sheen
+    0x0635: 0x05d5, // XK_Arabic_sad
+    0x0636: 0x05d6, // XK_Arabic_dad
+    0x0637: 0x05d7, // XK_Arabic_tah
+    0x0638: 0x05d8, // XK_Arabic_zah
+    0x0639: 0x05d9, // XK_Arabic_ain
+    0x063a: 0x05da, // XK_Arabic_ghain
+    0x0640: 0x05e0, // XK_Arabic_tatweel
+    0x0641: 0x05e1, // XK_Arabic_feh
+    0x0642: 0x05e2, // XK_Arabic_qaf
+    0x0643: 0x05e3, // XK_Arabic_kaf
+    0x0644: 0x05e4, // XK_Arabic_lam
+    0x0645: 0x05e5, // XK_Arabic_meem
+    0x0646: 0x05e6, // XK_Arabic_noon
+    0x0647: 0x05e7, // XK_Arabic_ha
+    0x0648: 0x05e8, // XK_Arabic_waw
+    0x0649: 0x05e9, // XK_Arabic_alefmaksura
+    0x064a: 0x05ea, // XK_Arabic_yeh
+    0x064b: 0x05eb, // XK_Arabic_fathatan
+    0x064c: 0x05ec, // XK_Arabic_dammatan
+    0x064d: 0x05ed, // XK_Arabic_kasratan
+    0x064e: 0x05ee, // XK_Arabic_fatha
+    0x064f: 0x05ef, // XK_Arabic_damma
+    0x0650: 0x05f0, // XK_Arabic_kasra
+    0x0651: 0x05f1, // XK_Arabic_shadda
+    0x0652: 0x05f2, // XK_Arabic_sukun
+    0x0e01: 0x0da1, // XK_Thai_kokai
+    0x0e02: 0x0da2, // XK_Thai_khokhai
+    0x0e03: 0x0da3, // XK_Thai_khokhuat
+    0x0e04: 0x0da4, // XK_Thai_khokhwai
+    0x0e05: 0x0da5, // XK_Thai_khokhon
+    0x0e06: 0x0da6, // XK_Thai_khorakhang
+    0x0e07: 0x0da7, // XK_Thai_ngongu
+    0x0e08: 0x0da8, // XK_Thai_chochan
+    0x0e09: 0x0da9, // XK_Thai_choching
+    0x0e0a: 0x0daa, // XK_Thai_chochang
+    0x0e0b: 0x0dab, // XK_Thai_soso
+    0x0e0c: 0x0dac, // XK_Thai_chochoe
+    0x0e0d: 0x0dad, // XK_Thai_yoying
+    0x0e0e: 0x0dae, // XK_Thai_dochada
+    0x0e0f: 0x0daf, // XK_Thai_topatak
+    0x0e10: 0x0db0, // XK_Thai_thothan
+    0x0e11: 0x0db1, // XK_Thai_thonangmontho
+    0x0e12: 0x0db2, // XK_Thai_thophuthao
+    0x0e13: 0x0db3, // XK_Thai_nonen
+    0x0e14: 0x0db4, // XK_Thai_dodek
+    0x0e15: 0x0db5, // XK_Thai_totao
+    0x0e16: 0x0db6, // XK_Thai_thothung
+    0x0e17: 0x0db7, // XK_Thai_thothahan
+    0x0e18: 0x0db8, // XK_Thai_thothong
+    0x0e19: 0x0db9, // XK_Thai_nonu
+    0x0e1a: 0x0dba, // XK_Thai_bobaimai
+    0x0e1b: 0x0dbb, // XK_Thai_popla
+    0x0e1c: 0x0dbc, // XK_Thai_phophung
+    0x0e1d: 0x0dbd, // XK_Thai_fofa
+    0x0e1e: 0x0dbe, // XK_Thai_phophan
+    0x0e1f: 0x0dbf, // XK_Thai_fofan
+    0x0e20: 0x0dc0, // XK_Thai_phosamphao
+    0x0e21: 0x0dc1, // XK_Thai_moma
+    0x0e22: 0x0dc2, // XK_Thai_yoyak
+    0x0e23: 0x0dc3, // XK_Thai_rorua
+    0x0e24: 0x0dc4, // XK_Thai_ru
+    0x0e25: 0x0dc5, // XK_Thai_loling
+    0x0e26: 0x0dc6, // XK_Thai_lu
+    0x0e27: 0x0dc7, // XK_Thai_wowaen
+    0x0e28: 0x0dc8, // XK_Thai_sosala
+    0x0e29: 0x0dc9, // XK_Thai_sorusi
+    0x0e2a: 0x0dca, // XK_Thai_sosua
+    0x0e2b: 0x0dcb, // XK_Thai_hohip
+    0x0e2c: 0x0dcc, // XK_Thai_lochula
+    0x0e2d: 0x0dcd, // XK_Thai_oang
+    0x0e2e: 0x0dce, // XK_Thai_honokhuk
+    0x0e2f: 0x0dcf, // XK_Thai_paiyannoi
+    0x0e30: 0x0dd0, // XK_Thai_saraa
+    0x0e31: 0x0dd1, // XK_Thai_maihanakat
+    0x0e32: 0x0dd2, // XK_Thai_saraaa
+    0x0e33: 0x0dd3, // XK_Thai_saraam
+    0x0e34: 0x0dd4, // XK_Thai_sarai
+    0x0e35: 0x0dd5, // XK_Thai_saraii
+    0x0e36: 0x0dd6, // XK_Thai_saraue
+    0x0e37: 0x0dd7, // XK_Thai_sarauee
+    0x0e38: 0x0dd8, // XK_Thai_sarau
+    0x0e39: 0x0dd9, // XK_Thai_sarauu
+    0x0e3a: 0x0dda, // XK_Thai_phinthu
+    0x0e3f: 0x0ddf, // XK_Thai_baht
+    0x0e40: 0x0de0, // XK_Thai_sarae
+    0x0e41: 0x0de1, // XK_Thai_saraae
+    0x0e42: 0x0de2, // XK_Thai_sarao
+    0x0e43: 0x0de3, // XK_Thai_saraaimaimuan
+    0x0e44: 0x0de4, // XK_Thai_saraaimaimalai
+    0x0e45: 0x0de5, // XK_Thai_lakkhangyao
+    0x0e46: 0x0de6, // XK_Thai_maiyamok
+    0x0e47: 0x0de7, // XK_Thai_maitaikhu
+    0x0e48: 0x0de8, // XK_Thai_maiek
+    0x0e49: 0x0de9, // XK_Thai_maitho
+    0x0e4a: 0x0dea, // XK_Thai_maitri
+    0x0e4b: 0x0deb, // XK_Thai_maichattawa
+    0x0e4c: 0x0dec, // XK_Thai_thanthakhat
+    0x0e4d: 0x0ded, // XK_Thai_nikhahit
+    0x0e50: 0x0df0, // XK_Thai_leksun
+    0x0e51: 0x0df1, // XK_Thai_leknung
+    0x0e52: 0x0df2, // XK_Thai_leksong
+    0x0e53: 0x0df3, // XK_Thai_leksam
+    0x0e54: 0x0df4, // XK_Thai_leksi
+    0x0e55: 0x0df5, // XK_Thai_lekha
+    0x0e56: 0x0df6, // XK_Thai_lekhok
+    0x0e57: 0x0df7, // XK_Thai_lekchet
+    0x0e58: 0x0df8, // XK_Thai_lekpaet
+    0x0e59: 0x0df9, // XK_Thai_lekkao
+    0x2002: 0x0aa2, // XK_enspace
+    0x2003: 0x0aa1, // XK_emspace
+    0x2004: 0x0aa3, // XK_em3space
+    0x2005: 0x0aa4, // XK_em4space
+    0x2007: 0x0aa5, // XK_digitspace
+    0x2008: 0x0aa6, // XK_punctspace
+    0x2009: 0x0aa7, // XK_thinspace
+    0x200a: 0x0aa8, // XK_hairspace
+    0x2012: 0x0abb, // XK_figdash
+    0x2013: 0x0aaa, // XK_endash
+    0x2014: 0x0aa9, // XK_emdash
+    0x2015: 0x07af, // XK_Greek_horizbar
+    0x2017: 0x0cdf, // XK_hebrew_doublelowline
+    0x2018: 0x0ad0, // XK_leftsinglequotemark
+    0x2019: 0x0ad1, // XK_rightsinglequotemark
+    0x201a: 0x0afd, // XK_singlelowquotemark
+    0x201c: 0x0ad2, // XK_leftdoublequotemark
+    0x201d: 0x0ad3, // XK_rightdoublequotemark
+    0x201e: 0x0afe, // XK_doublelowquotemark
+    0x2020: 0x0af1, // XK_dagger
+    0x2021: 0x0af2, // XK_doubledagger
+    0x2022: 0x0ae6, // XK_enfilledcircbullet
+    0x2025: 0x0aaf, // XK_doubbaselinedot
+    0x2026: 0x0aae, // XK_ellipsis
+    0x2030: 0x0ad5, // XK_permille
+    0x2032: 0x0ad6, // XK_minutes
+    0x2033: 0x0ad7, // XK_seconds
+    0x2038: 0x0afc, // XK_caret
+    0x203e: 0x047e, // XK_overline
+    0x20a9: 0x0eff, // XK_Korean_Won
+    0x20ac: 0x20ac, // XK_EuroSign
+    0x2105: 0x0ab8, // XK_careof
+    0x2116: 0x06b0, // XK_numerosign
+    0x2117: 0x0afb, // XK_phonographcopyright
+    0x211e: 0x0ad4, // XK_prescription
+    0x2122: 0x0ac9, // XK_trademark
+    0x2153: 0x0ab0, // XK_onethird
+    0x2154: 0x0ab1, // XK_twothirds
+    0x2155: 0x0ab2, // XK_onefifth
+    0x2156: 0x0ab3, // XK_twofifths
+    0x2157: 0x0ab4, // XK_threefifths
+    0x2158: 0x0ab5, // XK_fourfifths
+    0x2159: 0x0ab6, // XK_onesixth
+    0x215a: 0x0ab7, // XK_fivesixths
+    0x215b: 0x0ac3, // XK_oneeighth
+    0x215c: 0x0ac4, // XK_threeeighths
+    0x215d: 0x0ac5, // XK_fiveeighths
+    0x215e: 0x0ac6, // XK_seveneighths
+    0x2190: 0x08fb, // XK_leftarrow
+    0x2191: 0x08fc, // XK_uparrow
+    0x2192: 0x08fd, // XK_rightarrow
+    0x2193: 0x08fe, // XK_downarrow
+    0x21d2: 0x08ce, // XK_implies
+    0x21d4: 0x08cd, // XK_ifonlyif
+    0x2202: 0x08ef, // XK_partialderivative
+    0x2207: 0x08c5, // XK_nabla
+    0x2218: 0x0bca, // XK_jot
+    0x221a: 0x08d6, // XK_radical
+    0x221d: 0x08c1, // XK_variation
+    0x221e: 0x08c2, // XK_infinity
+    0x2227: 0x08de, // XK_logicaland
+    0x2228: 0x08df, // XK_logicalor
+    0x2229: 0x08dc, // XK_intersection
+    0x222a: 0x08dd, // XK_union
+    0x222b: 0x08bf, // XK_integral
+    0x2234: 0x08c0, // XK_therefore
+    0x223c: 0x08c8, // XK_approximate
+    0x2243: 0x08c9, // XK_similarequal
+    0x2245: 0x1002248, // XK_approxeq
+    0x2260: 0x08bd, // XK_notequal
+    0x2261: 0x08cf, // XK_identical
+    0x2264: 0x08bc, // XK_lessthanequal
+    0x2265: 0x08be, // XK_greaterthanequal
+    0x2282: 0x08da, // XK_includedin
+    0x2283: 0x08db, // XK_includes
+    0x22a2: 0x0bfc, // XK_righttack
+    0x22a3: 0x0bdc, // XK_lefttack
+    0x22a4: 0x0bc2, // XK_downtack
+    0x22a5: 0x0bce, // XK_uptack
+    0x2308: 0x0bd3, // XK_upstile
+    0x230a: 0x0bc4, // XK_downstile
+    0x2315: 0x0afa, // XK_telephonerecorder
+    0x2320: 0x08a4, // XK_topintegral
+    0x2321: 0x08a5, // XK_botintegral
+    0x2395: 0x0bcc, // XK_quad
+    0x239b: 0x08ab, // XK_topleftparens
+    0x239d: 0x08ac, // XK_botleftparens
+    0x239e: 0x08ad, // XK_toprightparens
+    0x23a0: 0x08ae, // XK_botrightparens
+    0x23a1: 0x08a7, // XK_topleftsqbracket
+    0x23a3: 0x08a8, // XK_botleftsqbracket
+    0x23a4: 0x08a9, // XK_toprightsqbracket
+    0x23a6: 0x08aa, // XK_botrightsqbracket
+    0x23a8: 0x08af, // XK_leftmiddlecurlybrace
+    0x23ac: 0x08b0, // XK_rightmiddlecurlybrace
+    0x23b7: 0x08a1, // XK_leftradical
+    0x23ba: 0x09ef, // XK_horizlinescan1
+    0x23bb: 0x09f0, // XK_horizlinescan3
+    0x23bc: 0x09f2, // XK_horizlinescan7
+    0x23bd: 0x09f3, // XK_horizlinescan9
+    0x2409: 0x09e2, // XK_ht
+    0x240a: 0x09e5, // XK_lf
+    0x240b: 0x09e9, // XK_vt
+    0x240c: 0x09e3, // XK_ff
+    0x240d: 0x09e4, // XK_cr
+    0x2423: 0x0aac, // XK_signifblank
+    0x2424: 0x09e8, // XK_nl
+    0x2500: 0x08a3, // XK_horizconnector
+    0x2502: 0x08a6, // XK_vertconnector
+    0x250c: 0x08a2, // XK_topleftradical
+    0x2510: 0x09eb, // XK_uprightcorner
+    0x2514: 0x09ed, // XK_lowleftcorner
+    0x2518: 0x09ea, // XK_lowrightcorner
+    0x251c: 0x09f4, // XK_leftt
+    0x2524: 0x09f5, // XK_rightt
+    0x252c: 0x09f7, // XK_topt
+    0x2534: 0x09f6, // XK_bott
+    0x253c: 0x09ee, // XK_crossinglines
+    0x2592: 0x09e1, // XK_checkerboard
+    0x25aa: 0x0ae7, // XK_enfilledsqbullet
+    0x25ab: 0x0ae1, // XK_enopensquarebullet
+    0x25ac: 0x0adb, // XK_filledrectbullet
+    0x25ad: 0x0ae2, // XK_openrectbullet
+    0x25ae: 0x0adf, // XK_emfilledrect
+    0x25af: 0x0acf, // XK_emopenrectangle
+    0x25b2: 0x0ae8, // XK_filledtribulletup
+    0x25b3: 0x0ae3, // XK_opentribulletup
+    0x25b6: 0x0add, // XK_filledrighttribullet
+    0x25b7: 0x0acd, // XK_rightopentriangle
+    0x25bc: 0x0ae9, // XK_filledtribulletdown
+    0x25bd: 0x0ae4, // XK_opentribulletdown
+    0x25c0: 0x0adc, // XK_filledlefttribullet
+    0x25c1: 0x0acc, // XK_leftopentriangle
+    0x25c6: 0x09e0, // XK_soliddiamond
+    0x25cb: 0x0ace, // XK_emopencircle
+    0x25cf: 0x0ade, // XK_emfilledcircle
+    0x25e6: 0x0ae0, // XK_enopencircbullet
+    0x2606: 0x0ae5, // XK_openstar
+    0x260e: 0x0af9, // XK_telephone
+    0x2613: 0x0aca, // XK_signaturemark
+    0x261c: 0x0aea, // XK_leftpointer
+    0x261e: 0x0aeb, // XK_rightpointer
+    0x2640: 0x0af8, // XK_femalesymbol
+    0x2642: 0x0af7, // XK_malesymbol
+    0x2663: 0x0aec, // XK_club
+    0x2665: 0x0aee, // XK_heart
+    0x2666: 0x0aed, // XK_diamond
+    0x266d: 0x0af6, // XK_musicalflat
+    0x266f: 0x0af5, // XK_musicalsharp
+    0x2713: 0x0af3, // XK_checkmark
+    0x2717: 0x0af4, // XK_ballotcross
+    0x271d: 0x0ad9, // XK_latincross
+    0x2720: 0x0af0, // XK_maltesecross
+    0x27e8: 0x0abc, // XK_leftanglebracket
+    0x27e9: 0x0abe, // XK_rightanglebracket
+    0x3001: 0x04a4, // XK_kana_comma
+    0x3002: 0x04a1, // XK_kana_fullstop
+    0x300c: 0x04a2, // XK_kana_openingbracket
+    0x300d: 0x04a3, // XK_kana_closingbracket
+    0x309b: 0x04de, // XK_voicedsound
+    0x309c: 0x04df, // XK_semivoicedsound
+    0x30a1: 0x04a7, // XK_kana_a
+    0x30a2: 0x04b1, // XK_kana_A
+    0x30a3: 0x04a8, // XK_kana_i
+    0x30a4: 0x04b2, // XK_kana_I
+    0x30a5: 0x04a9, // XK_kana_u
+    0x30a6: 0x04b3, // XK_kana_U
+    0x30a7: 0x04aa, // XK_kana_e
+    0x30a8: 0x04b4, // XK_kana_E
+    0x30a9: 0x04ab, // XK_kana_o
+    0x30aa: 0x04b5, // XK_kana_O
+    0x30ab: 0x04b6, // XK_kana_KA
+    0x30ad: 0x04b7, // XK_kana_KI
+    0x30af: 0x04b8, // XK_kana_KU
+    0x30b1: 0x04b9, // XK_kana_KE
+    0x30b3: 0x04ba, // XK_kana_KO
+    0x30b5: 0x04bb, // XK_kana_SA
+    0x30b7: 0x04bc, // XK_kana_SHI
+    0x30b9: 0x04bd, // XK_kana_SU
+    0x30bb: 0x04be, // XK_kana_SE
+    0x30bd: 0x04bf, // XK_kana_SO
+    0x30bf: 0x04c0, // XK_kana_TA
+    0x30c1: 0x04c1, // XK_kana_CHI
+    0x30c3: 0x04af, // XK_kana_tsu
+    0x30c4: 0x04c2, // XK_kana_TSU
+    0x30c6: 0x04c3, // XK_kana_TE
+    0x30c8: 0x04c4, // XK_kana_TO
+    0x30ca: 0x04c5, // XK_kana_NA
+    0x30cb: 0x04c6, // XK_kana_NI
+    0x30cc: 0x04c7, // XK_kana_NU
+    0x30cd: 0x04c8, // XK_kana_NE
+    0x30ce: 0x04c9, // XK_kana_NO
+    0x30cf: 0x04ca, // XK_kana_HA
+    0x30d2: 0x04cb, // XK_kana_HI
+    0x30d5: 0x04cc, // XK_kana_FU
+    0x30d8: 0x04cd, // XK_kana_HE
+    0x30db: 0x04ce, // XK_kana_HO
+    0x30de: 0x04cf, // XK_kana_MA
+    0x30df: 0x04d0, // XK_kana_MI
+    0x30e0: 0x04d1, // XK_kana_MU
+    0x30e1: 0x04d2, // XK_kana_ME
+    0x30e2: 0x04d3, // XK_kana_MO
+    0x30e3: 0x04ac, // XK_kana_ya
+    0x30e4: 0x04d4, // XK_kana_YA
+    0x30e5: 0x04ad, // XK_kana_yu
+    0x30e6: 0x04d5, // XK_kana_YU
+    0x30e7: 0x04ae, // XK_kana_yo
+    0x30e8: 0x04d6, // XK_kana_YO
+    0x30e9: 0x04d7, // XK_kana_RA
+    0x30ea: 0x04d8, // XK_kana_RI
+    0x30eb: 0x04d9, // XK_kana_RU
+    0x30ec: 0x04da, // XK_kana_RE
+    0x30ed: 0x04db, // XK_kana_RO
+    0x30ef: 0x04dc, // XK_kana_WA
+    0x30f2: 0x04a6, // XK_kana_WO
+    0x30f3: 0x04dd, // XK_kana_N
+    0x30fb: 0x04a5, // XK_kana_conjunctive
+    0x30fc: 0x04b0, // XK_prolongedsound
+};
+
+export default {
+    lookup(u) {
+        // Latin-1 is one-to-one mapping
+        if ((u >= 0x20) && (u <= 0xff)) {
+            return u;
+        }
+
+        // Lookup table (fairly random)
+        const keysym = codepoints[u];
+        if (keysym !== undefined) {
+            return keysym;
+        }
+
+        // General mapping as final fallback
+        return 0x01000000 | u;
+    },
+};
diff --git a/src/component/utils/keyboards/novnc/util.js b/src/component/utils/keyboards/novnc/util.js
new file mode 100644
index 00000000..ae49b85a
--- /dev/null
+++ b/src/component/utils/keyboards/novnc/util.js
@@ -0,0 +1,191 @@
+import KeyTable from "./keysym.js";
+import keysyms from "./keysymdef.js";
+import vkeys from "./vkeys.js";
+import fixedkeys from "./fixedkeys.js";
+import DOMKeyTable from "./domkeytable.js";
+import * as browser from "./browser.js";
+
+// Get 'KeyboardEvent.code', handling legacy browsers
+export function getKeycode(evt) {
+    // Are we getting proper key identifiers?
+    // (unfortunately Firefox and Chrome are crappy here and gives
+    // us an empty string on some platforms, rather than leaving it
+    // undefined)
+    if (evt.code) {
+        // Mozilla isn't fully in sync with the spec yet
+        switch (evt.code) {
+            case 'OSLeft': return 'MetaLeft';
+            case 'OSRight': return 'MetaRight';
+        }
+
+        return evt.code;
+    }
+
+    // The de-facto standard is to use Windows Virtual-Key codes
+    // in the 'keyCode' field for non-printable characters
+    if (evt.keyCode in vkeys) {
+        let code = vkeys[evt.keyCode];
+
+        // macOS has messed up this code for some reason
+        if (browser.isMac() && (code === 'ContextMenu')) {
+            code = 'MetaRight';
+        }
+
+        // The keyCode doesn't distinguish between left and right
+        // for the standard modifiers
+        if (evt.location === 2) {
+            switch (code) {
+                case 'ShiftLeft': return 'ShiftRight';
+                case 'ControlLeft': return 'ControlRight';
+                case 'AltLeft': return 'AltRight';
+            }
+        }
+
+        // Nor a bunch of the numpad keys
+        if (evt.location === 3) {
+            switch (code) {
+                case 'Delete': return 'NumpadDecimal';
+                case 'Insert': return 'Numpad0';
+                case 'End': return 'Numpad1';
+                case 'ArrowDown': return 'Numpad2';
+                case 'PageDown': return 'Numpad3';
+                case 'ArrowLeft': return 'Numpad4';
+                case 'ArrowRight': return 'Numpad6';
+                case 'Home': return 'Numpad7';
+                case 'ArrowUp': return 'Numpad8';
+                case 'PageUp': return 'Numpad9';
+                case 'Enter': return 'NumpadEnter';
+            }
+        }
+
+        return code;
+    }
+
+    return 'Unidentified';
+}
+
+// Get 'KeyboardEvent.key', handling legacy browsers
+export function getKey(evt) {
+    // Are we getting a proper key value?
+    if (evt.key !== undefined) {
+        // Mozilla isn't fully in sync with the spec yet
+        switch (evt.key) {
+            case 'OS': return 'Meta';
+            case 'LaunchMyComputer': return 'LaunchApplication1';
+            case 'LaunchCalculator': return 'LaunchApplication2';
+        }
+
+        // iOS leaks some OS names
+        switch (evt.key) {
+            case 'UIKeyInputUpArrow': return 'ArrowUp';
+            case 'UIKeyInputDownArrow': return 'ArrowDown';
+            case 'UIKeyInputLeftArrow': return 'ArrowLeft';
+            case 'UIKeyInputRightArrow': return 'ArrowRight';
+            case 'UIKeyInputEscape': return 'Escape';
+        }
+
+        // Broken behaviour in Chrome
+        if ((evt.key === '\x00') && (evt.code === 'NumpadDecimal')) {
+            return 'Delete';
+        }
+
+        return evt.key;
+    }
+
+    // Try to deduce it based on the physical key
+    const code = getKeycode(evt);
+    if (code in fixedkeys) {
+        return fixedkeys[code];
+    }
+
+    // If that failed, then see if we have a printable character
+    if (evt.charCode) {
+        return String.fromCharCode(evt.charCode);
+    }
+
+    // At this point we have nothing left to go on
+    return 'Unidentified';
+}
+
+// Get the most reliable keysym value we can get from a key event
+export function getKeysym(evt) {
+    const key = getKey(evt);
+
+    if (key === 'Unidentified') {
+        return null;
+    }
+
+    // First look up special keys
+    if (key in DOMKeyTable) {
+        let location = evt.location;
+
+        // Safari screws up location for the right cmd key
+        if ((key === 'Meta') && (location === 0)) {
+            location = 2;
+        }
+
+        // And for Clear
+        if ((key === 'Clear') && (location === 3)) {
+            let code = getKeycode(evt);
+            if (code === 'NumLock') {
+                location = 0;
+            }
+        }
+
+        if ((location === undefined) || (location > 3)) {
+            location = 0;
+        }
+
+        // The original Meta key now gets confused with the Windows key
+        // https://bugs.chromium.org/p/chromium/issues/detail?id=1020141
+        // https://bugzilla.mozilla.org/show_bug.cgi?id=1232918
+        if (key === 'Meta') {
+            let code = getKeycode(evt);
+            if (code === 'AltLeft') {
+                return KeyTable.XK_Meta_L;
+            } else if (code === 'AltRight') {
+                return KeyTable.XK_Meta_R;
+            }
+        }
+
+        // macOS has Clear instead of NumLock, but the remote system is
+        // probably not macOS, so lying here is probably best...
+        if (key === 'Clear') {
+            let code = getKeycode(evt);
+            if (code === 'NumLock') {
+                return KeyTable.XK_Num_Lock;
+            }
+        }
+
+        // Windows sends alternating symbols for some keys when using a
+        // Japanese layout. We have no way of synchronising with the IM
+        // running on the remote system, so we send some combined keysym
+        // instead and hope for the best.
+        if (browser.isWindows()) {
+            switch (key) {
+                case 'Zenkaku':
+                case 'Hankaku':
+                    return KeyTable.XK_Zenkaku_Hankaku;
+                case 'Romaji':
+                case 'KanaMode':
+                    return KeyTable.XK_Romaji;
+            }
+        }
+
+        return DOMKeyTable[key][location];
+    }
+
+    // Now we need to look at the Unicode symbol instead
+
+    // Special key? (FIXME: Should have been caught earlier)
+    if (key.length !== 1) {
+        return null;
+    }
+
+    const codepoint = key.charCodeAt();
+    if (codepoint) {
+        return keysyms.lookup(codepoint);
+    }
+
+    return null;
+}
diff --git a/src/component/utils/keyboards/novnc/vkeys.js b/src/component/utils/keyboards/novnc/vkeys.js
new file mode 100644
index 00000000..dacc3580
--- /dev/null
+++ b/src/component/utils/keyboards/novnc/vkeys.js
@@ -0,0 +1,116 @@
+/*
+ * noVNC: HTML5 VNC client
+ * Copyright (C) 2018 The noVNC Authors
+ * Licensed under MPL 2.0 or any later version (see LICENSE.txt)
+ */
+
+/*
+ * Mapping between Microsoft® Windows® Virtual-Key codes and
+ * HTML key codes.
+ */
+
+export default {
+    0x08: 'Backspace',
+    0x09: 'Tab',
+    0x0a: 'NumpadClear',
+    0x0d: 'Enter',
+    0x10: 'ShiftLeft',
+    0x11: 'ControlLeft',
+    0x12: 'AltLeft',
+    0x13: 'Pause',
+    0x14: 'CapsLock',
+    0x15: 'Lang1',
+    0x19: 'Lang2',
+    0x1b: 'Escape',
+    0x1c: 'Convert',
+    0x1d: 'NonConvert',
+    0x20: 'Space',
+    0x21: 'PageUp',
+    0x22: 'PageDown',
+    0x23: 'End',
+    0x24: 'Home',
+    0x25: 'ArrowLeft',
+    0x26: 'ArrowUp',
+    0x27: 'ArrowRight',
+    0x28: 'ArrowDown',
+    0x29: 'Select',
+    0x2c: 'PrintScreen',
+    0x2d: 'Insert',
+    0x2e: 'Delete',
+    0x2f: 'Help',
+    0x30: 'Digit0',
+    0x31: 'Digit1',
+    0x32: 'Digit2',
+    0x33: 'Digit3',
+    0x34: 'Digit4',
+    0x35: 'Digit5',
+    0x36: 'Digit6',
+    0x37: 'Digit7',
+    0x38: 'Digit8',
+    0x39: 'Digit9',
+    0x5b: 'MetaLeft',
+    0x5c: 'MetaRight',
+    0x5d: 'ContextMenu',
+    0x5f: 'Sleep',
+    0x60: 'Numpad0',
+    0x61: 'Numpad1',
+    0x62: 'Numpad2',
+    0x63: 'Numpad3',
+    0x64: 'Numpad4',
+    0x65: 'Numpad5',
+    0x66: 'Numpad6',
+    0x67: 'Numpad7',
+    0x68: 'Numpad8',
+    0x69: 'Numpad9',
+    0x6a: 'NumpadMultiply',
+    0x6b: 'NumpadAdd',
+    0x6c: 'NumpadDecimal',
+    0x6d: 'NumpadSubtract',
+    0x6e: 'NumpadDecimal', // Duplicate, because buggy on Windows
+    0x6f: 'NumpadDivide',
+    0x70: 'F1',
+    0x71: 'F2',
+    0x72: 'F3',
+    0x73: 'F4',
+    0x74: 'F5',
+    0x75: 'F6',
+    0x76: 'F7',
+    0x77: 'F8',
+    0x78: 'F9',
+    0x79: 'F10',
+    0x7a: 'F11',
+    0x7b: 'F12',
+    0x7c: 'F13',
+    0x7d: 'F14',
+    0x7e: 'F15',
+    0x7f: 'F16',
+    0x80: 'F17',
+    0x81: 'F18',
+    0x82: 'F19',
+    0x83: 'F20',
+    0x84: 'F21',
+    0x85: 'F22',
+    0x86: 'F23',
+    0x87: 'F24',
+    0x90: 'NumLock',
+    0x91: 'ScrollLock',
+    0xa6: 'BrowserBack',
+    0xa7: 'BrowserForward',
+    0xa8: 'BrowserRefresh',
+    0xa9: 'BrowserStop',
+    0xaa: 'BrowserSearch',
+    0xab: 'BrowserFavorites',
+    0xac: 'BrowserHome',
+    0xad: 'AudioVolumeMute',
+    0xae: 'AudioVolumeDown',
+    0xaf: 'AudioVolumeUp',
+    0xb0: 'MediaTrackNext',
+    0xb1: 'MediaTrackPrevious',
+    0xb2: 'MediaStop',
+    0xb3: 'MediaPlayPause',
+    0xb4: 'LaunchMail',
+    0xb5: 'MediaSelect',
+    0xb6: 'LaunchApp1',
+    0xb7: 'LaunchApp2',
+    0xe1: 'AltRight', // Only when it is AltGraph
+};
diff --git a/vue.config.js b/vue.config.js
index 04b2829e..84ac0e04 100644
--- a/vue.config.js
+++ b/vue.config.js
@@ -1,4 +1,5 @@
 const path = require('path')
+const webpack = require('webpack')
 
 module.exports = {
   productionSourceMap: false,
@@ -9,6 +10,15 @@ module.exports = {
         '~': path.resolve(__dirname, 'src/'),
       },
     },
+    plugins: [
+      new webpack.NormalModuleReplacementPlugin(
+        /(.*)__KEYBOARD__/,
+        function(resource){
+          resource.request = resource.request
+            .replace(/__KEYBOARD__/, process.env.KEYBOARD || 'guacamole');
+        },
+      ),
+    ],
   },
   devServer: {
     allowedHosts: "all",