From 270c696d9d590b68c68c81457b73a7c900f0a0cf Mon Sep 17 00:00:00 2001
From: Luca Ban <mesqueeb@gmail.com>
Date: Sat, 23 Feb 2019 17:07:02 +0900
Subject: [PATCH 1/7] =?UTF-8?q?expand=20gitignore=20&=20rm=20pkg-lock!=20?=
 =?UTF-8?q?=F0=9F=A6=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .gitignore | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index ccb2c80..3a06dfb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,16 @@
 node_modules/
-package-lock.json
\ No newline at end of file
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# rollup
+.rpt2_cache
+
+# Editor directories and files
+.idea
+.vscode
+*.suo
+*.ntvs*
+*.njsproj
+*.sln

From 7c95582abaf2c11f66ef447e44866c723c4d88fb Mon Sep 17 00:00:00 2001
From: Luca Ban <mesqueeb@gmail.com>
Date: Sat, 23 Feb 2019 17:07:35 +0900
Subject: [PATCH 2/7] =?UTF-8?q?create=20rollup=20build=20file=20?=
 =?UTF-8?q?=F0=9F=8E=BA?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 build/rollup.js | 57 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 build/rollup.js

diff --git a/build/rollup.js b/build/rollup.js
new file mode 100644
index 0000000..4078c4a
--- /dev/null
+++ b/build/rollup.js
@@ -0,0 +1,57 @@
+/* eslint-disable */
+
+// npm install rollup-plugin-typescript2 typescript --save-dev
+import typescript from 'rollup-plugin-typescript2'
+// import { terser } from 'rollup-plugin-terser'
+// import resolve from 'rollup-plugin-node-resolve'
+
+// ------------------------------------------------------------------------------------------
+// formats
+// ------------------------------------------------------------------------------------------
+// amd – Asynchronous Module Definition, used with module loaders like RequireJS
+// cjs – CommonJS, suitable for Node and Browserify/Webpack
+// esm – Keep the bundle as an ES module file
+// iife – A self-executing function, suitable for inclusion as a <script> tag. (If you want to create a bundle for your application, you probably want to use this, because it leads to smaller file sizes.)
+// umd – Universal Module Definition, works as amd, cjs and iife all in one
+// system – Native format of the SystemJS loader
+
+// ------------------------------------------------------------------------------------------
+// setup
+// ------------------------------------------------------------------------------------------
+const pkg = require('../package.json')
+const name = pkg.name
+const className = name.replace(/(^\w|-\w)/g, c => c.replace('-', '').toUpperCase())
+const external = Object.keys(pkg.dependencies || [])
+const plugins = [
+  typescript({useTsconfigDeclarationDir: true}),
+]
+
+// ------------------------------------------------------------------------------------------
+// Builds
+// ------------------------------------------------------------------------------------------
+function defaults (config) {
+  // defaults
+  const defaults = {
+    plugins,
+    external
+  }
+  // defaults.output
+  config.output = config.output.map(output => {
+    return Object.assign({
+      sourcemap: false,
+      name: className,
+      exports: 'named',
+    }, output)
+  })
+  return Object.assign(defaults, config)
+}
+
+export default [
+  defaults({
+    input: 'src/index.ts',
+    output: [
+      {file: 'dist/index.cjs.js', format: 'cjs'},
+      {file: 'dist/index.esm.js', format: 'esm'},
+    ],
+  }),
+]

From 66d367fe5057c47c0dac18dfb838a4b3f156d8d3 Mon Sep 17 00:00:00 2001
From: Luca Ban <mesqueeb@gmail.com>
Date: Sat, 23 Feb 2019 17:08:03 +0900
Subject: [PATCH 3/7] =?UTF-8?q?switch=20to=20TypeScript=20&=20new=20build?=
 =?UTF-8?q?=20=F0=9F=A6=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 dist/HotStuff.js      | 357 ------------------------------------
 dist/HotStuff.min.js  |   1 -
 dist/index.cjs.js     | 321 +++++++++++++++++++++++++++++++++
 dist/index.esm.js     | 317 ++++++++++++++++++++++++++++++++
 package-lock.json     | 410 ++++++++++++++++++++++++++++++++++++++++++
 package.json          |  21 +--
 src/HotStuff.js       | 346 -----------------------------------
 src/index.ts          | 263 +++++++++++++++++++++++++++
 src/keyAliases.ts     |  80 +++++++++
 tsconfig.json         |  11 ++
 types/index.d.ts      |   2 +
 types/keyAliases.d.ts |  58 ++++++
 12 files changed, 1471 insertions(+), 716 deletions(-)
 delete mode 100644 dist/HotStuff.js
 delete mode 100644 dist/HotStuff.min.js
 create mode 100644 dist/index.cjs.js
 create mode 100644 dist/index.esm.js
 create mode 100644 package-lock.json
 delete mode 100644 src/HotStuff.js
 create mode 100644 src/index.ts
 create mode 100644 src/keyAliases.ts
 create mode 100644 tsconfig.json
 create mode 100644 types/index.d.ts
 create mode 100644 types/keyAliases.d.ts

