@cniot/android-pda-components 2.0.0-beta.12 → 2.0.0-beta.13

package/es/index.es.js

@@ -31,7 +31,7 @@ function getAugmentedNamespace(n2) {
   });
   return a;
 }
-var lib$2 = { exports: {} };
+var lib$3 = { exports: {} };
 var locale$1 = {};
 var cookie = {};
 var util$1 = {};
@@ -625,26 +625,26 @@ function assign$1(target) {
   var _default2 = exportObject;
   exports["default"] = _default2;
   module.exports = exportObject;
-})(lib$2, lib$2.exports);
-var locale = /* @__PURE__ */ getDefaultExportFromCjs(lib$2.exports);
+})(lib$3, lib$3.exports);
+var locale = /* @__PURE__ */ getDefaultExportFromCjs(lib$3.exports);
+var lib$2 = {};
 var lib$1 = {};
-var lib = {};
-lib.__esModule = true;
-lib.isIOS = lib.isAndroid = lib.isWeb = lib.isWechatApp = lib.isMiniApp = lib.isReactNative = lib.isWeex = lib.isNode = void 0;
+lib$1.__esModule = true;
+lib$1.isIOS = lib$1.isAndroid = lib$1.isWeb = lib$1.isWechatApp = lib$1.isMiniApp = lib$1.isReactNative = lib$1.isWeex = lib$1.isNode = void 0;
 var isTaoWebview = typeof __sfc__ !== "undefined";
 var isWebPure = typeof navigator === "object" && (navigator.appCodeName === "Mozilla" || navigator.product === "Gecko");
 var isNode = typeof process !== "undefined" && !!(process.versions && process.versions.node);
-lib.isNode = isNode;
+lib$1.isNode = isNode;
 var isWeex = typeof callNative === "function" || typeof WXEnvironment === "object" && WXEnvironment.platform !== "Web";
-lib.isWeex = isWeex;
+lib$1.isWeex = isWeex;
 var isReactNative = typeof __fbBatchedBridgeConfig !== "undefined";
-lib.isReactNative = isReactNative;
+lib$1.isReactNative = isReactNative;
 var isMiniApp = typeof my === "object" && typeof my.getSystemInfo !== "undefined" && !isTaoWebview;
-lib.isMiniApp = isMiniApp;
+lib$1.isMiniApp = isMiniApp;
 var isWechatApp = typeof wx === "object" && typeof wx.getSystemInfo !== "undefined";
-lib.isWechatApp = isWechatApp;
+lib$1.isWechatApp = isWechatApp;
 var isWeb = isWebPure && !isMiniApp && !isWechatApp || isTaoWebview;
-lib.isWeb = isWeb;
+lib$1.isWeb = isWeb;
 var systemInfo = {};
 if (isMiniApp) {
   systemInfo = my.getSystemInfoSync();
@@ -664,7 +664,7 @@ var isAndroid = function() {
   }
   return false;
 }();
