@difizen/mana-core
Version:
1,072 lines (1,060 loc) • 30.7 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.SpecialCases = exports.KeysOrKeyCodes = exports.KeySequence = exports.KeyModifier = exports.KeyCode = exports.Key = void 0;
var _manaCommon = require("@difizen/mana-common");
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 */
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 || (exports.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.
*/
var KeyCode = exports.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: _manaCommon.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 (_manaCommon.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 (_manaCommon.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 (_manaCommon.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 (_manaCommon.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 || (exports.KeyCode = KeyCode = {}));
var KeyModifier = exports.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 = _manaCommon.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 || (exports.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'
};
var SpecialCases;
(function (_SpecialCases) {
var META = _SpecialCases.META = 'meta';
var CTRLCMD = _SpecialCases.CTRLCMD = 'ctrlcmd';
})(SpecialCases || (exports.SpecialCases = SpecialCases = {}));
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 || (exports.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]);
})();
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 || (exports.KeysOrKeyCodes = KeysOrKeyCodes = {}));