diff --git a/dist/HotStuff.js b/dist/HotStuff.js
deleted file mode 100644
index af25539..0000000
--- a/dist/HotStuff.js
+++ /dev/null
@@ -1,357 +0,0 @@
-"use strict";
-
-var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
-
-(function (root, factory) {
-    if (typeof define === "function" && define.amd) {
-        define([], factory);
-    } else if ((typeof exports === "undefined" ? "undefined" : _typeof(exports)) === "object") {
-        module.exports = factory();
-    } else {
-        root.HotStuff = factory();
-    }
-})(window, function () {
-    // Normalise and change certain keys
-    var KEY_ALIAS_MAP = {
-        "+": "plus",
-        "-": "subtract",
-        ",": "comma",
-        " ": "space",
-        "   ": "tab",
-        arrowup: "up",
-        arrowdown: "down",
-        arrowleft: "left",
-        arrowright: "right",
-        control: "ctrl",
-        delete: "del"
-    };
-
-    // Generate KeyCode mapping. We could hardcode all of it, but its not too much a performance hit
-    // to generate some of the keys
-    var KEYCODE_ALIAS_MAP = function () {
-        var keys = {
-            8: "backspace",
-            9: "tab",
-            13: "enter",
-            16: "shift",
-            17: "ctrl",
-            18: "alt",
-            19: "pause",
-            20: "capslock",
-            27: "esc",
-            32: "space",
-            33: "pageup",
-            34: "pagedown",
-            35: "end",
-            36: "home",
-            37: "left",
-            38: "up",
-            39: "right",
-            40: "down",
-            45: "insert",
-            46: "del",
-            59: ";",
-            61: "equals",
-            91: "meta",
-            92: "meta",
-            93: "select",
-            106: "multiply",
-            107: "plus",
-            109: "subtract",
-            110: "decimal",
-            111: "divide",
-            144: "numlock",
-            145: "scrolllock",
-            186: ";",
-            187: "equals",
-            189: "minus",
-            190: ".",
-            191: "/",
-            192: "grave",
-            219: "[",
-            220: "\\",
-            221: "]",
-            222: "'",
-            223: "`"
-        };
-
-        for (var i = 0; i <= 9; i++) {
-            // 0-9
-            keys[48 + i] = String.fromCharCode(48 + i);
-            // numpad0-9
-            keys[96 + i] = "numpad" + i;
-        }
-
-        // f keys
-        for (var _i = 0; _i <= 11; _i++) {
-            keys[112 + _i] = "f" + (_i + 1);
-        } // a-z
-        for (var _i2 = 65; _i2 < 91; _i2++) {
-            keys[_i2] = String.fromCharCode(_i2).toLowerCase();
-        }return keys;
-    }();
-
-    // normalize keys by referring to KEY_ALIAS_MAP, this might have to be modified in the future
-    // to take into account OS
-    var normalizeHotKey = function normalizeHotKey(x) {
-        return KEY_ALIAS_MAP[x] ? KEY_ALIAS_MAP[x] : x;
-    };
-
-    // function to sort our key array, forces order to begin ctrl-alt-shift if they exist,
-    // at the moment this happens by setting them to unicode characters 0-2
-    // (which can't by typed normally on a keyboard)
-    var HotKeySort = function HotKeySort(a, b) {
-        if (a === "ctrl" || a === "control") a = "\x00";
-        if (a === "alt") a = "\x01";
-        if (a === "shift") a = "\x02";
-
-        if (b === "ctrl" || b === "control") b = "\x00";
-        if (b === "alt") b = "\x01";
-        if (b === "shift") b = "\x02";
-
-        return a > b;
-    };
-
-    // may require some refactoring to take in special cases
-    // such as having the ability to split multiple hotkeys by commas
-    var parseKeyCode = function parseKeyCode(str) {
-        return str.toLowerCase().split(/[+-]/);
-    };
-
-    // helper function to make sure that there is an array for us to push our handlers to
-    var addKeyListener = function addKeyListener(T, key) {
-        if (T._keyListeners[key] === undefined) T._keyListeners[key] = [];
-        return T._keyListeners[key];
-    };
-
-    var getKeyObject = function getKeyObject(keyObj, key) {
-        keyObj = keyObj._keys;
-        if (keyObj[key] === undefined) keyObj[key] = {
-            trigger: false,
-            event: null
-        };
-        return keyObj[key];
-    };
-
-    function createFakeEvent(event, el) {
-        var fakeEvent = document.createEventObject ? document.createEventObject() : document.createEvent("Event");
-        if (fakeEvent.initEvent) {
-            fakeEvent.initEvent("keyup", true, true);
-        }
-        // attempt to add as many properties from the original event to our new fakeEvent
-        // avoid using has own property, it won't get most of the properties
-        for (var prop in event) {
-            try {
-                fakeEvent[prop] = event[prop];
-            } catch (e) {
-                // do nothing, we'll just skip them.
-            }
-        }
-
-        el.dispatchEvent ? el.dispatchEvent(fakeEvent) : el.fireEvent("onkeyup", fakeEvent);
-    }
-
-    var DEFINE = function DEFINE(o) {
-        return function (p, v) {
-            return Object.defineProperty(o, p, v);
-        };
-    };
-
-    // Begin HotStuff Class
-    var HotStuff = function HotStuff() {
-        if (!(this instanceof HotStuff)) return new (Function.prototype.bind.apply(HotStuff, [null].concat(Array.prototype.slice.call(arguments))))();
-        this.init.apply(this, arguments);
-    };
-
-    // use assign to add methods to the prototype
-    Object.assign(HotStuff.prototype, {
-        constructor: HotStuff,
-        init: function init(el) {
-            var _this = this;
-
-            // with no element provided, try to attach to the window
-            if (el === null || el === undefined) if (window) el = window;else throw new Error("No element found to attach HotStuff to and could not find window object.");
-
-            var define = DEFINE(this);
-
-            define("el", {
-                get: function get() {
-                    return el;
-                },
-
-                readOnly: true,
-                enumerable: true
-            });
-
-            this._keyListeners = {};
-            this._keysActive = [];
-            this._unresolvedKeyUps = [];
-
-            // internal variables for generic key listeners (ones that listen to all keys)
-            this._genericKeyListeners = [];
-
-            el.addEventListener("keydown", this.handleKeyDown.bind(this));
-            el.addEventListener("keyup", this.handleKeyUp.bind(this));
-
-            // when the window loses or gains focus, trigger all key up events that haven't been triggered
-            (function (arr, func) {
-                arr.forEach(function (x) {
-                    return window.addEventListener(x, func);
-                });
-            })(['blur', 'focus'], function () {
-                _this._unresolvedKeyUps.forEach(function (listenerGroup) {
-                    createFakeEvent(listenerGroup._events[listenerGroup._events.length - 1], _this.el);
-                    listenerGroup._events.splice();
-                });
-
-                // triggering generic key listeners are slightly more complex
-                // loop through all the keys, checking if the trigger is set to true,
-                // then creates the fake event for that letter
-                _this._genericKeyListeners.forEach(function (listenerGroup) {
-                    var keys = listenerGroup._keys;
-                    for (var property in keys) {
-                        if (keys.hasOwnProperty(property) && keys[property].trigger) {
-                            createFakeEvent(keys[property].event, _this.el);
-                            keys[property].trigger = false;
-                        }
-                    }
-                });
-            });
-        },
-        addListener: function addListener(keysArr, keydownHandler, keyupHandler) {
-            var _this2 = this;
-
-            // prepare our arguments
-            if (typeof keysArr === "string") keysArr = [keysArr];
-            if (keysArr === null) keysArr = [];
-            if (keysArr instanceof Function) {
-                keyupHandler = keydownHandler;
-                keydownHandler = keysArr;
-                keysArr = []; // pass an empty array, we'll detect the length of this later to determine type of listener
-            }
-
-            if (!(keysArr instanceof Array)) throw new Error("Invalid Keys provided");
-
-            if (keyupHandler == null && keydownHandler == null) throw new Error("No handlers provided");
-
-            // provide generic functions if none are provided
-            if (keydownHandler == null) keydownHandler = function keydownHandler(_) {
-                return _;
-            };
-            if (keyupHandler == null) keyupHandler = function keyupHandler(_) {
-                return _;
-            };
-
-            var sharedStore = {};
-
-            // if the array has no items in it, we treat it as though it's listening to all keys presses
-            if (keysArr.length === 0) {
-                var _events = [];
-                var _keys = {};
-                keydownHandler = keydownHandler.bind(this);
-                keyupHandler = keyupHandler.bind(this);
-                this._genericKeyListeners.push({
-                    keyDown: function keyDown(e) {
-                        _events.push(e);
-                        return keydownHandler(e, sharedStore, _this2._keysActive.slice());
-                    },
-                    keyUp: function keyUp(e) {
-                        return keyupHandler(e, sharedStore, _this2._keysActive.slice());
-                    },
-                    _keys: _keys,
-                    _events: _events
-                });
-                // technically unnecessary bail out as the following forEach won't work
-                return;
-            }
-
-            // Hotkeys were provided, loop through them
-            keysArr.forEach(function (keys) {
-                // normalise our input
-                keys = parseKeyCode(keys).map(normalizeHotKey).sort(HotKeySort);
-
-                var keyActiveBuffer = [];
-                var _events = [];
-
-                keydownHandler = keydownHandler.bind(_this2);
-                keyupHandler = keyupHandler.bind(_this2);
-
-                addKeyListener(_this2, keys.join("+")).push({
-                    keyDown: function keyDown(e) {
-                        // we need to cache a copy of the active keys at the time of the keyDown event
-                        // as when keyUp is triggered the keysActive can be different. We can possibly fiddle with the
-                        // handleKeyDown method to fix this, but one way or another, we should make a separate copy
-                        // from the one that's sent to keydownHandler as we want to make sure its untampered with.
-                        _events.push(e);
-                        keyActiveBuffer = _this2._keysActive.slice();
-                        return keydownHandler(e, sharedStore, _this2._keysActive.slice());
-                    },
-                    keyUp: function keyUp(e) {
-                        return keyupHandler(e, sharedStore, keyActiveBuffer);
-                    },
-                    _events: _events // posibbly only need to set this to an item instead of an array
-                });
-            });
-        },
-        handleKeyDown: function handleKeyDown(e) {
-            var _this3 = this;
-
-            // perhaps refactor;
-            var key = (e.which && e.keyCode ? KEYCODE_ALIAS_MAP[e.which || e.keyCode] : e.key).toLowerCase();
-
-            // don't allow duplicates to be pushed into our active keys,
-            // sort our keys so that they're in the same order every time
-            if (!this._keysActive.includes(key)) {
-                this._keysActive.push(key);
-                this._keysActive.sort(HotKeySort);
-            }
-
-            // join the keys together to make a string, we can use this key to search our listeners to see
-            // if it contains a property with the strings name
-            var keyStr = this._keysActive.map(normalizeHotKey).join("+");
-
-            if (this._keyListeners[keyStr] != null) this._keyListeners[keyStr].forEach(function (listenerGroup) {
-                if (listenerGroup.keyDown(e) !== false) {
-                    // if keyDown returns false, don't add keyUp
-                    if (!_this3._unresolvedKeyUps.includes(listenerGroup)) {
-                        _this3._unresolvedKeyUps.push(listenerGroup);
-                    }
-                }
-            });
-
-            // generic key listeners are queried after specific key listeners ones
-            this._genericKeyListeners.forEach(function (listenerGroup) {
-                var keyObj = getKeyObject(listenerGroup, key);
-                keyObj.trigger = listenerGroup.keyDown(e) !== false;
-                keyObj.event = e;
-            });
-        },
-        handleKeyUp: function handleKeyUp(e) {
-            var key = (e.which && e.keyCode ? KEYCODE_ALIAS_MAP[e.which || e.keyCode] : e.key).toLowerCase();
-
-            if (this._keysActive.includes(key)) {
-                this._keysActive.splice(this._keysActive.indexOf(key), 1);
-                this._keysActive.sort(HotKeySort);
-            }
-
-            this._unresolvedKeyUps.forEach(function (listenerGroup) {
-                return listenerGroup.keyUp(e);
-            });
-            this._unresolvedKeyUps.splice(0); // clear array
-
-            // run through our generic key ups
-            this._genericKeyListeners.forEach(function (listenerGroup) {
-                var keyObj = getKeyObject(listenerGroup, key);
-                if (keyObj.trigger !== false) {
-                    listenerGroup.keyUp(e);
-                    // set this trigger to false, this will stop this keyup event being triggered again
-                    // on window blur
-                    keyObj.trigger = false;
-                    keyObj.event = null;
-                }
-            });
-        }
-    });
-
-    return HotStuff;
-});
\ No newline at end of file
diff --git a/dist/HotStuff.min.js b/dist/HotStuff.min.js
deleted file mode 100644
index c03435b..0000000
--- a/dist/HotStuff.min.js
+++ /dev/null
@@ -1 +0,0 @@
-"use strict";var _typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e};!function(e,t){"function"==typeof define&&define.amd?define([],t):"object"===("undefined"==typeof exports?"undefined":_typeof(exports))?module.exports=t():e.HotStuff=t()}(window,function(){function e(e,t){var n=document.createEventObject?document.createEventObject():document.createEvent("Event");n.initEvent&&n.initEvent("keyup",!0,!0);for(var r in e)try{n[r]=e[r]}catch(e){}t.dispatchEvent?t.dispatchEvent(n):t.fireEvent("onkeyup",n)}var t={"+":"plus","-":"subtract",",":"comma"," ":"space","   ":"tab",arrowup:"up",arrowdown:"down",arrowleft:"left",arrowright:"right",control:"ctrl",delete:"del"},n=function(){for(var e={8:"backspace",9:"tab",13:"enter",16:"shift",17:"ctrl",18:"alt",19:"pause",20:"capslock",27:"esc",32:"space",33:"pageup",34:"pagedown",35:"end",36:"home",37:"left",38:"up",39:"right",40:"down",45:"insert",46:"del",59:";",61:"equals",91:"meta",92:"meta",93:"select",106:"multiply",107:"plus",109:"subtract",110:"decimal",111:"divide",144:"numlock",145:"scrolllock",186:";",187:"equals",189:"minus",190:".",191:"/",192:"grave",219:"[",220:"\\",221:"]",222:"'",223:"`"},t=0;t<=9;t++)e[48+t]=String.fromCharCode(48+t),e[96+t]="numpad"+t;for(var n=0;n<=11;n++)e[112+n]="f"+(n+1);for(var r=65;r<91;r++)e[r]=String.fromCharCode(r).toLowerCase();return e}(),r=function(e){return t[e]?t[e]:e},i=function(e,t){return"ctrl"!==e&&"control"!==e||(e="\0"),"alt"===e&&(e="
"),"shift"===e&&(e=""),"ctrl"!==t&&"control"!==t||(t="\0"),"alt"===t&&(t="
"),"shift"===t&&(t=""),e>t},o=function(e){return e.toLowerCase().split(/[+-]/)},s=function(e,t){return void 0===e._keyListeners[t]&&(e._keyListeners[t]=[]),e._keyListeners[t]},c=function(e,t){return void 0===(e=e._keys)[t]&&(e[t]={trigger:!1,event:null}),e[t]},u=function(e){return function(t,n){return Object.defineProperty(e,t,n)}},a=function e(){if(!(this instanceof e))return new(Function.prototype.bind.apply(e,[null].concat(Array.prototype.slice.call(arguments))));this.init.apply(this,arguments)};return Object.assign(a.prototype,{constructor:a,init:function(t){var n=this;if(null===t||void 0===t){if(!window)throw new Error("No element found to attach HotStuff to and could not find window object.");t=window}u(this)("el",{get:function(){return t},readOnly:!0,enumerable:!0}),this._keyListeners={},this._keysActive=[],this._unresolvedKeyUps=[],this._genericKeyListeners=[],t.addEventListener("keydown",this.handleKeyDown.bind(this)),t.addEventListener("keyup",this.handleKeyUp.bind(this)),function(e,t){["blur","focus"].forEach(function(e){return window.addEventListener(e,t)})}(0,function(){n._unresolvedKeyUps.forEach(function(t){e(t._events[t._events.length-1],n.el),t._events.splice()}),n._genericKeyListeners.forEach(function(t){var r=t._keys;for(var i in r)r.hasOwnProperty(i)&&r[i].trigger&&(e(r[i].event,n.el),r[i].trigger=!1)})})},addListener:function(e,t,n){var c=this;if("string"==typeof e&&(e=[e]),null===e&&(e=[]),e instanceof Function&&(n=t,t=e,e=[]),!(e instanceof Array))throw new Error("Invalid Keys provided");if(null==n&&null==t)throw new Error("No handlers provided");null==t&&(t=function(e){return e}),null==n&&(n=function(e){return e});var u={};if(0===e.length){var a=[],l={};return t=t.bind(this),n=n.bind(this),void this._genericKeyListeners.push({keyDown:function(e){return a.push(e),t(e,u,c._keysActive.slice())},keyUp:function(e){return n(e,u,c._keysActive.slice())},_keys:l,_events:a})}e.forEach(function(e){e=o(e).map(r).sort(i);var a=[],l=[];t=t.bind(c),n=n.bind(c),s(c,e.join("+")).push({keyDown:function(e){return l.push(e),a=c._keysActive.slice(),t(e,u,c._keysActive.slice())},keyUp:function(e){return n(e,u,a)},_events:l})})},handleKeyDown:function(e){var t=this,o=(e.which&&e.keyCode?n[e.which||e.keyCode]:e.key).toLowerCase();this._keysActive.includes(o)||(this._keysActive.push(o),this._keysActive.sort(i));var s=this._keysActive.map(r).join("+");null!=this._keyListeners[s]&&this._keyListeners[s].forEach(function(n){!1!==n.keyDown(e)&&(t._unresolvedKeyUps.includes(n)||t._unresolvedKeyUps.push(n))}),this._genericKeyListeners.forEach(function(t){var n=c(t,o);n.trigger=!1!==t.keyDown(e),n.event=e})},handleKeyUp:function(e){var t=(e.which&&e.keyCode?n[e.which||e.keyCode]:e.key).toLowerCase();this._keysActive.includes(t)&&(this._keysActive.splice(this._keysActive.indexOf(t),1),this._keysActive.sort(i)),this._unresolvedKeyUps.forEach(function(t){return t.keyUp(e)}),this._unresolvedKeyUps.splice(0),this._genericKeyListeners.forEach(function(n){var r=c(n,t);!1!==r.trigger&&(n.keyUp(e),r.trigger=!1,r.event=null)})}}),a});
\ No newline at end of file
diff --git a/dist/index.cjs.js b/dist/index.cjs.js
new file mode 100644
index 0000000..d6a168e
--- /dev/null
+++ b/dist/index.cjs.js
@@ -0,0 +1,321 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// Normalise and change certain keys
+var KEY_ALIAS_MAP = {
+    "+": "plus",
+    "-": "subtract",
+    ",": "comma",
+    " ": "space",
+    "   ": "tab",
+    arrowup: "up",
+    arrowdown: "down",
+    arrowleft: "left",
+    arrowright: "right",
+    control: "ctrl",
+    delete: "del"
+};
+// Generate KeyCode mapping. We could hardcode all of it, but its not too much a performance hit
+// to generate some of the keys
+var KEYCODE_ALIAS_MAP = (function () {
+    var keys = {
+        8: "backspace",
+        9: "tab",
+        13: "enter",
+        16: "shift",
+        17: "ctrl",
+        18: "alt",
+        19: "pause",
+        20: "capslock",
+        27: "esc",
+        32: "space",
+        33: "pageup",
+        34: "pagedown",
+        35: "end",
+        36: "home",
+        37: "left",
+        38: "up",
+        39: "right",
+        40: "down",
+        45: "insert",
+        46: "del",
+        59: ";",
+        61: "equals",
+        91: "meta",
+        92: "meta",
+        93: "select",
+        106: "multiply",
+        107: "plus",
+        109: "subtract",
+        110: "decimal",
+        111: "divide",
+        144: "numlock",
+        145: "scrolllock",
+        186: ";",
+        187: "equals",
+        189: "minus",
+        190: ".",
+        191: "/",
+        192: "grave",
+        219: "[",
+        220: "\\",
+        221: "]",
+        222: "'",
+        223: "`"
+    };
+    for (var i = 0; i <= 9; i++) {
+        // 0-9
+        keys[48 + i] = String.fromCharCode(48 + i);
+        // numpad0-9
+        keys[96 + i] = "numpad" + i;
+    }
+    // f keys
+    for (var i = 0; i <= 11; i++)
+        keys[112 + i] = "f" + (i + 1);
+    // a-z
+    for (var i = 65; i < 91; i++)
+        keys[i] = String.fromCharCode(i).toLowerCase();
+    return keys;
+})();
+
+// normalize keys by referring to KEY_ALIAS_MAP, this might have to be modified in the future
+// to take into account OS
+var normalizeHotKey = function (x) { return (KEY_ALIAS_MAP[x] ? KEY_ALIAS_MAP[x] : x); };
+// function to sort our key array, forces order to begin ctrl-alt-shift if they exist,
+// at the moment this happens by setting them to unicode characters 0-2
+// (which can't by typed normally on a keyboard)
+var HotKeySort = function (a, b) {
+    if (a === "ctrl" || a === "control")
+        a = "\x00";
+    if (a === "alt")
+        a = "\x01";
+    if (a === "shift")
+        a = "\x02";
+    if (b === "ctrl" || b === "control")
+        b = "\x00";
+    if (b === "alt")
+        b = "\x01";
+    if (b === "shift")
+        b = "\x02";
+    return a > b;
+};
+// may require some refactoring to take in special cases
+// such as having the ability to split multiple hotkeys by commas
+var parseKeyCode = function (str) {
+    return str.toLowerCase().split(/[+-]/);
+};
+// helper function to make sure that there is an array for us to push our handlers to
+var addKeyListener = function (T, key) {
+    if (T._keyListeners[key] === undefined)
+        T._keyListeners[key] = [];
+    return T._keyListeners[key];
+};
+var getKeyObject = function (keyObj, key) {
+    keyObj = keyObj._keys;
+    if (keyObj[key] === undefined)
+        keyObj[key] = {
+            trigger: false,
+            event: null
+        };
+    return keyObj[key];
+};
+function createFakeEvent(event, el) {
+    // @ts-ignore
+    var fakeEvent = document.createEventObject
+        // @ts-ignore
+        ? document.createEventObject()
+        : document.createEvent("Event");
+    if (fakeEvent.initEvent) {
+        fakeEvent.initEvent("keyup", true, true);
+    }
+    // attempt to add as many properties from the original event to our new fakeEvent
+    // avoid using has own property, it won't get most of the properties
+    for (var prop in event) {
+        try {
+            fakeEvent[prop] = event[prop];
+        }
+        catch (e) {
+            // do nothing, we'll just skip them.
+        }
+    }
+    el.dispatchEvent
+        ? el.dispatchEvent(fakeEvent)
+        : el.fireEvent("onkeyup", fakeEvent);
+}
+var DEFINE = function (o) { return function (p, v) { return Object.defineProperty(o, p, v); }; };
+// Begin HotStuff Class
+var HotStuff = function (el) {
+    if (!(this instanceof HotStuff)) {
+        new HotStuff(el);
+        return;
+    }
+    this.init(el);
+};
+// use assign to add methods to the prototype
+Object.assign(HotStuff.prototype, {
+    constructor: HotStuff,
+    init: function (el) {
+        var _this = this;
+        // with no element provided, try to attach to the window
+        if (el === null || el === undefined)
+            if (window)
+                el = window;
+            else
+                throw new Error("No element found to attach HotStuff to and could not find window object.");
+        var define = DEFINE(this);
+        define("el", {
+            get: function () {
+                return el;
+            },
+            readOnly: true,
+            enumerable: true
+        });
+        this._keyListeners = {};
+        this._keysActive = [];
+        this._unresolvedKeyUps = [];
+        // internal variables for generic key listeners (ones that listen to all keys)
+        this._genericKeyListeners = [];
+        el.addEventListener("keydown", this.handleKeyDown.bind(this));
+        el.addEventListener("keyup", this.handleKeyUp.bind(this));
+        // when the window loses or gains focus, trigger all key up events that haven't been triggered
+        (function (arr, func) {
+            arr.forEach(function (x) { return window.addEventListener(x, func); });
+        })(['blur', 'focus'], function () {
+            _this._unresolvedKeyUps.forEach(function (listenerGroup) {
+                createFakeEvent(listenerGroup._events[listenerGroup._events.length - 1], _this.el);
+                listenerGroup._events.splice();
+            });
+            // triggering generic key listeners are slightly more complex
+            // loop through all the keys, checking if the trigger is set to true,
+            // then creates the fake event for that letter
+            _this._genericKeyListeners.forEach(function (listenerGroup) {
+                var keys = listenerGroup._keys;
+                for (var property in keys) {
+                    if (keys.hasOwnProperty(property) && keys[property].trigger) {
+                        createFakeEvent(keys[property].event, _this.el);
+                        keys[property].trigger = false;
+                    }
+                }
+            });
+        });
+    },
+    addListener: function (keysArr, keydownHandler, keyupHandler) {
+        var _this = this;
+        // prepare our arguments
+        if (typeof keysArr === "string")
+            keysArr = [keysArr];
+        if (keysArr === null)
+            keysArr = [];
+        if (keysArr instanceof Function) {
+            keyupHandler = keydownHandler;
+            keydownHandler = keysArr;
+            keysArr = []; // pass an empty array, we'll detect the length of this later to determine type of listener
+        }
+        if (!(keysArr instanceof Array))
+            throw new Error("Invalid Keys provided");
+        if (keyupHandler == null && keydownHandler == null)
+            throw new Error("No handlers provided");
+        // provide generic functions if none are provided
+        if (keydownHandler == null)
+            keydownHandler = function (_) { return _; };
+        if (keyupHandler == null)
+            keyupHandler = function (_) { return _; };
+        var sharedStore = {};
+        // if the array has no items in it, we treat it as though it's listening to all keys presses
+        if (keysArr.length === 0) {
+            var _events_1 = [];
+            var _keys = {};
+            keydownHandler = keydownHandler.bind(this);
+            keyupHandler = keyupHandler.bind(this);
+            this._genericKeyListeners.push({
+                keyDown: function (e) {
+                    _events_1.push(e);
+                    return keydownHandler(e, sharedStore, _this._keysActive.slice());
+                },
+                keyUp: function (e) { return keyupHandler(e, sharedStore, _this._keysActive.slice()); },
+                _keys: _keys,
+                _events: _events_1
+            });
+            // technically unnecessary bail out as the following forEach won't work
+            return;
+        }
+        // Hotkeys were provided, loop through them
+        keysArr.forEach(function (keys) {
+            // normalise our input
+            keys = parseKeyCode(keys).map(normalizeHotKey).sort(HotKeySort);
+            var keyActiveBuffer = [];
+            var _events = [];
+            keydownHandler = keydownHandler.bind(_this);
+            keyupHandler = keyupHandler.bind(_this);
+            addKeyListener(_this, keys.join("+")).push({
+                keyDown: function (e) {
+                    // we need to cache a copy of the active keys at the time of the keyDown event
+                    // as when keyUp is triggered the keysActive can be different. We can possibly fiddle with the
+                    // handleKeyDown method to fix this, but one way or another, we should make a separate copy
+                    // from the one that's sent to keydownHandler as we want to make sure its untampered with.
+                    _events.push(e);
+                    keyActiveBuffer = _this._keysActive.slice();
+                    return keydownHandler(e, sharedStore, _this._keysActive.slice());
+                },
+                keyUp: function (e) { return keyupHandler(e, sharedStore, keyActiveBuffer); },
+                _events: _events // posibbly only need to set this to an item instead of an array
+            });
+        });
+    },
+    handleKeyDown: function (e) {
+        var _this = this;
+        // perhaps refactor;
+        var key = (e.which && e.keyCode
+            ? KEYCODE_ALIAS_MAP[e.which || e.keyCode]
+            : e.key).toLowerCase();
+        // don't allow duplicates to be pushed into our active keys,
+        // sort our keys so that they're in the same order every time
+        if (!this._keysActive.includes(key)) {
+            this._keysActive.push(key);
+            this._keysActive.sort(HotKeySort);
+        }
+        // join the keys together to make a string, we can use this key to search our listeners to see
+        // if it contains a property with the strings name
+        var keyStr = this._keysActive.map(normalizeHotKey).join("+");
+        if (this._keyListeners[keyStr] != null)
+            this._keyListeners[keyStr].forEach(function (listenerGroup) {
+                if (listenerGroup.keyDown(e) !== false) {
+                    // if keyDown returns false, don't add keyUp
+                    if (!_this._unresolvedKeyUps.includes(listenerGroup)) {
+                        _this._unresolvedKeyUps.push(listenerGroup);
+                    }
+                }
+            });
+        // generic key listeners are queried after specific key listeners ones
+        this._genericKeyListeners.forEach(function (listenerGroup) {
+            var keyObj = getKeyObject(listenerGroup, key);
+            keyObj.trigger = listenerGroup.keyDown(e) !== false;
+            keyObj.event = e;
+        });
+    },
+    handleKeyUp: function (e) {
+        var key = (e.which && e.keyCode
+            ? KEYCODE_ALIAS_MAP[e.which || e.keyCode]
+            : e.key).toLowerCase();
+        if (this._keysActive.includes(key)) {
+            this._keysActive.splice(this._keysActive.indexOf(key), 1);
+            this._keysActive.sort(HotKeySort);
+        }
+        this._unresolvedKeyUps.forEach(function (listenerGroup) { return listenerGroup.keyUp(e); });
+        this._unresolvedKeyUps.splice(0); // clear array
+        // run through our generic key ups
+        this._genericKeyListeners.forEach(function (listenerGroup) {
+            var keyObj = getKeyObject(listenerGroup, key);
+            if (keyObj.trigger !== false) {
+                listenerGroup.keyUp(e);
+                // set this trigger to false, this will stop this keyup event being triggered again
+                // on window blur
+                keyObj.trigger = false;
+                keyObj.event = null;
+            }
+        });
+    }
+});
+
+exports.default = HotStuff;
diff --git a/dist/index.esm.js b/dist/index.esm.js
new file mode 100644
index 0000000..aa955ca
--- /dev/null
+++ b/dist/index.esm.js
@@ -0,0 +1,317 @@
+// Normalise and change certain keys
+var KEY_ALIAS_MAP = {
+    "+": "plus",
+    "-": "subtract",
+    ",": "comma",
+    " ": "space",
+    "   ": "tab",
+    arrowup: "up",
+    arrowdown: "down",
+    arrowleft: "left",
+    arrowright: "right",
+    control: "ctrl",
+    delete: "del"
+};
+// Generate KeyCode mapping. We could hardcode all of it, but its not too much a performance hit
+// to generate some of the keys
+var KEYCODE_ALIAS_MAP = (function () {
+    var keys = {
+        8: "backspace",
+        9: "tab",
+        13: "enter",
+        16: "shift",
+        17: "ctrl",
+        18: "alt",
+        19: "pause",
+        20: "capslock",
+        27: "esc",
+        32: "space",
+        33: "pageup",
+        34: "pagedown",
+        35: "end",
+        36: "home",
+        37: "left",
+        38: "up",
+        39: "right",
+        40: "down",
+        45: "insert",
+        46: "del",
+        59: ";",
+        61: "equals",
+        91: "meta",
+        92: "meta",
+        93: "select",
+        106: "multiply",
+        107: "plus",
+        109: "subtract",
+        110: "decimal",
+        111: "divide",
+        144: "numlock",
+        145: "scrolllock",
+        186: ";",
+        187: "equals",
+        189: "minus",
+        190: ".",
+        191: "/",
+        192: "grave",
+        219: "[",
+        220: "\\",
+        221: "]",
+        222: "'",
+        223: "`"
+    };
+    for (var i = 0; i <= 9; i++) {
+        // 0-9
+        keys[48 + i] = String.fromCharCode(48 + i);
+        // numpad0-9
+        keys[96 + i] = "numpad" + i;
+    }
+    // f keys
+    for (var i = 0; i <= 11; i++)
+        keys[112 + i] = "f" + (i + 1);
+    // a-z
+    for (var i = 65; i < 91; i++)
+        keys[i] = String.fromCharCode(i).toLowerCase();
+    return keys;
+})();
+
+// normalize keys by referring to KEY_ALIAS_MAP, this might have to be modified in the future
+// to take into account OS
+var normalizeHotKey = function (x) { return (KEY_ALIAS_MAP[x] ? KEY_ALIAS_MAP[x] : x); };
+// function to sort our key array, forces order to begin ctrl-alt-shift if they exist,
+// at the moment this happens by setting them to unicode characters 0-2
+// (which can't by typed normally on a keyboard)
+var HotKeySort = function (a, b) {
+    if (a === "ctrl" || a === "control")
+        a = "\x00";
+    if (a === "alt")
+        a = "\x01";
+    if (a === "shift")
+        a = "\x02";
+    if (b === "ctrl" || b === "control")
+        b = "\x00";
+    if (b === "alt")
+        b = "\x01";
+    if (b === "shift")
+        b = "\x02";
+    return a > b;
+};
+// may require some refactoring to take in special cases
+// such as having the ability to split multiple hotkeys by commas
+var parseKeyCode = function (str) {
+    return str.toLowerCase().split(/[+-]/);
+};
+// helper function to make sure that there is an array for us to push our handlers to
+var addKeyListener = function (T, key) {
+    if (T._keyListeners[key] === undefined)
+        T._keyListeners[key] = [];
+    return T._keyListeners[key];
+};
+var getKeyObject = function (keyObj, key) {
+    keyObj = keyObj._keys;
+    if (keyObj[key] === undefined)
+        keyObj[key] = {
+            trigger: false,
+            event: null
+        };
+    return keyObj[key];
+};
+function createFakeEvent(event, el) {
+    // @ts-ignore
+    var fakeEvent = document.createEventObject
+        // @ts-ignore
+        ? document.createEventObject()
+        : document.createEvent("Event");
+    if (fakeEvent.initEvent) {
+        fakeEvent.initEvent("keyup", true, true);
+    }
+    // attempt to add as many properties from the original event to our new fakeEvent
+    // avoid using has own property, it won't get most of the properties
+    for (var prop in event) {
+        try {
+            fakeEvent[prop] = event[prop];
+        }
+        catch (e) {
+            // do nothing, we'll just skip them.
+        }
+    }
+    el.dispatchEvent
+        ? el.dispatchEvent(fakeEvent)
+        : el.fireEvent("onkeyup", fakeEvent);
+}
+var DEFINE = function (o) { return function (p, v) { return Object.defineProperty(o, p, v); }; };
+// Begin HotStuff Class
+var HotStuff = function (el) {
+    if (!(this instanceof HotStuff)) {
+        new HotStuff(el);
+        return;
+    }
+    this.init(el);
+};
+// use assign to add methods to the prototype
+Object.assign(HotStuff.prototype, {
+    constructor: HotStuff,
+    init: function (el) {
+        var _this = this;
+        // with no element provided, try to attach to the window
+        if (el === null || el === undefined)
+            if (window)
+                el = window;
+            else
+                throw new Error("No element found to attach HotStuff to and could not find window object.");
+        var define = DEFINE(this);
+        define("el", {
+            get: function () {
+                return el;
+            },
+            readOnly: true,
+            enumerable: true
+        });
+        this._keyListeners = {};
+        this._keysActive = [];
+        this._unresolvedKeyUps = [];
+        // internal variables for generic key listeners (ones that listen to all keys)
+        this._genericKeyListeners = [];
+        el.addEventListener("keydown", this.handleKeyDown.bind(this));
+        el.addEventListener("keyup", this.handleKeyUp.bind(this));
+        // when the window loses or gains focus, trigger all key up events that haven't been triggered
+        (function (arr, func) {
+            arr.forEach(function (x) { return window.addEventListener(x, func); });
+        })(['blur', 'focus'], function () {
+            _this._unresolvedKeyUps.forEach(function (listenerGroup) {
+                createFakeEvent(listenerGroup._events[listenerGroup._events.length - 1], _this.el);
+                listenerGroup._events.splice();
+            });
+            // triggering generic key listeners are slightly more complex
+            // loop through all the keys, checking if the trigger is set to true,
+            // then creates the fake event for that letter
+            _this._genericKeyListeners.forEach(function (listenerGroup) {
+                var keys = listenerGroup._keys;
+                for (var property in keys) {
+                    if (keys.hasOwnProperty(property) && keys[property].trigger) {
+                        createFakeEvent(keys[property].event, _this.el);
+                        keys[property].trigger = false;
+                    }
+                }
+            });
+        });
+    },
+    addListener: function (keysArr, keydownHandler, keyupHandler) {
+        var _this = this;
+        // prepare our arguments
+        if (typeof keysArr === "string")
+            keysArr = [keysArr];
+        if (keysArr === null)
+            keysArr = [];
+        if (keysArr instanceof Function) {
+            keyupHandler = keydownHandler;
+            keydownHandler = keysArr;
+            keysArr = []; // pass an empty array, we'll detect the length of this later to determine type of listener
+        }
+        if (!(keysArr instanceof Array))
+            throw new Error("Invalid Keys provided");
+        if (keyupHandler == null && keydownHandler == null)
+            throw new Error("No handlers provided");
+        // provide generic functions if none are provided
+        if (keydownHandler == null)
+            keydownHandler = function (_) { return _; };
+        if (keyupHandler == null)
+            keyupHandler = function (_) { return _; };
+        var sharedStore = {};
+        // if the array has no items in it, we treat it as though it's listening to all keys presses
+        if (keysArr.length === 0) {
+            var _events_1 = [];
+            var _keys = {};
+            keydownHandler = keydownHandler.bind(this);
+            keyupHandler = keyupHandler.bind(this);
+            this._genericKeyListeners.push({
+                keyDown: function (e) {
+                    _events_1.push(e);
+                    return keydownHandler(e, sharedStore, _this._keysActive.slice());
+                },
+                keyUp: function (e) { return keyupHandler(e, sharedStore, _this._keysActive.slice()); },
+                _keys: _keys,
+                _events: _events_1
+            });
+            // technically unnecessary bail out as the following forEach won't work
+            return;
+        }
+        // Hotkeys were provided, loop through them
+        keysArr.forEach(function (keys) {
+            // normalise our input
+            keys = parseKeyCode(keys).map(normalizeHotKey).sort(HotKeySort);
+            var keyActiveBuffer = [];
+            var _events = [];
+            keydownHandler = keydownHandler.bind(_this);
+            keyupHandler = keyupHandler.bind(_this);
+            addKeyListener(_this, keys.join("+")).push({
+                keyDown: function (e) {
+                    // we need to cache a copy of the active keys at the time of the keyDown event
+                    // as when keyUp is triggered the keysActive can be different. We can possibly fiddle with the
+                    // handleKeyDown method to fix this, but one way or another, we should make a separate copy
+                    // from the one that's sent to keydownHandler as we want to make sure its untampered with.
+                    _events.push(e);
+                    keyActiveBuffer = _this._keysActive.slice();
+                    return keydownHandler(e, sharedStore, _this._keysActive.slice());
+                },
+                keyUp: function (e) { return keyupHandler(e, sharedStore, keyActiveBuffer); },
+                _events: _events // posibbly only need to set this to an item instead of an array
+            });
+        });
+    },
+    handleKeyDown: function (e) {
+        var _this = this;
+        // perhaps refactor;
+        var key = (e.which && e.keyCode
+            ? KEYCODE_ALIAS_MAP[e.which || e.keyCode]
+            : e.key).toLowerCase();
+        // don't allow duplicates to be pushed into our active keys,
+        // sort our keys so that they're in the same order every time
+        if (!this._keysActive.includes(key)) {
+            this._keysActive.push(key);
+            this._keysActive.sort(HotKeySort);
+        }
+        // join the keys together to make a string, we can use this key to search our listeners to see
+        // if it contains a property with the strings name
+        var keyStr = this._keysActive.map(normalizeHotKey).join("+");
+        if (this._keyListeners[keyStr] != null)
+            this._keyListeners[keyStr].forEach(function (listenerGroup) {
+                if (listenerGroup.keyDown(e) !== false) {
+                    // if keyDown returns false, don't add keyUp
+                    if (!_this._unresolvedKeyUps.includes(listenerGroup)) {
+                        _this._unresolvedKeyUps.push(listenerGroup);
+                    }
+                }
+            });
+        // generic key listeners are queried after specific key listeners ones
+        this._genericKeyListeners.forEach(function (listenerGroup) {
+            var keyObj = getKeyObject(listenerGroup, key);
+            keyObj.trigger = listenerGroup.keyDown(e) !== false;
+            keyObj.event = e;
+        });
+    },
+    handleKeyUp: function (e) {
+        var key = (e.which && e.keyCode
+            ? KEYCODE_ALIAS_MAP[e.which || e.keyCode]
+            : e.key).toLowerCase();
+        if (this._keysActive.includes(key)) {
+            this._keysActive.splice(this._keysActive.indexOf(key), 1);
+            this._keysActive.sort(HotKeySort);
+        }
+        this._unresolvedKeyUps.forEach(function (listenerGroup) { return listenerGroup.keyUp(e); });
+        this._unresolvedKeyUps.splice(0); // clear array
+        // run through our generic key ups
+        this._genericKeyListeners.forEach(function (listenerGroup) {
+            var keyObj = getKeyObject(listenerGroup, key);
+            if (keyObj.trigger !== false) {
+                listenerGroup.keyUp(e);
+                // set this trigger to false, this will stop this keyup event being triggered again
+                // on window blur
+                keyObj.trigger = false;
+                keyObj.event = null;
+            }
+        });
+    }
+});
+
+export default HotStuff;
diff --git a/package-lock.json b/package-lock.json
new file mode 100644
index 0000000..359c458
--- /dev/null
+++ b/package-lock.json
@@ -0,0 +1,410 @@
+{
+  "name": "hotstuff",
+  "version": "0.1.0",
+  "lockfileVersion": 1,
+  "requires": true,
+  "dependencies": {
+    "arr-diff": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-2.0.0.tgz",
+      "integrity": "sha1-jzuCf5Vai9ZpaX5KQlasPOrjVs8=",
+      "dev": true,
+      "requires": {
+        "arr-flatten": "^1.0.1"
+      }
+    },
+    "arr-flatten": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/arr-flatten/-/arr-flatten-1.1.0.tgz",
+      "integrity": "sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg==",
+      "dev": true
+    },
+    "array-unique": {
+      "version": "0.2.1",
+      "resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.2.1.tgz",
+      "integrity": "sha1-odl8yvy8JiXMcPrc6zalDFiwGlM=",
+      "dev": true
+    },
+    "braces": {
+      "version": "1.8.5",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-1.8.5.tgz",
+      "integrity": "sha1-uneWLhLf+WnWt2cR6RS3N4V79qc=",
+      "dev": true,
+      "requires": {
+        "expand-range": "^1.8.1",
+        "preserve": "^0.2.0",
+        "repeat-element": "^1.1.2"
+      }
+    },
+    "estree-walker": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-0.5.2.tgz",
+      "integrity": "sha512-XpCnW/AE10ws/kDAs37cngSkvgIR8aN3G0MS85m7dUpuK2EREo9VJ00uvw6Dg/hXEpfsE1I1TvJOJr+Z+TL+ig==",
+      "dev": true
+    },
+    "expand-brackets": {
+      "version": "0.1.5",
+      "resolved": "https://registry.npmjs.org/expand-brackets/-/expand-brackets-0.1.5.tgz",
+      "integrity": "sha1-3wcoTjQqgHzXM6xa9yQR5YHRF3s=",
+      "dev": true,
+      "requires": {
+        "is-posix-bracket": "^0.1.0"
+      }
+    },
+    "expand-range": {
+      "version": "1.8.2",
+      "resolved": "https://registry.npmjs.org/expand-range/-/expand-range-1.8.2.tgz",
+      "integrity": "sha1-opnv/TNf4nIeuujiV+x5ZE/IUzc=",
+      "dev": true,
+      "requires": {
+        "fill-range": "^2.1.0"
+      }
+    },
+    "extglob": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/extglob/-/extglob-0.3.2.tgz",
+      "integrity": "sha1-Lhj/PS9JqydlzskCPwEdqo2DSaE=",
+      "dev": true,
+      "requires": {
+        "is-extglob": "^1.0.0"
+      }
+    },
+    "filename-regex": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/filename-regex/-/filename-regex-2.0.1.tgz",
+      "integrity": "sha1-wcS5vuPglyXdsQa3XB4wH+LxiyY=",
+      "dev": true
+    },
+    "fill-range": {
+      "version": "2.2.4",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-2.2.4.tgz",
+      "integrity": "sha512-cnrcCbj01+j2gTG921VZPnHbjmdAf8oQV/iGeV2kZxGSyfYjjTyY79ErsK1WJWMpw6DaApEX72binqJE+/d+5Q==",
+      "dev": true,
+      "requires": {
+        "is-number": "^2.1.0",
+        "isobject": "^2.0.0",
+        "randomatic": "^3.0.0",
+        "repeat-element": "^1.1.2",
+        "repeat-string": "^1.5.2"
+      }
+    },
+    "for-in": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/for-in/-/for-in-1.0.2.tgz",
+      "integrity": "sha1-gQaNKVqBQuwKxybG4iAMMPttXoA=",
+      "dev": true
+    },
+    "for-own": {
+      "version": "0.1.5",
+      "resolved": "https://registry.npmjs.org/for-own/-/for-own-0.1.5.tgz",
+      "integrity": "sha1-UmXGgaTylNq78XyVCbZ2OqhFEM4=",
+      "dev": true,
+      "requires": {
+        "for-in": "^1.0.1"
+      }
+    },
+    "fs-extra": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-7.0.1.tgz",
+      "integrity": "sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw==",
+      "dev": true,
+      "requires": {
+        "graceful-fs": "^4.1.2",
+        "jsonfile": "^4.0.0",
+        "universalify": "^0.1.0"
+      }
+    },
+    "glob-base": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/glob-base/-/glob-base-0.3.0.tgz",
+      "integrity": "sha1-27Fk9iIbHAscz4Kuoyi0l98Oo8Q=",
+      "dev": true,
+      "requires": {
+        "glob-parent": "^2.0.0",
+        "is-glob": "^2.0.0"
+      }
+    },
+    "glob-parent": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-2.0.0.tgz",
+      "integrity": "sha1-gTg9ctsFT8zPUzbaqQLxgvbtuyg=",
+      "dev": true,
+      "requires": {
+        "is-glob": "^2.0.0"
+      }
+    },
+    "graceful-fs": {
+      "version": "4.1.15",
+      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.1.15.tgz",
+      "integrity": "sha512-6uHUhOPEBgQ24HM+r6b/QwWfZq+yiFcipKFrOFiBEnWdy5sdzYoi+pJeQaPI5qOLRFqWmAXUPQNsielzdLoecA==",
+      "dev": true
+    },
+    "is-buffer": {
+      "version": "1.1.6",
+      "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz",
+      "integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==",
+      "dev": true
+    },
+    "is-dotfile": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/is-dotfile/-/is-dotfile-1.0.3.tgz",
+      "integrity": "sha1-pqLzL/0t+wT1yiXs0Pa4PPeYoeE=",
+      "dev": true
+    },
+    "is-equal-shallow": {
+      "version": "0.1.3",
+      "resolved": "https://registry.npmjs.org/is-equal-shallow/-/is-equal-shallow-0.1.3.tgz",
+      "integrity": "sha1-IjgJj8Ih3gvPpdnqxMRdY4qhxTQ=",
+      "dev": true,
+      "requires": {
+        "is-primitive": "^2.0.0"
+      }
+    },
+    "is-extendable": {
+      "version": "0.1.1",
+      "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz",
+      "integrity": "sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=",
+      "dev": true
+    },
+    "is-extglob": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-1.0.0.tgz",
+      "integrity": "sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=",
+      "dev": true
+    },
+    "is-glob": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-2.0.1.tgz",
+      "integrity": "sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=",
+      "dev": true,
+      "requires": {
+        "is-extglob": "^1.0.0"
+      }
+    },
+    "is-number": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-number/-/is-number-2.1.0.tgz",
+      "integrity": "sha1-Afy7s5NGOlSPL0ZszhbezknbkI8=",
+      "dev": true,
+      "requires": {
+        "kind-of": "^3.0.2"
+      }
+    },
+    "is-posix-bracket": {
+      "version": "0.1.1",
+      "resolved": "https://registry.npmjs.org/is-posix-bracket/-/is-posix-bracket-0.1.1.tgz",
+      "integrity": "sha1-MzTceXdDaOkvAW5vvAqI9c1ua8Q=",
+      "dev": true
+    },
+    "is-primitive": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/is-primitive/-/is-primitive-2.0.0.tgz",
+      "integrity": "sha1-IHurkWOEmcB7Kt8kCkGochADRXU=",
+      "dev": true
+    },
+    "isarray": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
+      "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=",
+      "dev": true
+    },
+    "isobject": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/isobject/-/isobject-2.1.0.tgz",
+      "integrity": "sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=",
+      "dev": true,
+      "requires": {
+        "isarray": "1.0.0"
+      }
+    },
+    "jsonfile": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz",
+      "integrity": "sha1-h3Gq4HmbZAdrdmQPygWPnBDjPss=",
+      "dev": true,
+      "requires": {
+        "graceful-fs": "^4.1.6"
+      }
+    },
+    "kind-of": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz",
+      "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
+      "dev": true,
+      "requires": {
+        "is-buffer": "^1.1.5"
+      }
+    },
+    "math-random": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/math-random/-/math-random-1.0.4.tgz",
+      "integrity": "sha512-rUxjysqif/BZQH2yhd5Aaq7vXMSx9NdEsQcyA07uEzIvxgI7zIr33gGsh+RU0/XjmQpCW7RsVof1vlkvQVCK5A==",
+      "dev": true
+    },
+    "micromatch": {
+      "version": "2.3.11",
+      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-2.3.11.tgz",
+      "integrity": "sha1-hmd8l9FyCzY0MdBNDRUpO9OMFWU=",
+      "dev": true,
+      "requires": {
+        "arr-diff": "^2.0.0",
+        "array-unique": "^0.2.1",
+        "braces": "^1.8.2",
+        "expand-brackets": "^0.1.4",
+        "extglob": "^0.3.1",
+        "filename-regex": "^2.0.0",
+        "is-extglob": "^1.0.0",
+        "is-glob": "^2.0.1",
+        "kind-of": "^3.0.2",
+        "normalize-path": "^2.0.1",
+        "object.omit": "^2.0.0",
+        "parse-glob": "^3.0.4",
+        "regex-cache": "^0.4.2"
+      }
+    },
+    "normalize-path": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-2.1.1.tgz",
+      "integrity": "sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=",
+      "dev": true,
+      "requires": {
+        "remove-trailing-separator": "^1.0.1"
+      }
+    },
+    "object.omit": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/object.omit/-/object.omit-2.0.1.tgz",
+      "integrity": "sha1-Gpx0SCnznbuFjHbKNXmuKlTr0fo=",
+      "dev": true,
+      "requires": {
+        "for-own": "^0.1.4",
+        "is-extendable": "^0.1.1"
+      }
+    },
+    "parse-glob": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/parse-glob/-/parse-glob-3.0.4.tgz",
+      "integrity": "sha1-ssN2z7EfNVE7rdFz7wu246OIORw=",
+      "dev": true,
+      "requires": {
+        "glob-base": "^0.3.0",
+        "is-dotfile": "^1.0.0",
+        "is-extglob": "^1.0.0",
+        "is-glob": "^2.0.0"
+      }
+    },
+    "path-parse": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz",
+      "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==",
+      "dev": true
+    },
+    "preserve": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/preserve/-/preserve-0.2.0.tgz",
+      "integrity": "sha1-gV7R9uvGWSb4ZbMQwHE7yzMVzks=",
+      "dev": true
+    },
+    "randomatic": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/randomatic/-/randomatic-3.1.1.tgz",
+      "integrity": "sha512-TuDE5KxZ0J461RVjrJZCJc+J+zCkTb1MbH9AQUq68sMhOMcy9jLcb3BrZKgp9q9Ncltdg4QVqWrH02W2EFFVYw==",
+      "dev": true,
+      "requires": {
+        "is-number": "^4.0.0",
+        "kind-of": "^6.0.0",
+        "math-random": "^1.0.1"
+      },
+      "dependencies": {
+        "is-number": {
+          "version": "4.0.0",
+          "resolved": "https://registry.npmjs.org/is-number/-/is-number-4.0.0.tgz",
+          "integrity": "sha512-rSklcAIlf1OmFdyAqbnWTLVelsQ58uvZ66S/ZyawjWqIviTWCjg2PzVGw8WUA+nNuPTqb4wgA+NszrJ+08LlgQ==",
+          "dev": true
+        },
+        "kind-of": {
+          "version": "6.0.2",
+          "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.2.tgz",
+          "integrity": "sha512-s5kLOcnH0XqDO+FvuaLX8DDjZ18CGFk7VygH40QoKPUQhW4e2rvM0rwUq0t8IQDOwYSeLK01U90OjzBTme2QqA==",
+          "dev": true
+        }
+      }
+    },
+    "regex-cache": {
+      "version": "0.4.4",
+      "resolved": "https://registry.npmjs.org/regex-cache/-/regex-cache-0.4.4.tgz",
+      "integrity": "sha512-nVIZwtCjkC9YgvWkpM55B5rBhBYRZhAaJbgcFYXXsHnbZ9UZI9nnVWYZpBlCqv9ho2eZryPnWrZGsOdPwVWXWQ==",
+      "dev": true,
+      "requires": {
+        "is-equal-shallow": "^0.1.3"
+      }
+    },
+    "remove-trailing-separator": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz",
+      "integrity": "sha1-wkvOKig62tW8P1jg1IJJuSN52O8=",
+      "dev": true
+    },
+    "repeat-element": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/repeat-element/-/repeat-element-1.1.3.tgz",
+      "integrity": "sha512-ahGq0ZnV5m5XtZLMb+vP76kcAM5nkLqk0lpqAuojSKGgQtn4eRi4ZZGm2olo2zKFH+sMsWaqOCW1dqAnOru72g==",
+      "dev": true
+    },
+    "repeat-string": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz",
+      "integrity": "sha1-jcrkcOHIirwtYA//Sndihtp15jc=",
+      "dev": true
+    },
+    "resolve": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.8.1.tgz",
+      "integrity": "sha512-AicPrAC7Qu1JxPCZ9ZgCZlY35QgFnNqc+0LtbRNxnVw4TXvjQ72wnuL9JQcEBgXkI9JM8MsT9kaQoHcpCRJOYA==",
+      "dev": true,
+      "requires": {
+        "path-parse": "^1.0.5"
+      }
+    },
+    "rollup-plugin-typescript2": {
+      "version": "0.19.2",
+      "resolved": "https://registry.npmjs.org/rollup-plugin-typescript2/-/rollup-plugin-typescript2-0.19.2.tgz",
+      "integrity": "sha512-DRG7SaYX0QzBIz6rII5nm1UkiceS95r8mJjujugybyIueNF3auvzGTHMK62O7As/0q5RHjXsOguWOUv+KJKLFA==",
+      "dev": true,
+      "requires": {
+        "fs-extra": "7.0.1",
+        "resolve": "1.8.1",
+        "rollup-pluginutils": "2.3.3",
+        "tslib": "1.9.3"
+      }
+    },
+    "rollup-pluginutils": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/rollup-pluginutils/-/rollup-pluginutils-2.3.3.tgz",
+      "integrity": "sha512-2XZwja7b6P5q4RZ5FhyX1+f46xi1Z3qBKigLRZ6VTZjwbN0K1IFGMlwm06Uu0Emcre2Z63l77nq/pzn+KxIEoA==",
+      "dev": true,
+      "requires": {
+        "estree-walker": "^0.5.2",
+        "micromatch": "^2.3.11"
+      }
+    },
+    "tslib": {
+      "version": "1.9.3",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.9.3.tgz",
+      "integrity": "sha512-4krF8scpejhaOgqzBEcGM7yDIEfi0/8+8zDRZhNZZ2kjmHJ4hv3zCbQWxoJGz1iw5U0Jl0nma13xzHXcncMavQ==",
+      "dev": true
+    },
+    "typescript": {
+      "version": "3.3.3333",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.3.3333.tgz",
+      "integrity": "sha512-JjSKsAfuHBE/fB2oZ8NxtRTk5iGcg6hkYXMnZ3Wc+b2RSqejEqTaem11mHASMnFilHrax3sLK0GDzcJrekZYLw==",
+      "dev": true
+    },
+    "universalify": {
+      "version": "0.1.2",
+      "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz",
+      "integrity": "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==",
+      "dev": true
+    }
+  }
+}
diff --git a/package.json b/package.json
index 5f676c3..2cbc7a0 100644
--- a/package.json
+++ b/package.json
@@ -1,9 +1,11 @@
 {
   "name": "hotstuff",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "A small package to provide an easy way to add Hotkeys easily to any element.",
-  "main": "dist/HotStuff.js",
-  "keywords" : [
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.esm.js",
+  "typings": "types/index.d.ts",
+  "keywords": [
     "keyboard",
     "events",
     "keyboard events",
@@ -13,7 +15,8 @@
     "shortcuts"
   ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "rollup -c ./build/rollup.js"
   },
   "repository": {
     "type": "git",
@@ -32,13 +35,7 @@
   },
   "homepage": "https://github.com/laquasicinque/hotstuff#readme",
   "devDependencies": {
-    "babel-preset-es2015": "^6.24.1",
-    "brackets-eslint": "^3.0.6",
-    "gulp": "^3.9.1",
-    "gulp-babel": "^6.1.2",
-    "gulp-eslint": "^4.0.0",
-    "gulp-rename": "^1.2.2",
-    "gulp-uglify": "^3.0.0",
-    "pump": "^1.0.2"
+    "rollup-plugin-typescript2": "^0.19.2",
+    "typescript": "^3.3.3333"
   }
 }
diff --git a/src/HotStuff.js b/src/HotStuff.js
deleted file mode 100644
index b5db2e2..0000000
--- a/src/HotStuff.js
+++ /dev/null
@@ -1,346 +0,0 @@
-(function (root, factory) {
-    if (typeof define === "function" && define.amd) {
-        define([], factory);
-    } else if (typeof exports === "object") {
-        module.exports = factory();
-    } else {
-        root.HotStuff = factory();
-    }
-})(window, function () {
-    // Normalise and change certain keys
-    const KEY_ALIAS_MAP = {
-        "+": "plus",
-        "-": "subtract",
-        ",": "comma",
-        " ": "space",
-        "   ": "tab",
-        arrowup: "up",
-        arrowdown: "down",
-        arrowleft: "left",
-        arrowright: "right",
-        control: "ctrl",
-        delete: "del"
-    };
-
-    // Generate KeyCode mapping. We could hardcode all of it, but its not too much a performance hit
-    // to generate some of the keys
-    const KEYCODE_ALIAS_MAP = (function () {
-        const keys = {
-            8: "backspace",
-            9: "tab",
-            13: "enter",
-            16: "shift",
-            17: "ctrl",
-            18: "alt",
-            19: "pause",
-            20: "capslock",
-            27: "esc",
-            32: "space",
-            33: "pageup",
-            34: "pagedown",
-            35: "end",
-            36: "home",
-            37: "left",
-            38: "up",
-            39: "right",
-            40: "down",
-            45: "insert",
-            46: "del",
-            59: ";",
-            61: "equals",
-            91: "meta",
-            92: "meta",
-            93: "select",
-            106: "multiply",
-            107: "plus",
-            109: "subtract",
-            110: "decimal",
-            111: "divide",
-            144: "numlock",
-            145: "scrolllock",
-            186: ";",
-            187: "equals",
-            189: "minus",
-            190: ".",
-            191: "/",
-            192: "grave",
-            219: "[",
-            220: "\\",
-            221: "]",
-            222: "'",
-            223: "`"
-        };
-
-        for (let i = 0; i <= 9; i++) {
-            // 0-9
-            keys[48 + i] = String.fromCharCode(48 + i);
-            // numpad0-9
-            keys[96 + i] = "numpad" + i;
-        }
-
-        // f keys
-        for (let i = 0; i <= 11; i++) keys[112 + i] = "f" + (i + 1);
-        // a-z
-        for (let i = 65; i < 91; i++)
-            keys[i] = String.fromCharCode(i).toLowerCase();
-
-        return keys;
-    })();
-
-    // normalize keys by referring to KEY_ALIAS_MAP, this might have to be modified in the future
-    // to take into account OS
-    const normalizeHotKey = x => (KEY_ALIAS_MAP[x] ? KEY_ALIAS_MAP[x] : x);
-
-    // function to sort our key array, forces order to begin ctrl-alt-shift if they exist,
-    // at the moment this happens by setting them to unicode characters 0-2
-    // (which can't by typed normally on a keyboard)
-    const HotKeySort = function (a, b) {
-        if (a === "ctrl" || a === "control") a = "\x00";
-        if (a === "alt") a = "\x01";
-        if (a === "shift") a = "\x02";
-
-        if (b === "ctrl" || b === "control") b = "\x00";
-        if (b === "alt") b = "\x01";
-        if (b === "shift") b = "\x02";
-
-        return a > b;
-    };
-
-    // may require some refactoring to take in special cases
-    // such as having the ability to split multiple hotkeys by commas
-    const parseKeyCode = function (str) {
-        return str.toLowerCase().split(/[+-]/);
-    };
-
-    // helper function to make sure that there is an array for us to push our handlers to
-    const addKeyListener = function (T, key) {
-        if (T._keyListeners[key] === undefined) T._keyListeners[key] = [];
-        return T._keyListeners[key];
-    };
-
-    const getKeyObject = function (keyObj, key) {
-        keyObj = keyObj._keys;
-        if (keyObj[key] === undefined) keyObj[key] = {
-            trigger: false,
-            event: null
-        }
-        return keyObj[key];
-    };
-
-    function createFakeEvent(event, el) {
-        let fakeEvent = document.createEventObject
-            ? document.createEventObject()
-            : document.createEvent("Event");
-        if (fakeEvent.initEvent) {
-            fakeEvent.initEvent("keyup", true, true);
-        }
-        // attempt to add as many properties from the original event to our new fakeEvent
-        // avoid using has own property, it won't get most of the properties
-        for (let prop in event) {
-            try {
-                fakeEvent[prop] = event[prop];
-            } catch (e) {
-                // do nothing, we'll just skip them.
-            }
-        }
-
-        el.dispatchEvent
-            ? el.dispatchEvent(fakeEvent)
-            : el.fireEvent("onkeyup", fakeEvent);
-    }
-
-    const DEFINE = o => (p, v) => Object.defineProperty(o, p, v);
-
-    // Begin HotStuff Class
-    const HotStuff = function () {
-        if (!(this instanceof HotStuff)) return new HotStuff(...arguments);
-        this.init(...arguments);
-    };
-
-    // use assign to add methods to the prototype
-    Object.assign(HotStuff.prototype, {
-        constructor: HotStuff,
-        init(el) {
-            // with no element provided, try to attach to the window
-            if (el === null || el === undefined)
-                if (window) el = window;
-                else
-                    throw new Error(
-                        "No element found to attach HotStuff to and could not find window object."
-                    );
-
-            const define = DEFINE(this);
-
-            define("el", {
-                get() {
-                    return el;
-                },
-                readOnly: true,
-                enumerable: true
-            });
-
-            this._keyListeners = {};
-            this._keysActive = [];
-            this._unresolvedKeyUps = [];
-
-            // internal variables for generic key listeners (ones that listen to all keys)
-            this._genericKeyListeners = [];
-
-            el.addEventListener("keydown", this.handleKeyDown.bind(this));
-            el.addEventListener("keyup", this.handleKeyUp.bind(this));
-
-            // when the window loses or gains focus, trigger all key up events that haven't been triggered
-            (function (arr, func) {
-                arr.forEach(x => window.addEventListener(x, func));
-            })(['blur', 'focus'], () => {
-                this._unresolvedKeyUps.forEach(listenerGroup => {
-                    createFakeEvent(
-                        listenerGroup._events[listenerGroup._events.length - 1],
-                        this.el
-                    );
-                    listenerGroup._events.splice();
-                });
-
-                // triggering generic key listeners are slightly more complex
-                // loop through all the keys, checking if the trigger is set to true,
-                // then creates the fake event for that letter
-                this._genericKeyListeners.forEach(listenerGroup => {
-                    let keys = listenerGroup._keys;
-                    for (let property in keys) {
-                        if (keys.hasOwnProperty(property) && keys[property].trigger) {
-                            createFakeEvent(keys[property].event, this.el);
-                            keys[property].trigger = false;
-                        }
-                    }
-                });
-            });
-        },
-        addListener(keysArr, keydownHandler, keyupHandler) {
-            // prepare our arguments
-            if (typeof keysArr === "string") keysArr = [keysArr];
-            if (keysArr === null) keysArr = [];
-            if (keysArr instanceof Function) {
-                keyupHandler = keydownHandler;
-                keydownHandler = keysArr;
-                keysArr = []; // pass an empty array, we'll detect the length of this later to determine type of listener
-            }
-
-            if (!(keysArr instanceof Array)) throw new Error("Invalid Keys provided");
-
-            if (keyupHandler == null && keydownHandler == null)
-                throw new Error("No handlers provided");
-
-            // provide generic functions if none are provided
-            if (keydownHandler == null) keydownHandler = _ => _;
-            if (keyupHandler == null) keyupHandler = _ => _;
-
-            const sharedStore = {};
-
-            // if the array has no items in it, we treat it as though it's listening to all keys presses
-            if (keysArr.length === 0) {
-                let _events = [];
-                let _keys = {};
-                keydownHandler = keydownHandler.bind(this);
-                keyupHandler = keyupHandler.bind(this);
-                this._genericKeyListeners.push({
-                    keyDown: e => {
-                        _events.push(e);
-                        return keydownHandler(e, sharedStore, this._keysActive.slice());
-                    },
-                    keyUp: e => keyupHandler(e, sharedStore, this._keysActive.slice()),
-                    _keys: _keys,
-                    _events: _events
-                });
-                // technically unnecessary bail out as the following forEach won't work
-                return;
-            }
-
-            // Hotkeys were provided, loop through them
-            keysArr.forEach(keys => {
-                // normalise our input
-                keys = parseKeyCode(keys).map(normalizeHotKey).sort(HotKeySort);
-
-                let keyActiveBuffer = [];
-                let _events = [];
-
-                keydownHandler = keydownHandler.bind(this);
-                keyupHandler = keyupHandler.bind(this);
-
-                addKeyListener(this, keys.join("+")).push({
-                    keyDown: e => {
-                        // we need to cache a copy of the active keys at the time of the keyDown event
-                        // as when keyUp is triggered the keysActive can be different. We can possibly fiddle with the
-                        // handleKeyDown method to fix this, but one way or another, we should make a separate copy
-                        // from the one that's sent to keydownHandler as we want to make sure its untampered with.
-                        _events.push(e);
-                        keyActiveBuffer = this._keysActive.slice();
-                        return keydownHandler(e, sharedStore, this._keysActive.slice());
-                    },
-                    keyUp: e => keyupHandler(e, sharedStore, keyActiveBuffer),
-                    _events: _events // posibbly only need to set this to an item instead of an array
-                });
-            });
-        },
-        handleKeyDown(e) {
-            // perhaps refactor;
-            const key = (e.which && e.keyCode
-                ? KEYCODE_ALIAS_MAP[e.which || e.keyCode]
-                : e.key).toLowerCase();
-
-            // don't allow duplicates to be pushed into our active keys,
-            // sort our keys so that they're in the same order every time
-            if (!this._keysActive.includes(key)) {
-                this._keysActive.push(key);
-                this._keysActive.sort(HotKeySort);
-            }
-
-            // join the keys together to make a string, we can use this key to search our listeners to see
-            // if it contains a property with the strings name
-            const keyStr = this._keysActive.map(normalizeHotKey).join("+");
-
-            if (this._keyListeners[keyStr] != null)
-                this._keyListeners[keyStr].forEach(listenerGroup => {
-                    if (listenerGroup.keyDown(e) !== false) {
-                        // if keyDown returns false, don't add keyUp
-                        if (!this._unresolvedKeyUps.includes(listenerGroup)) {
-                            this._unresolvedKeyUps.push(listenerGroup);
-                        }
-                    }
-                });
-
-            // generic key listeners are queried after specific key listeners ones
-            this._genericKeyListeners.forEach(listenerGroup => {
-                let keyObj = getKeyObject(listenerGroup, key);
-                keyObj.trigger = listenerGroup.keyDown(e) !== false;
-                keyObj.event = e;
-            });
-        },
-        handleKeyUp(e) {
-            const key = (e.which && e.keyCode
-                ? KEYCODE_ALIAS_MAP[e.which || e.keyCode]
-                : e.key).toLowerCase();
-
-            if (this._keysActive.includes(key)) {
-                this._keysActive.splice(this._keysActive.indexOf(key), 1);
-                this._keysActive.sort(HotKeySort);
-            }
-
-            this._unresolvedKeyUps.forEach(listenerGroup => listenerGroup.keyUp(e));
-            this._unresolvedKeyUps.splice(0); // clear array
-
-            // run through our generic key ups
-            this._genericKeyListeners.forEach(listenerGroup => {
-                let keyObj = getKeyObject(listenerGroup, key);
-                if (keyObj.trigger !== false) {
-                    listenerGroup.keyUp(e);
-                    // set this trigger to false, this will stop this keyup event being triggered again
-                    // on window blur
-                    keyObj.trigger = false;
-                    keyObj.event = null;
-                }
-            });
-        }
-    });
-
-    return HotStuff;
-});
diff --git a/src/index.ts b/src/index.ts
new file mode 100644
index 0000000..07f1200
--- /dev/null
+++ b/src/index.ts
@@ -0,0 +1,263 @@
+import { KEY_ALIAS_MAP, KEYCODE_ALIAS_MAP } from './keyAliases'
+
+// normalize keys by referring to KEY_ALIAS_MAP, this might have to be modified in the future
+// to take into account OS
+const normalizeHotKey = x => (KEY_ALIAS_MAP[x] ? KEY_ALIAS_MAP[x] : x);
+
+// function to sort our key array, forces order to begin ctrl-alt-shift if they exist,
+// at the moment this happens by setting them to unicode characters 0-2
+// (which can't by typed normally on a keyboard)
+const HotKeySort = function (a, b) {
+    if (a === "ctrl" || a === "control") a = "\x00";
+    if (a === "alt") a = "\x01";
+    if (a === "shift") a = "\x02";
+
+    if (b === "ctrl" || b === "control") b = "\x00";
+    if (b === "alt") b = "\x01";
+    if (b === "shift") b = "\x02";
+
+    return a > b;
+};
+
+// may require some refactoring to take in special cases
+// such as having the ability to split multiple hotkeys by commas
+const parseKeyCode = function (str) {
+    return str.toLowerCase().split(/[+-]/);
+};
+
+// helper function to make sure that there is an array for us to push our handlers to
+const addKeyListener = function (T, key) {
+    if (T._keyListeners[key] === undefined) T._keyListeners[key] = [];
+    return T._keyListeners[key];
+};
+
+const getKeyObject = function (keyObj, key) {
+    keyObj = keyObj._keys;
+    if (keyObj[key] === undefined) keyObj[key] = {
+        trigger: false,
+        event: null
+    }
+    return keyObj[key];
+};
+
+function createFakeEvent(event, el) {
+    // @ts-ignore
+    let fakeEvent = document.createEventObject
+    // @ts-ignore
+        ? document.createEventObject()
+        : document.createEvent("Event");
+    if (fakeEvent.initEvent) {
+        fakeEvent.initEvent("keyup", true, true);
+    }
+    // attempt to add as many properties from the original event to our new fakeEvent
+    // avoid using has own property, it won't get most of the properties
+    for (let prop in event) {
+        try {
+            fakeEvent[prop] = event[prop];
+        } catch (e) {
+            // do nothing, we'll just skip them.
+        }
+    }
+
+    el.dispatchEvent
+        ? el.dispatchEvent(fakeEvent)
+        : el.fireEvent("onkeyup", fakeEvent);
+}
+
+const DEFINE = o => (p, v) => Object.defineProperty(o, p, v);
+
+// Begin HotStuff Class
+const HotStuff = function (el) {
+    if (!(this instanceof HotStuff)) {
+        new HotStuff(el);
+        return
+    }
+    this.init(el);
+};
+
+// use assign to add methods to the prototype
+Object.assign(HotStuff.prototype, {
+    constructor: HotStuff,
+    init(el) {
+        // with no element provided, try to attach to the window
+        if (el === null || el === undefined)
+            if (window) el = window;
+            else
+                throw new Error(
+                    "No element found to attach HotStuff to and could not find window object."
+                );
+
+        const define = DEFINE(this);
+
+        define("el", {
+            get() {
+                return el;
+            },
+            readOnly: true,
+            enumerable: true
+        });
+
+        this._keyListeners = {};
+        this._keysActive = [];
+        this._unresolvedKeyUps = [];
+
+        // internal variables for generic key listeners (ones that listen to all keys)
+        this._genericKeyListeners = [];
+
+        el.addEventListener("keydown", this.handleKeyDown.bind(this));
+        el.addEventListener("keyup", this.handleKeyUp.bind(this));
+
+        // when the window loses or gains focus, trigger all key up events that haven't been triggered
+        (function (arr, func) {
+            arr.forEach(x => window.addEventListener(x, func));
+        })(['blur', 'focus'], () => {
+            this._unresolvedKeyUps.forEach(listenerGroup => {
+                createFakeEvent(
+                    listenerGroup._events[listenerGroup._events.length - 1],
+                    this.el
+                );
+                listenerGroup._events.splice();
+            });
+
+            // triggering generic key listeners are slightly more complex
+            // loop through all the keys, checking if the trigger is set to true,
+            // then creates the fake event for that letter
+            this._genericKeyListeners.forEach(listenerGroup => {
+                let keys = listenerGroup._keys;
+                for (let property in keys) {
+                    if (keys.hasOwnProperty(property) && keys[property].trigger) {
+                        createFakeEvent(keys[property].event, this.el);
+                        keys[property].trigger = false;
+                    }
+                }
+            });
+        });
+    },
+    addListener(keysArr, keydownHandler, keyupHandler) {
+        // prepare our arguments
+        if (typeof keysArr === "string") keysArr = [keysArr];
+        if (keysArr === null) keysArr = [];
+        if (keysArr instanceof Function) {
+            keyupHandler = keydownHandler;
+            keydownHandler = keysArr;
+            keysArr = []; // pass an empty array, we'll detect the length of this later to determine type of listener
+        }
+
+        if (!(keysArr instanceof Array)) throw new Error("Invalid Keys provided");
+
+        if (keyupHandler == null && keydownHandler == null)
+            throw new Error("No handlers provided");
+
+        // provide generic functions if none are provided
+        if (keydownHandler == null) keydownHandler = _ => _;
+        if (keyupHandler == null) keyupHandler = _ => _;
+
+        const sharedStore = {};
+
+        // if the array has no items in it, we treat it as though it's listening to all keys presses
+        if (keysArr.length === 0) {
+            let _events = [];
+            let _keys = {};
+            keydownHandler = keydownHandler.bind(this);
+            keyupHandler = keyupHandler.bind(this);
+            this._genericKeyListeners.push({
+                keyDown: e => {
+                    _events.push(e);
+                    return keydownHandler(e, sharedStore, this._keysActive.slice());
+                },
+                keyUp: e => keyupHandler(e, sharedStore, this._keysActive.slice()),
+                _keys: _keys,
+                _events: _events
+            });
+            // technically unnecessary bail out as the following forEach won't work
+            return;
+        }
+
+        // Hotkeys were provided, loop through them
+        keysArr.forEach(keys => {
+            // normalise our input
+            keys = parseKeyCode(keys).map(normalizeHotKey).sort(HotKeySort);
+
+            let keyActiveBuffer = [];
+            let _events = [];
+
+            keydownHandler = keydownHandler.bind(this);
+            keyupHandler = keyupHandler.bind(this);
+
+            addKeyListener(this, keys.join("+")).push({
+                keyDown: e => {
+                    // we need to cache a copy of the active keys at the time of the keyDown event
+                    // as when keyUp is triggered the keysActive can be different. We can possibly fiddle with the
+                    // handleKeyDown method to fix this, but one way or another, we should make a separate copy
+                    // from the one that's sent to keydownHandler as we want to make sure its untampered with.
+                    _events.push(e);
+                    keyActiveBuffer = this._keysActive.slice();
+                    return keydownHandler(e, sharedStore, this._keysActive.slice());
+                },
+                keyUp: e => keyupHandler(e, sharedStore, keyActiveBuffer),
+                _events: _events // posibbly only need to set this to an item instead of an array
+            });
+        });
+    },
+    handleKeyDown(e) {
+        // perhaps refactor;
+        const key = (e.which && e.keyCode
+            ? KEYCODE_ALIAS_MAP[e.which || e.keyCode]
+            : e.key).toLowerCase();
+
+        // don't allow duplicates to be pushed into our active keys,
+        // sort our keys so that they're in the same order every time
+        if (!this._keysActive.includes(key)) {
+            this._keysActive.push(key);
+            this._keysActive.sort(HotKeySort);
+        }
+
+        // join the keys together to make a string, we can use this key to search our listeners to see
+        // if it contains a property with the strings name
+        const keyStr = this._keysActive.map(normalizeHotKey).join("+");
+
+        if (this._keyListeners[keyStr] != null)
+            this._keyListeners[keyStr].forEach(listenerGroup => {
+                if (listenerGroup.keyDown(e) !== false) {
+                    // if keyDown returns false, don't add keyUp
+                    if (!this._unresolvedKeyUps.includes(listenerGroup)) {
+                        this._unresolvedKeyUps.push(listenerGroup);
+                    }
+                }
+            });
+
+        // generic key listeners are queried after specific key listeners ones
+        this._genericKeyListeners.forEach(listenerGroup => {
+            let keyObj = getKeyObject(listenerGroup, key);
+            keyObj.trigger = listenerGroup.keyDown(e) !== false;
+            keyObj.event = e;
+        });
+    },
+    handleKeyUp(e) {
+        const key = (e.which && e.keyCode
+            ? KEYCODE_ALIAS_MAP[e.which || e.keyCode]
+            : e.key).toLowerCase();
+
+        if (this._keysActive.includes(key)) {
+            this._keysActive.splice(this._keysActive.indexOf(key), 1);
+            this._keysActive.sort(HotKeySort);
+        }
+
+        this._unresolvedKeyUps.forEach(listenerGroup => listenerGroup.keyUp(e));
+        this._unresolvedKeyUps.splice(0); // clear array
+
+        // run through our generic key ups
+        this._genericKeyListeners.forEach(listenerGroup => {
+            let keyObj = getKeyObject(listenerGroup, key);
+            if (keyObj.trigger !== false) {
+                listenerGroup.keyUp(e);
+                // set this trigger to false, this will stop this keyup event being triggered again
+                // on window blur
+                keyObj.trigger = false;
+                keyObj.event = null;
+            }
+        });
+    }
+});
+
+export default HotStuff;
diff --git a/src/keyAliases.ts b/src/keyAliases.ts
new file mode 100644
index 0000000..64e8f82
--- /dev/null
+++ b/src/keyAliases.ts
@@ -0,0 +1,80 @@
+
+// Normalise and change certain keys
+export const KEY_ALIAS_MAP = {
+  "+": "plus",
+  "-": "subtract",
+  ",": "comma",
+  " ": "space",
+  "   ": "tab",
+  arrowup: "up",
+  arrowdown: "down",
+  arrowleft: "left",
+  arrowright: "right",
+  control: "ctrl",
+  delete: "del"
+};
+
+// Generate KeyCode mapping. We could hardcode all of it, but its not too much a performance hit
+// to generate some of the keys
+export const KEYCODE_ALIAS_MAP = (function () {
+  const keys = {
+      8: "backspace",
+      9: "tab",
+      13: "enter",
+      16: "shift",
+      17: "ctrl",
+      18: "alt",
+      19: "pause",
+      20: "capslock",
+      27: "esc",
+      32: "space",
+      33: "pageup",
+      34: "pagedown",
+      35: "end",
+      36: "home",
+      37: "left",
+      38: "up",
+      39: "right",
+      40: "down",
+      45: "insert",
+      46: "del",
+      59: ";",
+      61: "equals",
+      91: "meta",
+      92: "meta",
+      93: "select",
+      106: "multiply",
+      107: "plus",
+      109: "subtract",
+      110: "decimal",
+      111: "divide",
+      144: "numlock",
+      145: "scrolllock",
+      186: ";",
+      187: "equals",
+      189: "minus",
+      190: ".",
+      191: "/",
+      192: "grave",
+      219: "[",
+      220: "\\",
+      221: "]",
+      222: "'",
+      223: "`"
+  };
+
+  for (let i = 0; i <= 9; i++) {
+      // 0-9
+      keys[48 + i] = String.fromCharCode(48 + i);
+      // numpad0-9
+      keys[96 + i] = "numpad" + i;
+  }
+
+  // f keys
+  for (let i = 0; i <= 11; i++) keys[112 + i] = "f" + (i + 1);
+  // a-z
+  for (let i = 65; i < 91; i++)
+      keys[i] = String.fromCharCode(i).toLowerCase();
+
+  return keys;
+})();
diff --git a/tsconfig.json b/tsconfig.json
new file mode 100644
index 0000000..2566f6a
--- /dev/null
+++ b/tsconfig.json
@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "declarationDir": "./types/",
+    "target": "es5",
+    "lib": ["es2015", "es2017", "dom"]
+  },
+  "include": [
+    "src/**/*"
+  ]
+}
\ No newline at end of file
diff --git a/types/index.d.ts b/types/index.d.ts
new file mode 100644
index 0000000..2f5de2f
--- /dev/null
+++ b/types/index.d.ts
@@ -0,0 +1,2 @@
+declare const HotStuff: (el: any) => void;
+export default HotStuff;
diff --git a/types/keyAliases.d.ts b/types/keyAliases.d.ts
new file mode 100644
index 0000000..df7d895
--- /dev/null
+++ b/types/keyAliases.d.ts
@@ -0,0 +1,58 @@
+export declare const KEY_ALIAS_MAP: {
+    "+": string;
+    "-": string;
+    ",": string;
+    " ": string;
+    "   ": string;
+    arrowup: string;
+    arrowdown: string;
+    arrowleft: string;
+    arrowright: string;
+    control: string;
+    delete: string;
+};
+export declare const KEYCODE_ALIAS_MAP: {
+    8: string;
+    9: string;
+    13: string;
+    16: string;
+    17: string;
+    18: string;
+    19: string;
+    20: string;
+    27: string;
+    32: string;
+    33: string;
+    34: string;
+    35: string;
+    36: string;
+    37: string;
+    38: string;
+    39: string;
+    40: string;
+    45: string;
+    46: string;
+    59: string;
+    61: string;
+    91: string;
+    92: string;
+    93: string;
+    106: string;
+    107: string;
+    109: string;
+    110: string;
+    111: string;
+    144: string;
+    145: string;
+    186: string;
+    187: string;
+    189: string;
+    190: string;
+    191: string;
+    192: string;
+    219: string;
+    220: string;
+    221: string;
+    222: string;
+    223: string;
+};

