@difizen/libro-common 0.3.3 → 1.0.0

package/es/core/keyboard/keys.js

@@ -0,0 +1,1070 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/* eslint-disable @typescript-eslint/no-use-before-define */
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable no-plusplus */
+/* eslint-disable @typescript-eslint/no-redeclare */
+import { isOSX } from "../../common/index.js";
+export var KeySequence;
+(function (_KeySequence) {
+  function equals(a, b) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    for (var i = 0; i < a.length; i++) {
+      if (!a[i].equals(b[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  _KeySequence.equals = equals;
+  var CompareResult = /*#__PURE__*/function (CompareResult) {
+    CompareResult[CompareResult["NONE"] = 0] = "NONE";
+    CompareResult[CompareResult["PARTIAL"] = 1] = "PARTIAL";
+    CompareResult[CompareResult["SHADOW"] = 2] = "SHADOW";
+    CompareResult[CompareResult["FULL"] = 3] = "FULL";
+    return CompareResult;
+  }({});
+  _KeySequence.CompareResult = CompareResult;
+  function compare(a, b) {
+    var first = a;
+    var second = b;
+    var shadow = false;
+    if (b.length < a.length) {
+      first = b;
+      second = a;
+      shadow = true;
+    }
+    for (var i = 0; i < first.length; i++) {
+      if (first[i].equals(second[i]) === false) {
+        return KeySequence.CompareResult.NONE;
+      }
+    }
+    if (first.length < second.length) {
+      if (shadow === false) {
+        return KeySequence.CompareResult.PARTIAL;
+      }
+      return KeySequence.CompareResult.SHADOW;
+    }
+    return KeySequence.CompareResult.FULL;
+  }
+  _KeySequence.compare = compare;
+  function parse(keybinding) {
+    var keyCodes = [];
+    var rawKeyCodes = keybinding.trim().split(/\s+/g);
+    var _iterator2 = _createForOfIteratorHelper(rawKeyCodes),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var rawKeyCode = _step2.value;
+        var _keyCode = KeyCode.parse(rawKeyCode);
+        if (_keyCode !== undefined) {
+          keyCodes.push(_keyCode);
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    return keyCodes;
+  }
+  _KeySequence.parse = parse;
+})(KeySequence || (KeySequence = {}));
+/**
+ * The key sequence for this binding. This key sequence should consist of one or more key strokes. Key strokes
+ * consist of one or more keys held down at the same time. This should be zero or more modifier keys, and zero or one other key.
+ * Since `M2+M3+<Key>` (Alt+Shift+<Key>) is reserved on MacOS X for writing special characters, such bindings are commonly
+ * undefined for platform MacOS X and redefined as `M1+M3+<Key>`. The rule applies on the `M3+M2+<Key>` sequence.
+ */
+/**
+ * Representation of a pressed key combined with key modifiers.
+ */
+export var KeyCode = /*#__PURE__*/function () {
+  function KeyCode(schema) {
+    _classCallCheck(this, KeyCode);
+    var key = schema.key;
+    if (key) {
+      if (key.code && key.keyCode && key.easyString) {
+        this.key = key;
+      } else if (key.code) {
+        this.key = Key.getKey(key.code);
+      } else if (key.keyCode) {
+        this.key = Key.getKey(key.keyCode);
+      }
+    }
+    this.ctrl = !!schema.ctrl;
+    this.shift = !!schema.shift;
+    this.alt = !!schema.alt;
+    this.meta = !!schema.meta;
+    this.character = schema.character;
+  }
+
+  /**
+   * Return true if this KeyCode only contains modifiers.
+   */
+  _createClass(KeyCode, [{
+    key: "isModifierOnly",
+    value: function isModifierOnly() {
+      return this.key === undefined;
+    }
+
+    /**
+     * Return true if the given KeyCode is equal to this one.
+     */
+  }, {
+    key: "equals",
+    value: function equals(other) {
+      if (this.key && (!other.key || this.key.code !== other.key.code) || !this.key && other.key) {
+        return false;
+      }
+      return this.ctrl === other.ctrl && this.alt === other.alt && this.shift === other.shift && this.meta === other.meta;
+    }
+
+    /*
+     * Return a keybinding string compatible with the `Keybinding.keybinding` property.
+     */
+  }, {
+    key: "toString",
+    value: function toString() {
+      var result = [];
+      if (this.meta) {
+        result.push(SpecialCases.META);
+      }
+      if (this.shift) {
+        result.push(Key.SHIFT_LEFT.easyString);
+      }
+      if (this.alt) {
+        result.push(Key.ALT_LEFT.easyString);
+      }
+      if (this.ctrl) {
+        result.push(Key.CONTROL_LEFT.easyString);
+      }
+      if (this.key) {
+        result.push(this.key.easyString);
+      }
+      return result.join('+');
+    }
+
+    /**
+     * Create a KeyCode from one of several input types.
+     */
+  }], [{
+    key: "createKeyCode",
+    value: function createKeyCode(input) {
+      var eventDispatch = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'code';
+      if (typeof input === 'string') {
+        var parts = input.split('+');
+        if (!KeyCode.isModifierString(parts[0])) {
+          return KeyCode.createKeyCode({
+            first: Key.getKey(parts[0]),
+            modifiers: parts.slice(1)
+          });
+        }
+        return KeyCode.createKeyCode({
+          modifiers: parts
+        });
+      }
+      if (KeyCode.isKeyboardEvent(input)) {
+        var key = KeyCode.toKey(input, eventDispatch);
+        return new KeyCode({
+          key: Key.isModifier(key.code) ? undefined : key,
+          meta: isOSX && input.metaKey,
+          shift: input.shiftKey,
+          alt: input.altKey,
+          ctrl: input.ctrlKey,
+          character: KeyCode.toCharacter(input)
+        });
+      }
+      if (input.first || input.modifiers) {
+        var keystroke = input;
+        var schema = {
+          key: keystroke.first
+        };
+        if (keystroke.modifiers) {
+          if (isOSX) {
+            schema.meta = keystroke.modifiers.some(function (mod) {
+              return mod === KeyModifier.CtrlCmd;
+            });
+            schema.ctrl = keystroke.modifiers.some(function (mod) {
+              return mod === KeyModifier.MacCtrl;
+            });
+          } else {
+            schema.meta = false;
+            schema.ctrl = keystroke.modifiers.some(function (mod) {
+              return mod === KeyModifier.CtrlCmd;
+            });
+          }
+          schema.shift = keystroke.modifiers.some(function (mod) {
+            return mod === KeyModifier.Shift;
+          });
+          schema.alt = keystroke.modifiers.some(function (mod) {
+            return mod === KeyModifier.Alt;
+          });
+        }
+        return new KeyCode(schema);
+      }
+      return new KeyCode(input);
+    }
+  }, {
+    key: "resetKeyBindings",
+    value: /* Reset the key hashmap, this is for testing purposes.  */
+    function resetKeyBindings() {
+      KeyCode.keybindings = {};
+    }
+
+    /**
+     * Parses a string and returns a KeyCode object.
+     * @param keybinding String representation of a keybinding
+     */
+  }, {
+    key: "parse",
+    value: function parse(keybinding) {
+      if (KeyCode.keybindings[keybinding]) {
+        return KeyCode.keybindings[keybinding];
+      }
+      var schema = {};
+      var keys = [];
+      var currentKey = '';
+      var _iterator = _createForOfIteratorHelper(keybinding.trim().toLowerCase()),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var character = _step.value;
+          if (currentKey && (character === '-' || character === '+')) {
+            keys.push(currentKey);
+            currentKey = '';
+          } else if (character !== '+') {
+            currentKey += character;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      if (currentKey) {
+        keys.push(currentKey);
+      }
+      /* If duplicates i.e ctrl+ctrl+a or alt+alt+b or b+alt+b it is invalid */
+      if (keys.length !== new Set(keys).size) {
+        throw new Error("Can't parse keybinding ".concat(keybinding, " Duplicate modifiers"));
+      }
+      for (var _i = 0, _keys = keys; _i < _keys.length; _i++) {
+        var keyString = _keys[_i];
+        if (SPECIAL_ALIASES[keyString] !== undefined) {
+          keyString = SPECIAL_ALIASES[keyString];
+        }
+        var key = EASY_TO_KEY[keyString];
+
+        /* meta only works on macOS */
+        if (keyString === SpecialCases.META) {
+          if (isOSX) {
+            schema.meta = true;
+          } else {
+            throw new Error("Can't parse keybinding ".concat(keybinding, " meta is for OSX only"));
+          }
+          /* ctrlcmd for M1 keybindings that work on both macOS and other platforms */
+        } else if (keyString === SpecialCases.CTRLCMD) {
+          if (isOSX) {
+            schema.meta = true;
+          } else {
+            schema.ctrl = true;
+          }
+        } else if (Key.isKey(key)) {
+          if (Key.isModifier(key.code)) {
+            if (key.code === Key.CONTROL_LEFT.code || key.code === Key.CONTROL_RIGHT.code) {
+              schema.ctrl = true;
+            } else if (key.code === Key.SHIFT_LEFT.code || key.code === Key.SHIFT_RIGHT.code) {
+              schema.shift = true;
+            } else if (key.code === Key.ALT_LEFT.code || key.code === Key.ALT_RIGHT.code) {
+              schema.alt = true;
+            }
+          } else {
+            schema.key = key;
+          }
+        } else {
+          throw new Error("Unrecognized key '".concat(keyString, "' in '").concat(keybinding, "'"));
+        }
+      }
+      KeyCode.keybindings[keybinding] = new KeyCode(schema);
+      return KeyCode.keybindings[keybinding];
+    }
+  }]);
+  return KeyCode;
+}();
+KeyCode.keybindings = {};
+(function (_KeyCode2) {
+  /**
+   * Determines a `true` of `false` value for the key code argument.
+   */
+
+  /*
+   * Return true if the string is a modifier M1 to M4.
+   */
+  function isModifierString(key) {
+    return key === KeyModifier.CtrlCmd || key === KeyModifier.Shift || key === KeyModifier.Alt || key === KeyModifier.MacCtrl;
+  }
+  _KeyCode2.isModifierString = isModifierString;
+  function isKeyboardEvent(event) {
+    if (typeof KeyboardEvent === 'undefined') {
+      // This can happen in tests
+      return false;
+    }
+    if (event instanceof KeyboardEvent) {
+      return true;
+    }
+    var type = event.type;
+    if (type) {
+      return type === 'keypress' || type === 'keydown' || type === 'keyup';
+    }
+    return false;
+  }
+  _KeyCode2.isKeyboardEvent = isKeyboardEvent;
+  function toKey(event) {
+    var dispatch = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'code';
+    var code = event.code;
+    if (code && dispatch === 'code') {
+      if (isOSX) {
+        // https://github.com/eclipse-mana/mana/issues/4986
+        var char = event.key;
+        if (code === 'IntlBackslash' && (char === '`' || char === '~')) {
+          return Key.BACKQUOTE;
+        }
+        if (code === 'Backquote' && (char === '§' || char === '±')) {
+          return Key.INTL_BACKSLASH;
+        }
+      }
+
+      // https://github.com/eclipse-mana/mana/issues/7315
+      if (code.startsWith('Numpad') && event.key && event.key.length > 1) {
+        var k = Key.getKey(event.key);
+        if (k) {
+          return k;
+        }
+      }
+      var key = Key.getKey(code);
+      if (key) {
+        return key;
+      }
+    }
+
+    // tslint:disable-next-line: deprecation
+    var keyCode = event.keyCode;
+    if (keyCode) {
+      var _key = Key.getKey(keyCode);
+      if (_key) {
+        return _key;
+      }
+    }
+    var _ref = event,
+      keyIdentifier = _ref.keyIdentifier;
+    if (keyIdentifier) {
+      var _key2 = Key.getKey(keyIdentifier);
+      if (_key2) {
+        return _key2;
+      }
+    }
+    throw new Error("Cannot get key code from the keyboard event: ".concat(event, "."));
+  }
+  _KeyCode2.toKey = toKey;
+  function toCharacter(event) {
+    var key = event.key;
+    // Use the key property if it contains exactly one unicode character
+    if (key && Array.from(key).length === 1) {
+      return key;
+    }
+    var charCode = event.charCode;
+    // Use the charCode property if it does not correspond to a unicode control character
+    if (charCode && charCode > 0x1f && !(charCode >= 0x80 && charCode <= 0x9f)) {
+      return String.fromCharCode(charCode);
+    }
+    return undefined;
+  }
+  _KeyCode2.toCharacter = toCharacter;
+})(KeyCode || (KeyCode = {}));
+export var KeyModifier = /*#__PURE__*/function (KeyModifier) {
+  /**
+   * M1 is the COMMAND key on MacOS X, and the CTRL key on most other platforms.
+   */
+  KeyModifier["CtrlCmd"] = "M1";
+  /**
+   * M2 is the SHIFT key.
+   */
+  KeyModifier["Shift"] = "M2";
+  /**
+   * M3 is the Option key on MacOS X, and the ALT key on most other platforms.
+   */
+  KeyModifier["Alt"] = "M3";
+  /**
+   * M4 is the CTRL key on MacOS X, and is undefined on other platforms.
+   */
+  KeyModifier["MacCtrl"] = "M4";
+  return KeyModifier;
+}({});
+(function (_KeyModifier) {
+  var CTRL = _KeyModifier.CTRL = isOSX ? KeyModifier.MacCtrl : KeyModifier.CtrlCmd;
+  var SHIFT = _KeyModifier.SHIFT = KeyModifier.Shift;
+  function isModifier(key) {
+    if (key) {
+      switch (key) {
+        case 'M1': // Fall through.
+        case 'M2': // Fall through.
+        case 'M3': // Fall through.
+        case 'M4':
+          return true;
+        default:
+          return false;
+      }
+    }
+    return false;
+  }
+  _KeyModifier.isModifier = isModifier;
+})(KeyModifier || (KeyModifier = {}));
+var CODE_TO_KEY = {};
+var KEY_CODE_TO_KEY = {};
+var EASY_TO_KEY = {}; // From 'ctrl' to Key structure
+var MODIFIERS = [];
+var SPECIAL_ALIASES = {
+  option: 'alt',
+  command: 'meta',
+  cmd: 'meta',
+  return: 'enter',
+  esc: 'escape',
+  mod: 'ctrl',
+  ins: 'insert',
+  del: 'delete',
+  control: 'ctrl'
+};
+export var SpecialCases;
+(function (_SpecialCases) {
+  var META = _SpecialCases.META = 'meta';
+  var CTRLCMD = _SpecialCases.CTRLCMD = 'ctrlcmd';
+})(SpecialCases || (SpecialCases = {}));
+export var Key;
+(function (_Key) {
+  function isKey(arg) {
+    return _typeof(arg) === 'object' && 'code' in arg && 'keyCode' in arg;
+  }
+  _Key.isKey = isKey;
+  function getKey(arg) {
+    if (typeof arg === 'number') {
+      return KEY_CODE_TO_KEY[arg];
+    }
+    return CODE_TO_KEY[arg];
+  }
+  _Key.getKey = getKey;
+  function isModifier(arg) {
+    if (typeof arg === 'number') {
+      return MODIFIERS.find(function (key) {
+        return key.keyCode === arg;
+      }) !== undefined;
+    }
+    return MODIFIERS.find(function (key) {
+      return key.code === arg;
+    }) !== undefined;
+  }
+  _Key.isModifier = isModifier;
+  function equals(key, keyCode) {
+    return !!keyCode.key && key.keyCode === keyCode.key.keyCode;
+  }
+  _Key.equals = equals;
+  var BACKSPACE = _Key.BACKSPACE = {
+    code: 'Backspace',
+    keyCode: 8,
+    easyString: 'backspace'
+  };
+  var TAB = _Key.TAB = {
+    code: 'Tab',
+    keyCode: 9,
+    easyString: 'tab'
+  };
+  var ENTER = _Key.ENTER = {
+    code: 'Enter',
+    keyCode: 13,
+    easyString: 'enter'
+  };
+  var ESCAPE = _Key.ESCAPE = {
+    code: 'Escape',
+    keyCode: 27,
+    easyString: 'escape'
+  };
+  var SPACE = _Key.SPACE = {
+    code: 'Space',
+    keyCode: 32,
+    easyString: 'space'
+  };
+  var PAGE_UP = _Key.PAGE_UP = {
+    code: 'PageUp',
+    keyCode: 33,
+    easyString: 'pageup'
+  };
+  var PAGE_DOWN = _Key.PAGE_DOWN = {
+    code: 'PageDown',
+    keyCode: 34,
+    easyString: 'pagedown'
+  };
+  var END = _Key.END = {
+    code: 'End',
+    keyCode: 35,
+    easyString: 'end'
+  };
+  var HOME = _Key.HOME = {
+    code: 'Home',
+    keyCode: 36,
+    easyString: 'home'
+  };
+  var ARROW_LEFT = _Key.ARROW_LEFT = {
+    code: 'ArrowLeft',
+    keyCode: 37,
+    easyString: 'left'
+  };
+  var ARROW_UP = _Key.ARROW_UP = {
+    code: 'ArrowUp',
+    keyCode: 38,
+    easyString: 'up'
+  };
+  var ARROW_RIGHT = _Key.ARROW_RIGHT = {
+    code: 'ArrowRight',
+    keyCode: 39,
+    easyString: 'right'
+  };
+  var ARROW_DOWN = _Key.ARROW_DOWN = {
+    code: 'ArrowDown',
+    keyCode: 40,
+    easyString: 'down'
+  };
+  var INSERT = _Key.INSERT = {
+    code: 'Insert',
+    keyCode: 45,
+    easyString: 'insert'
+  };
+  var DELETE = _Key.DELETE = {
+    code: 'Delete',
+    keyCode: 46,
+    easyString: 'delete'
+  };
+  var SHIFT_LEFT = _Key.SHIFT_LEFT = {
+    code: 'ShiftLeft',
+    keyCode: 16,
+    easyString: 'shift'
+  };
+  var SHIFT_RIGHT = _Key.SHIFT_RIGHT = {
+    code: 'ShiftRight',
+    keyCode: 16,
+    easyString: 'shift'
+  };
+  var CONTROL_LEFT = _Key.CONTROL_LEFT = {
+    code: 'ControlLeft',
+    keyCode: 17,
+    easyString: 'ctrl'
+  };
+  var CONTROL_RIGHT = _Key.CONTROL_RIGHT = {
+    code: 'ControlRight',
+    keyCode: 17,
+    easyString: 'ctrl'
+  };
+  var ALT_LEFT = _Key.ALT_LEFT = {
+    code: 'AltLeft',
+    keyCode: 18,
+    easyString: 'alt'
+  };
+  var ALT_RIGHT = _Key.ALT_RIGHT = {
+    code: 'AltRight',
+    keyCode: 18,
+    easyString: 'alt'
+  };
+  var CAPS_LOCK = _Key.CAPS_LOCK = {
+    code: 'CapsLock',
+    keyCode: 20,
+    easyString: 'capslock'
+  };
+  var OS_LEFT = _Key.OS_LEFT = {
+    code: 'OSLeft',
+    keyCode: 91,
+    easyString: 'super'
+  };
+  var OS_RIGHT = _Key.OS_RIGHT = {
+    code: 'OSRight',
+    keyCode: 92,
+    easyString: 'super'
+  };
+  var DIGIT0 = _Key.DIGIT0 = {
+    code: 'Digit0',
+    keyCode: 48,
+    easyString: '0'
+  };
+  var DIGIT1 = _Key.DIGIT1 = {
+    code: 'Digit1',
+    keyCode: 49,
+    easyString: '1'
+  };
+  var DIGIT2 = _Key.DIGIT2 = {
+    code: 'Digit2',
+    keyCode: 50,
+    easyString: '2'
+  };
+  var DIGIT3 = _Key.DIGIT3 = {
+    code: 'Digit3',
+    keyCode: 51,
+    easyString: '3'
+  };
+  var DIGIT4 = _Key.DIGIT4 = {
+    code: 'Digit4',
+    keyCode: 52,
+    easyString: '4'
+  };
+  var DIGIT5 = _Key.DIGIT5 = {
+    code: 'Digit5',
+    keyCode: 53,
+    easyString: '5'
+  };
+  var DIGIT6 = _Key.DIGIT6 = {
+    code: 'Digit6',
+    keyCode: 54,
+    easyString: '6'
+  };
+  var DIGIT7 = _Key.DIGIT7 = {
+    code: 'Digit7',
+    keyCode: 55,
+    easyString: '7'
+  };
+  var DIGIT8 = _Key.DIGIT8 = {
+    code: 'Digit8',
+    keyCode: 56,
+    easyString: '8'
+  };
+  var DIGIT9 = _Key.DIGIT9 = {
+    code: 'Digit9',
+    keyCode: 57,
+    easyString: '9'
+  };
+  var KEY_A = _Key.KEY_A = {
+    code: 'KeyA',
+    keyCode: 65,
+    easyString: 'a'
+  };
+  var KEY_B = _Key.KEY_B = {
+    code: 'KeyB',
+    keyCode: 66,
+    easyString: 'b'
+  };
+  var KEY_C = _Key.KEY_C = {
+    code: 'KeyC',
+    keyCode: 67,
+    easyString: 'c'
+  };
+  var KEY_D = _Key.KEY_D = {
+    code: 'KeyD',
+    keyCode: 68,
+    easyString: 'd'
+  };
+  var KEY_E = _Key.KEY_E = {
+    code: 'KeyE',
+    keyCode: 69,
+    easyString: 'e'
+  };
+  var KEY_F = _Key.KEY_F = {
+    code: 'KeyF',
+    keyCode: 70,
+    easyString: 'f'
+  };
+  var KEY_G = _Key.KEY_G = {
+    code: 'KeyG',
+    keyCode: 71,
+    easyString: 'g'
+  };
+  var KEY_H = _Key.KEY_H = {
+    code: 'KeyH',
+    keyCode: 72,
+    easyString: 'h'
+  };
+  var KEY_I = _Key.KEY_I = {
+    code: 'KeyI',
+    keyCode: 73,
+    easyString: 'i'
+  };
+  var KEY_J = _Key.KEY_J = {
+    code: 'KeyJ',
+    keyCode: 74,
+    easyString: 'j'
+  };
+  var KEY_K = _Key.KEY_K = {
+    code: 'KeyK',
+    keyCode: 75,
+    easyString: 'k'
+  };
+  var KEY_L = _Key.KEY_L = {
+    code: 'KeyL',
+    keyCode: 76,
+    easyString: 'l'
+  };
+  var KEY_M = _Key.KEY_M = {
+    code: 'KeyM',
+    keyCode: 77,
+    easyString: 'm'
+  };
+  var KEY_N = _Key.KEY_N = {
+    code: 'KeyN',
+    keyCode: 78,
+    easyString: 'n'
+  };
+  var KEY_O = _Key.KEY_O = {
+    code: 'KeyO',
+    keyCode: 79,
+    easyString: 'o'
+  };
+  var KEY_P = _Key.KEY_P = {
+    code: 'KeyP',
+    keyCode: 80,
+    easyString: 'p'
+  };
+  var KEY_Q = _Key.KEY_Q = {
+    code: 'KeyQ',
+    keyCode: 81,
+    easyString: 'q'
+  };
+  var KEY_R = _Key.KEY_R = {
+    code: 'KeyR',
+    keyCode: 82,
+    easyString: 'r'
+  };
+  var KEY_S = _Key.KEY_S = {
+    code: 'KeyS',
+    keyCode: 83,
+    easyString: 's'
+  };
+  var KEY_T = _Key.KEY_T = {
+    code: 'KeyT',
+    keyCode: 84,
+    easyString: 't'
+  };
+  var KEY_U = _Key.KEY_U = {
+    code: 'KeyU',
+    keyCode: 85,
+    easyString: 'u'
+  };
+  var KEY_V = _Key.KEY_V = {
+    code: 'KeyV',
+    keyCode: 86,
+    easyString: 'v'
+  };
+  var KEY_W = _Key.KEY_W = {
+    code: 'KeyW',
+    keyCode: 87,
+    easyString: 'w'
+  };
+  var KEY_X = _Key.KEY_X = {
+    code: 'KeyX',
+    keyCode: 88,
+    easyString: 'x'
+  };
+  var KEY_Y = _Key.KEY_Y = {
+    code: 'KeyY',
+    keyCode: 89,
+    easyString: 'y'
+  };
+  var KEY_Z = _Key.KEY_Z = {
+    code: 'KeyZ',
+    keyCode: 90,
+    easyString: 'z'
+  };
+  var MULTIPLY = _Key.MULTIPLY = {
+    code: 'NumpadMultiply',
+    keyCode: 106,
+    easyString: 'multiply'
+  };
+  var ADD = _Key.ADD = {
+    code: 'NumpadAdd',
+    keyCode: 107,
+    easyString: 'add'
+  };
+  var DECIMAL = _Key.DECIMAL = {
+    code: 'NumpadDecimal',
+    keyCode: 108,
+    easyString: 'decimal'
+  };
+  var SUBTRACT = _Key.SUBTRACT = {
+    code: 'NumpadSubtract',
+    keyCode: 109,
+    easyString: 'subtract'
+  };
+  var DIVIDE = _Key.DIVIDE = {
+    code: 'NumpadDivide',
+    keyCode: 111,
+    easyString: 'divide'
+  };
+  var F1 = _Key.F1 = {
+    code: 'F1',
+    keyCode: 112,
+    easyString: 'f1'
+  };
+  var F2 = _Key.F2 = {
+    code: 'F2',
+    keyCode: 113,
+    easyString: 'f2'
+  };
+  var F3 = _Key.F3 = {
+    code: 'F3',
+    keyCode: 114,
+    easyString: 'f3'
+  };
+  var F4 = _Key.F4 = {
+    code: 'F4',
+    keyCode: 115,
+    easyString: 'f4'
+  };
+  var F5 = _Key.F5 = {
+    code: 'F5',
+    keyCode: 116,
+    easyString: 'f5'
+  };
+  var F6 = _Key.F6 = {
+    code: 'F6',
+    keyCode: 117,
+    easyString: 'f6'
+  };
+  var F7 = _Key.F7 = {
+    code: 'F7',
+    keyCode: 118,
+    easyString: 'f7'
+  };
+  var F8 = _Key.F8 = {
+    code: 'F8',
+    keyCode: 119,
+    easyString: 'f8'
+  };
+  var F9 = _Key.F9 = {
+    code: 'F9',
+    keyCode: 120,
+    easyString: 'f9'
+  };
+  var F10 = _Key.F10 = {
+    code: 'F10',
+    keyCode: 121,
+    easyString: 'f10'
+  };
+  var F11 = _Key.F11 = {
+    code: 'F11',
+    keyCode: 122,
+    easyString: 'f11'
+  };
+  var F12 = _Key.F12 = {
+    code: 'F12',
+    keyCode: 123,
+    easyString: 'f12'
+  };
+  var F13 = _Key.F13 = {
+    code: 'F13',
+    keyCode: 124,
+    easyString: 'f13'
+  };
+  var F14 = _Key.F14 = {
+    code: 'F14',
+    keyCode: 125,
+    easyString: 'f14'
+  };
+  var F15 = _Key.F15 = {
+    code: 'F15',
+    keyCode: 126,
+    easyString: 'f15'
+  };
+  var F16 = _Key.F16 = {
+    code: 'F16',
+    keyCode: 127,
+    easyString: 'f16'
+  };
+  var F17 = _Key.F17 = {
+    code: 'F17',
+    keyCode: 128,
+    easyString: 'f17'
+  };
+  var F18 = _Key.F18 = {
+    code: 'F18',
+    keyCode: 129,
+    easyString: 'f18'
+  };
+  var F19 = _Key.F19 = {
+    code: 'F19',
+    keyCode: 130,
+    easyString: 'f19'
+  };
+  var F20 = _Key.F20 = {
+    code: 'F20',
+    keyCode: 131,
+    easyString: 'f20'
+  };
+  var F21 = _Key.F21 = {
+    code: 'F21',
+    keyCode: 132,
+    easyString: 'f21'
+  };
+  var F22 = _Key.F22 = {
+    code: 'F22',
+    keyCode: 133,
+    easyString: 'f22'
+  };
+  var F23 = _Key.F23 = {
+    code: 'F23',
+    keyCode: 134,
+    easyString: 'f23'
+  };
+  var F24 = _Key.F24 = {
+    code: 'F24',
+    keyCode: 135,
+    easyString: 'f24'
+  };
+  var NUM_LOCK = _Key.NUM_LOCK = {
+    code: 'NumLock',
+    keyCode: 144,
+    easyString: 'numlock'
+  };
+  var SEMICOLON = _Key.SEMICOLON = {
+    code: 'Semicolon',
+    keyCode: 186,
+    easyString: ';'
+  };
+  var EQUAL = _Key.EQUAL = {
+    code: 'Equal',
+    keyCode: 187,
+    easyString: '='
+  };
+  var COMMA = _Key.COMMA = {
+    code: 'Comma',
+    keyCode: 188,
+    easyString: ','
+  };
+  var MINUS = _Key.MINUS = {
+    code: 'Minus',
+    keyCode: 189,
+    easyString: '-'
+  };
+  var PERIOD = _Key.PERIOD = {
+    code: 'Period',
+    keyCode: 190,
+    easyString: '.'
+  };
+  var SLASH = _Key.SLASH = {
+    code: 'Slash',
+    keyCode: 191,
+    easyString: '/'
+  };
+  var BACKQUOTE = _Key.BACKQUOTE = {
+    code: 'Backquote',
+    keyCode: 192,
+    easyString: '`'
+  };
+  var INTL_RO = _Key.INTL_RO = {
+    code: 'IntlRo',
+    keyCode: 193,
+    easyString: 'intlro'
+  };
+  var BRACKET_LEFT = _Key.BRACKET_LEFT = {
+    code: 'BracketLeft',
+    keyCode: 219,
+    easyString: '['
+  };
+  var BACKSLASH = _Key.BACKSLASH = {
+    code: 'Backslash',
+    keyCode: 220,
+    easyString: '\\'
+  };
+  var BRACKET_RIGHT = _Key.BRACKET_RIGHT = {
+    code: 'BracketRight',
+    keyCode: 221,
+    easyString: ']'
+  };
+  var QUOTE = _Key.QUOTE = {
+    code: 'Quote',
+    keyCode: 222,
+    easyString: "'"
+  };
+  var INTL_BACKSLASH = _Key.INTL_BACKSLASH = {
+    code: 'IntlBackslash',
+    keyCode: 229,
+    easyString: 'intlbackslash'
+  };
+  var INTL_YEN = _Key.INTL_YEN = {
+    code: 'IntlYen',
+    keyCode: 255,
+    easyString: 'intlyen'
+  };
+  var MAX_KEY_CODE = _Key.MAX_KEY_CODE = INTL_YEN.keyCode;
+})(Key || (Key = {}));
+/* -------------------- Initialize the static key mappings -------------------- */
+(function () {
+  // Set the default key mappings from the constants in the Key namespace
+  Object.keys(Key).map(function (prop) {
+    return Reflect.get(Key, prop);
+  }).filter(function (key) {
+    return Key.isKey(key);
+  }).forEach(function (key) {
+    CODE_TO_KEY[key.code] = key;
+    KEY_CODE_TO_KEY[key.keyCode] = key;
+    EASY_TO_KEY[key.easyString] = key;
+  });
+
+  // Set additional key mappings
+  // Set additional key mappings
+  CODE_TO_KEY['Numpad0'] = Key.DIGIT0;
+  KEY_CODE_TO_KEY[96] = Key.DIGIT0;
+  CODE_TO_KEY['Numpad1'] = Key.DIGIT1;
+  KEY_CODE_TO_KEY[97] = Key.DIGIT1;
+  CODE_TO_KEY['Numpad2'] = Key.DIGIT2;
+  KEY_CODE_TO_KEY[98] = Key.DIGIT2;
+  CODE_TO_KEY['Numpad3'] = Key.DIGIT3;
+  KEY_CODE_TO_KEY[99] = Key.DIGIT3;
+  CODE_TO_KEY['Numpad4'] = Key.DIGIT4;
+  KEY_CODE_TO_KEY[100] = Key.DIGIT4;
+  CODE_TO_KEY['Numpad5'] = Key.DIGIT5;
+  KEY_CODE_TO_KEY[101] = Key.DIGIT5;
+  CODE_TO_KEY['Numpad6'] = Key.DIGIT6;
+  KEY_CODE_TO_KEY[102] = Key.DIGIT6;
+  CODE_TO_KEY['Numpad7'] = Key.DIGIT7;
+  KEY_CODE_TO_KEY[103] = Key.DIGIT7;
+  CODE_TO_KEY['Numpad8'] = Key.DIGIT8;
+  KEY_CODE_TO_KEY[104] = Key.DIGIT8;
+  CODE_TO_KEY['Numpad9'] = Key.DIGIT9;
+  KEY_CODE_TO_KEY[105] = Key.DIGIT9;
+  CODE_TO_KEY['NumpadEnter'] = Key.ENTER;
+  CODE_TO_KEY['NumpadEqual'] = Key.EQUAL;
+  CODE_TO_KEY['MetaLeft'] = Key.OS_LEFT; // Chrome, Safari
+  KEY_CODE_TO_KEY[224] = Key.OS_LEFT; // Firefox on Mac
+  CODE_TO_KEY['MetaRight'] = Key.OS_RIGHT; // Chrome, Safari
+  KEY_CODE_TO_KEY[93] = Key.OS_RIGHT; // Chrome, Safari, Edge
+  KEY_CODE_TO_KEY[225] = Key.ALT_RIGHT; // Linux
+  KEY_CODE_TO_KEY[110] = Key.DECIMAL; // Mac, Windows
+  KEY_CODE_TO_KEY[59] = Key.SEMICOLON; // Firefox
+  KEY_CODE_TO_KEY[61] = Key.EQUAL; // Firefox
+  KEY_CODE_TO_KEY[173] = Key.MINUS; // Firefox
+  KEY_CODE_TO_KEY[226] = Key.BACKSLASH; // Chrome, Edge on Windows
+  KEY_CODE_TO_KEY[60] = Key.BACKSLASH; // Firefox on Linux
+
+  // Set the modifier keys
+  MODIFIERS.push.apply(MODIFIERS, [Key.ALT_LEFT, Key.ALT_RIGHT, Key.CONTROL_LEFT, Key.CONTROL_RIGHT, Key.OS_LEFT, Key.OS_RIGHT, Key.SHIFT_LEFT, Key.SHIFT_RIGHT]);
+})();
+export var KeysOrKeyCodes;
+(function (_KeysOrKeyCodes) {
+  var toKeyCode = _KeysOrKeyCodes.toKeyCode = function (keyOrKeyCode) {
+    return keyOrKeyCode instanceof KeyCode ? keyOrKeyCode : KeyCode.createKeyCode({
+      first: keyOrKeyCode
+    });
+  };
+  var toKeyCodes = _KeysOrKeyCodes.toKeyCodes = function (keysOrKeyCodes) {
+    if (keysOrKeyCodes instanceof KeyCode) {
+      return [keysOrKeyCodes];
+    }
+    if (Array.isArray(keysOrKeyCodes)) {
+      return keysOrKeyCodes.slice().map(toKeyCode);
+    }
+    return [toKeyCode(keysOrKeyCodes)];
+  };
+})(KeysOrKeyCodes || (KeysOrKeyCodes = {}));