@baleada/logic 0.23.3 → 0.23.4

package/lib/index.cjs

@@ -13,6 +13,202 @@ var dequal = require('dequal');
 var slugify = require('@sindresorhus/slugify');
 var clsx = require('clsx');
 
+function fromComboToAliases(combo) {
+  const delimiter = "+";
+  return lazyCollections.pipe(
+    lazyCollections.unique(),
+    lazyCollections.map((name) => name === "" ? delimiter : name.toLowerCase()),
+    lazyCollections.toArray()
+  )(combo.split(delimiter));
+}
+
+function fromAliasToDownKeys(alias) {
+  if (alias in keysByAlias) {
+    return [{ key: keysByAlias[alias] }];
+  }
+  if (alias in keyStatusKeysByAlias)
+    return keyStatusKeysByAlias[alias];
+  return [{
+    code: (() => {
+      if (letterRE.test(alias))
+        return `Key${alias.toUpperCase()}`;
+      if (digitRE.test(alias))
+        return `Digit${alias}`;
+      if (functionRE.test(alias))
+        return alias.toUpperCase();
+      return "unsupported";
+    })()
+  }];
+}
+const digitRE = /^[0-9]$/;
+const letterRE = /^[a-zA-Z]$/;
+const functionRE = /^[fF][0-9]{1,2}$/;
+const keyStatusKeysByAlias = {
+  "`": [{ code: "Backquote" }],
+  "~": [{ code: "Backquote" }, { key: "Shift" }],
+  "-": [{ code: "Minus" }],
+  _: [{ code: "Minus" }, { key: "Shift" }],
+  "=": [{ code: "Equal" }],
+  "+": [{ code: "Equal" }, { key: "Shift" }],
+  "[": [{ code: "BracketLeft" }],
+  "{": [{ code: "BracketLeft" }, { key: "Shift" }],
+  "]": [{ code: "BracketRight" }],
+  "}": [{ code: "BracketRight" }, { key: "Shift" }],
+  "\\": [{ code: "Backslash" }],
+  "|": [{ code: "Backslash" }, { key: "Shift" }],
+  ";": [{ code: "Semicolon" }],
+  ":": [{ code: "Semicolon" }, { key: "Shift" }],
+  "'": [{ code: "Quote" }],
+  '"': [{ code: "Quote" }, { key: "Shift" }],
+  ",": [{ code: "Comma" }],
+  "<": [{ code: "Comma" }, { key: "Shift" }],
+  ".": [{ code: "Period" }],
+  ">": [{ code: "Period" }, { key: "Shift" }],
+  "/": [{ code: "Slash" }],
+  "?": [{ code: "Slash" }, { key: "Shift" }],
+  "!": [{ code: "Digit1" }, { key: "Shift" }],
+  "@": [{ code: "Digit2" }, { key: "Shift" }],
+  "#": [{ code: "Digit3" }, { key: "Shift" }],
+  $: [{ code: "Digit4" }, { key: "Shift" }],
+  "%": [{ code: "Digit5" }, { key: "Shift" }],
+  "^": [{ code: "Digit6" }, { key: "Shift" }],
+  "&": [{ code: "Digit7" }, { key: "Shift" }],
+  "*": [{ code: "Digit8" }, { key: "Shift" }],
+  "(": [{ code: "Digit9" }, { key: "Shift" }],
+  ")": [{ code: "Digit0" }, { key: "Shift" }],
+  up: [{ code: "ArrowUp" }],
+  down: [{ code: "ArrowDown" }],
+  left: [{ code: "ArrowLeft" }],
+  right: [{ code: "ArrowRight" }],
+  enter: [{ code: "Enter" }],
+  space: [{ code: "Space" }],
+  tab: [{ code: "Tab" }],
+  esc: [{ code: "Escape" }],
+  backspace: [{ code: "Backspace" }],
+  delete: [{ code: "Delete" }],
+  home: [{ code: "Home" }],
+  end: [{ code: "End" }],
+  pagedown: [{ code: "PageDown" }],
+  pageup: [{ code: "PageUp" }],
+  capslock: [{ code: "CapsLock" }],
+  camera: [{ code: "Camera" }]
+};
+const keysByAlias = {
+  alt: "Alt",
+  opt: "Alt",
+  option: "Alt",
+  ctrl: "Control",
+  control: "Control",
+  meta: "Meta",
+  cmd: "Meta",
+  command: "Meta",
+  shift: "Shift"
+};
+
+const defaultOptions$m = {
+  toDownKeys: (alias) => fromAliasToDownKeys(alias)
+};
+const createPredicateKeycomboDown = (keycombo, options = {}) => {
+  const { toDownKeys } = { ...defaultOptions$m, ...options }, downKeys = lazyCollections.pipe(
+    fromComboToAliases,
+    lazyCollections.map(toDownKeys)
+  )(keycombo);
+  return (statuses) => {
+    const predicateAliasEntriesDown = lazyCollections.every(
+      (key) => statuses.toValue(key) === "down"
+    );
+    return lazyCollections.every(predicateAliasEntriesDown)(downKeys);
+  };
+};
+
+function fromEventToAliases(event) {
+  if (event.shiftKey && event.code in aliasesByShiftCode) {
+    return [aliasesByShiftCode[event.code]];
+  }
+  if (event.key in aliasListsByModifier) {
+    return aliasListsByModifier[event.key];
+  }
+  return event.code in aliasesByCode ? [aliasesByCode[event.code]] : [event.code.match(aliasCaptureRE)?.[1].toLowerCase() || "unsupported"];
+}
+const aliasCaptureRE = /^(?:Digit|Key)?(F[0-9]{1,2}|[0-9]|[A-Z])$/;
+const aliasesByCode = {
+  Backquote: "`",
+  Minus: "-",
+  Equal: "=",
+  BracketLeft: "[",
+  BracketRight: "]",
+  Backslash: "\\",
+  Semicolon: ";",
+  Quote: "'",
+  Comma: ",",
+  Period: ".",
+  Slash: "/",
+  ArrowUp: "up",
+  ArrowDown: "down",
+  ArrowLeft: "left",
+  ArrowRight: "right",
+  Enter: "enter",
+  Space: "space",
+  Tab: "tab",
+  Escape: "esc",
+  Backspace: "backspace",
+  Delete: "delete",
+  Home: "home",
+  End: "end",
+  PageDown: "pagedown",
+  PageUp: "pageup",
+  CapsLock: "capslock",
+  Camera: "camera"
+};
+const aliasesByShiftCode = {
+  Backquote: "~",
+  Minus: "_",
+  Equal: "+",
+  BracketLeft: "{",
+  BracketRight: "}",
+  Backslash: "|",
+  Semicolon: ":",
+  Quote: '"',
+  Comma: "<",
+  Period: ">",
+  Slash: "?",
+  Digit1: "!",
+  Digit2: "@",
+  Digit3: "#",
+  Digit4: "$",
+  Digit5: "%",
+  Digit6: "^",
+  Digit7: "&",
+  Digit8: "*",
+  Digit9: "(",
+  Digit0: ")"
+};
+const aliasListsByModifier = {
+  Alt: ["alt", "option", "opt"],
+  Control: ["control", "ctrl"],
+  Meta: ["meta", "command", "cmd"],
+  Shift: ["shift"]
+};
+
+const defaultOptions$l = {
+  toDownKeys: (alias) => fromAliasToDownKeys(alias),
+  toAliases: (event) => fromEventToAliases(event)
+};
+const createPredicateKeycomboMatch$1 = (keycombo, options = {}) => {
+  const { toDownKeys, toAliases } = { ...defaultOptions$l, ...options }, aliases = fromComboToAliases(keycombo), downKeys = lazyCollections.map(toDownKeys)(aliases);
+  return (statuses) => {
+    const predicateAliasDown = lazyCollections.every(
+      (key) => statuses.toValue(key) === "down"
+    );
+    return lazyCollections.every(predicateAliasDown)(downKeys) && lazyCollections.every(
+      ([key, value]) => value === "up" || lazyCollections.pipe(
+        toAliases,
+        lazyCollections.some((alias) => lazyCollections.includes(alias)(aliases))
+      )(key)
+    )(statuses.toEntries());
+  };
+};
+
 function createClone() {
   return (any) => {
     return klona.klona(any);
@@ -280,7 +476,7 @@ function createRename(from, to) {
   };
 }
 
-const defaultOptions$m = {
+const defaultOptions$k = {
   elementIsCandidate: false,
   // Adapted from React Aria https://github.com/adobe/react-spectrum/blob/b6786da906973130a1746b2bee63215bba013ca4/packages/%40react-aria/focus/src/FocusScope.tsx#L256
   tabbableSelector: lazyCollections.join(':not([hidden]):not([tabindex="-1"]),')([
@@ -301,7 +497,7 @@ const defaultOptions$m = {
   ])
 };
 function createFocusable(order, options = {}) {
-  const { elementIsCandidate, tabbableSelector } = { ...defaultOptions$m, ...options }, predicateFocusable = (element) => element.matches(tabbableSelector);
+  const { elementIsCandidate, tabbableSelector } = { ...defaultOptions$k, ...options }, predicateFocusable = (element) => element.matches(tabbableSelector);
   return (element) => {
     if (elementIsCandidate && predicateFocusable(element))
       return element;
@@ -736,12 +932,12 @@ function createList() {
   return (...classValues) => clsx(...classValues);
 }
 
-const defaultOptions$l = {
+const defaultOptions$j = {
   toId: (node) => node.id,
   toChildren: (node) => node.children
 };
 function createToGraph(options = {}) {
-  const { toId, toChildren } = { ...defaultOptions$l, ...options };
+  const { toId, toChildren } = { ...defaultOptions$j, ...options };
   return function* (tree) {
     const root = tree[0], rootId = toId(root);
     function* toPair(node, id) {
@@ -760,36 +956,56 @@ function createToGraph(options = {}) {
   };
 }
 
-const defaultOptions$k = {
-  toKey: (alias) => fromAliasToKeyStatusKey(alias),
+const defaultOptions$i = {
+  toDownKeys: (alias) => fromAliasToDownKeys(alias),
   toAliases: (event) => fromEventToAliases(event)
 };
-const createPredicateKeycomboMatch$1 = (keycombo, options = {}) => {
-  const { toKey, toAliases } = { ...defaultOptions$k, ...options }, aliases = fromComboToAliases(keycombo), keys = lazyCollections.map(toKey)(aliases);
+const createPredicateKeycomboMatch = (keycombo, options = {}) => {
+  const { toDownKeys, toAliases } = { ...defaultOptions$i, ...options }, aliases = fromComboToAliases(keycombo), downKeys = createMap(toDownKeys)(aliases), implicitModifierAliases = (() => {
+    const implicitModifierAliases2 = [];
+    for (const aliasDownKeys of downKeys) {
+      for (const { key } of aliasDownKeys) {
+        if (lazyCollections.includes(key)(modifiers))
+          implicitModifierAliases2.push(key.toLowerCase());
+      }
+    }
+    return implicitModifierAliases2;
+  })();
   return (event) => {
-    const { toValue, set, toEntries } = createKeyStatuses();
-    set(fromEventToKeyStatusKey(event), "down");
+    const statuses = createKeyStatuses(), predicateAliasDown = lazyCollections.every(
+      (key) => statuses.toValue(key) === "down"
+    );
+    statuses.set(fromEventToKeyStatusKey(event), "down");
     for (const modifier of modifiers) {
       if (event[`${modifier.toLowerCase()}Key`])
-        set({ key: modifier }, "down");
-    }
-    return lazyCollections.every(lazyCollections.pipe(
-      toValue,
-      predicateDown
-    ))(keys) && lazyCollections.every(
-      ([key]) => lazyCollections.some(
-        (alias) => lazyCollections.includes(alias)(aliases)
-      )(toAliases(key))
-    )(toEntries());
+        statuses.set({ key: modifier }, "down");
+    }
+    const events = createMap(
+      ([key]) => {
+        const e = { ...key };
+        for (const modifier of modifiers) {
+          e[`${modifier.toLowerCase()}Key`] = event[`${modifier.toLowerCase()}Key`];
+        }
+        return e;
+      }
+    )(statuses.toEntries());
+    return lazyCollections.every(predicateAliasDown)(downKeys) && lazyCollections.every(
+      (e) => lazyCollections.pipe(
+        toAliases,
+        lazyCollections.some(
+          (alias) => lazyCollections.includes(alias)(aliases) || lazyCollections.includes(alias)(implicitModifierAliases)
+        )
+      )(e)
+    )(events);
   };
 };
 
-const defaultOptions$j = {
+const defaultOptions$h = {
   initial: [],
   createPredicateKey: (query) => (candidate) => query === candidate
 };
 function createAssociativeArray(options = {}) {
-  const { initial, createPredicateKey } = { ...defaultOptions$j, ...options }, entries = [...initial];
+  const { initial, createPredicateKey } = { ...defaultOptions$h, ...options }, entries = [...initial];
   const toValue = (key) => {
     const predicateKey = createPredicateKey(key);
     return lazyCollections.find(
@@ -850,22 +1066,22 @@ function createAssociativeArray(options = {}) {
   };
 }
 
-const defaultOptions$i = {
+const defaultOptions$g = {
   minDuration: 0,
   preventsDefaultUnlessDenied: true,
-  toKey: (alias) => fromAliasToKeyStatusKey(alias),
+  toDownKeys: (alias) => fromAliasToDownKeys(alias),
   toAliases: (event) => fromEventToAliases(event)
 };
 function createKeypress(keycomboOrKeycombos, options = {}) {
   const {
     minDuration,
     preventsDefaultUnlessDenied,
-    toKey,
+    toDownKeys,
     toAliases,
     onDown,
     onUp,
     onVisibilitychange
-  } = { ...defaultOptions$i, ...options }, {
+  } = { ...defaultOptions$g, ...options }, {
     matchPredicatesByKeycombo,
     getDownCombos,
     predicateValid,
@@ -874,7 +1090,7 @@ function createKeypress(keycomboOrKeycombos, options = {}) {
   } = createKeyState({
     keycomboOrKeycombos,
     unsupportedAliases: unsupportedAliases$2,
-    toKey,
+    toDownKeys,
     toAliases,
     getRequest: () => request
   });
@@ -973,22 +1189,22 @@ function createKeypress(keycomboOrKeycombos, options = {}) {
 const unsupportedAliases$2 = ["meta", "command", "cmd"];
 const unsupportedKeys$2 = ["Meta"];
 
-const defaultOptions$h = {
+const defaultOptions$f = {
   minDuration: 0,
   preventsDefaultUnlessDenied: true,
-  toKey: (alias) => fromAliasToKeyStatusKey(alias),
+  toDownKeys: (alias) => fromAliasToDownKeys(alias),
   toAliases: (event) => fromEventToAliases(event)
 };
 function createKeyrelease(keycomboOrKeycombos, options = {}) {
   const {
     minDuration,
     preventsDefaultUnlessDenied,
-    toKey,
+    toDownKeys,
     toAliases,
     onDown,
     onUp,
     onVisibilitychange
-  } = { ...defaultOptions$h, ...options }, {
+  } = { ...defaultOptions$f, ...options }, {
     matchPredicatesByKeycombo,
     getDownCombos,
     predicateValid,
@@ -997,7 +1213,7 @@ function createKeyrelease(keycomboOrKeycombos, options = {}) {
   } = createKeyState({
     keycomboOrKeycombos,
     unsupportedAliases: unsupportedAliases$1,
-    toKey,
+    toDownKeys,
     toAliases,
     getRequest: () => request
   });
@@ -1099,12 +1315,12 @@ function createKeyrelease(keycomboOrKeycombos, options = {}) {
 const unsupportedAliases$1 = ["meta", "command", "cmd"];
 const unsupportedKeys$1 = ["Meta"];
 
-const defaultOptions$g = {
+const defaultOptions$e = {
   minDuration: 0,
   maxInterval: 5e3,
   // VS Code default
   preventsDefaultUnlessDenied: true,
-  toKey: (alias) => fromAliasToKeyStatusKey(alias),
+  toDownKeys: (alias) => fromAliasToDownKeys(alias),
   toAliases: (event) => fromEventToAliases(event)
 };
 function createKeychord(keychord, options = {}) {
@@ -1112,15 +1328,15 @@ function createKeychord(keychord, options = {}) {
     minDuration,
     maxInterval,
     preventsDefaultUnlessDenied,
-    toKey,
+    toDownKeys,
     toAliases,
     onDown,
     onUp,
     onVisibilitychange
-  } = { ...defaultOptions$g, ...options }, narrowedKeychord = keychord.split(" "), keyStates = createMap((keycombo) => createKeyState({
+  } = { ...defaultOptions$e, ...options }, narrowedKeychord = keychord.split(" "), keyStates = createMap((keycombo) => createKeyState({
     keycomboOrKeycombos: keycombo,
     unsupportedAliases,
-    toKey,
+    toDownKeys,
     toAliases,
     getRequest: () => request
   }))(narrowedKeychord), localStatuses = createMap(
@@ -1265,7 +1481,7 @@ function createKonami(options = {}) {
   return createKeychord("up up down down left right left right b a enter", options);
 }
 
-const defaultOptions$f = {
+const defaultOptions$d = {
   minDuration: 0,
   minDistance: 0,
   getMousemoveTarget: (event) => event.target
@@ -1279,7 +1495,7 @@ function createMousepress(options = {}) {
     onLeave,
     onMove,
     onUp
-  } = { ...defaultOptions$f, ...options }, cleanup = (event) => {
+  } = { ...defaultOptions$d, ...options }, cleanup = (event) => {
     window.cancelAnimationFrame(request);
     getMousemoveTarget(event).removeEventListener("mousemove", mousemoveEffect);
   };
@@ -1339,7 +1555,7 @@ function createMousepress(options = {}) {
   };
 }
 
-const defaultOptions$e = {
+const defaultOptions$c = {
   minDuration: 0,
   minDistance: 0,
   minVelocity: 0,
@@ -1355,7 +1571,7 @@ function createMouserelease(options = {}) {
     onLeave,
     onMove,
     onUp
-  } = { ...defaultOptions$e, ...options }, cleanup = (event) => {
+  } = { ...defaultOptions$c, ...options }, cleanup = (event) => {
     window.cancelAnimationFrame(request);
     getMousemoveTarget(event).removeEventListener("mousemove", mousemoveEffect);
   };
@@ -1413,7 +1629,7 @@ function createMouserelease(options = {}) {
   };
 }
 
-const defaultOptions$d = {
+const defaultOptions$b = {
   minDuration: 0,
   minDistance: 0
 };
@@ -1425,7 +1641,7 @@ function createTouchpress(options = {}) {
     onCancel,
     onMove,
     onEnd
-  } = { ...defaultOptions$d, ...options }, cleanup = () => {
+  } = { ...defaultOptions$b, ...options }, cleanup = () => {
     window.cancelAnimationFrame(request);
   };
   let request;
@@ -1486,7 +1702,7 @@ function createTouchpress(options = {}) {
   };
 }
 
-const defaultOptions$c = {
+const defaultOptions$a = {
   minDuration: 0,
   minDistance: 0,
   minVelocity: 0
@@ -1500,7 +1716,7 @@ function createTouchrelease(options = {}) {
     onCancel,
     onMove,
     onEnd
-  } = { ...defaultOptions$c, ...options }, cleanup = () => {
+  } = { ...defaultOptions$a, ...options }, cleanup = () => {
     window.cancelAnimationFrame(request);
   };
   let request;
@@ -1567,12 +1783,12 @@ function createTouchrelease(options = {}) {
   };
 }
 
-const defaultOptions$b = {
+const defaultOptions$9 = {
   initial: []
 };
 function createKeyStatuses(options = {}) {
   return createAssociativeArray({
-    ...defaultOptions$b,
+    ...defaultOptions$9,
     ...options,
     createPredicateKey: (query) => (key) => {
       for (const prop in query) {
@@ -1584,214 +1800,14 @@ function createKeyStatuses(options = {}) {
     }
   });
 }
-function predicateDown(status) {
-  return status === "down";
-}
 function predicateSomeKeyDown(statuses) {
   return lazyCollections.includes("down")(statuses.toValues());
 }
 
-function fromComboToAliases(combo) {
-  const delimiter = "+";
-  return lazyCollections.pipe(
-    lazyCollections.unique(),
-    lazyCollections.map((name) => name === "" ? delimiter : name.toLowerCase()),
-    lazyCollections.toArray()
-  )(combo.split(delimiter));
-}
-
-function fromAliasToKeyStatusKey(alias) {
-  if (alias in keysByAlias) {
-    return { key: keysByAlias[alias] };
-  }
-  return {
-    code: (() => {
-      if (alias in codesByAlias)
-        return codesByAlias[alias];
-      if (letterRE.test(alias))
-        return `Key${alias.toUpperCase()}`;
-      if (digitRE.test(alias))
-        return `Digit${alias}`;
-      if (functionRE.test(alias))
-        return alias.toUpperCase();
-      return "unsupported";
-    })()
-  };
-}
-const digitRE = /^[0-9]$/;
-const letterRE = /^[a-zA-Z]$/;
-const functionRE = /^[fF][0-9]{1,2}$/;
-const codesByAlias = {
-  "`": "Backquote",
-  "~": "Backquote",
-  "-": "Minus",
-  _: "Minus",
-  "=": "Equal",
-  "+": "Equal",
-  "[": "BracketLeft",
-  "{": "BracketLeft",
-  "]": "BracketRight",
-  "}": "BracketRight",
-  "\\": "Backslash",
-  "|": "Backslash",
-  ";": "Semicolon",
-  ":": "Semicolon",
-  "'": "Quote",
-  '"': "Quote",
-  ",": "Comma",
-  "<": "Comma",
-  ".": "Period",
-  ">": "Period",
-  "/": "Slash",
-  "?": "Slash",
-  "!": "Digit1",
-  "@": "Digit2",
-  "#": "Digit3",
-  $: "Digit4",
-  "%": "Digit5",
-  "^": "Digit6",
-  "&": "Digit7",
-  "*": "Digit8",
-  "(": "Digit9",
-  ")": "Digit0",
-  up: "ArrowUp",
-  down: "ArrowDown",
-  left: "ArrowLeft",
-  right: "ArrowRight",
-  enter: "Enter",
-  space: "Space",
-  tab: "Tab",
-  esc: "Escape",
-  backspace: "Backspace",
-  delete: "Delete",
-  home: "Home",
-  end: "End",
-  pagedown: "PageDown",
-  pageup: "PageUp",
-  capslock: "CapsLock",
-  camera: "Camera"
-};
-const keysByAlias = {
-  alt: "Alt",
-  opt: "Alt",
-  option: "Alt",
-  ctrl: "Control",
-  control: "Control",
-  meta: "Meta",
-  cmd: "Meta",
-  command: "Meta",
-  shift: "Shift"
-};
-
-const defaultOptions$a = {
-  toKey: (alias) => fromAliasToKeyStatusKey(alias)
-};
-const createPredicateKeycomboDown = (keycombo, options = {}) => {
-  const { toKey } = { ...defaultOptions$a, ...options }, keys = lazyCollections.pipe(
-    fromComboToAliases,
-    lazyCollections.map(toKey)
-  )(keycombo);
-  return (statuses) => {
-    const { toValue } = statuses;
-    return lazyCollections.every(lazyCollections.pipe(
-      toValue,
-      predicateDown
-    ))(keys);
-  };
-};
-
-function fromEventToAliases(event) {
-  if (event.shiftKey && event.code in aliasesByShiftCode) {
-    return [aliasesByShiftCode[event.code]];
-  }
-  if (event.key in aliasListsByModifier) {
-    return aliasListsByModifier[event.key];
-  }
-  return event.code in aliasesByCode ? [aliasesByCode[event.code]] : [event.code.match(aliasCaptureRE)?.[1].toLowerCase() || "unsupported"];
-}
-const aliasCaptureRE = /^(?:Digit|Key)?(F[0-9]{1,2}|[0-9]|[A-Z])$/;
-const aliasesByCode = {
-  Backquote: "`",
-  Minus: "-",
-  Equal: "=",
-  BracketLeft: "[",
-  BracketRight: "]",
-  Backslash: "\\",
-  Semicolon: ";",
-  Quote: "'",
-  Comma: ",",
-  Period: ".",
-  Slash: "/",
-  ArrowUp: "up",
-  ArrowDown: "down",
-  ArrowLeft: "left",
-  ArrowRight: "right",
-  Enter: "enter",
-  Space: "space",
-  Tab: "tab",
-  Escape: "esc",
-  Backspace: "backspace",
-  Delete: "delete",
-  Home: "home",
-  End: "end",
-  PageDown: "pagedown",
-  PageUp: "pageup",
-  CapsLock: "capslock",
-  Camera: "camera"
-};
-const aliasesByShiftCode = {
-  Backquote: "~",
-  Minus: "_",
-  Equal: "+",
-  BracketLeft: "{",
-  BracketRight: "}",
-  Backslash: "|",
-  Semicolon: ":",
-  Quote: '"',
-  Comma: "<",
-  Period: ">",
-  Slash: "?",
-  Digit1: "!",
-  Digit2: "@",
-  Digit3: "#",
-  Digit4: "$",
-  Digit5: "%",
-  Digit6: "^",
-  Digit7: "&",
-  Digit8: "*",
-  Digit9: "(",
-  Digit0: ")"
-};
-const aliasListsByModifier = {
-  Alt: ["alt", "option", "opt"],
-  Control: ["control", "ctrl"],
-  Meta: ["meta", "command", "cmd"],
-  Shift: ["shift"]
-};
-
-const defaultOptions$9 = {
-  toKey: (alias) => fromAliasToKeyStatusKey(alias),
-  toAliases: (event) => fromEventToAliases(event)
-};
-const createPredicateKeycomboMatch = (keycombo, options = {}) => {
-  const { toKey, toAliases } = { ...defaultOptions$9, ...options }, aliases = fromComboToAliases(keycombo), keys = lazyCollections.map(toKey)(aliases);
-  return (statuses) => {
-    const { toValue } = statuses;
-    return lazyCollections.every(lazyCollections.pipe(
-      toValue,
-      predicateDown
-    ))(keys) && lazyCollections.every(
-      ([key, value]) => value === "up" || lazyCollections.some(
-        (alias) => lazyCollections.includes(alias)(aliases)
-      )(toAliases(key))
-    )(statuses.toEntries());
-  };
-};
-
 function createKeyState({
   keycomboOrKeycombos,
   unsupportedAliases,
-  toKey,
+  toDownKeys,
   toAliases,
   getRequest
 }) {
@@ -1799,7 +1815,7 @@ function createKeyState({
     (keycombo) => !lazyCollections.some(
       (alias) => lazyCollections.includes(alias)(unsupportedAliases)
     )(fromComboToAliases(keycombo))
-  )(Array.isArray(keycomboOrKeycombos) ? keycomboOrKeycombos : [keycomboOrKeycombos]), createPredicateKeycomboDownOptions = { toKey }, downPredicatesByKeycombo = (() => {
+  )(Array.isArray(keycomboOrKeycombos) ? keycomboOrKeycombos : [keycomboOrKeycombos]), createPredicateKeycomboDownOptions = { toDownKeys }, downPredicatesByKeycombo = (() => {
     const predicates = [];
     for (const keycombo of narrowedKeycombos) {
       predicates.push([
@@ -1814,7 +1830,7 @@ function createKeyState({
   })(), createPredicateKeycomboMatchOptions = { ...createPredicateKeycomboDownOptions, toAliases }, matchPredicatesByKeycombo = (() => {
     const predicates = {};
     for (const keycombo of narrowedKeycombos) {
-      predicates[keycombo] = createPredicateKeycomboMatch(
+      predicates[keycombo] = createPredicateKeycomboMatch$1(
         keycombo,
         createPredicateKeycomboMatchOptions
       );
@@ -5047,7 +5063,7 @@ exports.createMap = createMap;
 exports.createMapAsync = createMapAsync;
 exports.createMousepress = createMousepress;
 exports.createMouserelease = createMouserelease;
-exports.createPredicateKeycomboMatch = createPredicateKeycomboMatch$1;
+exports.createPredicateKeycomboMatch = createPredicateKeycomboMatch;
 exports.createPredicateRoot = createPredicateRoot;
 exports.createReduce = createReduce;
 exports.createReduceAsync = createReduceAsync;