From bcbe94a1ade05745803de385d1feb7b71974c584 Mon Sep 17 00:00:00 2001
From: Luca Ban <mesqueeb@gmail.com>
Date: Sat, 23 Feb 2019 17:18:10 +0900
Subject: [PATCH 4/7] =?UTF-8?q?update=20readme=20=F0=9F=A6=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 README.md         | 9 ++++++---
 package-lock.json | 2 +-
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 1647139..a27933e 100644
--- a/README.md
+++ b/README.md
@@ -8,19 +8,22 @@ npm install hotstuff
 ```
 
 ## Usage
-The preferred method of pulling HotStuff into your project is using NPM and a CommonJS module system.
+The preferred method of pulling HotStuff into your project is using NPM. You can use either the CommonJS `require` or module `import` syntax.
 
 ```javascript
 const HotStuff = require('hotstuff')
+// or
+import HotStuff from 'hotstuff'
 ```
+
 You can then create a new HotStuff object using one of the methods below.
-Note: HotStuff attaches events using addEventListener on both the keydown and keyup events so the object you pass to HotStuff must support those events. 
+Note: HotStuff attaches events using addEventListener on both the keydown and keyup events so the object you pass to HotStuff must support those events.
 
 ```javascript
 const element = document.getElementById('elem')
 const hotStuff = new HotStuff(element)
 
