diff --git a/package.json b/package.json
index bb003487..2dce9e71 100644
--- a/package.json
+++ b/package.json
@@ -1,50 +1,51 @@
-{
-  "name": "@demodesk/neko",
-  "version": "0.1.1",
-  "description": "Client as reusable Vue.js component for neko streaming server.",
-  "main": "dist/neko.umd.js",
-  "module": "dist/neko.common.js",
-  "unpkg": "dist/neko.min.js",
-  "browser": {
-    "./sfc": "src/components/canvas.vue"
-  },
-  "scripts": {
-    "serve": "vue-cli-service serve --mode development",
-    "lint": "vue-cli-service lint",
-    "build": "vue-cli-service build --target lib --name neko ./src/components/canvas.vue"
-  },
-  "dependencies": {
-    "eventemitter3": "^4.0.7",
-    "resize-observer-polyfill": "^1.5.1",
-    "typed-vuex": "^0.1.21",
-    "vue": "^2.6.12",
-    "vue-class-component": "^7.2.6",
-    "vue-context": "^6.0.0",
-    "vue-property-decorator": "^9.0.2"
-  },
-  "devDependencies": {
-    "@types/node": "^14.14.7",
-    "@types/vue": "^2.0.0",
-    "@typescript-eslint/eslint-plugin": "^4.7.0",
-    "@typescript-eslint/parser": "^4.7.0",
-    "@vue/cli-plugin-babel": "^4.5.6",
-    "@vue/cli-plugin-eslint": "^4.5.6",
-    "@vue/cli-plugin-typescript": "^4.5.8",
-    "@vue/cli-service": "^4.5.6",
-    "@vue/eslint-config-prettier": "^6.0.0",
-    "@vue/eslint-config-typescript": "^7.0.0",
-    "eslint": "^7.13.0",
-    "eslint-plugin-prettier": "^3.1.4",
-    "eslint-plugin-vue": "^7.1.0",
-    "node-sass": "^5.0.0",
-    "prettier": "^2.1.2",
-    "sass-loader": "^10.0.5",
-    "ts-node": "^9.0.0",
-    "typescript": "^4.0.5",
-    "vue-template-compiler": "^2.6.12"
-  },
-  "browserslist": [
-    "> 1%",
-    "last 2 versions"
-  ]
-}
+{
+  "name": "@demodesk/neko",
+  "version": "0.1.1",
+  "description": "Client as reusable Vue.js component for neko streaming server.",
+  "main": "dist/neko.umd.js",
+  "module": "dist/neko.common.js",
+  "unpkg": "dist/neko.min.js",
+  "browser": {
+    "./sfc": "src/component/main.vue"
+  },
+  "scripts": {
+    "serve": "vue-cli-service serve --mode development",
+    "lint": "vue-cli-service lint",
+    "build": "vue-cli-service build --target lib --name neko ./src/component/main.vue",
+    "build:page": "vue-cli-service build"
+  },
+  "dependencies": {
+    "eventemitter3": "^4.0.7",
+    "resize-observer-polyfill": "^1.5.1",
+    "typed-vuex": "^0.1.21",
+    "vue": "^2.6.12",
+    "vue-class-component": "^7.2.6",
+    "vue-context": "^6.0.0",
+    "vue-property-decorator": "^9.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "^14.14.7",
+    "@types/vue": "^2.0.0",
+    "@typescript-eslint/eslint-plugin": "^4.7.0",
+    "@typescript-eslint/parser": "^4.7.0",
+    "@vue/cli-plugin-babel": "^4.5.6",
+    "@vue/cli-plugin-eslint": "^4.5.6",
+    "@vue/cli-plugin-typescript": "^4.5.8",
+    "@vue/cli-service": "^4.5.6",
+    "@vue/eslint-config-prettier": "^6.0.0",
+    "@vue/eslint-config-typescript": "^7.0.0",
+    "eslint": "^7.13.0",
+    "eslint-plugin-prettier": "^3.1.4",
+    "eslint-plugin-vue": "^7.1.0",
+    "node-sass": "^5.0.0",
+    "prettier": "^2.1.2",
+    "sass-loader": "^10.0.5",
+    "ts-node": "^9.0.0",
+    "typescript": "^4.0.5",
+    "vue-template-compiler": "^2.6.12"
+  },
+  "browserslist": [
+    "> 1%",
+    "last 2 versions"
+  ]
+}
diff --git a/src/app.vue b/src/app.vue
deleted file mode 100644
index c1dd6978..00000000
--- a/src/app.vue
+++ /dev/null
@@ -1,315 +0,0 @@
-<template>
-  <div>
-    <div style="float: right; max-width: 500px">
-      <h3>State</h3>
-      <table class="states" v-if="loaded">
-        <tr class="ok">
-          <th>connection.websocket</th>
-          <td>{{ neko.state.connection.websocket }}</td>
-        </tr>
-        <tr class="ok">
-          <th>connection.webrtc</th>
-          <td>{{ neko.state.connection.webrtc }}</td>
-        </tr>
-        <tr class="ok">
-          <th>connection.type</th>
-          <td>{{ neko.state.connection.type }}</td>
-        </tr>
-        <tr class="ok">
-          <th>connection.can_watch</th>
-          <td>{{ neko.state.connection.can_watch }}</td>
-        </tr>
-        <tr class="ok">
-          <th>connection.can_control</th>
-          <td>{{ neko.state.connection.can_control }}</td>
-        </tr>
-        <tr>
-          <th>connection.clipboard_access</th>
-          <td>{{ neko.state.connection.clipboard_access }}</td>
-        </tr>
-        <tr class="ok">
-          <th>video.playable</th>
-          <td>{{ neko.state.video.playable }}</td>
-        </tr>
-        <tr class="ok">
-          <th rowspan="2">video.playing</th>
-          <td>{{ neko.state.video.playing }}</td>
-        </tr>
-        <tr class="ok">
-          <td>
-            <button v-if="!neko.state.video.playing" @click="neko.play()">play</button>
-            <button v-else @click="neko.pause()">pause</button>
-          </td>
-        </tr>
-        <tr class="ok">
-          <th rowspan="2">video.volume</th>
-          <td>{{ neko.state.video.volume }}</td>
-        </tr>
-        <tr class="ok">
-          <td>
-            <input
-              type="range"
-              min="0"
-              max="1"
-              :value="neko.state.video.volume"
-              @input="neko.setVolume(Number($event.target.value))"
-              step="0.01"
-            />
-          </td>
-        </tr>
-        <tr class="ok">
-          <th rowspan="2">video.fullscreen</th>
-          <td>{{ neko.state.video.fullscreen }}</td>
-        </tr>
-        <tr class="ok">
-          <td>
-            <button v-if="!neko.state.video.fullscreen" @click="neko.requestFullscreen()">request</button>
-            <button v-else @click="neko.exitFullscreen()">exit</button>
-          </td>
-        </tr>
-        <tr class="ok">
-          <th rowspan="2">control.scroll.inverse</th>
-          <td>{{ neko.state.control.scroll.inverse }}</td>
-        </tr>
-        <tr class="ok">
-          <td>
-            <button @click="neko.setScrollInverse(!neko.state.control.scroll.inverse)">toggle</button>
-          </td>
-        </tr>
-        <tr class="ok">
-          <th rowspan="2">control.scroll.sensitivity</th>
-          <td>{{ neko.state.control.scroll.sensitivity }}</td>
-        </tr>
-        <tr class="ok">
-          <td>
-            <input
-              type="number"
-              :value="neko.state.control.scroll.sensitivity"
-              @input="neko.setScrollSensitivity(parseInt($event.target.value))"
-            />
-          </td>
-        </tr>
-        <tr>
-          <th>control.clipboard.data</th>
-          <td>{{ neko.state.control.clipboard.data }}</td>
-        </tr>
-        <tr>
-          <th>control.host</th>
-          <td>{{ neko.state.control.host }}</td>
-        </tr>
-        <tr class="ok">
-          <th>screen.size.width</th>
-          <td>{{ neko.state.screen.size.width }}</td>
-        </tr>
-        <tr class="ok">
-          <th>screen.size.height</th>
-          <td>{{ neko.state.screen.size.height }}</td>
-        </tr>
-        <tr class="ok">
-          <th>screen.size.rate</th>
-          <td>{{ neko.state.screen.size.rate }}</td>
-        </tr>
-        <tr class="ok">
-          <th rowspan="2">screen.configurations</th>
-          <td>Total {{ neko.state.screen.configurations.length }} configurations.</td>
-        </tr>
-        <tr class="ok">
-          <td>
-            <select
-              :value="Object.values(neko.state.screen.size).join()"
-              @input="
-                a = String($event.target.value).split(',')
-                neko.setScreenSize(parseInt(a[0]), parseInt(a[1]), parseInt(a[2]))
-              "
-            >
-              <option
-                v-for="{ width, height, rate } in neko.state.screen.configurations"
-                :key="width + height + rate"
-                :value="[width, height, rate].join()"
-              >
-                {{ width }}x{{ height }}@{{ rate }}
-              </option>
-            </select>
-            <button @click="screenChangingToggle">screenChangingToggle</button>
-          </td>
-        </tr>
-        <tr class="ok">
-          <th>member.id</th>
-          <td>{{ neko.state.member.id }}</td>
-        </tr>
-        <tr class="ok">
-          <th>member.name</th>
-          <td>{{ neko.state.member.name }}</td>
-        </tr>
-        <tr class="ok">
-          <th>member.is_admin</th>
-          <td>{{ neko.state.member.is_admin }}</td>
-        </tr>
-        <tr class="ok">
-          <th>member.is_watching</th>
-          <td>{{ neko.state.member.is_watching }}</td>
-        </tr>
-        <tr class="ok">
-          <th rowspan="2">member.is_controlling</th>
-          <td>{{ neko.state.member.is_controlling }}</td>
-        </tr>
-        <tr class="ok">
-          <td>
-            <button v-if="!neko.state.member.is_controlling" @click="neko.requestControl()">request control</button>
-            <button v-else @click="neko.releaseControl()">release control</button>
-          </td>
-        </tr>
-        <tr>
-          <th>member.can_watch</th>
-          <td>{{ neko.state.member.can_watch }}</td>
-        </tr>
-        <tr>
-          <th>member.can_control</th>
-          <td>{{ neko.state.member.can_control }}</td>
-        </tr>
-        <tr>
-          <th>member.clipboard_access</th>
-          <td>{{ neko.state.member.clipboard_access }}</td>
-        </tr>
-        <tr>
-          <th>members</th>
-          <td>{{ neko.state.members }}</td>
-        </tr>
-      </table>
-    </div>
-    <div>
-      <div v-if="loaded && !neko.connected">
-        <input type="text" placeholder="URL" v-model="url" />
-        <input type="text" placeholder="Member ID" v-model="member_id" />
-        <input type="text" placeholder="Member Secret" v-model="member_secret" />
-        <button @click="connect()">Connect</button>
-      </div>
-      <button v-if="loaded && neko.connected" @click="disconnect()">Disonnect</button>
-
-      <template v-if="loaded && neko.connected">
-        <button v-if="!is_controlling" @click="neko.requestControl()">request control</button>
-        <button v-else @click="neko.releaseControl()">release control</button>
-      </template>
-
-      <div ref="container" style="width: 1280px; height: 720px; border: 2px solid red">
-        <neko-canvas ref="neko" />
-      </div>
-    </div>
-  </div>
-</template>
-
-<style lang="scss" scoped>
-  .states {
-    td,
-    th {
-      border: 1px solid black;
-      padding: 4px;
-    }
-
-    th {
-      text-align: left;
-    }
-
-    .ok {
-      background: #97f197;
-    }
-  }
-</style>
-
-<script lang="ts">
-  import { Vue, Component, Ref, Watch } from 'vue-property-decorator'
-
-  import Neko from '~/components/canvas.vue'
-
-  @Component({
-    name: 'neko',
-    components: {
-      'neko-canvas': Neko,
-    },
-  })
-  export default class extends Vue {
-    @Ref('container') readonly container!: HTMLElement
-    @Ref('neko') readonly neko!: Neko
-    loaded: boolean = false
-
-    get is_controlling() {
-      return this.neko.state.member.is_controlling
-    }
-
-    url: string = 'ws://192.168.1.20:3000/ws'
-    member_id: string = 'admin'
-    member_secret: string = 'admin'
-
-    connect() {
-      this.neko.connect(this.url, this.member_id, this.member_secret)
-    }
-
-    disconnect() {
-      this.neko.disconnect()
-    }
-
-    // fast sceen changing test
-    screen_interval = null
-    screenChangingToggle() {
-      if (this.screen_interval === null) {
-        let sizes = this.neko.state.screen.configurations
-        let len = sizes.length
-
-        //@ts-ignore
-        this.screen_interval = setInterval(() => {
-          let { width, height, rate } = sizes[Math.floor(Math.random() * len)]
-
-          this.neko.setScreenSize(width, height, rate)
-        }, 10)
-      } else {
-        //@ts-ignore
-        clearInterval(this.screen_interval)
-        this.screen_interval = null
-      }
-    }
-
-    mounted() {
-      this.loaded = true
-
-      this.neko.events.on('system.websocket', (status) => {
-        console.log('system.websocket', status)
-      })
-      this.neko.events.on('system.webrtc', (status) => {
-        console.log('system.webrtc', status)
-      })
-      this.neko.events.on('system.connect', () => {
-        console.log('system.connect')
-      })
-      this.neko.events.on('system.disconnect', (message) => {
-        console.log('system.disconnect', message)
-      })
-      this.neko.events.on('member.list', (members) => {
-        console.log('member.list', members)
-      })
-      this.neko.events.on('member.connected', (id) => {
-        console.log('member.connected', id)
-      })
-      this.neko.events.on('member.disconnected', (id) => {
-        console.log('member.disconnected', id)
-      })
-      this.neko.events.on('control.host', (id) => {
-        console.log('control.host', id)
-      })
-      this.neko.events.on('control.request', (id) => {
-        console.log('control.request', id)
-      })
-      this.neko.events.on('control.requesting', (id) => {
-        console.log('control.requesting', id)
-      })
-      this.neko.events.on('clipboard.update', (text) => {
-        console.log('clipboard.update', text)
-      })
-      this.neko.events.on('screen.size', (id) => {
-        console.log('screen.size', id)
-      })
-      this.neko.events.on('broadcast.status', (payload) => {
-        console.log('broadcast.status', payload)
-      })
-    }
-  }
-</script>
diff --git a/src/component/internal/messages.ts b/src/component/internal/messages.ts
new file mode 100644
index 00000000..e69de29b
diff --git a/src/internal/video.ts b/src/component/internal/video.ts
similarity index 95%
rename from src/internal/video.ts
rename to src/component/internal/video.ts
index 9b6de7d5..0446a2bc 100644
--- a/src/internal/video.ts
+++ b/src/component/internal/video.ts
@@ -1,5 +1,5 @@
 import Vue from 'vue'