-lib.isAndroid = isAndroid;
+lib$1.isAndroid = isAndroid;
 var isIOS$1 = function() {
   if (isMiniApp || isWechatApp || isWeex) {
     return ["ios", "iOS", "iPhone OS"].indexOf(systemInfo.platform) > -1;
@@ -673,7 +673,7 @@ var isIOS$1 = function() {
   }
   return false;
 }();
-lib.isIOS = isIOS$1;
+lib$1.isIOS = isIOS$1;
 var stringFormat = {};
 var hop = Object.prototype.hasOwnProperty;
 function extend(obj) {
@@ -2541,13 +2541,13 @@ var StringFormat = /* @__PURE__ */ function() {
   return StringFormat2;
 }();
 stringFormat.default = StringFormat;
-Object.defineProperty(lib$1, "__esModule", {
+Object.defineProperty(lib$2, "__esModule", {
   value: true
 });
-lib$1.init = init;
-lib$1.format = format;
-var default_1 = lib$1.default = void 0;
-var _universalEnv = lib;
+lib$2.init = init;
+lib$2.format = format;
+var default_1 = lib$2.default = void 0;
+var _universalEnv = lib$1;
 var _stringFormat = _interopRequireDefault(stringFormat);
 var _util = util;
 function _interopRequireDefault(obj) {
@@ -2598,7 +2598,7 @@ var _default = {
   format,
   StringFormat: _stringFormat.default
 };
-default_1 = lib$1.default = _default;
+default_1 = lib$2.default = _default;
 var enUS = {
   "\u786E\u5B9A\u79BB\u5F00\u5F53\u524D\u9875\u9762\u5417\uFF1F": "Are you sure you want to leave the current page?",
   "\u8FDC": "Far",
@@ -2878,9 +2878,9 @@ var _keycode_2_2_1_keycode = { exports: {} };
       return search.charCodeAt(0);
     return void 0;
   }
-  keyCode.isEventKey = function isEventKey(event, nameOrCode) {
-    if (event && "object" === typeof event) {
-      var keyCode2 = event.which || event.keyCode || event.charCode;
+  keyCode.isEventKey = function isEventKey(event2, nameOrCode) {
+    if (event2 && "object" === typeof event2) {
+      var keyCode2 = event2.which || event2.keyCode || event2.charCode;
       if (keyCode2 === null || keyCode2 === void 0) {
         return false;
       }
@@ -3126,11 +3126,11 @@ function getShortcutKeyCodes(shortcutKey) {
   }).filter((k2) => k2 !== void 0);
 }
 function bindShortcutKey(keys, callback) {
-  function keyUpCallback(event) {
-    const key = event.key.toLowerCase();
-    const keyCode = SPECIAL_KEY_MAP.indexOf(key) > -1 ? key : event.keyCode;
+  function keyUpCallback(event2) {
+    const key = event2.key.toLowerCase();
+    const keyCode = SPECIAL_KEY_MAP.indexOf(key) > -1 ? key : event2.keyCode;
     if (keys.indexOf(keyCode) > -1) {
-      callback && callback(event);
+      callback && callback(event2);
     }
   }
   document.addEventListener("keyup", keyUpCallback);
@@ -4668,8 +4668,8 @@ class ImageUploader extends Component {
         let fileData = e2.target.files[0];
         const reader = new FileReader();
         reader.readAsDataURL(fileData);
-        reader.onload = (event) => {
-          const base64 = event.target.result;
+        reader.onload = (event2) => {
+          const base64 = event2.target.result;
           beforeUpload && beforeUpload({
             data: base64,
             base64
@@ -6105,8 +6105,8 @@ function index$r(props) {
     min,
     max,
     type: "date",
-    onChange: (event) => {
-      onChange && onChange(event.target.value);
+    onChange: (event2) => {
+      onChange && onChange(event2.target.value);
     },
     onKeyUp: (e2) => {
       const { keyCode } = e2;
@@ -7620,18 +7620,18 @@ var _reactFastCompare_3_2_2_reactFastCompare = function isEqual(a, b2) {
       }
     };
   }
-  function addEvent(node, event, fn, opt_useCapture) {
+  function addEvent(node, event2, fn, opt_useCapture) {
     if (typeof node.addEventListener == "function") {
-      node.addEventListener(event, fn, opt_useCapture || false);
+      node.addEventListener(event2, fn, opt_useCapture || false);
     } else if (typeof node.attachEvent == "function") {
-      node.attachEvent("on" + event, fn);
+      node.attachEvent("on" + event2, fn);
     }
   }
-  function removeEvent(node, event, fn, opt_useCapture) {
+  function removeEvent(node, event2, fn, opt_useCapture) {
     if (typeof node.removeEventListener == "function") {
-      node.removeEventListener(event, fn, opt_useCapture || false);
+      node.removeEventListener(event2, fn, opt_useCapture || false);
     } else if (typeof node.detachEvent == "function") {
-      node.detachEvent("on" + event, fn);
+      node.detachEvent("on" + event2, fn);
     }
   }
   function computeRectIntersection(rect1, rect2) {
@@ -7849,13 +7849,13 @@ function useTouch() {
     offsetY.current = 0;
     direction.current = "";
   };
-  const start2 = (event) => {
+  const start2 = (event2) => {
     reset();
-    startX.current = event.touches[0].clientX;
-    startY.current = event.touches[0].clientY;
+    startX.current = event2.touches[0].clientX;
+    startY.current = event2.touches[0].clientY;
   };
-  const move = (event) => {
-    const touch = event.touches[0];
+  const move = (event2) => {
+    const touch = event2.touches[0];
     deltaX.current = touch.clientX < 0 ? 0 : touch.clientX - startX.current;
     deltaY.current = touch.clientY - startY.current;
     offsetX.current = Math.abs(deltaX.current);
@@ -7928,16 +7928,16 @@ function getScrollableElement(el) {
 }
 function useLockScroll(rootRef, shouldLock) {
   const touch = useTouch();
-  const onTouchMove = (event) => {
-    touch.move(event);
+  const onTouchMove = (event2) => {
+    touch.move(event2);
     const direction = touch.deltaY.current > 0 ? "10" : "01";
-    const el = getScrollParent(event.target, rootRef.current);
+    const el = getScrollParent(event2.target, rootRef.current);
     if (!el)
       return;
     if (shouldLock === "strict") {
-      const scrollableParent = getScrollableElement(event.target);
+      const scrollableParent = getScrollableElement(event2.target);
       if (scrollableParent === document.body || scrollableParent === document.documentElement) {
-        event.preventDefault();
+        event2.preventDefault();
         return;
       }
     }
@@ -7956,8 +7956,8 @@ function useLockScroll(rootRef, shouldLock) {
       status = "10";
     }
     if (status !== "11" && touch.isVertical() && !(parseInt(status, 2) & parseInt(direction, 2))) {
-      if (event.cancelable && supportsPassive) {
-        event.preventDefault();
+      if (event2.cancelable && supportsPassive) {
+        event2.preventDefault();
       }
     }
   };
@@ -8708,18 +8708,18 @@ const $observers = Symbol.for("FluidValue.observers");
 const hasFluidValue = (arg) => Boolean(arg && arg[$get]);
 const getFluidValue = (arg) => arg && arg[$get] ? arg[$get]() : arg;
 const getFluidObservers = (target) => target[$observers] || null;
-function callFluidObserver(observer, event) {
+function callFluidObserver(observer, event2) {
   if (observer.eventObserved) {
-    observer.eventObserved(event);
+    observer.eventObserved(event2);
   } else {
-    observer(event);
+    observer(event2);
   }
 }
-function callFluidObservers(target, event) {
+function callFluidObservers(target, event2) {
   let observers = target[$observers];
   if (observers) {
     observers.forEach((observer) => {
-      callFluidObserver(observer, event);
+      callFluidObserver(observer, event2);
     });
   }
 }
@@ -9163,8 +9163,8 @@ class PropsObserver {
     this.update = update2;
     this.deps = deps;
   }
-  eventObserved(event) {
-    if (event.type == "change") {
+  eventObserved(event2) {
+    if (event2.type == "change") {
       raf.write(this.update);
     }
   }
@@ -9961,11 +9961,11 @@ class SpringValue extends FrameValue {
       reset: true
     });
   }
-  eventObserved(event) {
-    if (event.type == "change") {
+  eventObserved(event2) {
+    if (event2.type == "change") {
       this._start();
-    } else if (event.type == "priority") {
-      this.priority = event.priority + 1;
+    } else if (event2.type == "priority") {
+      this.priority = event2.priority + 1;
     }
   }
   _prepareNode(props) {
@@ -10499,14 +10499,14 @@ class Controller$1 {
       });
     }
   }
-  eventObserved(event) {
-    if (event.type == "change") {
-      this._changed.add(event.parent);
-      if (!event.idle) {
-        this._active.add(event.parent);
+  eventObserved(event2) {
+    if (event2.type == "change") {
+      this._changed.add(event2.parent);
+      if (!event2.idle) {
+        this._active.add(event2.parent);
       }
-    } else if (event.type == "idle") {
-      this._active.delete(event.parent);
+    } else if (event2.type == "idle") {
+      this._active.delete(event2.parent);
     } else
       return;
     raf.onFrame(this._onFrame);
@@ -10935,17 +10935,17 @@ class Interpolation extends FrameValue {
     this._active.clear();
     becomeIdle(this);
   }
-  eventObserved(event) {
-    if (event.type == "change") {
-      if (event.idle) {
+  eventObserved(event2) {
+    if (event2.type == "change") {
+      if (event2.idle) {
         this.advance();
       } else {
-        this._active.add(event.parent);
+        this._active.add(event2.parent);
         this._start();
       }
-    } else if (event.type == "idle") {
-      this._active.delete(event.parent);
-    } else if (event.type == "priority") {
+    } else if (event2.type == "idle") {
+      this._active.delete(event2.parent);
+    } else if (event2.type == "priority") {
       this.priority = toArray(this.source).reduce((highest, parent) => Math.max(highest, (isFrameValue(parent) ? parent.priority : 0) + 1), 0);
     }
   }
@@ -11152,11 +11152,11 @@ class FluidTransform extends FluidValue {
     if (count == 0)
       each(this.inputs, (input2) => each(input2, (value) => hasFluidValue(value) && removeFluidObserver(value, this)));
   }
-  eventObserved(event) {
-    if (event.type == "change") {
+  eventObserved(event2) {
+    if (event2.type == "change") {
       this._value = null;
     }
-    callFluidObservers(this, event);
+    callFluidObservers(this, event2);
   }
 }
 const primitives = ["a", "abbr", "address", "area", "article", "aside", "audio", "b", "base", "bdi", "bdo", "big", "blockquote", "body", "br", "button", "canvas", "caption", "cite", "code", "col", "colgroup", "data", "datalist", "dd", "del", "details", "dfn", "dialog", "div", "dl", "dt", "em", "embed", "fieldset", "figcaption", "figure", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "head", "header", "hgroup", "hr", "html", "i", "iframe", "img", "input", "ins", "kbd", "keygen", "label", "legend", "li", "link", "main", "map", "mark", "menu", "menuitem", "meta", "meter", "nav", "noscript", "object", "ol", "optgroup", "option", "output", "p", "param", "picture", "pre", "progress", "q", "rp", "rt", "ruby", "s", "samp", "script", "section", "select", "small", "source", "span", "strong", "style", "sub", "summary", "sup", "table", "tbody", "td", "textarea", "tfoot", "th", "thead", "time", "title", "tr", "track", "u", "ul", "var", "video", "wbr", "circle", "clipPath", "defs", "ellipse", "foreignObject", "g", "image", "line", "linearGradient", "mask", "path", "pattern", "polygon", "polyline", "radialGradient", "rect", "stop", "svg", "text", "tspan"];
@@ -11938,47 +11938,47 @@ function toDomEventType(device, action = "") {
   const actionKey = deviceProps ? deviceProps[action] || action : action;
   return device + actionKey;
 }
-function isTouch(event) {
-  return "touches" in event;
+function isTouch(event2) {
+  return "touches" in event2;
 }
-function getPointerType(event) {
-  if (isTouch(event))
+function getPointerType(event2) {
+  if (isTouch(event2))
     return "touch";
-  if ("pointerType" in event)
-    return event.pointerType;
+  if ("pointerType" in event2)
+    return event2.pointerType;
   return "mouse";
 }
-function getCurrentTargetTouchList(event) {
-  return Array.from(event.touches).filter((e2) => {
+function getCurrentTargetTouchList(event2) {
+  return Array.from(event2.touches).filter((e2) => {
     var _event$currentTarget, _event$currentTarget$;
-    return e2.target === event.currentTarget || ((_event$currentTarget = event.currentTarget) === null || _event$currentTarget === void 0 || (_event$currentTarget$ = _event$currentTarget.contains) === null || _event$currentTarget$ === void 0 ? void 0 : _event$currentTarget$.call(_event$currentTarget, e2.target));
+    return e2.target === event2.currentTarget || ((_event$currentTarget = event2.currentTarget) === null || _event$currentTarget === void 0 || (_event$currentTarget$ = _event$currentTarget.contains) === null || _event$currentTarget$ === void 0 ? void 0 : _event$currentTarget$.call(_event$currentTarget, e2.target));
   });
 }
-function getTouchList(event) {
-  return event.type === "touchend" || event.type === "touchcancel" ? event.changedTouches : event.targetTouches;
+function getTouchList(event2) {
+  return event2.type === "touchend" || event2.type === "touchcancel" ? event2.changedTouches : event2.targetTouches;
 }
-function getValueEvent(event) {
-  return isTouch(event) ? getTouchList(event)[0] : event;
+function getValueEvent(event2) {
+  return isTouch(event2) ? getTouchList(event2)[0] : event2;
 }
-function touchIds(event) {
-  return getCurrentTargetTouchList(event).map((touch) => touch.identifier);
+function touchIds(event2) {
+  return getCurrentTargetTouchList(event2).map((touch) => touch.identifier);
 }
-function pointerId(event) {
-  const valueEvent = getValueEvent(event);
-  return isTouch(event) ? valueEvent.identifier : valueEvent.pointerId;
+function pointerId(event2) {
+  const valueEvent = getValueEvent(event2);
+  return isTouch(event2) ? valueEvent.identifier : valueEvent.pointerId;
 }
-function pointerValues(event) {
-  const valueEvent = getValueEvent(event);
+function pointerValues(event2) {
+  const valueEvent = getValueEvent(event2);
   return [valueEvent.clientX, valueEvent.clientY];
 }
 const LINE_HEIGHT = 40;
 const PAGE_HEIGHT = 800;
-function wheelValues(event) {
+function wheelValues(event2) {
   let {
     deltaX,
     deltaY,
     deltaMode
-  } = event;
+  } = event2;
   if (deltaMode === 1) {
     deltaX *= LINE_HEIGHT;
     deltaY *= LINE_HEIGHT;
@@ -11988,17 +11988,17 @@ function wheelValues(event) {
   }
   return [deltaX, deltaY];
 }
-function getEventDetails(event) {
+function getEventDetails(event2) {
   const payload = {};
-  if ("buttons" in event)
-    payload.buttons = event.buttons;
-  if ("shiftKey" in event) {
+  if ("buttons" in event2)
+    payload.buttons = event2.buttons;
+  if ("shiftKey" in event2) {
     const {
       shiftKey,
       altKey,
       metaKey,
       ctrlKey
-    } = event;
+    } = event2;
     Object.assign(payload, {
       shiftKey,
       altKey,
@@ -12100,18 +12100,18 @@ class Engine {
     state.delta = [0, 0];
     state.timeStamp = 0;
   }
-  start(event) {
+  start(event2) {
     const state = this.state;
     const config2 = this.config;
     if (!state._active) {
       this.reset();
       this.computeInitial();
       state._active = true;
-      state.target = event.target;
-      state.currentTarget = event.currentTarget;
+      state.target = event2.target;
+      state.currentTarget = event2.currentTarget;
       state.lastOffset = config2.from ? call(config2.from, state) : state.offset;
       state.offset = state.lastOffset;
-      state.startTime = state.timeStamp = event.timeStamp;
+      state.startTime = state.timeStamp = event2.timeStamp;
     }
   }
   computeValues(values) {
@@ -12124,7 +12124,7 @@ class Engine {
     state._initial = state._values;
     state.initial = state.values;
   }
-  compute(event) {
+  compute(event2) {
     const {
       state,
       config: config2,
@@ -12132,17 +12132,17 @@ class Engine {
     } = this;
     state.args = this.args;
     let dt = 0;
-    if (event) {
-      state.event = event;
-      if (config2.preventDefault && event.cancelable)
+    if (event2) {
+      state.event = event2;
+      if (config2.preventDefault && event2.cancelable)
         state.event.preventDefault();
-      state.type = event.type;
+      state.type = event2.type;
       shared.touches = this.ctrl.pointerIds.size || this.ctrl.touchIds.size;
       shared.locked = !!document.pointerLockElement;
-      Object.assign(shared, getEventDetails(event));
+      Object.assign(shared, getEventDetails(event2));
       shared.down = shared.pressed = shared.buttons % 2 === 1 || shared.touches > 0;
-      dt = event.timeStamp - state.timeStamp;
-      state.timeStamp = event.timeStamp;
+      dt = event2.timeStamp - state.timeStamp;
+      state.timeStamp = event2.timeStamp;
       state.elapsedTime = state.timeStamp - state.startTime;
     }
     if (state._active) {
@@ -12150,7 +12150,7 @@ class Engine {
       V.addTo(state._distance, _absoluteDelta);
     }
     if (this.axisIntent)
-      this.axisIntent(event);
+      this.axisIntent(event2);
     const [_m0, _m1] = state._movement;
     const [t0, t1] = config2.threshold;
     const {
@@ -12188,7 +12188,7 @@ class Engine {
       state.first = state._active && !state.active;
       state.last = !state._active && state.active;
       state.active = shared[this.ingKey] = state._active;
-      if (event) {
+      if (event2) {
         if (state.first) {
           if ("bounds" in config2)
             state._bounds = call(config2.bounds, state);
@@ -12269,11 +12269,11 @@ class CoordinatesEngine extends Engine {
   computeMovement() {
     this.state.movement = V.sub(this.state.offset, this.state.lastOffset);
   }
-  axisIntent(event) {
+  axisIntent(event2) {
     const state = this.state;
     const config2 = this.config;
-    if (!state.axis && event) {
-      const threshold = typeof config2.axisThreshold === "object" ? config2.axisThreshold[getPointerType(event)] : config2.axisThreshold;
+    if (!state.axis && event2) {
+      const threshold = typeof config2.axisThreshold === "object" ? config2.axisThreshold[getPointerType(event2)] : config2.axisThreshold;
       state.axis = selectAxis(state._movement, threshold);
     }
     state._blocked = (config2.lockDirection || !!config2.axis) && !state.axis || !!config2.axis && config2.axis !== state.axis;
@@ -12420,65 +12420,65 @@ class DragEngine extends CoordinatesEngine {
     this.state._keyboardActive = false;
     super.clean();
   }
-  pointerDown(event) {
+  pointerDown(event2) {
     const config2 = this.config;
     const state = this.state;
-    if (event.buttons != null && (Array.isArray(config2.pointerButtons) ? !config2.pointerButtons.includes(event.buttons) : config2.pointerButtons !== -1 && config2.pointerButtons !== event.buttons))
+    if (event2.buttons != null && (Array.isArray(config2.pointerButtons) ? !config2.pointerButtons.includes(event2.buttons) : config2.pointerButtons !== -1 && config2.pointerButtons !== event2.buttons))
       return;
-    const ctrlIds = this.ctrl.setEventIds(event);
+    const ctrlIds = this.ctrl.setEventIds(event2);
     if (config2.pointerCapture) {
-      event.target.setPointerCapture(event.pointerId);
+      event2.target.setPointerCapture(event2.pointerId);
     }
     if (ctrlIds && ctrlIds.size > 1 && state._pointerActive)
       return;
-    this.start(event);
-    this.setupPointer(event);
-    state._pointerId = pointerId(event);
+    this.start(event2);
+    this.setupPointer(event2);
+    state._pointerId = pointerId(event2);
     state._pointerActive = true;
-    this.computeValues(pointerValues(event));
+    this.computeValues(pointerValues(event2));
     this.computeInitial();
-    if (config2.preventScrollAxis && getPointerType(event) !== "mouse") {
+    if (config2.preventScrollAxis && getPointerType(event2) !== "mouse") {
       state._active = false;
-      this.setupScrollPrevention(event);
+      this.setupScrollPrevention(event2);
     } else if (config2.delay > 0) {
-      this.setupDelayTrigger(event);
+      this.setupDelayTrigger(event2);
       if (config2.triggerAllEvents) {
-        this.compute(event);
+        this.compute(event2);
         this.emit();
       }
     } else {
-      this.startPointerDrag(event);
+      this.startPointerDrag(event2);
     }
   }
-  startPointerDrag(event) {
+  startPointerDrag(event2) {
     const state = this.state;
     state._active = true;
     state._preventScroll = true;
     state._delayed = false;
-    this.compute(event);
+    this.compute(event2);
     this.emit();
   }
-  pointerMove(event) {
+  pointerMove(event2) {
     const state = this.state;
     const config2 = this.config;
     if (!state._pointerActive)
       return;
-    const id = pointerId(event);
+    const id = pointerId(event2);
     if (state._pointerId !== void 0 && id !== state._pointerId)
       return;
-    const _values = pointerValues(event);
-    if (document.pointerLockElement === event.target) {
-      state._delta = [event.movementX, event.movementY];
+    const _values = pointerValues(event2);
+    if (document.pointerLockElement === event2.target) {
+      state._delta = [event2.movementX, event2.movementY];
     } else {
       state._delta = V.sub(_values, state._values);
       this.computeValues(_values);
     }
     V.addTo(state._movement, state._delta);
-    this.compute(event);
+    this.compute(event2);
     if (state._delayed && state.intentional) {
       this.timeoutStore.remove("dragDelay");
       state.active = false;
-      this.startPointerDrag(event);
+      this.startPointerDrag(event2);
       return;
     }
     if (config2.preventScrollAxis && !state._preventScroll) {
@@ -12489,7 +12489,7 @@ class DragEngine extends CoordinatesEngine {
           return;
         } else {
           this.timeoutStore.remove("startPointerDrag");
-          this.startPointerDrag(event);
+          this.startPointerDrag(event2);
           return;
         }
       } else {
@@ -12498,12 +12498,12 @@ class DragEngine extends CoordinatesEngine {
     }
     this.emit();
   }
-  pointerUp(event) {
-    this.ctrl.setEventIds(event);
+  pointerUp(event2) {
+    this.ctrl.setEventIds(event2);
     try {
-      if (this.config.pointerCapture && event.target.hasPointerCapture(event.pointerId)) {
+      if (this.config.pointerCapture && event2.target.hasPointerCapture(event2.pointerId)) {
         ;
-        event.target.releasePointerCapture(event.pointerId);
+        event2.target.releasePointerCapture(event2.pointerId);
       }
     } catch (_unused) {
     }
@@ -12511,12 +12511,12 @@ class DragEngine extends CoordinatesEngine {
     const config2 = this.config;
     if (!state._active || !state._pointerActive)
       return;
-    const id = pointerId(event);
+    const id = pointerId(event2);
     if (state._pointerId !== void 0 && id !== state._pointerId)
       return;
     this.state._pointerActive = false;
     this.setActive();
-    this.compute(event);
+    this.compute(event2);
     const [dx, dy] = state._distance;
     state.tap = dx <= config2.tapsThreshold && dy <= config2.tapsThreshold;
     if (state.tap && config2.filterTaps) {
@@ -12538,17 +12538,17 @@ class DragEngine extends CoordinatesEngine {
     }
     this.emit();
   }
-  pointerClick(event) {
-    if (!this.state.tap && event.detail > 0) {
-      event.preventDefault();
-      event.stopPropagation();
+  pointerClick(event2) {
+    if (!this.state.tap && event2.detail > 0) {
+      event2.preventDefault();
+      event2.stopPropagation();
     }
   }
-  setupPointer(event) {
+  setupPointer(event2) {
     const config2 = this.config;
     const device = config2.device;
     if (config2.pointerLock) {
-      event.currentTarget.requestPointerLock();
+      event2.currentTarget.requestPointerLock();
     }
     if (!config2.pointerCapture) {
       this.eventStore.add(this.sharedConfig.window, device, "change", this.pointerMove.bind(this));
@@ -12561,47 +12561,47 @@ class DragEngine extends CoordinatesEngine {
       document.exitPointerLock();
     }
   }
-  preventScroll(event) {
-    if (this.state._preventScroll && event.cancelable) {
-      event.preventDefault();
+  preventScroll(event2) {
+    if (this.state._preventScroll && event2.cancelable) {
+      event2.preventDefault();
     }
   }
-  setupScrollPrevention(event) {
+  setupScrollPrevention(event2) {
     this.state._preventScroll = false;
-    persistEvent(event);
+    persistEvent(event2);
     const remove = this.eventStore.add(this.sharedConfig.window, "touch", "change", this.preventScroll.bind(this), {
       passive: false
     });
     this.eventStore.add(this.sharedConfig.window, "touch", "end", remove);
     this.eventStore.add(this.sharedConfig.window, "touch", "cancel", remove);
-    this.timeoutStore.add("startPointerDrag", this.startPointerDrag.bind(this), this.config.preventScrollDelay, event);
+    this.timeoutStore.add("startPointerDrag", this.startPointerDrag.bind(this), this.config.preventScrollDelay, event2);
   }
-  setupDelayTrigger(event) {
+  setupDelayTrigger(event2) {
     this.state._delayed = true;
     this.timeoutStore.add("dragDelay", () => {
       this.state._step = [0, 0];
-      this.startPointerDrag(event);
+      this.startPointerDrag(event2);
     }, this.config.delay);
   }
-  keyDown(event) {
-    const deltaFn = KEYS_DELTA_MAP[event.key];
+  keyDown(event2) {
+    const deltaFn = KEYS_DELTA_MAP[event2.key];
     if (deltaFn) {
       const state = this.state;
-      const factor = event.shiftKey ? 10 : event.altKey ? 0.1 : 1;
-      this.start(event);
+      const factor = event2.shiftKey ? 10 : event2.altKey ? 0.1 : 1;
+      this.start(event2);
       state._delta = deltaFn(this.config.keyboardDisplacement, factor);
       state._keyboardActive = true;
       V.addTo(state._movement, state._delta);
-      this.compute(event);
+      this.compute(event2);
       this.emit();
     }
   }
-  keyUp(event) {
-    if (!(event.key in KEYS_DELTA_MAP))
+  keyUp(event2) {
+    if (!(event2.key in KEYS_DELTA_MAP))
       return;
     this.state._keyboardActive = false;
     this.setActive();
-    this.compute(event);
+    this.compute(event2);
     this.emit();
   }
   bind(bindFunction) {
@@ -12625,8 +12625,8 @@ class DragEngine extends CoordinatesEngine {
     }
   }
 }
-function persistEvent(event) {
-  "persist" in event && typeof event.persist === "function" && event.persist();
+function persistEvent(event2) {
+  "persist" in event2 && typeof event2.persist === "function" && event2.persist();
 }
 const isBrowser = typeof window !== "undefined" && window.document && window.document.createElement;
 function supportsTouchEvents() {
@@ -12819,18 +12819,18 @@ class WheelEngine extends CoordinatesEngine {
     super(...args);
     _defineProperty$1(this, "ingKey", "wheeling");
   }
-  wheel(event) {
+  wheel(event2) {
     if (!this.state._active)
-      this.start(event);
-    this.wheelChange(event);
+      this.start(event2);
+    this.wheelChange(event2);
     this.timeoutStore.add("wheelEnd", this.wheelEnd.bind(this));
   }
-  wheelChange(event) {
+  wheelChange(event2) {
     const state = this.state;
-    state._delta = wheelValues(event);
+    state._delta = wheelValues(event2);
     V.addTo(state._movement, state._delta);
     clampStateInternalMovementToBounds(state);
-    this.compute(event);
+    this.compute(event2);
     this.emit();
   }
   wheelEnd() {
@@ -13037,15 +13037,15 @@ class Controller {
     });
     resolveGestures(this, handlers);
   }
-  setEventIds(event) {
-    if (isTouch(event)) {
-      this.touchIds = new Set(touchIds(event));
+  setEventIds(event2) {
+    if (isTouch(event2)) {
+      this.touchIds = new Set(touchIds(event2));
       return this.touchIds;
-    } else if ("pointerId" in event) {
-      if (event.type === "pointerup" || event.type === "pointercancel")
-        this.pointerIds.delete(event.pointerId);
-      else if (event.type === "pointerdown")
-        this.pointerIds.add(event.pointerId);
+    } else if ("pointerId" in event2) {
+      if (event2.type === "pointerup" || event2.type === "pointercancel")
+        this.pointerIds.delete(event2.pointerId);
+      else if (event2.type === "pointerdown")
+        this.pointerIds.add(event2.pointerId);
       return this.pointerIds;
     }
   }
@@ -13088,8 +13088,8 @@ class Controller {
       }
       const nativeBindFunction = bindToProps(props, sharedConfig.eventOptions, !!target);
       for (const eventKey in this.nativeHandlers) {
-        nativeBindFunction(eventKey, "", (event) => this.nativeHandlers[eventKey](_objectSpread2(_objectSpread2({}, this.state.shared), {}, {
-          event,
+        nativeBindFunction(eventKey, "", (event2) => this.nativeHandlers[eventKey](_objectSpread2(_objectSpread2({}, this.state.shared), {}, {
+          event: event2,
           args
         })), void 0, true);
       }
@@ -16028,6 +16028,15 @@ function _createClass(e2, r, t2) {
     writable: false
   }), e2;
 }
+var interopRequireDefault = { exports: {} };
+(function(module) {
+  function _interopRequireDefault2(e2) {
+    return e2 && e2.__esModule ? e2 : {
+      "default": e2
+    };
+  }
+  module.exports = _interopRequireDefault2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+})(interopRequireDefault);
 var input = "";
 function useInputHandleKeyDown({
   onEnterPress,
@@ -17052,7 +17061,1105 @@ function TagV2(props) {
     style: { color, backgroundColor }
   }, props.children);
 }
+var lib = {};
+var keyboard = { exports: {} };
+(function(module, exports) {
+  (function(global2, factory) {
+    module.exports = factory();
+  })(commonjsGlobal, function() {
+    function _typeof2(obj) {
+      "@babel/helpers - typeof";
+      if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+        _typeof2 = function(obj2) {
+          return typeof obj2;
+        };
+      } else {
+        _typeof2 = function(obj2) {
+          return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+        };
+      }
+      return _typeof2(obj);
+    }
+    function _classCallCheck2(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    function _defineProperties2(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, descriptor.key, descriptor);
+      }
+    }
+    function _createClass2(Constructor, protoProps, staticProps) {
+      if (protoProps)
+        _defineProperties2(Constructor.prototype, protoProps);
+      if (staticProps)
+        _defineProperties2(Constructor, staticProps);
+      return Constructor;
+    }
+    function _toConsumableArray2(arr) {
+      return _arrayWithoutHoles2(arr) || _iterableToArray2(arr) || _unsupportedIterableToArray2(arr) || _nonIterableSpread2();
+    }
+    function _arrayWithoutHoles2(arr) {
+      if (Array.isArray(arr))
+        return _arrayLikeToArray2(arr);
+    }
+    function _iterableToArray2(iter) {
+      if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter))
+        return Array.from(iter);
+    }
+    function _unsupportedIterableToArray2(o, minLen) {
+      if (!o)
+        return;
+      if (typeof o === "string")
+        return _arrayLikeToArray2(o, minLen);
+      var n2 = Object.prototype.toString.call(o).slice(8, -1);
+      if (n2 === "Object" && o.constructor)
+        n2 = o.constructor.name;
+      if (n2 === "Map" || n2 === "Set")
+        return Array.from(o);
+      if (n2 === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n2))
+        return _arrayLikeToArray2(o, minLen);
+    }
+    function _arrayLikeToArray2(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 _nonIterableSpread2() {
+      throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }
+    var KeyCombo = /* @__PURE__ */ function() {
+      function KeyCombo2(keyComboStr) {
+        _classCallCheck2(this, KeyCombo2);
+        this.sourceStr = keyComboStr;
+        this.subCombos = KeyCombo2.parseComboStr(keyComboStr);
+        this.keyNames = this.subCombos.reduce(function(memo2, nextSubCombo) {
+          return memo2.concat(nextSubCombo);
+        }, []);
+      }
+      _createClass2(KeyCombo2, [{
+        key: "check",
+        value: function check(pressedKeyNames) {
+          var startingKeyNameIndex = 0;
+          for (var i = 0; i < this.subCombos.length; i += 1) {
+            startingKeyNameIndex = this._checkSubCombo(this.subCombos[i], startingKeyNameIndex, pressedKeyNames);
+            if (startingKeyNameIndex === -1) {
+              return false;
+            }
+          }
+          return true;
+        }
+      }, {
+        key: "isEqual",
+        value: function isEqual3(otherKeyCombo) {
+          if (!otherKeyCombo || typeof otherKeyCombo !== "string" && _typeof2(otherKeyCombo) !== "object") {
+            return false;
+          }
+          if (typeof otherKeyCombo === "string") {
+            otherKeyCombo = new KeyCombo2(otherKeyCombo);
+          }
+          if (this.subCombos.length !== otherKeyCombo.subCombos.length) {
+            return false;
+          }
+          for (var i = 0; i < this.subCombos.length; i += 1) {
+            if (this.subCombos[i].length !== otherKeyCombo.subCombos[i].length) {
+              return false;
+            }
+          }
+          for (var _i = 0; _i < this.subCombos.length; _i += 1) {
+            var subCombo = this.subCombos[_i];
+            var otherSubCombo = otherKeyCombo.subCombos[_i].slice(0);
+            for (var j = 0; j < subCombo.length; j += 1) {
+              var keyName = subCombo[j];
+              var index2 = otherSubCombo.indexOf(keyName);
+              if (index2 > -1) {
+                otherSubCombo.splice(index2, 1);
+              }
+            }
+            if (otherSubCombo.length !== 0) {
+              return false;
+            }
+          }
+          return true;
+        }
+      }, {
+        key: "_checkSubCombo",
+        value: function _checkSubCombo(subCombo, startingKeyNameIndex, pressedKeyNames) {
+          subCombo = subCombo.slice(0);
+          pressedKeyNames = pressedKeyNames.slice(startingKeyNameIndex);
+          var endIndex = startingKeyNameIndex;
+          for (var i = 0; i < subCombo.length; i += 1) {
+            var keyName = subCombo[i];
+            if (keyName[0] === "\\") {
+              var escapedKeyName = keyName.slice(1);
+              if (escapedKeyName === KeyCombo2.comboDeliminator || escapedKeyName === KeyCombo2.keyDeliminator) {
+                keyName = escapedKeyName;
+              }
+            }
+            var index2 = pressedKeyNames.indexOf(keyName);
+            if (index2 > -1) {
+              subCombo.splice(i, 1);
+              i -= 1;
+              if (index2 > endIndex) {
+                endIndex = index2;
+              }
+              if (subCombo.length === 0) {
+                return endIndex;
+              }
+            }
+          }
+          return -1;
+        }
+      }]);
+      return KeyCombo2;
+    }();
+    KeyCombo.comboDeliminator = ">";
+    KeyCombo.keyDeliminator = "+";
+    KeyCombo.parseComboStr = function(keyComboStr) {
+      var subComboStrs = KeyCombo._splitStr(keyComboStr, KeyCombo.comboDeliminator);
+      var combo = [];
+      for (var i = 0; i < subComboStrs.length; i += 1) {
+        combo.push(KeyCombo._splitStr(subComboStrs[i], KeyCombo.keyDeliminator));
+      }
+      return combo;
+    };
+    KeyCombo._splitStr = function(str, deliminator) {
+      var s = str;
+      var d2 = deliminator;
+      var c6 = "";
+      var ca = [];
+      for (var ci = 0; ci < s.length; ci += 1) {
+        if (ci > 0 && s[ci] === d2 && s[ci - 1] !== "\\") {
+          ca.push(c6.trim());
+          c6 = "";
+          ci += 1;
+        }
+        c6 += s[ci];
+      }
+      if (c6) {
+        ca.push(c6.trim());
+      }
+      return ca;
+    };
+    var Locale = /* @__PURE__ */ function() {
+      function Locale2(name) {
+        _classCallCheck2(this, Locale2);
+        this.localeName = name;
+        this.activeTargetKeys = [];
+        this.pressedKeys = [];
+        this._appliedMacros = [];
+        this._keyMap = {};
+        this._killKeyCodes = [];
+        this._macros = [];
+      }
+      _createClass2(Locale2, [{
+        key: "bindKeyCode",
+        value: function bindKeyCode(keyCode, keyNames) {
+          if (typeof keyNames === "string") {
+            keyNames = [keyNames];
+          }
+          this._keyMap[keyCode] = keyNames;
+        }
+      }, {
+        key: "bindMacro",
+        value: function bindMacro(keyComboStr, keyNames) {
+          if (typeof keyNames === "string") {
+            keyNames = [keyNames];
+          }
+          var handler = null;
+          if (typeof keyNames === "function") {
+            handler = keyNames;
+            keyNames = null;
+          }
+          var macro = {
+            keyCombo: new KeyCombo(keyComboStr),
+            keyNames,
+            handler
+          };
+          this._macros.push(macro);
+        }
+      }, {
+        key: "getKeyCodes",
+        value: function getKeyCodes(keyName) {
+          var keyCodes = [];
+          for (var keyCode in this._keyMap) {
+            var index2 = this._keyMap[keyCode].indexOf(keyName);
+            if (index2 > -1) {
+              keyCodes.push(keyCode | 0);
+            }
+          }
+          return keyCodes;
+        }
+      }, {
+        key: "getKeyNames",
+        value: function getKeyNames(keyCode) {
+          return this._keyMap[keyCode] || [];
+        }
+      }, {
+        key: "setKillKey",
+        value: function setKillKey(keyCode) {
+          if (typeof keyCode === "string") {
+            var keyCodes = this.getKeyCodes(keyCode);
+            for (var i = 0; i < keyCodes.length; i += 1) {
+              this.setKillKey(keyCodes[i]);
+            }
+            return;
+          }
+          this._killKeyCodes.push(keyCode);
+        }
+      }, {
+        key: "pressKey",
+        value: function pressKey(keyCode) {
+          if (typeof keyCode === "string") {
+            var keyCodes = this.getKeyCodes(keyCode);
+            for (var i = 0; i < keyCodes.length; i += 1) {
+              this.pressKey(keyCodes[i]);
+            }
+            return;
+          }
+          this.activeTargetKeys.length = 0;
+          var keyNames = this.getKeyNames(keyCode);
+          for (var _i = 0; _i < keyNames.length; _i += 1) {
+            this.activeTargetKeys.push(keyNames[_i]);
+            if (this.pressedKeys.indexOf(keyNames[_i]) === -1) {
+              this.pressedKeys.push(keyNames[_i]);
+            }
+          }
+          this._applyMacros();
+        }
+      }, {
+        key: "releaseKey",
+        value: function releaseKey(keyCode) {
+          if (typeof keyCode === "string") {
+            var keyCodes = this.getKeyCodes(keyCode);
+            for (var i = 0; i < keyCodes.length; i += 1) {
+              this.releaseKey(keyCodes[i]);
+            }
+          } else {
+            var keyNames = this.getKeyNames(keyCode);
+            var killKeyCodeIndex = this._killKeyCodes.indexOf(keyCode);
+            if (killKeyCodeIndex !== -1) {
+              this.pressedKeys.length = 0;
+            } else {
+              for (var _i2 = 0; _i2 < keyNames.length; _i2 += 1) {
+                var index2 = this.pressedKeys.indexOf(keyNames[_i2]);
+                if (index2 > -1) {
+                  this.pressedKeys.splice(index2, 1);
+                }
+              }
+            }
+            this.activeTargetKeys.length = 0;
+            this._clearMacros();
+          }
+        }
+      }, {
+        key: "_applyMacros",
+        value: function _applyMacros() {
+          var macros = this._macros.slice(0);
+          for (var i = 0; i < macros.length; i += 1) {
+            var macro = macros[i];
+            if (macro.keyCombo.check(this.pressedKeys)) {
+              if (macro.handler) {
+                macro.keyNames = macro.handler(this.pressedKeys);
+              }
+              for (var j = 0; j < macro.keyNames.length; j += 1) {
+                if (this.pressedKeys.indexOf(macro.keyNames[j]) === -1) {
+                  this.pressedKeys.push(macro.keyNames[j]);
+                }
+              }
+              this._appliedMacros.push(macro);
+            }
+          }
+        }
+      }, {
+        key: "_clearMacros",
+        value: function _clearMacros() {
+          for (var i = 0; i < this._appliedMacros.length; i += 1) {
+            var macro = this._appliedMacros[i];
+            if (!macro.keyCombo.check(this.pressedKeys)) {
+              for (var j = 0; j < macro.keyNames.length; j += 1) {
+                var index2 = this.pressedKeys.indexOf(macro.keyNames[j]);
+                if (index2 > -1) {
+                  this.pressedKeys.splice(index2, 1);
+                }
+              }
+              if (macro.handler) {
+                macro.keyNames = null;
+              }
+              this._appliedMacros.splice(i, 1);
+              i -= 1;
+            }
+          }
+        }
+      }]);
+      return Locale2;
+    }();
+    var Keyboard = /* @__PURE__ */ function() {
+      function Keyboard2(targetWindow, targetElement, targetPlatform, targetUserAgent) {
+        _classCallCheck2(this, Keyboard2);
+        this._locale = null;
+        this._currentContext = "";
+        this._contexts = {};
+        this._listeners = [];
+        this._appliedListeners = [];
+        this._locales = {};
+        this._targetElement = null;
+        this._targetWindow = null;
+        this._targetPlatform = "";
+        this._targetUserAgent = "";
+        this._isModernBrowser = false;
+        this._targetKeyDownBinding = null;
+        this._targetKeyUpBinding = null;
+        this._targetResetBinding = null;
+        this._paused = false;
+        this._contexts.global = {
+          listeners: this._listeners,
+          targetWindow,
+          targetElement,
+          targetPlatform,
+          targetUserAgent
+        };
+        this.setContext("global");
+      }
+      _createClass2(Keyboard2, [{
+        key: "setLocale",
+        value: function setLocale(localeName, localeBuilder) {
+          var locale2 = null;
+          if (typeof localeName === "string") {
+            if (localeBuilder) {
+              locale2 = new Locale(localeName);
+              localeBuilder(locale2, this._targetPlatform, this._targetUserAgent);
+            } else {
+              locale2 = this._locales[localeName] || null;
+            }
+          } else {
+            locale2 = localeName;
+            localeName = locale2._localeName;
+          }
+          this._locale = locale2;
+          this._locales[localeName] = locale2;
+          if (locale2) {
+            this._locale.pressedKeys = locale2.pressedKeys;
+          }
+          return this;
+        }
+      }, {
+        key: "getLocale",
+        value: function getLocale(localName) {
+          localName || (localName = this._locale.localeName);
+          return this._locales[localName] || null;
+        }
+      }, {
+        key: "bind",
+        value: function bind(keyComboStr, pressHandler, releaseHandler, preventRepeatByDefault2) {
+          if (keyComboStr === null || typeof keyComboStr === "function") {
+            preventRepeatByDefault2 = releaseHandler;
+            releaseHandler = pressHandler;
+            pressHandler = keyComboStr;
+            keyComboStr = null;
+          }
+          if (keyComboStr && _typeof2(keyComboStr) === "object" && typeof keyComboStr.length === "number") {
+            for (var i = 0; i < keyComboStr.length; i += 1) {
+              this.bind(keyComboStr[i], pressHandler, releaseHandler);
+            }
+            return this;
+          }
+          this._listeners.push({
+            keyCombo: keyComboStr ? new KeyCombo(keyComboStr) : null,
+            pressHandler: pressHandler || null,
+            releaseHandler: releaseHandler || null,
+            preventRepeat: false,
+            preventRepeatByDefault: preventRepeatByDefault2 || false,
+            executingHandler: false
+          });
+          return this;
+        }
+      }, {
+        key: "addListener",
+        value: function addListener(keyComboStr, pressHandler, releaseHandler, preventRepeatByDefault2) {
+          return this.bind(keyComboStr, pressHandler, releaseHandler, preventRepeatByDefault2);
+        }
+      }, {
+        key: "on",
+        value: function on(keyComboStr, pressHandler, releaseHandler, preventRepeatByDefault2) {
+          return this.bind(keyComboStr, pressHandler, releaseHandler, preventRepeatByDefault2);
+        }
+      }, {
+        key: "bindPress",
+        value: function bindPress(keyComboStr, pressHandler, preventRepeatByDefault2) {
+          return this.bind(keyComboStr, pressHandler, null, preventRepeatByDefault2);
+        }
+      }, {
+        key: "bindRelease",
+        value: function bindRelease(keyComboStr, releaseHandler) {
+          return this.bind(keyComboStr, null, releaseHandler, preventRepeatByDefault);
+        }
+      }, {
+        key: "unbind",
+        value: function unbind(keyComboStr, pressHandler, releaseHandler) {
+          if (keyComboStr === null || typeof keyComboStr === "function") {
+            releaseHandler = pressHandler;
+            pressHandler = keyComboStr;
+            keyComboStr = null;
+          }
+          if (keyComboStr && _typeof2(keyComboStr) === "object" && typeof keyComboStr.length === "number") {
+            for (var i = 0; i < keyComboStr.length; i += 1) {
+              this.unbind(keyComboStr[i], pressHandler, releaseHandler);
+            }
+            return this;
+          }
+          for (var _i = 0; _i < this._listeners.length; _i += 1) {
+            var listener = this._listeners[_i];
+            var comboMatches = !keyComboStr && !listener.keyCombo || listener.keyCombo && listener.keyCombo.isEqual(keyComboStr);
+            var pressHandlerMatches = !pressHandler && !releaseHandler || !pressHandler && !listener.pressHandler || pressHandler === listener.pressHandler;
+            var releaseHandlerMatches = !pressHandler && !releaseHandler || !releaseHandler && !listener.releaseHandler || releaseHandler === listener.releaseHandler;
+            if (comboMatches && pressHandlerMatches && releaseHandlerMatches) {
+              this._listeners.splice(_i, 1);
+              _i -= 1;
+            }
+          }
+          return this;
+        }
+      }, {
+        key: "removeListener",
+        value: function removeListener(keyComboStr, pressHandler, releaseHandler) {
+          return this.unbind(keyComboStr, pressHandler, releaseHandler);
+        }
+      }, {
+        key: "off",
+        value: function off(keyComboStr, pressHandler, releaseHandler) {
+          return this.unbind(keyComboStr, pressHandler, releaseHandler);
+        }
+      }, {
+        key: "setContext",
+        value: function setContext(contextName) {
+          if (this._locale) {
+            this.releaseAllKeys();
+          }
+          if (!this._contexts[contextName]) {
+            var globalContext = this._contexts.global;
+            this._contexts[contextName] = {
+              listeners: [],
+              targetWindow: globalContext.targetWindow,
+              targetElement: globalContext.targetElement,
+              targetPlatform: globalContext.targetPlatform,
+              targetUserAgent: globalContext.targetUserAgent
+            };
+          }
+          var context = this._contexts[contextName];
+          this._currentContext = contextName;
+          this._listeners = context.listeners;
+          this.stop();
+          this.watch(context.targetWindow, context.targetElement, context.targetPlatform, context.targetUserAgent);
+          return this;
+        }
+      }, {
+        key: "getContext",
+        value: function getContext() {
+          return this._currentContext;
+        }
+      }, {
+        key: "withContext",
+        value: function withContext(contextName, callback) {
+          var previousContextName = this.getContext();
+          this.setContext(contextName);
+          callback();
+          this.setContext(previousContextName);
+          return this;
+        }
+      }, {
+        key: "watch",
+        value: function watch(targetWindow, targetElement, targetPlatform, targetUserAgent) {
+          var _this = this;
+          this.stop();
+          var win = typeof globalThis !== "undefined" ? globalThis : typeof commonjsGlobal !== "undefined" ? commonjsGlobal : typeof window !== "undefined" ? window : {};
+          if (!targetWindow) {
+            if (!win.addEventListener && !win.attachEvent) {
+              if (this._currentContext === "global") {
+                return;
+              }
+              throw new Error("Cannot find window functions addEventListener or attachEvent.");
+            }
+            targetWindow = win;
+          }
+          if (typeof targetWindow.nodeType === "number") {
+            targetUserAgent = targetPlatform;
+            targetPlatform = targetElement;
+            targetElement = targetWindow;
+            targetWindow = win;
+          }
+          if (!targetWindow.addEventListener && !targetWindow.attachEvent) {
+            throw new Error("Cannot find addEventListener or attachEvent methods on targetWindow.");
+          }
+          this._isModernBrowser = !!targetWindow.addEventListener;
+          var userAgent = targetWindow.navigator && targetWindow.navigator.userAgent || "";
+          var platform = targetWindow.navigator && targetWindow.navigator.platform || "";
+          targetElement && targetElement !== null || (targetElement = targetWindow.document);
+          targetPlatform && targetPlatform !== null || (targetPlatform = platform);
+          targetUserAgent && targetUserAgent !== null || (targetUserAgent = userAgent);
+          this._targetKeyDownBinding = function(event2) {
+            _this.pressKey(event2.keyCode, event2);
+            _this._handleCommandBug(event2, platform);
+          };
+          this._targetKeyUpBinding = function(event2) {
+            _this.releaseKey(event2.keyCode, event2);
+          };
+          this._targetResetBinding = function(event2) {
+            _this.releaseAllKeys(event2);
+          };
+          this._bindEvent(targetElement, "keydown", this._targetKeyDownBinding);
+          this._bindEvent(targetElement, "keyup", this._targetKeyUpBinding);
+          this._bindEvent(targetWindow, "focus", this._targetResetBinding);
+          this._bindEvent(targetWindow, "blur", this._targetResetBinding);
+          this._targetElement = targetElement;
+          this._targetWindow = targetWindow;
+          this._targetPlatform = targetPlatform;
+          this._targetUserAgent = targetUserAgent;
+          var currentContext = this._contexts[this._currentContext];
+          currentContext.targetWindow = this._targetWindow;
+          currentContext.targetElement = this._targetElement;
+          currentContext.targetPlatform = this._targetPlatform;
+          currentContext.targetUserAgent = this._targetUserAgent;
+          return this;
+        }
+      }, {
+        key: "stop",
+        value: function stop2() {
+          if (!this._targetElement || !this._targetWindow) {
+            return;
+          }
+          this._unbindEvent(this._targetElement, "keydown", this._targetKeyDownBinding);
+          this._unbindEvent(this._targetElement, "keyup", this._targetKeyUpBinding);
+          this._unbindEvent(this._targetWindow, "focus", this._targetResetBinding);
+          this._unbindEvent(this._targetWindow, "blur", this._targetResetBinding);
+          this._targetWindow = null;
+          this._targetElement = null;
+          return this;
+        }
+      }, {
+        key: "pressKey",
+        value: function pressKey(keyCode, event2) {
+          if (this._paused) {
+            return this;
+          }
+          if (!this._locale) {
+            throw new Error("Locale not set");
+          }
+          this._locale.pressKey(keyCode);
+          this._applyBindings(event2);
+          return this;
+        }
+      }, {
+        key: "releaseKey",
+        value: function releaseKey(keyCode, event2) {
+          if (this._paused) {
+            return this;
+          }
+          if (!this._locale) {
+            throw new Error("Locale not set");
+          }
+          this._locale.releaseKey(keyCode);
+          this._clearBindings(event2);
+          return this;
+        }
+      }, {
+        key: "releaseAllKeys",
+        value: function releaseAllKeys(event2) {
+          if (this._paused) {
+            return this;
+          }
+          if (!this._locale) {
+            throw new Error("Locale not set");
+          }
+          this._locale.pressedKeys.length = 0;
+          this._clearBindings(event2);
+          return this;
+        }
+      }, {
+        key: "pause",
+        value: function pause() {
+          if (this._paused) {
+            return this;
+          }
+          if (this._locale) {
+            this.releaseAllKeys();
+          }
+          this._paused = true;
+          return this;
+        }
+      }, {
+        key: "resume",
+        value: function resume() {
+          this._paused = false;
+          return this;
+        }
+      }, {
+        key: "reset",
+        value: function reset() {
+          this.releaseAllKeys();
+          this._listeners.length = 0;
+          return this;
+        }
+      }, {
+        key: "_bindEvent",
+        value: function _bindEvent(targetElement, eventName, handler) {
+          return this._isModernBrowser ? targetElement.addEventListener(eventName, handler, false) : targetElement.attachEvent("on" + eventName, handler);
+        }
+      }, {
+        key: "_unbindEvent",
+        value: function _unbindEvent(targetElement, eventName, handler) {
+          return this._isModernBrowser ? targetElement.removeEventListener(eventName, handler, false) : targetElement.detachEvent("on" + eventName, handler);
+        }
+      }, {
+        key: "_getGroupedListeners",
+        value: function _getGroupedListeners() {
+          var listenerGroups = [];
+          var listenerGroupMap = [];
+          var listeners = this._listeners;
+          if (this._currentContext !== "global") {
+            listeners = [].concat(_toConsumableArray2(listeners), _toConsumableArray2(this._contexts.global.listeners));
+          }
+          listeners.sort(function(a, b2) {
+            return (b2.keyCombo ? b2.keyCombo.keyNames.length : 0) - (a.keyCombo ? a.keyCombo.keyNames.length : 0);
+          }).forEach(function(l2) {
+            var mapIndex = -1;
+            for (var i = 0; i < listenerGroupMap.length; i += 1) {
+              if (listenerGroupMap[i] === null && l2.keyCombo === null || listenerGroupMap[i] !== null && listenerGroupMap[i].isEqual(l2.keyCombo)) {
+                mapIndex = i;
+              }
+            }
+            if (mapIndex === -1) {
+              mapIndex = listenerGroupMap.length;
+              listenerGroupMap.push(l2.keyCombo);
+            }
+            if (!listenerGroups[mapIndex]) {
+              listenerGroups[mapIndex] = [];
+            }
+            listenerGroups[mapIndex].push(l2);
+          });
+          return listenerGroups;
+        }
+      }, {
+        key: "_applyBindings",
+        value: function _applyBindings(event2) {
+          var _this2 = this;
+          var preventRepeat = false;
+          event2 || (event2 = {});
+          event2.preventRepeat = function() {
+            preventRepeat = true;
+          };
+          event2.pressedKeys = this._locale.pressedKeys.slice(0);
+          var activeTargetKeys = this._locale.activeTargetKeys;
+          var pressedKeys = this._locale.pressedKeys.slice(0);
+          var listenerGroups = this._getGroupedListeners();
+          var _loop = function _loop2(i2) {
+            var listeners = listenerGroups[i2];
+            var keyCombo = listeners[0].keyCombo;
+            if (keyCombo === null || keyCombo.check(pressedKeys) && activeTargetKeys.some(function(k2) {
+              return keyCombo.keyNames.includes(k2);
+            })) {
+              for (var j = 0; j < listeners.length; j += 1) {
+                var listener = listeners[j];
+                if (!listener.executingHandler && listener.pressHandler && !listener.preventRepeat) {
+                  listener.executingHandler = true;
+                  listener.pressHandler.call(_this2, event2);
+                  listener.executingHandler = false;
+                  if (preventRepeat || listener.preventRepeatByDefault) {
+                    listener.preventRepeat = true;
+                    preventRepeat = false;
+                  }
+                }
+                if (_this2._appliedListeners.indexOf(listener) === -1) {
+                  _this2._appliedListeners.push(listener);
+                }
+              }
+              if (keyCombo) {
+                for (var _j = 0; _j < keyCombo.keyNames.length; _j += 1) {
+                  var index2 = pressedKeys.indexOf(keyCombo.keyNames[_j]);
+                  if (index2 !== -1) {
+                    pressedKeys.splice(index2, 1);
+                    _j -= 1;
+                  }
+                }
+              }
+            }
+          };
+          for (var i = 0; i < listenerGroups.length; i += 1) {
+            _loop(i);
+          }
+        }
+      }, {
+        key: "_clearBindings",
+        value: function _clearBindings(event2) {
+          event2 || (event2 = {});
+          event2.pressedKeys = this._locale.pressedKeys.slice(0);
+          for (var i = 0; i < this._appliedListeners.length; i += 1) {
+            var listener = this._appliedListeners[i];
+            var keyCombo = listener.keyCombo;
+            if (keyCombo === null || !keyCombo.check(this._locale.pressedKeys)) {
+              listener.preventRepeat = false;
+              if (keyCombo !== null || event2.pressedKeys.length === 0) {
+                this._appliedListeners.splice(i, 1);
+                i -= 1;
+              }
+              if (!listener.executingHandler && listener.releaseHandler) {
+                listener.executingHandler = true;
+                listener.releaseHandler.call(this, event2);
+                listener.executingHandler = false;
+              }
+            }
+          }
+        }
+      }, {
+        key: "_handleCommandBug",
+        value: function _handleCommandBug(event2, platform) {
+          var modifierKeys = ["shift", "ctrl", "alt", "capslock", "tab", "command"];
+          if (platform.match("Mac") && this._locale.pressedKeys.includes("command") && !modifierKeys.includes(this._locale.getKeyNames(event2.keyCode)[0])) {
+            this._targetKeyUpBinding(event2);
+          }
+        }
+      }]);
+      return Keyboard2;
+    }();
+    function us(locale2, platform, userAgent) {
+      locale2.bindKeyCode(3, ["cancel"]);
+      locale2.bindKeyCode(8, ["backspace"]);
+      locale2.bindKeyCode(9, ["tab"]);
+      locale2.bindKeyCode(12, ["clear"]);
+      locale2.bindKeyCode(13, ["enter"]);
+      locale2.bindKeyCode(16, ["shift"]);
+      locale2.bindKeyCode(17, ["ctrl"]);
+      locale2.bindKeyCode(18, ["alt", "menu"]);
+      locale2.bindKeyCode(19, ["pause", "break"]);
+      locale2.bindKeyCode(20, ["capslock"]);
+      locale2.bindKeyCode(27, ["escape", "esc"]);
+      locale2.bindKeyCode(32, ["space", "spacebar"]);
+      locale2.bindKeyCode(33, ["pageup"]);
+      locale2.bindKeyCode(34, ["pagedown"]);
+      locale2.bindKeyCode(35, ["end"]);
+      locale2.bindKeyCode(36, ["home"]);
+      locale2.bindKeyCode(37, ["left"]);
+      locale2.bindKeyCode(38, ["up"]);
+      locale2.bindKeyCode(39, ["right"]);
+      locale2.bindKeyCode(40, ["down"]);
+      locale2.bindKeyCode(41, ["select"]);
+      locale2.bindKeyCode(42, ["printscreen"]);
+      locale2.bindKeyCode(43, ["execute"]);
+      locale2.bindKeyCode(44, ["snapshot"]);
+      locale2.bindKeyCode(45, ["insert", "ins"]);
+      locale2.bindKeyCode(46, ["delete", "del"]);
+      locale2.bindKeyCode(47, ["help"]);
+      locale2.bindKeyCode(145, ["scrolllock", "scroll"]);
+      locale2.bindKeyCode(188, ["comma", ","]);
+      locale2.bindKeyCode(190, ["period", "."]);
+      locale2.bindKeyCode(191, ["slash", "forwardslash", "/"]);
+      locale2.bindKeyCode(192, ["graveaccent", "`"]);
+      locale2.bindKeyCode(219, ["openbracket", "["]);
+      locale2.bindKeyCode(220, ["backslash", "\\"]);
+      locale2.bindKeyCode(221, ["closebracket", "]"]);
+      locale2.bindKeyCode(222, ["apostrophe", "'"]);
+      locale2.bindKeyCode(48, ["zero", "0"]);
+      locale2.bindKeyCode(49, ["one", "1"]);
+      locale2.bindKeyCode(50, ["two", "2"]);
+      locale2.bindKeyCode(51, ["three", "3"]);
+      locale2.bindKeyCode(52, ["four", "4"]);
+      locale2.bindKeyCode(53, ["five", "5"]);
+      locale2.bindKeyCode(54, ["six", "6"]);
+      locale2.bindKeyCode(55, ["seven", "7"]);
+      locale2.bindKeyCode(56, ["eight", "8"]);
+      locale2.bindKeyCode(57, ["nine", "9"]);
+      locale2.bindKeyCode(96, ["numzero", "num0"]);
+      locale2.bindKeyCode(97, ["numone", "num1"]);
+      locale2.bindKeyCode(98, ["numtwo", "num2"]);
+      locale2.bindKeyCode(99, ["numthree", "num3"]);
+      locale2.bindKeyCode(100, ["numfour", "num4"]);
+      locale2.bindKeyCode(101, ["numfive", "num5"]);
+      locale2.bindKeyCode(102, ["numsix", "num6"]);
+      locale2.bindKeyCode(103, ["numseven", "num7"]);
+      locale2.bindKeyCode(104, ["numeight", "num8"]);
+      locale2.bindKeyCode(105, ["numnine", "num9"]);
+      locale2.bindKeyCode(106, ["nummultiply", "num*"]);
+      locale2.bindKeyCode(107, ["numadd", "num+"]);
+      locale2.bindKeyCode(108, ["numenter"]);
+      locale2.bindKeyCode(109, ["numsubtract", "num-"]);
+      locale2.bindKeyCode(110, ["numdecimal", "num."]);
+      locale2.bindKeyCode(111, ["numdivide", "num/"]);
+      locale2.bindKeyCode(144, ["numlock", "num"]);
+      locale2.bindKeyCode(112, ["f1"]);
+      locale2.bindKeyCode(113, ["f2"]);
+      locale2.bindKeyCode(114, ["f3"]);
+      locale2.bindKeyCode(115, ["f4"]);
+      locale2.bindKeyCode(116, ["f5"]);
+      locale2.bindKeyCode(117, ["f6"]);
+      locale2.bindKeyCode(118, ["f7"]);
+      locale2.bindKeyCode(119, ["f8"]);
+      locale2.bindKeyCode(120, ["f9"]);
+      locale2.bindKeyCode(121, ["f10"]);
+      locale2.bindKeyCode(122, ["f11"]);
+      locale2.bindKeyCode(123, ["f12"]);
+      locale2.bindKeyCode(124, ["f13"]);
+      locale2.bindKeyCode(125, ["f14"]);
+      locale2.bindKeyCode(126, ["f15"]);
+      locale2.bindKeyCode(127, ["f16"]);
+      locale2.bindKeyCode(128, ["f17"]);
+      locale2.bindKeyCode(129, ["f18"]);
+      locale2.bindKeyCode(130, ["f19"]);
+      locale2.bindKeyCode(131, ["f20"]);
+      locale2.bindKeyCode(132, ["f21"]);
+      locale2.bindKeyCode(133, ["f22"]);
+      locale2.bindKeyCode(134, ["f23"]);
+      locale2.bindKeyCode(135, ["f24"]);
+      locale2.bindMacro("shift + `", ["tilde", "~"]);
+      locale2.bindMacro("shift + 1", ["exclamation", "exclamationpoint", "!"]);
+      locale2.bindMacro("shift + 2", ["at", "@"]);
+      locale2.bindMacro("shift + 3", ["number", "#"]);
+      locale2.bindMacro("shift + 4", ["dollar", "dollars", "dollarsign", "$"]);
+      locale2.bindMacro("shift + 5", ["percent", "%"]);
+      locale2.bindMacro("shift + 6", ["caret", "^"]);
+      locale2.bindMacro("shift + 7", ["ampersand", "and", "&"]);
+      locale2.bindMacro("shift + 8", ["asterisk", "*"]);
+      locale2.bindMacro("shift + 9", ["openparen", "("]);
+      locale2.bindMacro("shift + 0", ["closeparen", ")"]);
+      locale2.bindMacro("shift + -", ["underscore", "_"]);
+      locale2.bindMacro("shift + =", ["plus", "+"]);
+      locale2.bindMacro("shift + [", ["opencurlybrace", "opencurlybracket", "{"]);
+      locale2.bindMacro("shift + ]", ["closecurlybrace", "closecurlybracket", "}"]);
+      locale2.bindMacro("shift + \\", ["verticalbar", "|"]);
+      locale2.bindMacro("shift + ;", ["colon", ":"]);
+      locale2.bindMacro("shift + '", ["quotationmark", "'"]);
+      locale2.bindMacro("shift + !,", ["openanglebracket", "<"]);
+      locale2.bindMacro("shift + .", ["closeanglebracket", ">"]);
+      locale2.bindMacro("shift + /", ["questionmark", "?"]);
+      if (platform.match("Mac")) {
+        locale2.bindMacro("command", ["mod", "modifier"]);
+      } else {
+        locale2.bindMacro("ctrl", ["mod", "modifier"]);
+      }
+      for (var keyCode = 65; keyCode <= 90; keyCode += 1) {
+        var keyName = String.fromCharCode(keyCode + 32);
+        var capitalKeyName = String.fromCharCode(keyCode);
+        locale2.bindKeyCode(keyCode, keyName);
+        locale2.bindMacro("shift + " + keyName, capitalKeyName);
+        locale2.bindMacro("capslock + " + keyName, capitalKeyName);
+      }
+      var semicolonKeyCode = userAgent.match("Firefox") ? 59 : 186;
+      var dashKeyCode = userAgent.match("Firefox") ? 173 : 189;
+      var equalKeyCode = userAgent.match("Firefox") ? 61 : 187;
+      var leftCommandKeyCode;
+      var rightCommandKeyCode;
+      if (platform.match("Mac") && (userAgent.match("Safari") || userAgent.match("Chrome"))) {
+        leftCommandKeyCode = 91;
+        rightCommandKeyCode = 93;
+      } else if (platform.match("Mac") && userAgent.match("Opera")) {
+        leftCommandKeyCode = 17;
+        rightCommandKeyCode = 17;
+      } else if (platform.match("Mac") && userAgent.match("Firefox")) {
+        leftCommandKeyCode = 224;
+        rightCommandKeyCode = 224;
+      }
+      locale2.bindKeyCode(semicolonKeyCode, ["semicolon", ";"]);
+      locale2.bindKeyCode(dashKeyCode, ["dash", "-"]);
+      locale2.bindKeyCode(equalKeyCode, ["equal", "equalsign", "="]);
+      locale2.bindKeyCode(leftCommandKeyCode, ["command", "windows", "win", "super", "leftcommand", "leftwindows", "leftwin", "leftsuper"]);
+      locale2.bindKeyCode(rightCommandKeyCode, ["command", "windows", "win", "super", "rightcommand", "rightwindows", "rightwin", "rightsuper"]);
+      locale2.setKillKey("command");
+    }
+    var keyboard2 = new Keyboard();
+    keyboard2.setLocale("us", us);
+    keyboard2.Keyboard = Keyboard;
+    keyboard2.Locale = Locale;
+    keyboard2.KeyCombo = KeyCombo;
+    return keyboard2;
+  });
+})(keyboard);
+var inputElement = document.createElement("input");
+inputElement.onfocus = function(event2) {
+  event2.target.blur();
+  document.body.removeChild(inputElement);
+};
+inputElement.style.width = "0px";
+document.body.appendChild(inputElement);
+setTimeout(function() {
+  inputElement.focus();
+});
+(function(exports) {
+  var _interopRequireDefault2 = interopRequireDefault.exports;
+  exports.__esModule = true;
+  exports["default"] = exports.AllKeyBind = void 0;
+  var _keyboardjs = _interopRequireDefault2(keyboard.exports);
+  var Stack = /* @__PURE__ */ function() {
+    function Stack2() {
+      this.list = void 0;
+      this.list = [];
+    }
+    var _proto = Stack2.prototype;
+    _proto.getHeader = function getHeader() {
+      return this.list[this.list.length - 1];
+    };
+    _proto.findIndex = function findIndex2(element) {
+      var matchIndex = this.list.findIndex(function(item) {
+        return item === element;
+      });
+      return matchIndex;
+    };
+    _proto.put = function put(element) {
+      var matchIndex = this.findIndex(element);
+      if (matchIndex > -1) {
+        this.list.splice(matchIndex, 1);
+        return;
+      }
+      this.list.push(element);
+    };
+    _proto.pop = function pop() {
+      this.list.pop();
+    };
+    _proto.removeItem = function removeItem(element) {
+      var matchIndex = this.findIndex(element);
+      var matchItem = this.list[matchIndex];
+      if (matchIndex > -1) {
+        this.list.splice(matchIndex, 1);
+      }
+      return matchItem;
+    };
+    _proto.getList = function getList() {
+      return this.list;
+    };
+    return Stack2;
+  }();
+  var AllKeyBind = /* @__PURE__ */ function() {
+    function AllKeyBind2() {
+      this.list = [];
+      this.onDocumentKeyDown = this.onDocumentKeyDown.bind(this);
+    }
+    var _proto2 = AllKeyBind2.prototype;
+    _proto2.onDocumentKeyDown = function onDocumentKeyDown(event2) {
+      this.list.forEach(function(itemFunc) {
+        itemFunc instanceof Function && itemFunc(event2);
+      });
+    };
+    _proto2.init = function init2() {
+      document.addEventListener("keydown", this.onDocumentKeyDown, false);
+    };
+    _proto2.findIndex = function findIndex2(element) {
+      var matchIndex = this.list.findIndex(function(item) {
+        return item === element;
+      });
+      return matchIndex;
+    };
+    _proto2.add = function add(handler) {
+      if (this.findIndex(handler) > -1) {
+        return;
+      }
+      this.list.push(handler);
+    };
+    _proto2.bind = function bind(handler) {
+      if (!(handler instanceof Function)) {
+        return;
+      }
+      var beforeSize = this.list.length;
+      this.add(handler);
+      if (beforeSize === 0 && this.list.length === 1) {
+        this.init();
+      }
+    };
+    _proto2.unbind = function unbind(handler) {
+      if (!(handler instanceof Function)) {
+        return;
+      }
+      var mathIndex = this.findIndex(handler);
+      var beforeSize = this.list.length;
+      if (mathIndex > -1) {
+        this.list.splice(mathIndex, 1);
+        return;
+      }
+      if (beforeSize === 1 && this.list.length === 0) {
+        this.destroy();
+      }
+    };
+    _proto2.release = function release() {
+      this.list = [];
+      this.destroy();
+    };
+    _proto2.destroy = function destroy() {
+      document.removeEventListener("keydown", this.onDocumentKeyDown);
+    };
+    return AllKeyBind2;
+  }();
+  exports.AllKeyBind = AllKeyBind;
+  var Event2 = /* @__PURE__ */ function() {
+    function Event3() {
+      this.mapStack = {};
+      this.allBind = new AllKeyBind();
+      _keyboardjs["default"].setContext("operate-event" + Date.now());
+    }
+    var _proto3 = Event3.prototype;
+    _proto3.midBind = function midBind(key, handler) {
+      if (key === "all") {
+        this.allBind.bind(handler);
+      } else {
+        _keyboardjs["default"].bind(key, handler);
+      }
+    };
+    _proto3.midUnBind = function midUnBind(key, handler) {
+      if (key === "all") {
+        this.allBind.unbind(handler);
+      } else {
+        _keyboardjs["default"].unbind(key, handler);
+      }
+    };
+    _proto3.bind = function bind(key, handler) {
+      var lowerKey = key.toLowerCase();
+      if (!(handler instanceof Function)) {
+        return;
+      }
+      if (!this.mapStack[lowerKey]) {
+        this.mapStack[lowerKey] = new Stack();
+      }
+      var stack = this.mapStack[lowerKey];
+      var oldHeader = stack.getHeader();
+      this.midUnBind(lowerKey, oldHeader);
+      this.midBind(lowerKey, handler);
+      stack.put(handler);
+    };
+    _proto3.unbind = function unbind(key, handler) {
+      var lowerKey = key.toLowerCase();
+      var stack = this.mapStack[lowerKey];
+      if (!stack) {
+        return;
+      }
+      var header = stack.getHeader();
+      if (header === handler) {
+        this.midUnBind(lowerKey, header);
+        stack.pop();
+        this.midBind(lowerKey, stack.getHeader());
+      } else {
+        stack.removeItem(handler);
+      }
+    };
+    _proto3.releaseKey = function releaseKey(key) {
+      var lowerKey = key.toLowerCase();
+      this.mapStack[lowerKey] = new Stack();
+      if (lowerKey === "all") {
+        this.allBind.release();
+      } else {
+        _keyboardjs["default"].unbind(lowerKey);
+      }
+    };
+    return Event3;
+  }();
+  exports["default"] = Event2;
+})(lib);
+var Event = /* @__PURE__ */ getDefaultExportFromCjs(lib);
 var index$n = "";
+const event = new Event();
 function ButtonV2(props) {
   if ((props == null ? void 0 : props.type) === "antd")
     return /* @__PURE__ */ React__default.createElement(Button, {
@@ -17067,13 +18174,33 @@ function ButtonV2(props) {
     children,
     disabled,
     fullWidth,
+    hotkey,
+    hotkeyHandler,
     ...resetProps
   } = props;
   function handleClick(e2) {
-    e2.stopPropagation();
+    var _a2;
+    (_a2 = e2 == null ? void 0 : e2.stopPropagation) == null ? void 0 : _a2.call(e2);
     if (!disabled && typeof onClick === "function")
       onClick();
   }
+  React__default.useEffect(() => {
+    const bindHandler = () => {
+      if (hotkeyHandler instanceof Function) {
+        hotkeyHandler();
+      } else {
+        handleClick();
+      }
+    };
+    if (hotkey && (hotkey == null ? void 0 : hotkey.toLowerCase)) {
+      event.bind(hotkey.toLowerCase(), bindHandler);
+    }
+    return () => {
+      if (hotkey && (hotkey == null ? void 0 : hotkey.toLowerCase)) {
+        event.unbind(hotkey.toLowerCase(), bindHandler);
+      }
+    };
+  }, [onClick, hotkeyHandler, hotkey]);
   return /* @__PURE__ */ React__default.createElement("div", {
     ...resetProps,
     className: classNames({