-// You can also attach to the window 
+// You can also attach to the window
 const hotStuff = new HotStuff(window)
 // by default HotStuff attaches itself to the window object if there is one
 const hotStuff = new HotStuff()
diff --git a/package-lock.json b/package-lock.json
index 359c458..20253ff 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,6 +1,6 @@
 {
   "name": "hotstuff",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

From 4ffb2b01df3c4b67e459756dbe939a57c3815941 Mon Sep 17 00:00:00 2001
From: Luca Ban <mesqueeb@gmail.com>
Date: Wed, 27 Feb 2019 08:45:09 +0900
Subject: [PATCH 5/7] =?UTF-8?q?Rollup=20global=20=E2=9F=B6=20local=20?=
 =?UTF-8?q?=F0=9F=8E=A3?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 package-lock.json | 29 +++++++++++++++++++++++++++++
 package.json      |  3 ++-
 2 files changed, 31 insertions(+), 1 deletion(-)

diff --git a/package-lock.json b/package-lock.json
index 20253ff..d8e6b28 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -4,6 +4,24 @@
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
+    "@types/estree": {
+      "version": "0.0.39",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-0.0.39.tgz",
+      "integrity": "sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==",
+      "dev": true
+    },
+    "@types/node": {
+      "version": "11.9.5",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-11.9.5.tgz",
+      "integrity": "sha512-vVjM0SVzgaOUpflq4GYBvCpozes8OgIIS5gVXVka+OfK3hvnkC1i93U8WiY2OtNE4XUWyyy/86Kf6e0IHTQw1Q==",
+      "dev": true
+    },
+    "acorn": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-6.1.0.tgz",
+      "integrity": "sha512-MW/FjM+IvU9CgBzjO3UIPCE2pyEwUsoFl+VGdczOPEdxfGFjuKny/gN54mOuX7Qxmb9Rg9MCn2oKiSUeW+pjrw==",
+      "dev": true
+    },
     "arr-diff": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-2.0.0.tgz",