-import { Video } from '~/types/state'
+import { Video } from '../types/state'
 
 export function register(el: HTMLVideoElement, state: Video) {
   el.addEventListener('canplaythrough', () => {
diff --git a/src/internal/webrtc.ts b/src/component/internal/webrtc.ts
similarity index 100%
rename from src/internal/webrtc.ts
rename to src/component/internal/webrtc.ts
diff --git a/src/internal/websocket.ts b/src/component/internal/websocket.ts
similarity index 100%
rename from src/internal/websocket.ts
rename to src/component/internal/websocket.ts
diff --git a/src/components/canvas.vue b/src/component/main.vue
similarity index 97%
rename from src/components/canvas.vue
rename to src/component/main.vue
index 3b690e4a..347c49b9 100644
--- a/src/components/canvas.vue
+++ b/src/component/main.vue
@@ -44,12 +44,12 @@
   import ResizeObserver from 'resize-observer-polyfill'
   import EventEmitter from 'eventemitter3'
 
-  import { NekoWebSocket } from '~/internal/websocket'
-  import { NekoWebRTC } from '~/internal/webrtc'
-  import { NekoMessages } from '~/internal/messages'
-  import { register as VideoRegister } from '~/internal/video'
+  import { NekoWebSocket } from './internal/websocket'
+  import { NekoWebRTC } from './internal/webrtc'
+  import { NekoMessages } from './internal/messages'
+  import { register as VideoRegister } from './internal/video'
 
-  import NekoState from '~/types/state'
+  import NekoState from './types/state'
   import Overlay from './overlay.vue'
 
   @Component({
diff --git a/src/components/overlay.vue b/src/component/overlay.vue
similarity index 97%
rename from src/components/overlay.vue
rename to src/component/overlay.vue
index da051c7b..92ef0a77 100644
--- a/src/components/overlay.vue
+++ b/src/component/overlay.vue
@@ -28,8 +28,8 @@
 <script lang="ts">
   import { Vue, Component, Ref, Prop } from 'vue-property-decorator'
 
-  import GuacamoleKeyboard from '~/utils/guacamole-keyboard.ts'
-  import { NekoWebRTC } from '~/internal/webrtc'
+  import GuacamoleKeyboard from './utils/guacamole-keyboard'
+  import { NekoWebRTC } from './internal/webrtc'
 
   @Component({
     name: 'neko-overlay',
diff --git a/src/types/events.ts b/src/component/types/events.ts
similarity index 100%
rename from src/types/events.ts
rename to src/component/types/events.ts
diff --git a/src/types/messages.ts b/src/component/types/messages.ts
similarity index 100%
rename from src/types/messages.ts
rename to src/component/types/messages.ts
diff --git a/src/types/state.ts b/src/component/types/state.ts
similarity index 100%
rename from src/types/state.ts
rename to src/component/types/state.ts
diff --git a/src/types/structs.ts b/src/component/types/structs.ts
similarity index 100%
rename from src/types/structs.ts
rename to src/component/types/structs.ts
diff --git a/src/utils/guacamole-keyboard.js b/src/component/utils/guacamole-keyboard.js
similarity index 97%
rename from src/utils/guacamole-keyboard.js
rename to src/component/utils/guacamole-keyboard.js
index 8f0e984e..f84616df 100644
--- a/src/utils/guacamole-keyboard.js
+++ b/src/component/utils/guacamole-keyboard.js
@@ -1,1517 +1,1517 @@
-/* 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
-     */
-    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
-     */
-    var KeyEvent = function() {
-
-        /**
-         * Reference to this key event.
-         */
-        var key_event = this;
-
-        /**
-         * 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 {Number} keyCode The JavaScript key code of the key pressed.
-     * @param {String} keyIdentifier 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
-     * @param {String} key The standard name of the key pressed, as defined at:
-     *                     http://www.w3.org/TR/DOM-Level-3-Events/#events-KeyboardEvent
-     * @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 KeydownEvent = function(keyCode, keyIdentifier, key, location) {
-
-        // We extend KeyEvent
-        KeyEvent.apply(this);
-
-        /**
-         * The JavaScript key code of the key pressed.
-         *
-         * @type {Number}
-         */
-        this.keyCode = keyCode;
-
-        /**
-         * 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 = 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 = 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 = location;
-
-        // If key is known from keyCode or DOM3 alone, use that
-        this.keysym =  keysym_from_key_identifier(key, location)
-                    || keysym_from_keycode(keyCode, 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(keyCode, keyIdentifier))
-            this.keysym = keysym_from_key_identifier(keyIdentifier, location, guac_keyboard.modifiers.shift);
-
-        // If a key is pressed while meta is held down, the keyup will
-        // never be sent in Chrome (bug #108404)
-        if (guac_keyboard.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 = !guac_keyboard.modifiers.ctrl && !quirks.altIsTypableOnly;
-
-        // Determine whether default action for Ctrl+combinations must be prevented
-        var prevent_ctrl = !guac_keyboard.modifiers.alt;
-
-        // We must rely on the (potentially buggy) keyIdentifier if preventing
-        // the default action is important
-        if ((prevent_ctrl && guac_keyboard.modifiers.ctrl)
-         || (prevent_alt  && guac_keyboard.modifiers.alt)
-         || guac_keyboard.modifiers.meta
-         || guac_keyboard.modifiers.hyper)
-            this.reliable = true;
-
-        // Record most recently known keysym by associated key code
-        recentKeysym[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 {Number} charCode The Unicode codepoint of the character that
-     *                          would be typed by the key pressed.
-     */
-    var KeypressEvent = function(charCode) {
-
-        // We extend KeyEvent
-        KeyEvent.apply(this);
-
-        /**
-         * The Unicode codepoint of the character that would be typed by the
-         * key pressed.
-         *
-         * @type {Number}
-         */
-        this.charCode = charCode;
-
-        // Pull keysym from char code
-        this.keysym = keysym_from_charcode(charCode);
-
-        // Keypress is always reliable
-        this.reliable = true;
-
-    };
-
-    KeypressEvent.prototype = new KeyEvent();
-
-    /**
-     * 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 {Number} keyCode The JavaScript key code of the key released.
-     * @param {String} keyIdentifier The legacy DOM3 "keyIdentifier" of the key
-     *                               released, as defined at:
-     *                               http://www.w3.org/TR/2009/WD-DOM-Level-3-Events-20090908/#events-Events-KeyboardEvent
-     * @param {String} key The standard name of the key released, as defined at:
-     *                     http://www.w3.org/TR/DOM-Level-3-Events/#events-KeyboardEvent
-     * @param {Number} location The location on the keyboard corresponding to
-     *                          the key released, as defined at:
-     *                          http://www.w3.org/TR/DOM-Level-3-Events/#events-KeyboardEvent
-     */
-    var KeyupEvent = function(keyCode, keyIdentifier, key, location) {
-
-        // We extend KeyEvent
-        KeyEvent.apply(this);
-
-        /**
-         * The JavaScript key code of the key released.
-         *
-         * @type {Number}
-         */
-        this.keyCode = keyCode;
-
-        /**
-         * The legacy DOM3 "keyIdentifier" of the key released, as defined at:
-         * http://www.w3.org/TR/2009/WD-DOM-Level-3-Events-20090908/#events-Events-KeyboardEvent
-         *
-         * @type {String}
-         */
-        this.keyIdentifier = keyIdentifier;
-
-        /**
-         * The standard name of the key released, as defined at:
-         * http://www.w3.org/TR/DOM-Level-3-Events/#events-KeyboardEvent
-         * 
-         * @type {String}
-         */
-        this.key = key;
-
-        /**
-         * The location on the keyboard corresponding to the key released, as
-         * defined at:
-         * http://www.w3.org/TR/DOM-Level-3-Events/#events-KeyboardEvent
-         * 
-         * @type {Number}
-         */
-        this.location = location;
-
-        // If key is known from keyCode or DOM3 alone, use that
-        this.keysym =  keysym_from_keycode(keyCode, location)
-                    || keysym_from_key_identifier(key, location); // keyCode is still more reliable for keyup when dead keys are in use
-
-        // 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[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
-     */
-    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:  [0xFFEB], // left window key (hyper_l)
-        92:  [0xFF67], // right window key (menu key?)
-        93:  null,     // select 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
-     */
-    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": [0xFFEB],
-        "Zenkaku": [0xFF28],
-        "ZenkakuHankaku": [0xFF2A]
-    };
-
-    /**
-     * All keysyms which should not repeat when held down.
-     * @private
-     */
-    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 hyper
-        0xFFEC: true  // Right hyper
-    };
-
-    /**
-     * All modifiers and their states.
-     */
-    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. 
-     */
-    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
-     * @tyle {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
-     */
-    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
-     */
-    var key_repeat_timeout = null;
-
-    /**
-     * Interval which presses and releases the last key pressed while that
-     * key is still being held down.
-     * @private
-     */
-    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 = [];
-
-    };
-
-    /**
-     * Given the remote and local state of a particular key, resynchronizes the
-     * remote state of that key with the local state through pressing or
-     * releasing keysyms.
-     *
-     * @private
-     * @param {Boolean} remoteState
-     *     Whether the key is currently pressed remotely.
-     *
-     * @param {Boolean} localState
-     *     Whether the key is currently pressed remotely locally. If the state
-     *     of the key is not known, this may be undefined.
-     *
-     * @param {Number[]} keysyms
-     *     The keysyms which represent the key being updated.
-     *
-     * @param {KeyEvent} keyEvent
-     *     Guacamole's current best interpretation of the key event being
-     *     processed.
-     */
-    var updateModifierState = function updateModifierState(remoteState,
-        localState, keysyms, keyEvent) {
-
-        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 local modifier state and remote
-     * key state based on the modifier flags within the event. This function
-     * pays no attention to keycodes.
-     *
-     * @private
-     * @param {KeyboardEvent} e
-     *     The keyboard event containing the flags to update.
-     *
-     * @param {KeyEvent} keyEvent
-     *     Guacamole's current best interpretation of the key event being
-     *     processed.
-     */
-    var syncModifierStates = function syncModifierStates(e, keyEvent) {
-
-        // Get state
-        var state = Guacamole.Keyboard.ModifierState.fromKeyboardEvent(e);
-
-        // Resync state of alt
-        updateModifierState(guac_keyboard.modifiers.alt, state.alt, [
-            0xFFE9, // Left alt
-            0xFFEA, // Right alt
-            0xFE03  // AltGr
-        ], keyEvent);
-
-        // Resync state of shift
-        updateModifierState(guac_keyboard.modifiers.shift, state.shift, [
-            0xFFE1, // Left shift
-            0xFFE2  // Right shift
-        ], keyEvent);
-
-        // Resync state of ctrl
-        updateModifierState(guac_keyboard.modifiers.ctrl, state.ctrl, [
-            0xFFE3, // Left ctrl
-            0xFFE4  // Right ctrl
-        ], keyEvent);
-
-        // Resync state of meta
-        updateModifierState(guac_keyboard.modifiers.meta, state.meta, [
-            0xFFE7, // Left meta
-            0xFFE8  // Right meta
-        ], keyEvent);
-
-        // Resync state of hyper
-        updateModifierState(guac_keyboard.modifiers.hyper, state.hyper, [
-            0xFFEB, // Left hyper
-            0xFFEC  // Right hyper
-        ], keyEvent);
-
-        // Update state
-        guac_keyboard.modifiers = state;
-
-    };
-
-    /**
-     * 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 = [];
-
-            // 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) {
-
-                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;
-            }
-
-            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 keyCode;
-            if (window.event) keyCode = window.event.keyCode;
-            else if (e.which) keyCode = e.which;
-
-            // Fix modifier states
-            var keydownEvent = new KeydownEvent(keyCode, e.keyIdentifier, e.key, getEventLocation(e));
-            syncModifierStates(e, keydownEvent);
-
-            // 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 (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;
-
-            var charCode;
-            if (window.event) charCode = window.event.keyCode;
-            else if (e.which) charCode = e.which;
-
-            // Fix modifier states
-            var keypressEvent = new KeypressEvent(charCode);
-            syncModifierStates(e, keypressEvent);
-
-            // Log event
-            eventLog.push(keypressEvent);
-
-            // 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();
-
-            var keyCode;
-            if (window.event) keyCode = window.event.keyCode;
-            else if (e.which) keyCode = e.which;
-
-            // Fix modifier states
-            var keyupEvent = new KeyupEvent(keyCode, e.keyIdentifier, e.key, getEventLocation(e));
-            syncModifierStates(e, keyupEvent);
-
-            // Log event, call for interpretation
-            eventLog.push(keyupEvent);
-            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
-        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;
+/* 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
+     */
+    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
+     */
+    var KeyEvent = function() {
+
+        /**
+         * Reference to this key event.
+         */
+        var key_event = this;
+
+        /**
+         * 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 {Number} keyCode The JavaScript key code of the key pressed.
+     * @param {String} keyIdentifier 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
+     * @param {String} key The standard name of the key pressed, as defined at:
+     *                     http://www.w3.org/TR/DOM-Level-3-Events/#events-KeyboardEvent
+     * @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 KeydownEvent = function(keyCode, keyIdentifier, key, location) {
+
+        // We extend KeyEvent
+        KeyEvent.apply(this);
+
+        /**
+         * The JavaScript key code of the key pressed.
+         *
+         * @type {Number}
+         */
+        this.keyCode = keyCode;
+
+        /**
+         * 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 = 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 = 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 = location;
+
+        // If key is known from keyCode or DOM3 alone, use that
+        this.keysym =  keysym_from_key_identifier(key, location)
+                    || keysym_from_keycode(keyCode, 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(keyCode, keyIdentifier))
+            this.keysym = keysym_from_key_identifier(keyIdentifier, location, guac_keyboard.modifiers.shift);
+
+        // If a key is pressed while meta is held down, the keyup will
+        // never be sent in Chrome (bug #108404)
+        if (guac_keyboard.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 = !guac_keyboard.modifiers.ctrl && !quirks.altIsTypableOnly;
+
+        // Determine whether default action for Ctrl+combinations must be prevented
+        var prevent_ctrl = !guac_keyboard.modifiers.alt;
+
+        // We must rely on the (potentially buggy) keyIdentifier if preventing
+        // the default action is important
+        if ((prevent_ctrl && guac_keyboard.modifiers.ctrl)
+         || (prevent_alt  && guac_keyboard.modifiers.alt)
+         || guac_keyboard.modifiers.meta
+         || guac_keyboard.modifiers.hyper)
+            this.reliable = true;
+
+        // Record most recently known keysym by associated key code
+        recentKeysym[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 {Number} charCode The Unicode codepoint of the character that
+     *                          would be typed by the key pressed.
+     */
+    var KeypressEvent = function(charCode) {
+
+        // We extend KeyEvent
+        KeyEvent.apply(this);
+
+        /**
+         * The Unicode codepoint of the character that would be typed by the
+         * key pressed.
+         *
+         * @type {Number}
+         */
+        this.charCode = charCode;
+
+        // Pull keysym from char code
+        this.keysym = keysym_from_charcode(charCode);
+
+        // Keypress is always reliable
+        this.reliable = true;
+
+    };
+
+    KeypressEvent.prototype = new KeyEvent();
+
+    /**
+     * 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 {Number} keyCode The JavaScript key code of the key released.
+     * @param {String} keyIdentifier The legacy DOM3 "keyIdentifier" of the key
+     *                               released, as defined at:
+     *                               http://www.w3.org/TR/2009/WD-DOM-Level-3-Events-20090908/#events-Events-KeyboardEvent
+     * @param {String} key The standard name of the key released, as defined at:
+     *                     http://www.w3.org/TR/DOM-Level-3-Events/#events-KeyboardEvent
+     * @param {Number} location The location on the keyboard corresponding to
+     *                          the key released, as defined at:
+     *                          http://www.w3.org/TR/DOM-Level-3-Events/#events-KeyboardEvent
+     */
+    var KeyupEvent = function(keyCode, keyIdentifier, key, location) {
+
+        // We extend KeyEvent
+        KeyEvent.apply(this);
+
+        /**
+         * The JavaScript key code of the key released.
+         *
+         * @type {Number}
+         */
+        this.keyCode = keyCode;
+
+        /**
+         * The legacy DOM3 "keyIdentifier" of the key released, as defined at:
+         * http://www.w3.org/TR/2009/WD-DOM-Level-3-Events-20090908/#events-Events-KeyboardEvent
+         *
+         * @type {String}
+         */
+        this.keyIdentifier = keyIdentifier;
+
+        /**
+         * The standard name of the key released, as defined at:
+         * http://www.w3.org/TR/DOM-Level-3-Events/#events-KeyboardEvent
+         * 
+         * @type {String}
+         */
+        this.key = key;
+
+        /**
+         * The location on the keyboard corresponding to the key released, as
+         * defined at:
+         * http://www.w3.org/TR/DOM-Level-3-Events/#events-KeyboardEvent
+         * 
+         * @type {Number}
+         */
+        this.location = location;
+
+        // If key is known from keyCode or DOM3 alone, use that
+        this.keysym =  keysym_from_keycode(keyCode, location)
+                    || keysym_from_key_identifier(key, location); // keyCode is still more reliable for keyup when dead keys are in use
+
+        // 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[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
+     */
+    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:  [0xFFEB], // left window key (hyper_l)
+        92:  [0xFF67], // right window key (menu key?)
+        93:  null,     // select 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
+     */
+    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": [0xFFEB],
+        "Zenkaku": [0xFF28],
+        "ZenkakuHankaku": [0xFF2A]
+    };
+
+    /**
+     * All keysyms which should not repeat when held down.
+     * @private
+     */
+    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 hyper
+        0xFFEC: true  // Right hyper
+    };
+
+    /**
+     * All modifiers and their states.
+     */
+    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. 
+     */
+    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
+     * @tyle {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
+     */
+    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
+     */
+    var key_repeat_timeout = null;
+
+    /**
+     * Interval which presses and releases the last key pressed while that
+     * key is still being held down.
+     * @private
+     */
+    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 = [];
+
+    };
+
+    /**
+     * Given the remote and local state of a particular key, resynchronizes the
+     * remote state of that key with the local state through pressing or
+     * releasing keysyms.
+     *
+     * @private
+     * @param {Boolean} remoteState
+     *     Whether the key is currently pressed remotely.
+     *
+     * @param {Boolean} localState
+     *     Whether the key is currently pressed remotely locally. If the state
+     *     of the key is not known, this may be undefined.
+     *
+     * @param {Number[]} keysyms
+     *     The keysyms which represent the key being updated.
+     *
+     * @param {KeyEvent} keyEvent
+     *     Guacamole's current best interpretation of the key event being
+     *     processed.
+     */
+    var updateModifierState = function updateModifierState(remoteState,
+        localState, keysyms, keyEvent) {
+
+        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 local modifier state and remote
+     * key state based on the modifier flags within the event. This function
+     * pays no attention to keycodes.
+     *
+     * @private
+     * @param {KeyboardEvent} e
+     *     The keyboard event containing the flags to update.
+     *
+     * @param {KeyEvent} keyEvent
+     *     Guacamole's current best interpretation of the key event being
+     *     processed.
+     */
+    var syncModifierStates = function syncModifierStates(e, keyEvent) {
+
+        // Get state
+        var state = Guacamole.Keyboard.ModifierState.fromKeyboardEvent(e);
+
+        // Resync state of alt
+        updateModifierState(guac_keyboard.modifiers.alt, state.alt, [
+            0xFFE9, // Left alt
+            0xFFEA, // Right alt
+            0xFE03  // AltGr
+        ], keyEvent);
+
+        // Resync state of shift
+        updateModifierState(guac_keyboard.modifiers.shift, state.shift, [
+            0xFFE1, // Left shift
+            0xFFE2  // Right shift
+        ], keyEvent);
+
+        // Resync state of ctrl
+        updateModifierState(guac_keyboard.modifiers.ctrl, state.ctrl, [
+            0xFFE3, // Left ctrl
+            0xFFE4  // Right ctrl
+        ], keyEvent);
+
+        // Resync state of meta
+        updateModifierState(guac_keyboard.modifiers.meta, state.meta, [
+            0xFFE7, // Left meta
+            0xFFE8  // Right meta
+        ], keyEvent);
+
+        // Resync state of hyper
+        updateModifierState(guac_keyboard.modifiers.hyper, state.hyper, [
+            0xFFEB, // Left hyper
+            0xFFEC  // Right hyper
+        ], keyEvent);
+
+        // Update state
+        guac_keyboard.modifiers = state;
+
+    };
+
+    /**
+     * 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 = [];
+
+            // 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) {
+
+                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;
+            }
+
+            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 keyCode;
+            if (window.event) keyCode = window.event.keyCode;
+            else if (e.which) keyCode = e.which;
+
+            // Fix modifier states
+            var keydownEvent = new KeydownEvent(keyCode, e.keyIdentifier, e.key, getEventLocation(e));
+            syncModifierStates(e, keydownEvent);
+
+            // 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 (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;
+
+            var charCode;
+            if (window.event) charCode = window.event.keyCode;
+            else if (e.which) charCode = e.which;
+
+            // Fix modifier states
+            var keypressEvent = new KeypressEvent(charCode);
+            syncModifierStates(e, keypressEvent);
+
+            // Log event
+            eventLog.push(keypressEvent);
+
+            // 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();
+
+            var keyCode;
+            if (window.event) keyCode = window.event.keyCode;
+            else if (e.which) keyCode = e.which;
+
+            // Fix modifier states
+            var keyupEvent = new KeyupEvent(keyCode, e.keyIdentifier, e.key, getEventLocation(e));
+            syncModifierStates(e, keyupEvent);
+
+            // Log event, call for interpretation
+            eventLog.push(keyupEvent);
+            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
+        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/utils/guacamole-keyboard.ts b/src/component/utils/guacamole-keyboard.ts
similarity index 100%
rename from src/utils/guacamole-keyboard.ts
rename to src/component/utils/guacamole-keyboard.ts
diff --git a/src/utils/logger.ts b/src/component/utils/logger.ts
similarity index 100%
rename from src/utils/logger.ts
rename to src/component/utils/logger.ts
diff --git a/src/internal/messages.ts b/src/internal/messages.ts
deleted file mode 100644
index cb47aaf0..00000000
--- a/src/internal/messages.ts
+++ /dev/null
@@ -1,205 +0,0 @@
-import Vue from 'vue'
-import { Member, ScreenConfigurations } from '../types/structs'
-import { EVENT } from '../types/events'
-import {
-  DisconnectPayload,
-  MemberListPayload,
-  MemberDisconnectPayload,
-  MemberPayload,
-  ControlPayload,
-  ControlTargetPayload,
-  ControlClipboardPayload,
-  ScreenConfigurationsPayload,
-  ScreenResolutionPayload,
-  BroadcastStatusPayload,
-  AdminPayload,
-  AdminTargetPayload,
-} from '../types/messages'
-
-import EventEmitter from 'eventemitter3'
-import { NekoWebSocket } from './websocket'
-import NekoState from '~/types/state'
-
-export interface NekoEvents {
-  ['system.websocket']: (state: 'connected' | 'connecting' | 'disconnected') => void
-  ['system.webrtc']: (state: 'connected' | 'connecting' | 'disconnected') => void
-  ['system.connect']: () => void
-  ['system.disconnect']: (message: string) => void
-  ['control.host']: (id: string | null) => void
-  ['member.list']: (members: Member[]) => void
-  ['member.connected']: (id: string) => void
-  ['member.disconnected']: (id: string) => void
-  ['control.request']: (id: string) => void
-  ['control.requesting']: (id: string) => void
-  ['clipboard.update']: (text: string) => void
-  ['screen.size']: (id: string) => void
-  ['broadcast.status']: (url: string, isActive: boolean) => void
-}
-
-export class NekoMessages extends EventEmitter<NekoEvents> {
-  state: NekoState
-
-  constructor(websocket: NekoWebSocket, state: NekoState) {
-    super()
-
-    this.state = state
-    websocket.on('message', async (event: string, payload: any) => {
-      // @ts-ignore
-      if (typeof this[event] === 'function') {
-        // @ts-ignore
-        this[event](payload)
-      } else {
-        console.log(`unhandled websocket event '${event}':`, payload)
-      }
-    })
-  }
-
-  /////////////////////////////
-  // System Events
-  /////////////////////////////
-  protected [EVENT.SYSTEM.DISCONNECT]({ message }: DisconnectPayload) {
-    console.log('EVENT.SYSTEM.DISCONNECT')
-    this.emit('system.disconnect', message)
-  }
-
-  /////////////////////////////
-  // Member Events
-  /////////////////////////////
-  protected [EVENT.MEMBER.LIST]({ members }: MemberListPayload) {
-    console.log('EVENT.MEMBER.LIST')
-    this.emit('member.list', members)
-    //user.setMembers(members)
-  }
-
-  protected [EVENT.MEMBER.CONNECTED](member: MemberPayload) {
-    console.log('EVENT.MEMBER.CONNECTED')
-    this.emit('member.connected', member.id)
-    //user.addMember(member)
-
-    if (member.id === this.state.member.id) {
-      Vue.set(this.state.member, 'name', member.name)
-      Vue.set(this.state.member, 'is_admin', member.admin)
-    }
-  }
-
-  protected [EVENT.MEMBER.DISCONNECTED]({ id }: MemberDisconnectPayload) {
-    console.log('EVENT.MEMBER.DISCONNECTED')
-    this.emit('member.disconnected', id)
-    //user.delMember(id)
-  }
-
-  /////////////////////////////
-  // Control Events
-  /////////////////////////////
-  protected [EVENT.CONTROL.LOCKED]({ id }: ControlPayload) {
-    console.log('EVENT.CONTROL.LOCKED')
-    this.emit('control.host', id)
-    //remote.setHost(id)
-    //remote.changeKeyboard()
-  }
-
-  protected [EVENT.CONTROL.RELEASE]({ id }: ControlPayload) {
-    console.log('EVENT.CONTROL.RELEASE')
-    this.emit('control.host', null)
-    //remote.reset()
-  }
-
-  protected [EVENT.CONTROL.REQUEST]({ id }: ControlPayload) {
-    console.log('EVENT.CONTROL.REQUEST')
-    this.emit('control.request', id)
-  }
-
-  protected [EVENT.CONTROL.REQUESTING]({ id }: ControlPayload) {
-    console.log('EVENT.CONTROL.REQUESTING')
-    this.emit('control.requesting', id)
-  }
-
-  protected [EVENT.CONTROL.GIVE]({ id, target }: ControlTargetPayload) {
-    console.log('EVENT.CONTROL.GIVE')
-    this.emit('control.host', target)
-    //remote.setHost(target)
-    //remote.changeKeyboard()
-  }
-
-  protected [EVENT.CONTROL.CLIPBOARD]({ text }: ControlClipboardPayload) {
-    console.log('EVENT.CONTROL.CLIPBOARD')
-    this.emit('clipboard.update', text)
-    //remote.setClipboard(text)
-  }
-
-  /////////////////////////////
-  // Screen Events
-  /////////////////////////////
-  protected [EVENT.SCREEN.CONFIGURATIONS]({ configurations }: ScreenConfigurationsPayload) {
-    const data = []
-    for (const i of Object.keys(configurations)) {
-      const { width, height, rates } = configurations[i]
-      if (width >= 600 && height >= 300) {
-        for (const j of Object.keys(rates)) {
-          const rate = rates[j]
-          if (rate === 30 || rate === 60) {
-            data.push({
-              width,
-              height,
-              rate,
-            })
-          }
-        }
-      }
-    }
-
-    const conf = data.sort((a, b) => {
-      if (b.width === a.width && b.height == a.height) {
-        return b.rate - a.rate
-      } else if (b.width === a.width) {
-        return b.height - a.height
-      }
-      return b.width - a.width
-    })
-
-    Vue.set(this.state.screen, 'configurations', conf)
-  }
-
-  protected [EVENT.SCREEN.RESOLUTION]({ id, width, height, rate }: ScreenResolutionPayload) {
-    Vue.set(this.state.screen, 'size', { width, height, rate })
-    if (id) this.emit('screen.size', id)
-  }
-
-  /////////////////////////////
-  // Broadcast Events
-  /////////////////////////////
-  protected [EVENT.BROADCAST.STATUS](payload: BroadcastStatusPayload) {
-    console.log('EVENT.BROADCAST.STATUS')
-    this.emit('broadcast.status', payload.url, payload.isActive)
-    //settings.broadcastStatus(payload)
-  }
-
-  /////////////////////////////
-  // Admin Events
-  /////////////////////////////
-  protected [EVENT.ADMIN.CONTROL]({ id, target }: AdminTargetPayload) {
-    if (!target) return
-
-    console.log('EVENT.ADMIN.CONTROL')
-    this.emit('control.host', id)
-    //remote.setHost(id)
-    //remote.changeKeyboard()
-  }
-
-  protected [EVENT.ADMIN.RELEASE]({ id, target }: AdminTargetPayload) {
-    if (!target) return
-
-    console.log('EVENT.ADMIN.RELEASE')
-    this.emit('control.host', null)
-    //remote.reset()
-  }
-
-  protected [EVENT.ADMIN.GIVE]({ id, target }: AdminTargetPayload) {
-    if (!target) return
-
-    console.log('EVENT.ADMIN.GIVE')
-    this.emit('control.host', target)
-    //remote.setHost(target)
-    //remote.changeKeyboard()
-  }
-}