@@ -366,6 +384,17 @@
         "path-parse": "^1.0.5"
       }
     },
+    "rollup": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-1.3.0.tgz",
+      "integrity": "sha512-QiT0wFmu0IzkGgT5LvzRK5hezHcJW8T9MQdvdC+FylrNpsprpz0gTOpcyY9iM6Sda1fD1SatwNutCxcQd3Y/Lg==",
+      "dev": true,
+      "requires": {
+        "@types/estree": "0.0.39",
+        "@types/node": "^11.9.5",
+        "acorn": "^6.1.0"
+      }
+    },
     "rollup-plugin-typescript2": {
       "version": "0.19.2",
       "resolved": "https://registry.npmjs.org/rollup-plugin-typescript2/-/rollup-plugin-typescript2-0.19.2.tgz",
diff --git a/package.json b/package.json
index 2cbc7a0..cd4ee9b 100644
--- a/package.json
+++ b/package.json
@@ -16,7 +16,7 @@
   ],
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "rollup -c ./build/rollup.js"
+    "build": "./node_modules/.bin/rollup --config ./build/rollup.js"
   },
   "repository": {
     "type": "git",
@@ -35,6 +35,7 @@
   },
   "homepage": "https://github.com/laquasicinque/hotstuff#readme",
   "devDependencies": {
+    "rollup": "^1.3.0",
     "rollup-plugin-typescript2": "^0.19.2",
     "typescript": "^3.3.3333"
   }

From 7044592e14943d2ba2d41ab5403b94ebfbbdec84 Mon Sep 17 00:00:00 2001
From: Luca Ban <mesqueeb@gmail.com>
Date: Wed, 27 Feb 2019 08:45:45 +0900
Subject: [PATCH 6/7] =?UTF-8?q?reformat=20build=20file=20for=20easier=20se?=
 =?UTF-8?q?tup=20=F0=9F=A5=8A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 build/rollup.js | 60 ++++++++++++++++++++++---------------------------
 1 file changed, 27 insertions(+), 33 deletions(-)

diff --git a/build/rollup.js b/build/rollup.js
index 4078c4a..b26d5ca 100644
--- a/build/rollup.js
+++ b/build/rollup.js
@@ -15,43 +15,37 @@ import typescript from 'rollup-plugin-typescript2'
 // umd – Universal Module Definition, works as amd, cjs and iife all in one
 // system – Native format of the SystemJS loader
 
-// ------------------------------------------------------------------------------------------
-// setup
-// ------------------------------------------------------------------------------------------
 const pkg = require('../package.json')
-const name = pkg.name
-const className = name.replace(/(^\w|-\w)/g, c => c.replace('-', '').toUpperCase())
-const external = Object.keys(pkg.dependencies || [])
-const plugins = [
-  typescript({useTsconfigDeclarationDir: true}),
-]
 
-// ------------------------------------------------------------------------------------------
-// Builds
-// ------------------------------------------------------------------------------------------
-function defaults (config) {
-  // defaults
-  const defaults = {
-    plugins,
-    external
-  }
-  // defaults.output
-  config.output = config.output.map(output => {
-    return Object.assign({
+export default [
+  // CJS
+  {
+    input: 'src/index.ts',
+    plugins: [
+      typescript({useTsconfigDeclarationDir: true}),
+    ],
+    external: Object.keys(pkg.dependencies || []),
+    output: {
+      file: 'dist/index.cjs.js',
+      format: 'cjs',
       sourcemap: false,
-      name: className,
+      name: 'Hotstuff',
       exports: 'named',
-    }, output)
-  })
-  return Object.assign(defaults, config)
-}
-
-export default [
-  defaults({
+    }
+  },
+  // ESM
+  {
     input: 'src/index.ts',
-    output: [
-      {file: 'dist/index.cjs.js', format: 'cjs'},
-      {file: 'dist/index.esm.js', format: 'esm'},
+    plugins: [
+      typescript({useTsconfigDeclarationDir: true}),
     ],
-  }),
+    external: Object.keys(pkg.dependencies || []),
+    output: {
+      file: 'dist/index.esm.js',
+      format: 'esm',
+      sourcemap: false,
+      name: 'Hotstuff',
+      exports: 'named',
+    }
+  }
 ]

From d3a4c1b626b6ff5dd6ac2f0300b7c63a1fe643d0 Mon Sep 17 00:00:00 2001
From: Luca Ban <mesqueeb@gmail.com>
Date: Thu, 28 Feb 2019 08:14:02 +0900
Subject: [PATCH 7/7] =?UTF-8?q?Add=20minified=20files=20to=20dist=20folder?=
 =?UTF-8?q?=20=F0=9F=90=BF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 build/rollup.js       |  34 +++++-
 dist/index.cjs.min.js |   1 +
 dist/index.esm.min.js |   1 +
 package-lock.json     | 249 ++++++++++++++++++++++++++++++++++++++++--
 package.json          |   5 +-
 5 files changed, 277 insertions(+), 13 deletions(-)
 create mode 100644 dist/index.cjs.min.js
 create mode 100644 dist/index.esm.min.js

diff --git a/build/rollup.js b/build/rollup.js
index b26d5ca..75aada2 100644
--- a/build/rollup.js
+++ b/build/rollup.js
@@ -2,7 +2,7 @@
 
 // npm install rollup-plugin-typescript2 typescript --save-dev
 import typescript from 'rollup-plugin-typescript2'
-// import { terser } from 'rollup-plugin-terser'
+import { terser } from 'rollup-plugin-terser'
 // import resolve from 'rollup-plugin-node-resolve'
 
 // ------------------------------------------------------------------------------------------
@@ -47,5 +47,37 @@ export default [
       name: 'Hotstuff',
       exports: 'named',
     }
+  },
+  // CJS minified
+  {
+    input: 'src/index.ts',
+    plugins: [
+      typescript({useTsconfigDeclarationDir: true}),
+      terser()
+    ],
+    external: Object.keys(pkg.dependencies || []),
+    output: {
+      file: 'dist/index.cjs.min.js',
+      format: 'cjs',
+      sourcemap: false,
+      name: 'Hotstuff',
+      exports: 'named',
+    }
+  },
+  // ESM minified
+  {
+    input: 'src/index.ts',
+    plugins: [
+      typescript({useTsconfigDeclarationDir: true}),
+      terser()
+    ],
+    external: Object.keys(pkg.dependencies || []),
+    output: {
+      file: 'dist/index.esm.min.js',
+      format: 'esm',
+      sourcemap: false,
+      name: 'Hotstuff',
+      exports: 'named',
+    }
   }
 ]
diff --git a/dist/index.cjs.min.js b/dist/index.cjs.min.js
new file mode 100644
index 0000000..c8b80dd
--- /dev/null
+++ b/dist/index.cjs.min.js
@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var KEY_ALIAS_MAP={"+":"plus","-":"subtract",",":"comma"," ":"space","   ":"tab",arrowup:"up",arrowdown:"down",arrowleft:"left",arrowright:"right",control:"ctrl",delete:"del"},KEYCODE_ALIAS_MAP=function(){for(var e={8:"backspace",9:"tab",13:"enter",16:"shift",17:"ctrl",18:"alt",19:"pause",20:"capslock",27:"esc",32:"space",33:"pageup",34:"pagedown",35:"end",36:"home",37:"left",38:"up",39:"right",40:"down",45:"insert",46:"del",59:";",61:"equals",91:"meta",92:"meta",93:"select",106:"multiply",107:"plus",109:"subtract",110:"decimal",111:"divide",144:"numlock",145:"scrolllock",186:";",187:"equals",189:"minus",190:".",191:"/",192:"grave",219:"[",220:"\\",221:"]",222:"'",223:"`"},t=0;t<=9;t++)e[48+t]=String.fromCharCode(48+t),e[96+t]="numpad"+t;for(t=0;t<=11;t++)e[112+t]="f"+(t+1);for(t=65;t<91;t++)e[t]=String.fromCharCode(t).toLowerCase();return e}(),normalizeHotKey=function(e){return KEY_ALIAS_MAP[e]?KEY_ALIAS_MAP[e]:e},HotKeySort=function(e,t){return"ctrl"!==e&&"control"!==e||(e="\0"),"alt"===e&&(e="
"),"shift"===e&&(e=""),"ctrl"!==t&&"control"!==t||(t="\0"),"alt"===t&&(t="
"),"shift"===t&&(t=""),e>t},parseKeyCode=function(e){return e.toLowerCase().split(/[+-]/)},addKeyListener=function(e,t){return void 0===e._keyListeners[t]&&(e._keyListeners[t]=[]),e._keyListeners[t]},getKeyObject=function(e,t){return void 0===(e=e._keys)[t]&&(e[t]={trigger:!1,event:null}),e[t]};function createFakeEvent(e,t){var n=document.createEventObject?document.createEventObject():document.createEvent("Event");for(var r in n.initEvent&&n.initEvent("keyup",!0,!0),e)try{n[r]=e[r]}catch(e){}t.dispatchEvent?t.dispatchEvent(n):t.fireEvent("onkeyup",n)}var DEFINE=function(e){return function(t,n){return Object.defineProperty(e,t,n)}},HotStuff=function(e){this instanceof HotStuff?this.init(e):new HotStuff(e)};Object.assign(HotStuff.prototype,{constructor:HotStuff,init:function(e){var t,n=this;if(null==e){if(!window)throw new Error("No element found to attach HotStuff to and could not find window object.");e=window}DEFINE(this)("el",{get:function(){return e},readOnly:!0,enumerable:!0}),this._keyListeners={},this._keysActive=[],this._unresolvedKeyUps=[],this._genericKeyListeners=[],e.addEventListener("keydown",this.handleKeyDown.bind(this)),e.addEventListener("keyup",this.handleKeyUp.bind(this)),t=function(){n._unresolvedKeyUps.forEach(function(e){createFakeEvent(e._events[e._events.length-1],n.el),e._events.splice()}),n._genericKeyListeners.forEach(function(e){var t=e._keys;for(var r in t)t.hasOwnProperty(r)&&t[r].trigger&&(createFakeEvent(t[r].event,n.el),t[r].trigger=!1)})},["blur","focus"].forEach(function(e){return window.addEventListener(e,t)})},addListener:function(e,t,n){var r=this;if("string"==typeof e&&(e=[e]),null===e&&(e=[]),e instanceof Function&&(n=t,t=e,e=[]),!(e instanceof Array))throw new Error("Invalid Keys provided");if(null==n&&null==t)throw new Error("No handlers provided");null==t&&(t=function(e){return e}),null==n&&(n=function(e){return e});var i={};if(0===e.length){var o=[];return t=t.bind(this),n=n.bind(this),void this._genericKeyListeners.push({keyDown:function(e){return o.push(e),t(e,i,r._keysActive.slice())},keyUp:function(e){return n(e,i,r._keysActive.slice())},_keys:{},_events:o})}e.forEach(function(e){e=parseKeyCode(e).map(normalizeHotKey).sort(HotKeySort);var o=[],s=[];t=t.bind(r),n=n.bind(r),addKeyListener(r,e.join("+")).push({keyDown:function(e){return s.push(e),o=r._keysActive.slice(),t(e,i,r._keysActive.slice())},keyUp:function(e){return n(e,i,o)},_events:s})})},handleKeyDown:function(e){var t=this,n=(e.which&&e.keyCode?KEYCODE_ALIAS_MAP[e.which||e.keyCode]:e.key).toLowerCase();this._keysActive.includes(n)||(this._keysActive.push(n),this._keysActive.sort(HotKeySort));var r=this._keysActive.map(normalizeHotKey).join("+");null!=this._keyListeners[r]&&this._keyListeners[r].forEach(function(n){!1!==n.keyDown(e)&&(t._unresolvedKeyUps.includes(n)||t._unresolvedKeyUps.push(n))}),this._genericKeyListeners.forEach(function(t){var r=getKeyObject(t,n);r.trigger=!1!==t.keyDown(e),r.event=e})},handleKeyUp:function(e){var t=(e.which&&e.keyCode?KEYCODE_ALIAS_MAP[e.which||e.keyCode]:e.key).toLowerCase();this._keysActive.includes(t)&&(this._keysActive.splice(this._keysActive.indexOf(t),1),this._keysActive.sort(HotKeySort)),this._unresolvedKeyUps.forEach(function(t){return t.keyUp(e)}),this._unresolvedKeyUps.splice(0),this._genericKeyListeners.forEach(function(n){var r=getKeyObject(n,t);!1!==r.trigger&&(n.keyUp(e),r.trigger=!1,r.event=null)})}}),exports.default=HotStuff;
diff --git a/dist/index.esm.min.js b/dist/index.esm.min.js
new file mode 100644
index 0000000..a185a1c
--- /dev/null
+++ b/dist/index.esm.min.js
@@ -0,0 +1 @@
+var e={"+":"plus","-":"subtract",",":"comma"," ":"space","   ":"tab",arrowup:"up",arrowdown:"down",arrowleft:"left",arrowright:"right",control:"ctrl",delete:"del"},t=function(){for(var e={8:"backspace",9:"tab",13:"enter",16:"shift",17:"ctrl",18:"alt",19:"pause",20:"capslock",27:"esc",32:"space",33:"pageup",34:"pagedown",35:"end",36:"home",37:"left",38:"up",39:"right",40:"down",45:"insert",46:"del",59:";",61:"equals",91:"meta",92:"meta",93:"select",106:"multiply",107:"plus",109:"subtract",110:"decimal",111:"divide",144:"numlock",145:"scrolllock",186:";",187:"equals",189:"minus",190:".",191:"/",192:"grave",219:"[",220:"\\",221:"]",222:"'",223:"`"},t=0;t<=9;t++)e[48+t]=String.fromCharCode(48+t),e[96+t]="numpad"+t;for(t=0;t<=11;t++)e[112+t]="f"+(t+1);for(t=65;t<91;t++)e[t]=String.fromCharCode(t).toLowerCase();return e}(),n=function(t){return e[t]?e[t]:t},i=function(e,t){return"ctrl"!==e&&"control"!==e||(e="\0"),"alt"===e&&(e="
"),"shift"===e&&(e=""),"ctrl"!==t&&"control"!==t||(t="\0"),"alt"===t&&(t="
"),"shift"===t&&(t=""),e>t},r=function(e,t){return void 0===(e=e._keys)[t]&&(e[t]={trigger:!1,event:null}),e[t]};function s(e,t){var n=document.createEventObject?document.createEventObject():document.createEvent("Event");for(var i in n.initEvent&&n.initEvent("keyup",!0,!0),e)try{n[i]=e[i]}catch(e){}t.dispatchEvent?t.dispatchEvent(n):t.fireEvent("onkeyup",n)}var o=function(e){this instanceof o?this.init(e):new o(e)};Object.assign(o.prototype,{constructor:o,init:function(e){var t,n,i=this;if(null==e){if(!window)throw new Error("No element found to attach HotStuff to and could not find window object.");e=window}(t=this,function(e,n){return Object.defineProperty(t,e,n)})("el",{get:function(){return e},readOnly:!0,enumerable:!0}),this._keyListeners={},this._keysActive=[],this._unresolvedKeyUps=[],this._genericKeyListeners=[],e.addEventListener("keydown",this.handleKeyDown.bind(this)),e.addEventListener("keyup",this.handleKeyUp.bind(this)),n=function(){i._unresolvedKeyUps.forEach(function(e){s(e._events[e._events.length-1],i.el),e._events.splice()}),i._genericKeyListeners.forEach(function(e){var t=e._keys;for(var n in t)t.hasOwnProperty(n)&&t[n].trigger&&(s(t[n].event,i.el),t[n].trigger=!1)})},["blur","focus"].forEach(function(e){return window.addEventListener(e,n)})},addListener:function(e,t,r){var s=this;if("string"==typeof e&&(e=[e]),null===e&&(e=[]),e instanceof Function&&(r=t,t=e,e=[]),!(e instanceof Array))throw new Error("Invalid Keys provided");if(null==r&&null==t)throw new Error("No handlers provided");null==t&&(t=function(e){return e}),null==r&&(r=function(e){return e});var o={};if(0===e.length){var c=[];return t=t.bind(this),r=r.bind(this),void this._genericKeyListeners.push({keyDown:function(e){return c.push(e),t(e,o,s._keysActive.slice())},keyUp:function(e){return r(e,o,s._keysActive.slice())},_keys:{},_events:c})}e.forEach(function(e){var c;e=(c=e,c.toLowerCase().split(/[+-]/)).map(n).sort(i);var u,a,l=[],h=[];t=t.bind(s),r=r.bind(s),(u=s,a=e.join("+"),void 0===u._keyListeners[a]&&(u._keyListeners[a]=[]),u._keyListeners[a]).push({keyDown:function(e){return h.push(e),l=s._keysActive.slice(),t(e,o,s._keysActive.slice())},keyUp:function(e){return r(e,o,l)},_events:h})})},handleKeyDown:function(e){var s=this,o=(e.which&&e.keyCode?t[e.which||e.keyCode]:e.key).toLowerCase();this._keysActive.includes(o)||(this._keysActive.push(o),this._keysActive.sort(i));var c=this._keysActive.map(n).join("+");null!=this._keyListeners[c]&&this._keyListeners[c].forEach(function(t){!1!==t.keyDown(e)&&(s._unresolvedKeyUps.includes(t)||s._unresolvedKeyUps.push(t))}),this._genericKeyListeners.forEach(function(t){var n=r(t,o);n.trigger=!1!==t.keyDown(e),n.event=e})},handleKeyUp:function(e){var n=(e.which&&e.keyCode?t[e.which||e.keyCode]:e.key).toLowerCase();this._keysActive.includes(n)&&(this._keysActive.splice(this._keysActive.indexOf(n),1),this._keysActive.sort(i)),this._unresolvedKeyUps.forEach(function(t){return t.keyUp(e)}),this._unresolvedKeyUps.splice(0),this._genericKeyListeners.forEach(function(t){var i=r(t,n);!1!==i.trigger&&(t.keyUp(e),i.trigger=!1,i.event=null)})}});export default o;
diff --git a/package-lock.json b/package-lock.json
index d8e6b28..a785aa9 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -4,6 +4,26 @@
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
+    "@babel/code-frame": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.0.0.tgz",
+      "integrity": "sha512-OfC2uemaknXr87bdLUkWog7nYuliM9Ij5HUcajsVcMCpQrcLmtxRbVFTIqmcSkSeYRBFBRxs2FiUqFJDLdiebA==",
+      "dev": true,
+      "requires": {
+        "@babel/highlight": "^7.0.0"
+      }
+    },
+    "@babel/highlight": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.0.0.tgz",
+      "integrity": "sha512-UFMC4ZeFC48Tpvj7C8UgLvtkaUuovQX+5xNWrsIoMG8o2z+XFKjKaN9iVmS84dPwVN00W4wPmqvYoZF3EGAsfw==",
+      "dev": true,
+      "requires": {
+        "chalk": "^2.0.0",
+        "esutils": "^2.0.2",
+        "js-tokens": "^4.0.0"
+      }
+    },
     "@types/estree": {
       "version": "0.0.39",
       "resolved": "https://registry.npmjs.org/@types/estree/-/estree-0.0.39.tgz",
@@ -17,11 +37,20 @@
       "dev": true
     },
     "acorn": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-6.1.0.tgz",
-      "integrity": "sha512-MW/FjM+IvU9CgBzjO3UIPCE2pyEwUsoFl+VGdczOPEdxfGFjuKny/gN54mOuX7Qxmb9Rg9MCn2oKiSUeW+pjrw==",
+      "version": "6.1.1",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-6.1.1.tgz",
+      "integrity": "sha512-jPTiwtOxaHNaAPg/dmrJ/beuzLRnXtB0kQPQ8JpotKJgTB6rX6c8mlf315941pyjBSaPg8NHXS9fhP4u17DpGA==",
       "dev": true
     },
+    "ansi-styles": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
+      "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
+      "dev": true,
+      "requires": {
+        "color-convert": "^1.9.0"
+      }
+    },
     "arr-diff": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-2.0.0.tgz",
@@ -54,12 +83,68 @@
         "repeat-element": "^1.1.2"
       }
     },
+    "buffer-from": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.1.tgz",
+      "integrity": "sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==",
+      "dev": true
+    },
+    "chalk": {
+      "version": "2.4.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
+      "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
+      "dev": true,
+      "requires": {
+        "ansi-styles": "^3.2.1",
+        "escape-string-regexp": "^1.0.5",
+        "supports-color": "^5.3.0"
+      }
+    },
+    "color-convert": {
+      "version": "1.9.3",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
+      "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
+      "dev": true,
+      "requires": {
+        "color-name": "1.1.3"
+      }
+    },
+    "color-name": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
+      "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=",
+      "dev": true
+    },
+    "commander": {
+      "version": "2.17.1",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-2.17.1.tgz",
+      "integrity": "sha512-wPMUt6FnH2yzG95SA6mzjQOEKUU3aLaDEmzs1ti+1E9h+CsrZghRlqEM/EJ4KscsQVG8uNN4uVreUeT8+drlgg==",
+      "dev": true
+    },
+    "core-util-is": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz",
+      "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=",
+      "dev": true
+    },
+    "escape-string-regexp": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
+      "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=",
+      "dev": true
+    },
     "estree-walker": {
       "version": "0.5.2",
       "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-0.5.2.tgz",
       "integrity": "sha512-XpCnW/AE10ws/kDAs37cngSkvgIR8aN3G0MS85m7dUpuK2EREo9VJ00uvw6Dg/hXEpfsE1I1TvJOJr+Z+TL+ig==",
       "dev": true
     },
+    "esutils": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.2.tgz",
+      "integrity": "sha1-Cr9PHKpbyx96nYrMbepPqqBLrJs=",
+      "dev": true
+    },
     "expand-brackets": {
       "version": "0.1.5",
       "resolved": "https://registry.npmjs.org/expand-brackets/-/expand-brackets-0.1.5.tgz",
@@ -157,6 +242,18 @@
       "integrity": "sha512-6uHUhOPEBgQ24HM+r6b/QwWfZq+yiFcipKFrOFiBEnWdy5sdzYoi+pJeQaPI5qOLRFqWmAXUPQNsielzdLoecA==",
       "dev": true
     },
+    "has-flag": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
+      "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=",
+      "dev": true
+    },
+    "inherits": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
+      "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=",
+      "dev": true
+    },
     "is-buffer": {
       "version": "1.1.6",
       "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz",
@@ -235,6 +332,33 @@
         "isarray": "1.0.0"
       }
     },
+    "jest-worker": {
+      "version": "24.0.0",
+      "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-24.0.0.tgz",
+      "integrity": "sha512-s64/OThpfQvoCeHG963MiEZOAAxu8kHsaL/rCMF7lpdzo7vgF0CtPml9hfguOMgykgH/eOm4jFP4ibfHLruytg==",
+      "dev": true,
+      "requires": {
+        "merge-stream": "^1.0.1",
+        "supports-color": "^6.1.0"
+      },
+      "dependencies": {
+        "supports-color": {
+          "version": "6.1.0",
+          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-6.1.0.tgz",
+          "integrity": "sha512-qe1jfm1Mg7Nq/NSh6XE24gPXROEVsWHxC1LIx//XNlD9iw7YZQGjZNjYN7xGaEG6iKdA8EtNFW6R0gjnVXp+wQ==",
+          "dev": true,
+          "requires": {
+            "has-flag": "^3.0.0"
+          }
+        }
+      }
+    },
+    "js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "dev": true
+    },
     "jsonfile": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz",
@@ -259,6 +383,15 @@
       "integrity": "sha512-rUxjysqif/BZQH2yhd5Aaq7vXMSx9NdEsQcyA07uEzIvxgI7zIr33gGsh+RU0/XjmQpCW7RsVof1vlkvQVCK5A==",
       "dev": true
     },
+    "merge-stream": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-1.0.1.tgz",
+      "integrity": "sha1-QEEgLVCKNCugAXQAjfDCUbjBNeE=",
+      "dev": true,
+      "requires": {
+        "readable-stream": "^2.0.1"
+      }
+    },
     "micromatch": {
       "version": "2.3.11",
       "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-2.3.11.tgz",
@@ -323,6 +456,12 @@
       "integrity": "sha1-gV7R9uvGWSb4ZbMQwHE7yzMVzks=",
       "dev": true
     },
+    "process-nextick-args": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.0.tgz",
+      "integrity": "sha512-MtEC1TqN0EU5nephaJ4rAtThHtC86dNN9qCuEhtshvpVBkAW5ZO7BASN9REnF9eoXGcRub+pFuKEpOHE+HbEMw==",
+      "dev": true
+    },
     "randomatic": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/randomatic/-/randomatic-3.1.1.tgz",
@@ -348,6 +487,21 @@
         }
       }
     },
+    "readable-stream": {
+      "version": "2.3.6",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz",
+      "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==",
+      "dev": true,
+      "requires": {
+        "core-util-is": "~1.0.0",
+        "inherits": "~2.0.3",
+        "isarray": "~1.0.0",
+        "process-nextick-args": "~2.0.0",
+        "safe-buffer": "~5.1.1",
+        "string_decoder": "~1.1.1",
+        "util-deprecate": "~1.0.1"
+      }
+    },
     "regex-cache": {
       "version": "0.4.4",
       "resolved": "https://registry.npmjs.org/regex-cache/-/regex-cache-0.4.4.tgz",
@@ -385,20 +539,32 @@
       }
     },
     "rollup": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/rollup/-/rollup-1.3.0.tgz",
-      "integrity": "sha512-QiT0wFmu0IzkGgT5LvzRK5hezHcJW8T9MQdvdC+FylrNpsprpz0gTOpcyY9iM6Sda1fD1SatwNutCxcQd3Y/Lg==",
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-1.3.2.tgz",
+      "integrity": "sha512-xU6L5HqOY0sDeFxMTTs/GoYwcLiuKWfxxFWQTlwsZlQinQh1wfoxtDR4F3E2cHLS81nL9yl8LjZzuOWKd19smg==",
       "dev": true,
       "requires": {
         "@types/estree": "0.0.39",
         "@types/node": "^11.9.5",
-        "acorn": "^6.1.0"
+        "acorn": "^6.1.1"
+      }
+    },
+    "rollup-plugin-terser": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/rollup-plugin-terser/-/rollup-plugin-terser-4.0.4.tgz",
+      "integrity": "sha512-wPANT5XKVJJ8RDUN0+wIr7UPd0lIXBo4UdJ59VmlPCtlFsE20AM+14pe+tk7YunCsWEiuzkDBY3QIkSCjtrPXg==",
+      "dev": true,
+      "requires": {
+        "@babel/code-frame": "^7.0.0",
+        "jest-worker": "^24.0.0",
+        "serialize-javascript": "^1.6.1",
+        "terser": "^3.14.1"
       }
     },
     "rollup-plugin-typescript2": {
-      "version": "0.19.2",
-      "resolved": "https://registry.npmjs.org/rollup-plugin-typescript2/-/rollup-plugin-typescript2-0.19.2.tgz",
-      "integrity": "sha512-DRG7SaYX0QzBIz6rII5nm1UkiceS95r8mJjujugybyIueNF3auvzGTHMK62O7As/0q5RHjXsOguWOUv+KJKLFA==",
+      "version": "0.19.3",
+      "resolved": "https://registry.npmjs.org/rollup-plugin-typescript2/-/rollup-plugin-typescript2-0.19.3.tgz",
+      "integrity": "sha512-lsRqfBCZhMl/tq9AT5YnQvzQWzXtnx3EQYFcHD72gul7nyyoOrzx5yCEH20smpw58v6UkHHZz03FbdLEPoHWjA==",
       "dev": true,
       "requires": {
         "fs-extra": "7.0.1",
@@ -417,6 +583,63 @@
         "micromatch": "^2.3.11"
       }
     },
+    "safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "dev": true
+    },
+    "serialize-javascript": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-1.6.1.tgz",
+      "integrity": "sha512-A5MOagrPFga4YaKQSWHryl7AXvbQkEqpw4NNYMTNYUNV51bA8ABHgYFpqKx+YFFrw59xMV1qGH1R4AgoNIVgCw==",
+      "dev": true
+    },
+    "source-map": {
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+      "dev": true
+    },
+    "source-map-support": {
+      "version": "0.5.10",
+      "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.10.tgz",
+      "integrity": "sha512-YfQ3tQFTK/yzlGJuX8pTwa4tifQj4QS2Mj7UegOu8jAz59MqIiMGPXxQhVQiIMNzayuUSF/jEuVnfFF5JqybmQ==",
+      "dev": true,
+      "requires": {
+        "buffer-from": "^1.0.0",
+        "source-map": "^0.6.0"
+      }
+    },
+    "string_decoder": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
+      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+      "dev": true,
+      "requires": {
+        "safe-buffer": "~5.1.0"
+      }
+    },
+    "supports-color": {
+      "version": "5.5.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
+      "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+      "dev": true,
+      "requires": {
+        "has-flag": "^3.0.0"
+      }
+    },
+    "terser": {
+      "version": "3.16.1",
+      "resolved": "https://registry.npmjs.org/terser/-/terser-3.16.1.tgz",
+      "integrity": "sha512-JDJjgleBROeek2iBcSNzOHLKsB/MdDf+E/BOAJ0Tk9r7p9/fVobfv7LMJ/g/k3v9SXdmjZnIlFd5nfn/Rt0Xow==",
+      "dev": true,
+      "requires": {
+        "commander": "~2.17.1",
+        "source-map": "~0.6.1",
+        "source-map-support": "~0.5.9"
+      }
+    },
     "tslib": {
       "version": "1.9.3",
       "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.9.3.tgz",
@@ -434,6 +657,12 @@
       "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz",
       "integrity": "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==",
       "dev": true
+    },
+    "util-deprecate": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+      "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=",
+      "dev": true
     }
   }
 }
diff --git a/package.json b/package.json
index cd4ee9b..968060c 100644
--- a/package.json
+++ b/package.json
@@ -35,8 +35,9 @@
   },
   "homepage": "https://github.com/laquasicinque/hotstuff#readme",
   "devDependencies": {
-    "rollup": "^1.3.0",
-    "rollup-plugin-typescript2": "^0.19.2",
+    "rollup": "^1.3.2",
+    "rollup-plugin-terser": "^4.0.4",
+    "rollup-plugin-typescript2": "^0.19.3",
     "typescript": "^3.3.3333"
   }
 }