@baleada/logic 0.23.4 → 0.24.1

package/lib/index.cjs

@@ -1,99 +1,152 @@
 'use strict';
 
 var BezierEasing = require('bezier-easing');
-var color = require('@snigo.dev/color');
 var lazyCollections = require('lazy-collections');
-var perfectFreehand = require('perfect-freehand');
-var polygonClipping = require('polygon-clipping');
-var ky = require('ky');
-var createDOMPurify = require('dompurify');
 var fastFuzzy = require('fast-fuzzy');
+var createDOMPurify = require('dompurify');
+var slugify = require('@sindresorhus/slugify');
+var arrayShuffle = require('array-shuffle');
 var klona = require('klona');
 var dequal = require('dequal');
-var slugify = require('@sindresorhus/slugify');
+var merge = require('dset/merge');
+var perfectFreehand = require('perfect-freehand');
+var polygonClipping = require('polygon-clipping');
+var ky = require('ky');
 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 createClip(content) {
+  return (string) => {
+    return string.replace(content, "");
+  };
+}
+function createSlug(options) {
+  return (string) => {
+    return slugify(string, options);
+  };
+}
+function createSanitize(options) {
+  const dompurify = createDOMPurify();
+  dompurify.setConfig(options);
+  return (string) => {
+    return dompurify.sanitize(string);
+  };
+}
+function createSplit(options) {
+  const { separator = "", limit } = options;
+  return (string) => {
+    return string.split(separator, limit);
+  };
+}
+function createNumber(options = {}) {
+  const { radix = 10 } = options;
+  return (string) => parseInt(string, radix);
+}
+function createResults(candidates, options = {}) {
+  const narrowedOptions = predicateFunction(options) ? options({ sortKind: fastFuzzy.sortKind }) : options, searcher = new fastFuzzy.Searcher(candidates, narrowedOptions);
+  return (query) => searcher.search(query);
 }
 
-function fromAliasToDownKeys(alias) {
-  if (alias in keysByAlias) {
-    return [{ key: keysByAlias[alias] }];
-  }
+function fromShorthandAliasToLonghandAlias(shorthand) {
+  if (capitalLetterRE.test(shorthand))
+    return `shift+${shorthand.toLowerCase()}`;
+  if (shorthand in keycombosBySpecialCharacter)
+    return keycombosBySpecialCharacter[shorthand];
+  return shorthand;
+}
+const capitalLetterRE = /^[A-Z]$/;
+const keycombosBySpecialCharacter = {
+  "~": "shift+`",
+  _: "shift+-",
+  "+": "shift+=",
+  "{": "shift+[",
+  "}": "shift+]",
+  "|": "shift+\\",
+  ":": "shift+;",
+  '"': "shift+'",
+  "<": "shift+,",
+  ">": "shift+.",
+  "?": "shift+/",
+  "!": "shift+1",
+  "@": "shift+2",
+  "#": "shift+3",
+  $: "shift+4",
+  "%": "shift+5",
+  "^": "shift+6",
+  "&": "shift+7",
+  "*": "shift+8",
+  "(": "shift+9",
+  ")": "shift+0"
+};
+
+function createAliases(options = {}) {
+  const { toLonghand = fromShorthandAliasToLonghandAlias } = options;
+  return (combo) => {
+    const separator = "+", splitByPlus = createSplit({ separator });
+    return lazyCollections.pipe(
+      splitByPlus,
+      lazyCollections.flatMap(
+        (alias) => lazyCollections.pipe(
+          toLonghand,
+          splitByPlus
+        )(alias)
+      ),
+      // If the separator is used as a character in the type,
+      // two empty strings will be produced by the split.
+      // unique() combines those two into one, and also removes
+      // duplicates in longhand transformations.
+      lazyCollections.unique(),
+      lazyCollections.map((name) => name === "" ? separator : name.toLowerCase()),
+      lazyCollections.toArray()
+    )(combo);
+  };
+}
+
+function fromAliasToCode(alias) {
+  if (alias in partialCodesByAlias)
+    return partialCodesByAlias[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";
-    })()
-  }];
+  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" }]
+  "`": "Backquote",
+  "-": "Minus",
+  "=": "Equal",
+  "": "BracketLeft",
+  "]": "BracketRight",
+  "\\": "Backslash",
+  ";": "Semicolon",
+  "'": "Quote",
+  ",": "Comma",
+  ".": "Period",
+  "/": "Slash",
+  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 = {
+const partialCodesByAlias = {
   alt: "Alt",
   opt: "Alt",
   option: "Alt",
@@ -105,119 +158,6 @@ const keysByAlias = {
   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);
-  };
-}
-function createEqual(compared) {
-  return (any) => dequal.dequal(any, compared);
-}
-
 function createConcat(...arrays) {
   return (array) => lazyCollections.pipe(
     lazyCollections.concat(array, ...arrays),
@@ -297,6 +237,8 @@ function createReverse() {
   };
 }
 function createSlice(from, to) {
+  if (from < 0 || to && to < 0)
+    return (array) => array.slice(from, to);
   const toSliced = to ? lazyCollections.slice(from, to - 1) : lazyCollections.slice(from);
   return (array) => {
     return from === to ? [] : lazyCollections.pipe(
@@ -305,6 +247,11 @@ function createSlice(from, to) {
     )(array);
   };
 }
+function createShuffle() {
+  return (array) => {
+    return arrayShuffle(array);
+  };
+}
 function createSort(compare) {
   return (array) => {
     return lazyCollections.pipe(
@@ -313,19 +260,19 @@ function createSort(compare) {
     )(array);
   };
 }
-function createSwap(indices) {
+function createSwap(item1Index, item2Index) {
   return (array) => {
-    const { 0: from, 1: to } = indices, { reorderFrom, reorderTo } = (() => {
-      if (from < to) {
+    const { reorderFrom, reorderTo } = (() => {
+      if (item1Index < item2Index) {
         return {
-          reorderFrom: createReorder(from, to),
-          reorderTo: createReorder(to - 1, from)
+          reorderFrom: createReorder(item1Index, item2Index),
+          reorderTo: createReorder(item2Index - 1, item1Index)
         };
       }
-      if (from > to) {
+      if (item1Index > item2Index) {
         return {
-          reorderFrom: createReorder(from, to),
-          reorderTo: createReorder(to + 1, from)
+          reorderFrom: createReorder(item1Index, item2Index),
+          reorderTo: createReorder(item2Index + 1, item1Index)
         };
       }
       return {
@@ -343,6 +290,55 @@ function createUnique() {
   )(array);
 }
 
+function createClone() {
+  return (any) => {
+    return klona.klona(any);
+  };
+}
+function createDeepEqual(compared) {
+  return (any) => dequal.dequal(any, compared);
+}
+function createEqual(compared) {
+  return (any) => any === compared;
+}
+
+function createValue$2(key, options = {}) {
+  const { predicateKey = createEqual(key) } = options;
+  return (associativeArray) => {
+    return lazyCollections.find(
+      ([candidate]) => predicateKey(candidate)
+    )(associativeArray)?.[1];
+  };
+}
+function createHas$1(key, options = {}) {
+  const { predicateKey = createEqual(key) } = options;
+  return (associativeArray) => {
+    return lazyCollections.findIndex(
+      ([candidate]) => predicateKey(candidate)
+    )(associativeArray) !== -1;
+  };
+}
+function createKeys$1() {
+  return (associativeArray) => {
+    return createMap(([key]) => key)(associativeArray);
+  };
+}
+function createValues$1() {
+  return (associativeArray) => {
+    return createMap(([, value]) => value)(associativeArray);
+  };
+}
+
+function createForEachAsync(effect) {
+  return async (array) => {
+    for (let i = 0; i < array.length; i++) {
+      const item = array[i];
+      await effect(item, i);
+    }
+    return array;
+  };
+}
+
 function createFilterAsync(predicate) {
   return async (array) => {
     const transformedAsync = await createMapAsync(predicate)(array);
@@ -367,15 +363,6 @@ function createFindIndexAsync(predicate) {
     }
   };
 }
-function createForEachAsync(forEach) {
-  return async (array) => {
-    for (let i = 0; i < array.length; i++) {
-      const item = array[i];
-      await forEach(item, i);
-    }
-    return array;
-  };
-}
 function createMapAsync(transform) {
   return async (array) => {
     return await createReduceAsync(
@@ -400,709 +387,495 @@ function createReduceAsync(accumulate, initialValue) {
   };
 }
 
-function createClip(required) {
-  return (string) => {
-    return string.replace(required, "");
-  };
-}
-function createSlug(options) {
-  return (string) => {
-    return slugify(string, options);
-  };
-}
-
-function createClamp(min, max) {
-  return (number) => {
-    const maxed = Math.max(number, min);
-    return Math.min(maxed, max);
-  };
-}
-function createDetermine(potentialities) {
-  const predicates = createMap(({ outcome, probability }, index) => {
-    const lowerBound = index === 0 ? 0 : lazyCollections.pipe(
-      lazyCollections.slice(0, index - 1),
-      lazyCollections.reduce((lowerBound2, { probability: probability2 }) => lowerBound2 + probability2, 0)
-    )(potentialities), upperBound = lowerBound + probability;
-    return {
-      outcome,
-      predicate: (determinant) => determinant >= lowerBound && determinant < upperBound || determinant < 0 && index === 0 || index === predicates.length - 1
-    };
-  })(potentialities);
-  return (determinant) => lazyCollections.find(({ predicate }) => predicate(determinant))(predicates).outcome;
+function createList() {
+  return (...classValues) => clsx(...classValues);
 }
 
-function createEntries() {
-  return (object) => {
-    const entries = [];
-    for (const key in object) {
-      entries.push([key, object[key]]);
-    }
-    return entries;
-  };
-}
-function createKeys() {
-  return (object) => {
-    const keys = [];
-    for (const key in object) {
-      keys.push(key);
-    }
-    return keys;
-  };
-}
-function createEvery(predicate) {
-  return (object) => {
-    for (const key in object) {
-      if (!predicate(key, object[key])) {
-        return false;
-      }
-    }
-    return true;
-  };
-}
-function createSome(predicate) {
-  return (object) => {
-    for (const key in object) {
-      if (predicate(key, object[key]))
-        return true;
-    }
-    return false;
+const defaultCreateMixOptions = {
+  method: "oklch",
+  tag: "div",
+  getParent: () => document.body
+};
+function createMix(color2, options = {}) {
+  const { method, tag, getParent } = { ...defaultCreateMixOptions, ...options };
+  return (color1) => {
+    const element = document.createElement(tag), parent = getParent();
+    element.style.color = `color-mix(in ${method}, ${color1}, ${color2})`;
+    parent.appendChild(element);
+    const mixed = getComputedStyle(element).color;
+    parent.removeChild(element);
+    return mixed;
   };
 }
 
-function createRename(from, to) {
-  return (map) => {
-    const keys = [...map.keys()], keyToRenameIndex = lazyCollections.findIndex((k) => k === from)(keys), newKeys = createReplace(keyToRenameIndex, to)(keys), values = [...map.values()];
-    return createReduce((renamed, key, index) => renamed.set(key, values[index]), /* @__PURE__ */ new Map())(newKeys);
-  };
+function createDepthPathConfig(directedAcyclic) {
+  const predicateTerminal = createTerminal(directedAcyclic), predicatePathable = (node) => !predicateTerminal(node), toTraversalCandidates = (path) => lazyCollections.pipe(
+    lazyCollections.at(-1),
+    createOutgoing(directedAcyclic)
+  )(path);
+  return { predicatePathable, toTraversalCandidates };
 }
 
-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"]),')([
-    "input:not([disabled]):not([type=hidden])",
-    "select:not([disabled])",
-    "textarea:not([disabled])",
-    "button:not([disabled])",
-    "a[href]",
-    "area[href]",
-    "summary",
-    "iframe",
-    "object",
-    "embed",
-    "audio[controls]",
-    "video[controls]",
-    "[contenteditable]",
-    "[tabindex]:not([disabled])"
-  ])
-};
-function createFocusable(order, options = {}) {
-  const { elementIsCandidate, tabbableSelector } = { ...defaultOptions$k, ...options }, predicateFocusable = (element) => element.matches(tabbableSelector);
-  return (element) => {
-    if (elementIsCandidate && predicateFocusable(element))
-      return element;
-    switch (order) {
-      case "first":
-        for (let i = 0; i < element.children.length; i++) {
-          const focusable = createFocusable(order, { elementIsCandidate: true })(element.children[i]);
-          if (focusable)
-            return focusable;
-        }
-        break;
-      case "last":
-        for (let i = element.children.length - 1; i > -1; i--) {
-          const focusable = createFocusable(order, { elementIsCandidate: true })(element.children[i]);
-          if (focusable)
-            return focusable;
-        }
-        break;
-    }
-  };
+function createBreadthPathConfig(directedAcyclic) {
+  const predicateOnlyChild = createOnlyChild(directedAcyclic), predicatePathable = (node) => !predicateOnlyChild(node), toTraversalCandidates = (path) => lazyCollections.pipe(
+    lazyCollections.at(-2),
+    createOutgoing(directedAcyclic)
+  )(path);
+  return { predicatePathable, toTraversalCandidates };
 }
 
-function createToIndegree(graph) {
-  const toIncoming = createToIncoming(graph);
-  return (node) => lazyCollections.pipe(
-    toIncoming,
-    toLength()
-  )(node);
-}
-function createToOutdegree(graph) {
-  const toOutgoing = createToOutgoing(graph);
-  return (node) => lazyCollections.pipe(
-    toOutgoing,
-    toLength()
-  )(node);
-}
-function createToIncoming(graph) {
-  const { edges } = graph;
-  return function* (node) {
-    yield* lazyCollections.filter(
-      ({ to }) => to === node
-    )(edges);
-  };
-}
-function createToOutgoing(graph) {
-  const { edges } = graph;
-  return function* (node) {
-    yield* lazyCollections.filter(
-      ({ from }) => from === node
-    )(edges);
-  };
-}
-function createPredicateRoot(graph) {
-  const toIndegree = createToIndegree(graph);
-  return (node) => toIndegree(node) === 0;
-}
-
-function createFind(node) {
-  return (tree) => {
-    for (const treeNode of tree) {
-      if (treeNode.node === node)
-        return treeNode;
-      const found = createFind(node)(treeNode.children);
-      if (found)
-        return found;
-    }
-  };
-}
-
-function createToLayers$1(options = {}) {
-  const toSteps = createToSteps$2(options.createToSteps);
-  return function toLayers(directedAcyclic) {
-    const layers = [];
-    for (const { path } of toSteps(directedAcyclic)) {
-      const node = path.at(-1), depth = path.length - 1;
-      (layers[depth] || (layers[depth] = [])).push(node);
-    }
-    return layers;
-  };
-}
-function createToTree$2(options = {}) {
-  const toSteps = createToSteps$2(options.createToSteps);
-  return function toTree(directedAcyclic) {
-    const firstRoot = lazyCollections.pipe(
-      createToRoots(),
-      lazyCollections.at(0)
-    )(directedAcyclic), tree = [];
-    tree.push({
-      node: firstRoot,
-      children: []
-    });
-    for (const { path } of toSteps(directedAcyclic)) {
-      const node = path.at(-1), parent = path.at(-2);
-      if (parent) {
-        const parentTreeNode = createFind(parent)(tree);
-        if (parentTreeNode) {
-          parentTreeNode.children.push({
-            node,
-            children: []
-          });
-        }
-      }
-    }
-    return tree;
-  };
-}
-function createToCommonAncestors$2(directedAcyclic) {
-  const toNodeSteps = createToNodeSteps$2(directedAcyclic);
-  return function* (a, b) {
-    for (const { path: aPath } of toNodeSteps(a)) {
-      for (const { path: bPath } of toNodeSteps(b)) {
-        for (let aPathIndex = aPath.length - 1; aPathIndex >= 0; aPathIndex--) {
-          for (let bPathIndex = bPath.length - 1; bPathIndex >= 0; bPathIndex--) {
-            if (aPath[aPathIndex] === bPath[bPathIndex] && !lazyCollections.includes(aPath[aPathIndex])([a, b])) {
-              yield {
-                node: aPath[aPathIndex],
-                distances: {
-                  [a]: aPath.length - aPathIndex - 1,
-                  [b]: bPath.length - bPathIndex - 1
-                }
-              };
-            }
-          }
-        }
+class Recognizeable {
+  maxSequenceLength;
+  effects;
+  effectApi;
+  constructor(sequence, options = {}) {
+    const defaultOptions = {
+      maxSequenceLength: true,
+      effects: {}
+    };
+    this.maxSequenceLength = options?.maxSequenceLength || defaultOptions.maxSequenceLength;
+    this.effects = options?.effects || defaultOptions.effects;
+    this.resetComputedMetadata();
+    this.setSequence(sequence);
+    this.effectApi = {
+      getStatus: () => this.status,
+      getMetadata: () => this.metadata,
+      setMetadata: (metadata) => this.computedMetadata = metadata,
+      recognized: () => this.recognized(),
+      denied: () => this.denied(),
+      ready: () => this.ready()
+    };
+    this.ready();
+  }
+  computedMetadata;
+  resetComputedMetadata() {
+    this.computedMetadata = {};
+  }
+  recognized() {
+    this.computedStatus = "recognized";
+  }
+  denied() {
+    this.computedStatus = "denied";
+  }
+  computedStatus;
+  ready() {
+    this.computedStatus = "ready";
+  }
+  get sequence() {
+    return this.computedSequence;
+  }
+  set sequence(sequence) {
+    this.setSequence(sequence);
+  }
+  get status() {
+    return this.computedStatus;
+  }
+  get metadata() {
+    return this.computedMetadata;
+  }
+  computedSequence;
+  setSequence(sequence) {
+    this.computedSequence = sequence;
+    return this;
+  }
+  recognize(sequenceItem, options = {}) {
+    this.recognizing();
+    const type = this.toType(sequenceItem), pushSequence = (sequenceItem2) => {
+      newSequence.push(sequenceItem2);
+      if (this.maxSequenceLength !== true && newSequence.length > this.maxSequenceLength) {
+        newSequence.shift();
       }
+    }, newSequence = [];
+    for (const sequenceItem2 of this.sequence) {
+      pushSequence(sequenceItem2);
     }
-  };
-}
-function createPredicateAncestor$2(directedAcyclic) {
-  const toNodeSteps = createToNodeSteps$2(directedAcyclic);
-  return function(descendant, ancestor) {
-    return lazyCollections.pipe(
-      toNodeSteps,
-      lazyCollections.some(({ path }) => lazyCollections.includes(ancestor)(path))
-    )(descendant);
-  };
-}
-function createToNodeSteps$2(directedAcyclic, options = {}) {
-  const toSteps = createToSteps$2(options.createToSteps);
-  return function* (node) {
-    yield* lazyCollections.pipe(
-      toSteps,
-      lazyCollections.filter(({ path }) => path.at(-1) === node)
-    )(directedAcyclic);
-  };
-}
-const defaultCreateToStepsOptions$1 = {
-  toUnsetMetadata: () => 0,
-  toMockMetadata: (node, totalConnectionsFollowed) => totalConnectionsFollowed,
-  kind: "directed acyclic"
-};
-function createToSteps$2(options = {}) {
-  const { toUnsetMetadata, toMockMetadata, root, kind } = { ...defaultCreateToStepsOptions$1, ...options };
-  return function* (directedAcyclic) {
-    const { nodes } = directedAcyclic, toOutdegree = createToOutdegree(directedAcyclic), toPath = createToPath$2(directedAcyclic), roots = lazyCollections.pipe(
-      createToRoots({ kind }),
-      lazyCollections.toArray()
-    )(directedAcyclic), state = {}, totalConnectionsFollowedByNode = {}, predicateExhausted = (node) => {
-      return totalConnectionsFollowedByNode[node] === toOutdegree(node);
+    pushSequence(sequenceItem);
+    this.effectApi.getSequence = () => newSequence;
+    this.effectApi.pushSequence = pushSequence;
+    this.effectApi.listenInjection = {
+      effect: options.listenInjection?.effect || (() => {
+      }),
+      optionsByType: options.listenInjection?.optionsByType || {}
     };
-    for (const node of nodes) {
-      state[node] = {
-        status: "unset",
-        metadata: toUnsetMetadata(node)
-      };
+    this.effects[type]?.(sequenceItem, { ...this.effectApi });
+    switch (this.status) {
+      case "ready":
+      case "denied":
+        this.resetComputedMetadata();
+        this.setSequence([]);
+        break;
+      case "recognizing":
+      case "recognized":
+        this.setSequence(newSequence);
+        break;
     }
-    let location = root || lazyCollections.at(0)(roots);
-    const path = toPath(state);
-    yield { path, state: JSON.parse(JSON.stringify(state)) };
-    function* toStep() {
-      if (predicateExhausted(location)) {
-        if (lazyCollections.includes(location)(roots))
-          return;
-        state[location].status = "unset";
-        state[location].metadata = toUnsetMetadata(location);
-        const path3 = toPath(state);
-        location = path3.at(-2);
-        yield* toStep();
-        return;
+    return this;
+  }
+  recognizing() {
+    this.computedStatus = "recognizing";
+  }
+  toType(sequenceItem) {
+    if (predicateArray(sequenceItem)) {
+      if (sequenceItem[0] instanceof IntersectionObserverEntry) {
+        return "intersect";
       }
-      if (!(location in totalConnectionsFollowedByNode))
-        totalConnectionsFollowedByNode[location] = 0;
-      state[location].status = "set";
-      state[location].metadata = toMockMetadata(location, totalConnectionsFollowedByNode[location]);
-      const path2 = toPath(state);
-      yield { path: path2, state: JSON.parse(JSON.stringify(state)) };
-      totalConnectionsFollowedByNode[location]++;
-      const newLocation = path2.at(-1);
-      if (toOutdegree(newLocation) > 0)
-        location = newLocation;
-      yield* toStep();
-    }
-    yield* toStep();
-  };
-}
-function createToPath$2(directedAcyclic) {
-  const toOutdegree = createToOutdegree(directedAcyclic), toOutgoing = createToOutgoing(directedAcyclic), firstRoot = lazyCollections.pipe(
-    createToRoots(),
-    lazyCollections.at(0)
-  )(directedAcyclic);
-  return (state) => {
-    const path = [firstRoot], getLastOutdegree = () => toOutdegree(path.at(-1)), getLastStatus = () => state[path.at(-1)].status;
-    while (getLastOutdegree() > 0 && getLastStatus() === "set") {
-      const edge = lazyCollections.pipe(
-        toOutgoing,
-        lazyCollections.find(
-          ({ predicateTraversable }) => predicateTraversable(state)
-        )
-      )(path.at(-1));
-      path.push(edge.to);
-    }
-    return path;
-  };
-}
-function createToRoots(options = {}) {
-  return function* (directedAcyclic) {
-    const { nodes } = directedAcyclic;
-    for (const node of nodes) {
-      if (createPredicateRoot(directedAcyclic)(node))
-        yield node;
-      if (options.kind === "arborescence")
-        break;
+      if (sequenceItem[0] instanceof MutationRecord) {
+        return "mutate";
+      }
+      if (sequenceItem[0] instanceof ResizeObserverEntry) {
+        return "resize";
+      }
+    } else {
+      if (sequenceItem instanceof MediaQueryListEvent) {
+        return sequenceItem.media;
+      }
+      if ("didTimeout" in sequenceItem) {
+        return "idle";
+      }
+      return sequenceItem.type;
     }
-  };
+  }
 }
 
-function createToLayers(options = {}) {
-  const toSteps = createToSteps$1(options.createToSteps);
-  return async function toLayers(directedAcyclic) {
-    const layers = [];
-    for await (const { path } of toSteps(directedAcyclic)) {
-      const node = path.at(-1), depth = path.length - 1;
-      (layers[depth] || (layers[depth] = [])).push(node);
-    }
-    return layers;
-  };
-}
-function createToTree$1(options = {}) {
-  const toSteps = createToSteps$1(options.createToSteps);
-  return async function toTree(directedAcyclic) {
-    const firstRoot = lazyCollections.pipe(
-      createToRoots(),
-      lazyCollections.at(0)
-    )(directedAcyclic), tree = [];
-    tree.push({
-      node: firstRoot,
-      children: []
-    });
-    for await (const { path } of toSteps(directedAcyclic)) {
-      const node = path.at(-1), parent = path.at(-2);
-      if (parent) {
-        const parentTreeNode = createFind(parent)(tree);
-        if (parentTreeNode) {
-          parentTreeNode.children.push({
-            node,
-            children: []
-          });
-        }
-      }
+class Listenable {
+  computedRecognizeable;
+  recognizeableEffectsKeys;
+  computedActive;
+  constructor(type, options) {
+    if (type === "recognizeable") {
+      this.computedRecognizeable = new Recognizeable([], options?.recognizeable);
+      this.recognizeableEffectsKeys = Object.keys(options?.recognizeable?.effects);
     }
-    return tree;
-  };
-}
-function createToCommonAncestors$1(directedAcyclic) {
-  const toNodeSteps = createToNodeSteps$1(directedAcyclic);
-  return async function* (a, b) {
-    for await (const { path: aPath } of toNodeSteps(a)) {
-      for await (const { path: bPath } of toNodeSteps(b)) {
-        for (let aPathIndex = aPath.length - 1; aPathIndex >= 0; aPathIndex--) {
-          for (let bPathIndex = bPath.length - 1; bPathIndex >= 0; bPathIndex--) {
-            if (aPath[aPathIndex] === bPath[bPathIndex] && !lazyCollections.includes(aPath[aPathIndex])([a, b])) {
-              yield {
-                node: aPath[aPathIndex],
-                distances: {
-                  [a]: aPath.length - aPathIndex - 1,
-                  [b]: bPath.length - bPathIndex - 1
-                }
-              };
-            }
-          }
-        }
-      }
+    this.computedActive = /* @__PURE__ */ new Set();
+    this.setType(type);
+    this.ready();
+  }
+  computedStatus;
+  ready() {
+    this.computedStatus = "ready";
+  }
+  get type() {
+    return this.computedType;
+  }
+  set type(type) {
+    this.setType(type);
+  }
+  get status() {
+    return this.computedStatus;
+  }
+  get active() {
+    return this.computedActive;
+  }
+  get recognizeable() {
+    return this.computedRecognizeable;
+  }
+  computedType;
+  implementation;
+  setType(type) {
+    this.stop();
+    this.computedType = type;
+    this.implementation = toImplementation(type);
+    return this;
+  }
+  listen(effect, options = {}) {
+    switch (this.implementation) {
+      case "intersection":
+        this.intersectionListen(effect, options);
+        break;
+      case "mutation":
+        this.mutationListen(effect, options);
+        break;
+      case "resize":
+        this.resizeListen(effect, options);
+        break;
+      case "mediaquery":
+        this.mediaQueryListen(effect, options);
+        break;
+      case "idle":
+        this.idleListen(effect, options);
+        break;
+      case "message":
+        this.messageListen(effect, options);
+        break;
+      case "recognizeable":
+        this.recognizeableListen(effect, options);
+        break;
+      case "documentevent":
+        this.documentEventListen(effect, options);
+        break;
+      case "event":
+        this.eventListen(effect, options);
+        break;
     }
-  };
-}
-function createPredicateAncestor$1(directedAcyclic) {
-  const toNodeSteps = createToNodeSteps$1(directedAcyclic);
-  return async function(descendant, ancestor) {
-    return await lazyCollections.pipe(
-      toNodeSteps,
-      lazyCollections.some(({ path }) => lazyCollections.includes(ancestor)(path))
-    )(descendant);
-  };
-}
-function createToNodeSteps$1(directedAcyclic, options = {}) {
-  const toSteps = createToSteps$1(options.createToSteps);
-  return async function* (node) {
-    yield* await lazyCollections.pipe(
-      toSteps,
-      lazyCollections.filter(({ path }) => path.at(-1) === node)
-    )(directedAcyclic);
-  };
-}
-function createToSteps$1(options = {}) {
-  const { toUnsetMetadata, toMockMetadata, root, kind } = { ...defaultCreateToStepsOptions$1, ...options };
-  return async function* (directedAcyclic) {
-    const { nodes } = directedAcyclic, toOutdegree = createToOutdegree(directedAcyclic), toPath = createToPath$1(directedAcyclic), roots = lazyCollections.pipe(
-      createToRoots({ kind }),
-      lazyCollections.toArray()
-    )(directedAcyclic), state = {}, totalConnectionsFollowedByNode = {}, predicateExhausted = (node) => {
-      return totalConnectionsFollowedByNode[node] === toOutdegree(node);
-    };
-    for (const node of nodes) {
-      state[node] = {
-        status: "unset",
-        metadata: toUnsetMetadata(node)
+    this.listening();
+    return this;
+  }
+  intersectionListen(effect, options) {
+    const { target, observer } = { ...this.getDefaultListenOptions(), ...options }, id = new IntersectionObserver(effect, observer);
+    id.observe(target);
+    this.active.add({ target, id });
+  }
+  mutationListen(effect, options) {
+    const { target, observe } = { ...this.getDefaultListenOptions(), ...options }, id = new MutationObserver(effect);
+    id.observe(target, observe);
+    this.active.add({ target, id });
+  }
+  resizeListen(effect, options) {
+    const { target, observe } = { ...this.getDefaultListenOptions(), ...options }, id = new ResizeObserver(effect);
+    id.observe(target, observe);
+    this.active.add({ target, id });
+  }
+  mediaQueryListen(effect, options) {
+    const target = window.matchMedia(this.type), { instantEffect } = { ...this.getDefaultListenOptions(), ...options };
+    instantEffect(target);
+    const withApi = (event) => effect(event);
+    target.addEventListener("change", withApi);
+    this.active.add({ target, id: ["change", withApi] });
+  }
+  idleListen(effect, options) {
+    const { requestIdleCallback } = { ...this.getDefaultListenOptions(), ...options }, id = window.requestIdleCallback((deadline) => effect(deadline), requestIdleCallback);
+    this.active.add({ target: window, id });
+  }
+  messageListen(effect, options) {
+    const { target = new BroadcastChannel("baleada") } = options;
+    target.addEventListener(this.type, (event) => effect(event));
+    this.active.add({ target, id: [this.type, effect] });
+  }
+  recognizeableListen(effect, options) {
+    const guardedEffect = (sequenceItem) => {
+      this.recognizeable.recognize(
+        sequenceItem,
+        { listenInjection: { effect, optionsByType } }
+      );
+      if (this.recognizeable.status === "recognized")
+        effect(sequenceItem);
+    }, optionsByType = {};
+    for (const type of this.recognizeableEffectsKeys) {
+      optionsByType[type] = {
+        ...this.getDefaultListenOptions(toImplementation(type)),
+        ...options
       };
     }
-    let location = root || lazyCollections.at(0)(roots);
-    const path = await toPath(state);
-    yield { path, state: JSON.parse(JSON.stringify(state)) };
-    async function* toStep() {
-      if (predicateExhausted(location)) {
-        if (lazyCollections.includes(location)(roots))
-          return;
-        state[location].status = "unset";
-        state[location].metadata = toUnsetMetadata(location);
-        const path3 = await toPath(state);
-        location = path3.at(-2);
-        yield* await toStep();
-        return;
-      }
-      if (!(location in totalConnectionsFollowedByNode))
-        totalConnectionsFollowedByNode[location] = 0;
-      state[location].status = "set";
-      state[location].metadata = toMockMetadata(location, totalConnectionsFollowedByNode[location]);
-      const path2 = await toPath(state);
-      yield { path: path2, state: JSON.parse(JSON.stringify(state)) };
-      totalConnectionsFollowedByNode[location]++;
-      const newLocation = path2.at(-1);
-      if (toOutdegree(newLocation) > 0)
-        location = newLocation;
-      yield* await toStep();
-    }
-    yield* await toStep();
-  };
-}
-function createToPath$1(directedAcyclic) {
-  const toOutdegree = createToOutdegree(directedAcyclic), toOutgoing = createToOutgoing(directedAcyclic), firstRoot = lazyCollections.pipe(
-    createToRoots(),
-    lazyCollections.at(0)
-  )(directedAcyclic);
-  return async (state) => {
-    const path = [firstRoot], getLastOutdegree = () => toOutdegree(path.at(-1)), getLastStatus = () => state[path.at(-1)].status;
-    while (getLastOutdegree() > 0 && getLastStatus() === "set") {
-      const edge = await lazyCollections.pipe(
-        toOutgoing,
-        lazyCollections.toArray(),
-        createFindAsync(
-          async ({ predicateTraversable }) => await predicateTraversable(state)
-        )
-      )(path.at(-1));
-      path.push(edge.to);
+    for (const type of this.recognizeableEffectsKeys) {
+      const listenable = new Listenable(type);
+      listenable.listen(guardedEffect, options);
+      this.active.add({ id: listenable });
     }
-    return path;
-  };
-}
-
-const defaultCreateToStepsOptions = {
-  priorityBranch: false,
-  kind: "directed acyclic"
-};
-function createToTree(options = {}) {
-  const withDefaults = {
-    ...options,
-    createToSteps: {
-      ...defaultCreateToStepsOptions,
-      ...options.createToSteps
+  }
+  documentEventListen(effect, options) {
+    const narrowedOptions = {
+      ...this.getDefaultListenOptions(),
+      target: document
+    };
+    this.eventListen(effect, narrowedOptions);
+  }
+  eventListen(effect, options) {
+    const { exceptAndOnlyEffect, effectOptions } = toAddEventListenerParams(this.type, effect, options), eventListeners = [[this.type, exceptAndOnlyEffect, ...effectOptions]];
+    this.addEventListeners(eventListeners, options);
+  }
+  addEventListeners(eventListeners, options) {
+    const { target } = { ...this.getDefaultListenOptions(), ...options };
+    for (const eventListener of eventListeners) {
+      target.addEventListener(eventListener[0], eventListener[1], eventListener[2]);
+      this.active.add({ target, id: eventListener });
     }
-  };
-  return createToTree$2({
-    ...withDefaults,
-    createToSteps: toCreateDirectedAcyclicToStepsOptions(withDefaults.createToSteps)
-  });
-}
-function createToCommonAncestors(...params) {
-  return createToCommonAncestors$2(...params);
-}
-function createPredicateAncestor(...params) {
-  return createPredicateAncestor$2(...params);
-}
-function createToNodeSteps(decisionTree, options = {}) {
-  const withDefaults = {
-    ...options,
-    createToSteps: {
-      ...defaultCreateToStepsOptions,
-      ...options.createToSteps
+  }
+  listening() {
+    this.computedStatus = "listening";
+  }
+  stop(options = {}) {
+    const { target } = options;
+    switch (this.status) {
+      case "ready":
+      case void 0:
+        break;
+      default:
+        const stoppables = [...this.active].filter((active) => !target || ("target" in active ? active.target === target : false)), shouldUpdateStatus = stoppables.length === this.active.size;
+        for (const stoppable of stoppables) {
+          stop(stoppable);
+          this.active.delete(stoppable);
+        }
+        if (shouldUpdateStatus) {
+          this.stopped();
+        }
+        break;
     }
-  };
-  return createToNodeSteps$2(
-    decisionTree,
-    {
-      ...withDefaults,
-      createToSteps: toCreateDirectedAcyclicToStepsOptions(withDefaults.createToSteps)
+    return this;
+  }
+  stopped() {
+    this.computedStatus = "stopped";
+  }
+  getDefaultListenOptions(implementation) {
+    switch (implementation || this.implementation) {
+      case "intersection":
+        return {
+          target: document.querySelector("html"),
+          observer: {}
+        };
+      case "mutation":
+        return {
+          target: document.querySelector("html"),
+          observe: {}
+        };
+      case "resize":
+        return {
+          target: document.querySelector("html"),
+          observe: {}
+        };
+      case "mediaquery":
+        return {
+          instantEffect: () => {
+          }
+        };
+      case "idle":
+        return {
+          requestIdleCallback: {}
+        };
+      case "message":
+        return {
+          target: new BroadcastChannel("baleada")
+        };
+      case "recognizeable":
+        return {};
+      case "documentevent":
+        return {};
+      case "event":
+        return { target: document };
     }
-  );
-}
-function createToSteps(options = {}) {
-  const withDefaults = {
-    ...defaultCreateToStepsOptions,
-    ...options
-  };
-  return createToSteps$2(
-    toCreateDirectedAcyclicToStepsOptions(withDefaults)
-  );
-}
-function createToPath(...params) {
-  return createToPath$2(...params);
+  }
 }
-function toCreateDirectedAcyclicToStepsOptions(options) {
-  return {
-    ...defaultCreateToStepsOptions,
-    ...options,
-    ...{
-      toUnsetMetadata: () => false,
-      toMockMetadata: (node, totalConnectionsFollowed) => options.priorityBranch ? !totalConnectionsFollowed : !!totalConnectionsFollowed
-    }
-  };
+function stop(stoppable) {
+  if (stoppable.id instanceof Listenable) {
+    stoppable.id.stop();
+    return;
+  }
+  if (lazyCollections.some((type) => observerAssertionsByType[type](stoppable.id))(["intersect", "mutate", "resize"])) {
+    const { id: id2 } = stoppable;
+    id2.disconnect();
+    return;
+  }
+  if ("target" in stoppable && stoppable.target instanceof MediaQueryList) {
+    const { target: target2, id: id2 } = stoppable;
+    target2.removeEventListener(id2[0], id2[1]);
+    return;
+  }
+  if (predicateNumber(stoppable.id)) {
+    const { target: target2, id: id2 } = stoppable;
+    target2.cancelIdleCallback(id2);
+    return;
+  }
+  if ("target" in stoppable && stoppable.target instanceof BroadcastChannel) {
+    const { target: target2, id: id2 } = stoppable;
+    target2.removeEventListener(id2[0], id2[1]);
+    return;
+  }
+  const { target, id } = stoppable;
+  target.removeEventListener(id[0], id[1], id[2]);
 }
-
-function createList() {
-  return (...classValues) => clsx(...classValues);
+function toImplementation(type) {
+  return lazyCollections.find((implementation) => predicatesByImplementation.get(implementation)(type))(predicatesByImplementation.keys());
 }
-
-const defaultOptions$j = {
-  toId: (node) => node.id,
-  toChildren: (node) => node.children
+const predicatesByImplementation = /* @__PURE__ */ new Map([
+  [
+    "recognizeable",
+    (type) => type === "recognizeable"
+  ],
+  [
+    "intersection",
+    (type) => type === "intersect"
+  ],
+  [
+    "mutation",
+    (type) => type === "mutate"
+  ],
+  [
+    "resize",
+    (type) => type === "resize"
+  ],
+  [
+    "mediaquery",
+    (type) => implementationREs.mediaquery.test(type)
+  ],
+  [
+    "idle",
+    (type) => type === "idle"
+  ],
+  [
+    "message",
+    (type) => type === "message" || type === "messageerror"
+  ],
+  [
+    "documentevent",
+    (type) => documentEvents.has(type)
+  ],
+  [
+    "event",
+    () => true
+  ]
+]);
+const documentEvents = /* @__PURE__ */ new Set([
+  "fullscreenchange",
+  "fullscreenerror",
+  "pointerlockchange",
+  "pointerlockerror",
+  "readystatechange",
+  "visibilitychange"
+]);
+const implementationREs = {
+  mediaquery: /^\(.+\)$/
 };
-function createToGraph(options = {}) {
-  const { toId, toChildren } = { ...defaultOptions$j, ...options };
-  return function* (tree) {
-    const root = tree[0], rootId = toId(root);
-    function* toPair(node, id) {
-      const children = toChildren(node) || [];
-      for (const child of children) {
-        const childId = toId(child);
-        yield {
-          node: childId,
-          edge: { from: id, to: childId }
-        };
-        yield* toPair(child, childId);
-      }
-    }
-    yield { node: rootId };
-    yield* toPair(root, rootId);
-  };
+function toAddEventListenerParams(type, effect, options) {
+  const { addEventListener, useCapture } = options, exceptAndOnlyEffect = createExceptAndOnlyEffect(type, effect, options), effectOptions = [addEventListener || useCapture];
+  return { exceptAndOnlyEffect, effectOptions };
 }
-
-const defaultOptions$i = {
-  toDownKeys: (alias) => fromAliasToDownKeys(alias),
-  toAliases: (event) => fromEventToAliases(event)
-};
-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 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`])
-        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$h = {
-  initial: [],
-  createPredicateKey: (query) => (candidate) => query === candidate
+const observerAssertionsByType = {
+  intersect: (observer) => observer instanceof IntersectionObserver,
+  mutate: (observer) => observer instanceof MutationObserver,
+  resize: (observer) => observer instanceof ResizeObserver
 };
-function createAssociativeArray(options = {}) {
-  const { initial, createPredicateKey } = { ...defaultOptions$h, ...options }, entries = [...initial];
-  const toValue = (key) => {
-    const predicateKey = createPredicateKey(key);
-    return lazyCollections.find(
-      ([candidate]) => predicateKey(candidate)
-    )(entries)?.[1];
-  };
-  const set = (key, value) => {
-    const predicateKey = createPredicateKey(key), index = lazyCollections.findIndex(
-      ([candidate]) => predicateKey(candidate)
-    )(entries);
-    if (index === -1) {
-      entries.push([key, value]);
-      return;
-    }
-    entries[index][1] = value;
-  };
-  const predicateHas = (key) => {
-    const predicateKey = createPredicateKey(key);
-    return lazyCollections.findIndex(
-      ([candidate]) => predicateKey(candidate)
-    )(entries) !== -1;
-  };
-  const clear = () => {
-    entries.length = 0;
-  };
-  const del = (key) => {
-    const predicateKey = createPredicateKey(key), index = lazyCollections.findIndex(
-      ([candidate]) => predicateKey(candidate)
-    )(entries);
-    if (index === -1) {
-      return false;
-    }
-    entries.splice(index, 1);
-    return true;
-  };
-  const toKeys = () => {
-    return createMap(([key]) => key)(entries);
-  };
-  const toValues = () => {
-    return createMap(([, value]) => value)(entries);
-  };
-  const toEntries = () => {
-    return entries;
-  };
-  return {
-    toValue,
-    set,
-    predicateHas,
-    clear,
-    delete: del,
-    toKeys,
-    toValues,
-    toEntries
-    // get: toValue,
-    // has: predicateHas,
-    // keys: toKeys,
-    // values: toValues,
-  };
-}
 
-const defaultOptions$g = {
+const defaultOptions$k = {
   minDuration: 0,
   preventsDefaultUnlessDenied: true,
-  toDownKeys: (alias) => fromAliasToDownKeys(alias),
-  toAliases: (event) => fromEventToAliases(event)
+  toCode: (alias) => fromAliasToCode(alias),
+  toAliases: (code) => fromCodeToAliases(code)
 };
 function createKeypress(keycomboOrKeycombos, options = {}) {
   const {
     minDuration,
     preventsDefaultUnlessDenied,
-    toDownKeys,
+    toLonghand,
+    toCode,
     toAliases,
     onDown,
     onUp,
     onVisibilitychange
-  } = { ...defaultOptions$g, ...options }, {
+  } = { ...defaultOptions$k, ...options }, {
     matchPredicatesByKeycombo,
     getDownCombos,
     predicateValid,
     cleanup,
-    statuses
+    statuses,
+    toStatus,
+    setStatus,
+    clearStatuses,
+    deleteStatus
   } = createKeyState({
     keycomboOrKeycombos,
-    unsupportedAliases: unsupportedAliases$2,
-    toDownKeys,
+    toLonghand,
+    toCode,
     toAliases,
     getRequest: () => request
-  });
+  }), fromComboToAliasesLength = createAliasesLength({ toLonghand });
   let request;
   let localStatus;
   const keydown = (event, api) => {
-    const { denied, getStatus } = api, key = fromEventToKeyStatusKey(event);
-    if (statuses.toValue(key) === "down") {
+    const { denied, getStatus } = api, key = fromEventToKeyStatusCode(event);
+    if (toStatus(key) === "down") {
       onDown?.(toHookApi(api));
       return;
     }
-    statuses.set(key, "down");
+    setStatus(key, "down");
     if (localStatus === "denied") {
       denied();
       onDown?.(toHookApi(api));
@@ -1115,15 +888,15 @@ function createKeypress(keycomboOrKeycombos, options = {}) {
     ) {
       denied();
       localStatus = getStatus();
-      if (lazyCollections.includes(event.key)(unsupportedKeys$2))
-        statuses.clear();
+      if (lazyCollections.includes(event.key)(unsupportedKeys))
+        clearStatuses();
       onDown?.(toHookApi(api));
       return;
     }
     if (preventsDefaultUnlessDenied)
       event.preventDefault();
     const { getMetadata } = api, metadata = getMetadata();
-    metadata.pressed = downCombos[0];
+    metadata.keycombo = downCombos[0];
     localStatus = "recognizing";
     cleanup();
     storeKeyboardTimeMetadata({
@@ -1132,6 +905,7 @@ function createKeypress(keycomboOrKeycombos, options = {}) {
       getTimeMetadata: getMetadata,
       getShouldStore: () => downCombos.length && getDownCombos()[0] === downCombos[0],
       setRequest: (newRequest) => request = newRequest,
+      // @ts-expect-error
       recognize
     });
     onDown?.(toHookApi(api));
@@ -1145,23 +919,23 @@ function createKeypress(keycomboOrKeycombos, options = {}) {
     }
   };
   const keyup = (event, api) => {
-    const { denied } = api, key = fromEventToKeyStatusKey(event);
+    const { denied } = api, key = fromEventToKeyStatusCode(event);
     if (localStatus === "denied") {
       denied();
-      if (lazyCollections.includes(event.key)(unsupportedKeys$2))
-        statuses.clear();
+      if (lazyCollections.includes(event.key)(unsupportedKeys))
+        clearStatuses();
       else
-        statuses.delete(key);
+        deleteStatus(key);
       if (!predicateSomeKeyDown(statuses))
         localStatus = "recognizing";
       onUp?.(toHookApi(api));
       return;
     }
-    statuses.delete(key);
+    deleteStatus(key);
     const downCombos = getDownCombos(), matches = matchPredicatesByKeycombo[downCombos[0]]?.(statuses);
     if (downCombos.length && matches) {
       const { getMetadata } = api, metadata = getMetadata();
-      metadata.pressed = downCombos[0];
+      metadata.keycombo = downCombos[0];
       if (preventsDefaultUnlessDenied)
         event.preventDefault();
       localStatus = "recognizing";
@@ -1174,7 +948,7 @@ function createKeypress(keycomboOrKeycombos, options = {}) {
   };
   const visibilitychange = (event, api) => {
     if (document.visibilityState === "hidden") {
-      statuses.clear();
+      clearStatuses();
       localStatus = "recognizing";
       cleanup();
     }
@@ -1186,45 +960,63 @@ function createKeypress(keycomboOrKeycombos, options = {}) {
     visibilitychange
   };
 }
-const unsupportedAliases$2 = ["meta", "command", "cmd"];
-const unsupportedKeys$2 = ["Meta"];
+class Keypress extends Listenable {
+  constructor(keycomboOrKeycombos, options) {
+    super(
+      "recognizeable",
+      {
+        recognizeable: {
+          effects: createKeypress(keycomboOrKeycombos, options)
+        }
+      }
+    );
+  }
+  get metadata() {
+    return this.recognizeable.metadata;
+  }
+}
 
-const defaultOptions$f = {
+const defaultOptions$j = {
   minDuration: 0,
   preventsDefaultUnlessDenied: true,
-  toDownKeys: (alias) => fromAliasToDownKeys(alias),
-  toAliases: (event) => fromEventToAliases(event)
+  toCode: (alias) => fromAliasToCode(alias),
+  toAliases: (code) => fromCodeToAliases(code)
 };
 function createKeyrelease(keycomboOrKeycombos, options = {}) {
   const {
     minDuration,
     preventsDefaultUnlessDenied,
-    toDownKeys,
+    toLonghand,
+    toCode,
     toAliases,
     onDown,
     onUp,
     onVisibilitychange
-  } = { ...defaultOptions$f, ...options }, {
+  } = { ...defaultOptions$j, ...options }, {
     matchPredicatesByKeycombo,
     getDownCombos,
     predicateValid,
     cleanup,
-    statuses
+    statuses,
+    toStatus,
+    setStatus,
+    clearStatuses,
+    deleteStatus
   } = createKeyState({
     keycomboOrKeycombos,
-    unsupportedAliases: unsupportedAliases$1,
-    toDownKeys,
+    toLonghand,
+    toCode,
     toAliases,
     getRequest: () => request
-  });
+  }), fromComboToAliasesLength = createAliasesLength({ toLonghand });
   let request, localStatus;
   const keydown = (event, api) => {
-    const { denied, getStatus } = api, key = fromEventToKeyStatusKey(event);
-    if (statuses.toValue(key) === "down") {
+    const { denied, getStatus } = api, key = fromEventToKeyStatusCode(event);
+    if (toStatus(key) === "down") {
       onDown?.(toHookApi(api));
       return;
     }
-    statuses.set(key, "down");
+    setStatus(key, "down");
     if (localStatus === "denied") {
       denied();
       onDown?.(toHookApi(api));
@@ -1237,8 +1029,8 @@ function createKeyrelease(keycomboOrKeycombos, options = {}) {
     ) {
       denied();
       localStatus = getStatus();
-      if (lazyCollections.includes(event.key)(unsupportedKeys$1))
-        statuses.clear();
+      if (lazyCollections.includes(event.key)(unsupportedKeys))
+        clearStatuses();
       onDown?.(toHookApi(api));
       return;
     }
@@ -1261,21 +1053,21 @@ function createKeyrelease(keycomboOrKeycombos, options = {}) {
       getStatus,
       getMetadata,
       denied
-    } = api, metadata = getMetadata(), key = fromEventToKeyStatusKey(event);
+    } = api, metadata = getMetadata(), key = fromEventToKeyStatusCode(event);
     if (["denied", "recognized"].includes(localStatus)) {
       if (localStatus === "denied")
         denied();
-      if (lazyCollections.includes(event.key)(unsupportedKeys$1))
-        statuses.clear();
+      if (lazyCollections.includes(event.key)(unsupportedKeys))
+        clearStatuses();
       else
-        statuses.delete(key);
+        deleteStatus(key);
       if (!predicateSomeKeyDown(statuses))
         localStatus = "recognizing";
       onUp?.(toHookApi(api));
       return;
     }
     const downCombos = getDownCombos(), matches = matchPredicatesByKeycombo[downCombos[0]]?.(statuses);
-    statuses.delete(key);
+    deleteStatus(key);
     if (!downCombos.length || !matches) {
       onUp?.(toHookApi(api));
       return;
@@ -1284,7 +1076,7 @@ function createKeyrelease(keycomboOrKeycombos, options = {}) {
     const status = getStatus();
     if (status === "recognized") {
       localStatus = status;
-      metadata.released = downCombos[0];
+      metadata.keycombo = downCombos[0];
     }
     if (preventsDefaultUnlessDenied)
       event.preventDefault();
@@ -1300,7 +1092,7 @@ function createKeyrelease(keycomboOrKeycombos, options = {}) {
   };
   const visibilitychange = (event, api) => {
     if (document.visibilityState === "hidden") {
-      statuses.clear();
+      clearStatuses();
       localStatus = "recognizing";
       cleanup();
     }
@@ -1312,50 +1104,64 @@ function createKeyrelease(keycomboOrKeycombos, options = {}) {
     visibilitychange
   };
 }
-const unsupportedAliases$1 = ["meta", "command", "cmd"];
-const unsupportedKeys$1 = ["Meta"];
+class Keyrelease extends Listenable {
+  constructor(keycomboOrKeycombos, options) {
+    super(
+      "recognizeable",
+      {
+        recognizeable: {
+          effects: createKeyrelease(keycomboOrKeycombos, options)
+        }
+      }
+    );
+  }
+  get metadata() {
+    return this.recognizeable.metadata;
+  }
+}
 
-const defaultOptions$e = {
+const defaultOptions$i = {
   minDuration: 0,
   maxInterval: 5e3,
   // VS Code default
   preventsDefaultUnlessDenied: true,
-  toDownKeys: (alias) => fromAliasToDownKeys(alias),
-  toAliases: (event) => fromEventToAliases(event)
+  toCode: (alias) => fromAliasToCode(alias),
+  toAliases: (code) => fromCodeToAliases(code)
 };
-function createKeychord(keychord, options = {}) {
+function createKeychord(keycombos, options = {}) {
   const {
     minDuration,
     maxInterval,
     preventsDefaultUnlessDenied,
-    toDownKeys,
+    toLonghand,
+    toCode,
     toAliases,
     onDown,
     onUp,
     onVisibilitychange
-  } = { ...defaultOptions$e, ...options }, narrowedKeychord = keychord.split(" "), keyStates = createMap((keycombo) => createKeyState({
+  } = { ...defaultOptions$i, ...options }, narrowedKeycombos = keycombos.split(" "), keyStates = createMap((keycombo) => createKeyState({
     keycomboOrKeycombos: keycombo,
-    unsupportedAliases,
-    toDownKeys,
+    toLonghand,
+    toCode,
     toAliases,
     getRequest: () => request
-  }))(narrowedKeychord), localStatuses = createMap(
+  }))(narrowedKeycombos), localStatuses = createMap(
     () => "recognizing"
-  )(keyStates);
+  )(keyStates), fromComboToAliasesLength = createAliasesLength({ toLonghand });
   let request, playedIndex = 0;
   const keydown = (event, api) => {
-    const { denied, getStatus } = api, key = fromEventToKeyStatusKey(event);
-    if (keyStates[playedIndex].statuses.toValue(key) === "down") {
+    const { denied, getStatus } = api, key = fromEventToKeyStatusCode(event);
+    if (keyStates[playedIndex].toStatus(key) === "down") {
       onDown?.(toHookApi(api));
       return;
     }
     if (localStatuses[playedIndex] === "recognized") {
       playedIndex++;
-      for (const [key2, status] of keyStates[playedIndex - 1].statuses.toEntries()) {
-        keyStates[playedIndex].statuses.set(key2, status);
+      for (const [key2, status] of keyStates[playedIndex - 1].statuses) {
+        keyStates[playedIndex].setStatus(key2, status);
       }
     }
-    keyStates[playedIndex].statuses.set(key, "down");
+    keyStates[playedIndex].setStatus(key, "down");
     if (localStatuses[playedIndex] === "denied") {
       denied();
       onDown?.(toHookApi(api));
@@ -1371,8 +1177,8 @@ function createKeychord(keychord, options = {}) {
       denied();
       localStatuses[playedIndex] = getStatus();
       if (lazyCollections.includes(event.key)(unsupportedKeys)) {
-        for (const { statuses } of keyStates)
-          statuses.clear();
+        for (const { clearStatuses } of keyStates)
+          clearStatuses();
       }
       onDown?.(toHookApi(api));
       return;
@@ -1398,30 +1204,30 @@ function createKeychord(keychord, options = {}) {
       getStatus,
       getMetadata,
       denied
-    } = api, metadata = getMetadata(), key = fromEventToKeyStatusKey(event);
+    } = api, metadata = getMetadata(), key = fromEventToKeyStatusCode(event);
     if (["denied", "recognized"].includes(localStatuses[playedIndex])) {
       if (localStatuses[playedIndex] === "denied")
         denied();
-      for (const { statuses } of keyStates) {
+      for (const { clearStatuses, deleteStatus } of keyStates) {
         if (lazyCollections.includes(event.key)(unsupportedKeys))
-          statuses.clear();
+          clearStatuses();
         else
-          statuses.delete(key);
+          deleteStatus(key);
       }
       if (!predicateSomeKeyDown(keyStates[playedIndex].statuses)) {
-        if (localStatuses[playedIndex] === "denied" || playedIndex === narrowedKeychord.length - 1 && localStatuses[playedIndex] === "recognized") {
+        if (localStatuses[playedIndex] === "denied" || playedIndex === narrowedKeycombos.length - 1 && localStatuses[playedIndex] === "recognized") {
           playedIndex = 0;
           for (let i = 0; i < localStatuses.length; i++)
             localStatuses[i] = "recognizing";
-          for (const { statuses } of keyStates)
-            statuses.clear();
+          for (const { clearStatuses } of keyStates)
+            clearStatuses();
         }
       }
       onUp?.(toHookApi(api));
       return;
     }
     const downCombos = keyStates[playedIndex].getDownCombos(), matches = keyStates[playedIndex].matchPredicatesByKeycombo[downCombos[0]]?.(keyStates[playedIndex].statuses);
-    keyStates[playedIndex].statuses.delete(key);
+    keyStates[playedIndex].deleteStatus(key);
     if (!downCombos.length || !matches) {
       onUp?.(toHookApi(api));
       return;
@@ -1431,17 +1237,17 @@ function createKeychord(keychord, options = {}) {
     if (status === "recognizing" && localStatuses[playedIndex] === "recognized" || status === "recognized") {
       metadata.played[playedIndex] = {
         ...metadata.played[playedIndex],
-        released: downCombos[0]
+        keycombo: downCombos[0]
       };
     }
     if (preventsDefaultUnlessDenied)
       event.preventDefault();
-    if (playedIndex === narrowedKeychord.length - 1 && !predicateSomeKeyDown(keyStates[playedIndex].statuses)) {
+    if (playedIndex === narrowedKeycombos.length - 1 && !predicateSomeKeyDown(keyStates[playedIndex].statuses)) {
       playedIndex = 0;
       for (let i = 0; i < localStatuses.length; i++)
         localStatuses[i] = "recognizing";
-      for (const { statuses } of keyStates)
-        statuses.clear();
+      for (const { clearStatuses } of keyStates)
+        clearStatuses();
     }
     onUp?.(toHookApi(api));
   };
@@ -1451,7 +1257,7 @@ function createKeychord(keychord, options = {}) {
       denied();
       return;
     }
-    if (playedIndex === narrowedKeychord.length - 1) {
+    if (playedIndex === narrowedKeycombos.length - 1) {
       recognized();
       localStatuses[playedIndex] = "recognized";
       return;
@@ -1460,8 +1266,8 @@ function createKeychord(keychord, options = {}) {
   };
   const visibilitychange = (event, api) => {
     if (document.visibilityState === "hidden") {
-      for (const { statuses } of keyStates)
-        statuses.clear();
+      for (const { clearStatuses } of keyStates)
+        clearStatuses();
       localStatuses[playedIndex] = "recognizing";
       keyStates[playedIndex].cleanup();
       playedIndex = 0;
@@ -1474,30 +1280,56 @@ function createKeychord(keychord, options = {}) {
     visibilitychange
   };
 }
-const unsupportedAliases = ["meta", "command", "cmd"];
-const unsupportedKeys = ["Meta"];
+class Keychord extends Listenable {
+  constructor(keycombos, options) {
+    super(
+      "recognizeable",
+      {
+        recognizeable: {
+          effects: createKeychord(keycombos, options)
+        }
+      }
+    );
+  }
+  get metadata() {
+    return this.recognizeable.metadata;
+  }
+}
 
 function createKonami(options = {}) {
   return createKeychord("up up down down left right left right b a enter", options);
 }
+class Konami extends Listenable {
+  constructor(options) {
+    super(
+      "recognizeable",
+      {
+        recognizeable: {
+          effects: createKonami(options)
+        }
+      }
+    );
+  }
+  get metadata() {
+    return this.recognizeable.metadata;
+  }
+}
 
-const defaultOptions$d = {
+const defaultOptions$h = {
   minDuration: 0,
-  minDistance: 0,
-  getMousemoveTarget: (event) => event.target
+  minDistance: 0
 };
 function createMousepress(options = {}) {
   const {
     minDuration,
     minDistance,
-    getMousemoveTarget,
     onDown,
     onLeave,
     onMove,
     onUp
-  } = { ...defaultOptions$d, ...options }, cleanup = (event) => {
+  } = { ...defaultOptions$h, ...options }, cleanup = (target) => {
     window.cancelAnimationFrame(request);
-    getMousemoveTarget(event).removeEventListener("mousemove", mousemoveEffect);
+    target.removeEventListener("mousemove", mousemoveEffect);
   };
   let request;
   let mousemoveEffect;
@@ -1512,9 +1344,11 @@ function createMousepress(options = {}) {
       api,
       () => mouseStatus === "down",
       (newRequest) => request = newRequest,
+      // @ts-expect-error
       recognize
     );
-    getMousemoveTarget(event).addEventListener("mousemove", mousemoveEffect);
+    const { listenInjection: { optionsByType: { mousedown: { target } } } } = api;
+    target.addEventListener("mousemove", mousemoveEffect);
     onDown?.(toHookApi(api));
   };
   const mousemove = (event, api) => {
@@ -1531,20 +1365,20 @@ function createMousepress(options = {}) {
     }
   };
   const mouseleave = (event, api) => {
-    const { denied } = api;
+    const { denied, listenInjection: { optionsByType: { mouseleave: { target } } } } = api;
     if (mouseStatus === "down") {
       denied();
-      cleanup(event);
+      cleanup(target);
       mouseStatus = "leave";
     }
     onLeave?.(toHookApi(api));
   };
   const mouseup = (event, api) => {
-    const { denied } = api;
+    const { denied, listenInjection: { optionsByType: { mouseup: { target } } } } = api;
     if (mouseStatus !== "down")
       return;
     denied();
-    cleanup(event);
+    cleanup(target);
     mouseStatus = "up";
     onUp?.(toHookApi(api));
   };
@@ -1554,26 +1388,39 @@ function createMousepress(options = {}) {
     mouseup
   };
 }
+class Mousepress extends Listenable {
+  constructor(options) {
+    super(
+      "recognizeable",
+      {
+        recognizeable: {
+          effects: createMousepress(options)
+        }
+      }
+    );
+  }
+  get metadata() {
+    return this.recognizeable.metadata;
+  }
+}
 
-const defaultOptions$c = {
+const defaultOptions$g = {
   minDuration: 0,
   minDistance: 0,
-  minVelocity: 0,
-  getMousemoveTarget: (event) => event.target
+  minVelocity: 0
 };
 function createMouserelease(options = {}) {
   const {
     minDuration,
     minDistance,
     minVelocity,
-    getMousemoveTarget,
     onDown,
     onLeave,
     onMove,
     onUp
-  } = { ...defaultOptions$c, ...options }, cleanup = (event) => {
+  } = { ...defaultOptions$g, ...options }, cleanup = (target) => {
     window.cancelAnimationFrame(request);
-    getMousemoveTarget(event).removeEventListener("mousemove", mousemoveEffect);
+    target.removeEventListener("mousemove", mousemoveEffect);
   };
   let request;
   let mousemoveEffect;
@@ -1589,7 +1436,8 @@ function createMouserelease(options = {}) {
       () => mouseStatus === "down",
       (newRequest) => request = newRequest
     );
-    getMousemoveTarget(event).addEventListener("mousemove", mousemoveEffect);
+    const { listenInjection: { optionsByType: { mousedown: { target } } } } = api;
+    target.addEventListener("mousemove", mousemoveEffect);
     onDown?.(toHookApi(api));
   };
   const mousemove = (event, api) => {
@@ -1597,10 +1445,10 @@ function createMouserelease(options = {}) {
     onMove?.(toHookApi(api));
   };
   const mouseleave = (event, api) => {
-    const { denied } = api;
+    const { denied, listenInjection: { optionsByType: { mouseleave: { target } } } } = api;
     if (mouseStatus === "down") {
       denied();
-      cleanup(event);
+      cleanup(target);
       mouseStatus = "leave";
     }
     onLeave?.(toHookApi(api));
@@ -1609,7 +1457,8 @@ function createMouserelease(options = {}) {
     if (mouseStatus !== "down")
       return;
     storePointerMoveMetadata(event, api);
-    cleanup(event);
+    const { listenInjection: { optionsByType: { mouseup: { target } } } } = api;
+    cleanup(target);
     mouseStatus = "up";
     recognize(event, api);
     onUp?.(toHookApi(api));
@@ -1628,8 +1477,23 @@ function createMouserelease(options = {}) {
     mouseup
   };
 }
+class Mouserelease extends Listenable {
+  constructor(options) {
+    super(
+      "recognizeable",
+      {
+        recognizeable: {
+          effects: createMouserelease(options)
+        }
+      }
+    );
+  }
+  get metadata() {
+    return this.recognizeable.metadata;
+  }
+}
 
-const defaultOptions$b = {
+const defaultOptions$f = {
   minDuration: 0,
   minDistance: 0
 };
@@ -1641,7 +1505,7 @@ function createTouchpress(options = {}) {
     onCancel,
     onMove,
     onEnd
-  } = { ...defaultOptions$b, ...options }, cleanup = () => {
+  } = { ...defaultOptions$f, ...options }, cleanup = () => {
     window.cancelAnimationFrame(request);
   };
   let request;
@@ -1662,6 +1526,7 @@ function createTouchpress(options = {}) {
       api,
       () => totalTouches === 1,
       (newRequest) => request = newRequest,
+      // @ts-expect-error
       recognize
     );
     onStart?.(toHookApi(api));
@@ -1701,8 +1566,23 @@ function createTouchpress(options = {}) {
     touchend
   };
 }
+class Touchpress extends Listenable {
+  constructor(options) {
+    super(
+      "recognizeable",
+      {
+        recognizeable: {
+          effects: createTouchpress(options)
+        }
+      }
+    );
+  }
+  get metadata() {
+    return this.recognizeable.metadata;
+  }
+}
 
-const defaultOptions$a = {
+const defaultOptions$e = {
   minDuration: 0,
   minDistance: 0,
   minVelocity: 0
@@ -1716,7 +1596,7 @@ function createTouchrelease(options = {}) {
     onCancel,
     onMove,
     onEnd
-  } = { ...defaultOptions$a, ...options }, cleanup = () => {
+  } = { ...defaultOptions$e, ...options }, cleanup = () => {
     window.cancelAnimationFrame(request);
   };
   let request;
@@ -1730,867 +1610,1392 @@ function createTouchrelease(options = {}) {
       onStart?.(toHookApi(api));
       return;
     }
-    storePointerStartMetadata(event, api);
-    storePointerMoveMetadata(event, api);
-    storePointerTimeMetadata(
-      event,
-      api,
-      () => totalTouches === 1,
-      (newRequest) => request = newRequest
-    );
-    onStart?.(toHookApi(api));
-  };
-  const touchmove = (event, api) => {
-    const { getStatus } = api;
-    if (getStatus() !== "denied")
-      storePointerMoveMetadata(event, api);
-    onMove?.(toHookApi(api));
-  };
-  const touchcancel = (event, api) => {
-    const { denied } = api;
-    cleanup();
-    denied();
-    totalTouches--;
-    onCancel?.(toHookApi(api));
+    storePointerStartMetadata(event, api);
+    storePointerMoveMetadata(event, api);
+    storePointerTimeMetadata(
+      event,
+      api,
+      () => totalTouches === 1,
+      (newRequest) => request = newRequest
+    );
+    onStart?.(toHookApi(api));
+  };
+  const touchmove = (event, api) => {
+    const { getStatus } = api;
+    if (getStatus() !== "denied")
+      storePointerMoveMetadata(event, api);
+    onMove?.(toHookApi(api));
+  };
+  const touchcancel = (event, api) => {
+    const { denied } = api;
+    cleanup();
+    denied();
+    totalTouches--;
+    onCancel?.(toHookApi(api));
+  };
+  const touchend = (event, api) => {
+    const { denied } = api;
+    if (totalTouches !== 1) {
+      cleanup();
+      denied();
+      onEnd?.(toHookApi(api));
+      return;
+    }
+    storePointerMoveMetadata(event, api);
+    cleanup();
+    totalTouches--;
+    recognize(event, api);
+    onEnd?.(toHookApi(api));
+  };
+  const recognize = (event, api) => {
+    const { getMetadata, recognized, denied } = api, metadata = getMetadata();
+    if (metadata.duration >= minDuration && metadata.distance.straight.fromStart >= minDistance && metadata.velocity >= minVelocity) {
+      recognized();
+    } else {
+      denied();
+    }
+  };
+  return {
+    touchstart,
+    touchmove,
+    touchcancel,
+    touchend
+  };
+}
+class Touchrelease extends Listenable {
+  constructor(options) {
+    super(
+      "recognizeable",
+      {
+        recognizeable: {
+          effects: createTouchrelease(options)
+        }
+      }
+    );
+  }
+  get metadata() {
+    return this.recognizeable.metadata;
+  }
+}
+
+function createRoot(graph) {
+  const toIndegree = createIndegree(graph);
+  return (node) => toIndegree(node) === 0;
+}
+function createTerminal(graph) {
+  const toOutdegree = createOutdegree(graph);
+  return (node) => toOutdegree(node) === 0;
+}
+function createChildren(graph) {
+  return function* (node) {
+    const outgoing = createOutgoing(graph)(node);
+    for (const edge of outgoing)
+      yield edge.to;
+  };
+}
+function createIndegree(graph) {
+  const toIncoming = createIncoming(graph);
+  return (node) => lazyCollections.pipe(
+    toIncoming,
+    lazyCollections.toLength()
+  )(node);
+}
+function createOutdegree(graph) {
+  const toOutgoing = createOutgoing(graph);
+  return (node) => lazyCollections.pipe(
+    toOutgoing,
+    lazyCollections.toLength()
+  )(node);
+}
+function createIncoming(graph) {
+  const { edges } = graph;
+  return function* (node) {
+    yield* lazyCollections.filter(
+      ({ to }) => to === node
+    )(edges);
+  };
+}
+function createOutgoing(graph) {
+  const { edges } = graph;
+  return function* (node) {
+    yield* lazyCollections.filter(
+      ({ from }) => from === node
+    )(edges);
+  };
+}
+function createOnlyChild(graph) {
+  const toTotalSiblings = createTotalSiblings(graph);
+  return (node) => toTotalSiblings(node) === 0;
+}
+function createTotalSiblings(graph) {
+  const toSiblings = createSiblings(graph);
+  return (node) => lazyCollections.pipe(
+    toSiblings,
+    lazyCollections.toLength()
+  )(node);
+}
+function createSiblings(graph) {
+  const { edges } = graph;
+  return function* (node) {
+    const parents = lazyCollections.pipe(
+      lazyCollections.filter(
+        ({ to }) => to === node
+      ),
+      lazyCollections.map(
+        ({ from }) => from
+      )
+    )(edges);
+    for (const parent of parents) {
+      yield* lazyCollections.pipe(
+        lazyCollections.filter(
+          ({ from, to }) => from === parent && to !== node
+        ),
+        lazyCollections.map(
+          ({ to }) => to
+        )
+      )(edges);
+    }
+  };
+}
+
+function createFind(node) {
+  return (tree) => {
+    for (const treeNode of tree) {
+      if (treeNode.node === node)
+        return treeNode;
+      const found = createFind(node)(treeNode.children);
+      if (found)
+        return found;
+    }
+  };
+}
+
+function createPath$2(directedAcyclic, config) {
+  const { predicatePathable, toTraversalCandidates } = config, firstRoot = lazyCollections.pipe(
+    createRoots(),
+    lazyCollections.at(0)
+  )(directedAcyclic);
+  return (state) => {
+    const path = [firstRoot], getLastPathable = () => predicatePathable(path.at(-1)), getLastStatus = () => state[path.at(-1)].status;
+    while (getLastPathable() && getLastStatus() === "set") {
+      const edge = lazyCollections.pipe(
+        toTraversalCandidates,
+        lazyCollections.find(
+          ({ predicateShouldTraverse }) => predicateShouldTraverse(state)
+        )
+      )(path);
+      path.push(edge.to);
+    }
+    return path;
+  };
+}
+
+function createLayers$1(options = {}) {
+  const toSteps = createDepthFirstSteps$2(options.createDepthFirstSteps);
+  return function* toLayers(directedAcyclic) {
+    const layers = [];
+    for (const { path } of toSteps(directedAcyclic)) {
+      const node = path.at(-1), depth = path.length - 1;
+      if (!layers[depth] && depth > 0)
+        yield layers[depth - 1];
+      (layers[depth] || (layers[depth] = [])).push(node);
+    }
+  };
+}
+function createTree$2(options = {}) {
+  const toSteps = createDepthFirstSteps$2(options.createDepthFirstSteps);
+  return (directedAcyclic) => {
+    const firstRoot = lazyCollections.pipe(
+      createRoots(),
+      lazyCollections.at(0)
+    )(directedAcyclic), tree = [];
+    tree.push({
+      node: firstRoot,
+      children: []
+    });
+    for (const { path } of toSteps(directedAcyclic)) {
+      const node = path.at(-1), parent = path.at(-2);
+      if (parent) {
+        const parentTreeNode = createFind(parent)(tree);
+        if (parentTreeNode) {
+          parentTreeNode.children.push({
+            node,
+            children: []
+          });
+        }
+      }
+    }
+    return tree;
+  };
+}
+const defaultCreateDepthFirstStepsOptions = {
+  getSetStateValue: ({ totalChildrenDiscovered }) => totalChildrenDiscovered
+};
+function createDepthFirstSteps$2(options = {}) {
+  return createSteps$1(
+    createConfigureDepthFirstSteps(options),
+    options
+  );
+}
+function createConfigureDepthFirstSteps(options) {
+  const { getSetStateValue: getSetStateValueOption } = {
+    ...defaultCreateDepthFirstStepsOptions,
+    ...options
+  };
+  return function(directedAcyclic) {
+    const getSetStateValue = (node) => getSetStateValueOption({
+      node,
+      totalChildrenDiscovered: totalChildrenDiscoveredByNode[node]
+    }), stepFromEffect = (node) => totalChildrenDiscoveredByNode[node]++, predicateSteppable = (node) => !predicateTerminal(node), predicateTerminal = createTerminal(directedAcyclic), predicateExhausted = (node) => totalChildrenDiscoveredByNode[node] === toTotalSiblings(node), toTotalSiblings = createOutdegree(directedAcyclic), totalChildrenDiscoveredByNode = createReduce(
+      (totalChildrenDiscoveredByNode2, node) => {
+        totalChildrenDiscoveredByNode2[node] = 0;
+        return totalChildrenDiscoveredByNode2;
+      },
+      {}
+    )(directedAcyclic.nodes);
+    return {
+      getSetStateValue,
+      stepFromEffect,
+      predicateSteppable,
+      predicateExhausted,
+      createPath: createDepthPathConfig(directedAcyclic)
+    };
+  };
+}
+const defaultCreateStepsOptions$1 = {
+  kind: "directed acyclic"
+};
+function createSteps$1(configure, options = {}) {
+  return function* (directedAcyclic) {
+    const {
+      getSetStateValue,
+      stepFromEffect,
+      predicateSteppable,
+      predicateExhausted,
+      createPath: createPathConfig
+    } = configure(directedAcyclic), { kind, root } = { ...defaultCreateStepsOptions$1, ...options }, { nodes } = directedAcyclic, toPath = createPath$2(directedAcyclic, createPathConfig), roots = lazyCollections.pipe(
+      createRoots({ kind }),
+      lazyCollections.toArray()
+    )(directedAcyclic), state = {};
+    for (const node of nodes) {
+      state[node] = {
+        status: "unset",
+        value: void 0
+      };
+    }
+    let location = root || lazyCollections.at(0)(roots);
+    const path = toPath(state);
+    yield { path, state: JSON.parse(JSON.stringify(state)) };
+    function* toStep() {
+      if (predicateExhausted(location)) {
+        if (lazyCollections.includes(location)(roots))
+          return;
+        state[location].status = "unset";
+        delete state[location].value;
+        const path3 = toPath(state);
+        location = path3.at(-2);
+        yield* toStep();
+        return;
+      }
+      state[location].status = "set";
+      state[location].value = getSetStateValue(location);
+      const path2 = toPath(state);
+      yield { path: path2, state: JSON.parse(JSON.stringify(state)) };
+      stepFromEffect(location);
+      const newLocation = path2.at(-1);
+      if (predicateSteppable(newLocation))
+        location = newLocation;
+      yield* toStep();
+    }
+    yield* toStep();
   };
-  const touchend = (event, api) => {
-    const { denied } = api;
-    if (totalTouches !== 1) {
-      cleanup();
-      denied();
-      onEnd?.(toHookApi(api));
-      return;
+}
+function createRoots(options = {}) {
+  return function* (directedAcyclic) {
+    const { nodes } = directedAcyclic, predicateRoot = createRoot(directedAcyclic);
+    for (const node of nodes) {
+      if (predicateRoot(node))
+        yield node;
+      if (options.kind === "arborescence")
+        break;
     }
-    storePointerMoveMetadata(event, api);
-    cleanup();
-    totalTouches--;
-    recognize(event, api);
-    onEnd?.(toHookApi(api));
   };
-  const recognize = (event, api) => {
-    const { getMetadata, recognized, denied } = api, metadata = getMetadata();
-    if (metadata.duration >= minDuration && metadata.distance.straight.fromStart >= minDistance && metadata.velocity >= minVelocity) {
-      recognized();
-    } else {
-      denied();
+}
+
+function createCommonAncestors$2(directedAcyclic) {
+  const toNodeDepthFirstSteps = createNodeDepthFirstSteps$2(directedAcyclic);
+  return function* (a, b) {
+    for (const { path: aPath } of toNodeDepthFirstSteps(a)) {
+      for (const { path: bPath } of toNodeDepthFirstSteps(b)) {
+        for (let aPathIndex = aPath.length - 1; aPathIndex >= 0; aPathIndex--) {
+          for (let bPathIndex = bPath.length - 1; bPathIndex >= 0; bPathIndex--) {
+            if (aPath[aPathIndex] === bPath[bPathIndex] && !lazyCollections.includes(aPath[aPathIndex])([a, b])) {
+              yield {
+                node: aPath[aPathIndex],
+                distances: {
+                  [a]: aPath.length - aPathIndex - 1,
+                  [b]: bPath.length - bPathIndex - 1
+                }
+              };
+            }
+          }
+        }
+      }
     }
   };
-  return {
-    touchstart,
-    touchmove,
-    touchcancel,
-    touchend
+}
+function createAncestor$2(directedAcyclic) {
+  const toNodeDepthFirstSteps = createNodeDepthFirstSteps$2(directedAcyclic);
+  return function(descendant, ancestor) {
+    return lazyCollections.pipe(
+      toNodeDepthFirstSteps,
+      lazyCollections.some(({ path }) => lazyCollections.includes(ancestor)(path))
+    )(descendant);
+  };
+}
+function createNodeDepthFirstSteps$2(directedAcyclic, options = {}) {
+  const toSteps = createDepthFirstSteps$2(options.createDepthFirstSteps);
+  return function* (node) {
+    yield* lazyCollections.pipe(
+      toSteps,
+      lazyCollections.filter(({ path }) => path.at(-1) === node)
+    )(directedAcyclic);
   };
 }
 
-const defaultOptions$9 = {
-  initial: []
+const defaultCreateStepsOptions = {
+  priorityBranch: false,
+  kind: "directed acyclic"
 };
-function createKeyStatuses(options = {}) {
-  return createAssociativeArray({
-    ...defaultOptions$9,
+function createTree$1(options = {}) {
+  const withDefaults = {
     ...options,
-    createPredicateKey: (query) => (key) => {
-      for (const prop in query) {
-        if (query[prop] !== key[prop]) {
-          return false;
-        }
-      }
-      return true;
+    createDepthFirstSteps: {
+      ...defaultCreateStepsOptions,
+      ...options.createDepthFirstSteps
+    }
+  };
+  return createTree$2(withDefaults);
+}
+function createCommonAncestors$1(...params) {
+  return createCommonAncestors$2(...params);
+}
+function createAncestor$1(...params) {
+  return createAncestor$2(...params);
+}
+function createNodeDepthFirstSteps$1(decisionTree, options = {}) {
+  const withDefaults = {
+    ...options,
+    createDepthFirstSteps: {
+      ...defaultCreateStepsOptions,
+      ...options.createDepthFirstSteps
     }
+  };
+  return createNodeDepthFirstSteps$2(
+    decisionTree,
+    withDefaults
+  );
+}
+function createDepthFirstSteps$1(options) {
+  const { priorityBranch } = { ...defaultCreateStepsOptions, ...options }, configureDepthFirstSteps = createConfigureDepthFirstSteps({
+    getSetStateValue: ({ totalChildrenDiscovered }) => totalChildrenDiscovered === 0 ? priorityBranch : !priorityBranch
   });
+  return createSteps$1(configureDepthFirstSteps, options);
 }
-function predicateSomeKeyDown(statuses) {
-  return lazyCollections.includes("down")(statuses.toValues());
+function createPath$1(...params) {
+  return createPath$2(...params);
 }
 
-function createKeyState({
-  keycomboOrKeycombos,
-  unsupportedAliases,
-  toDownKeys,
-  toAliases,
-  getRequest
-}) {
-  const narrowedKeycombos = createFilter(
-    (keycombo) => !lazyCollections.some(
-      (alias) => lazyCollections.includes(alias)(unsupportedAliases)
-    )(fromComboToAliases(keycombo))
-  )(Array.isArray(keycomboOrKeycombos) ? keycomboOrKeycombos : [keycomboOrKeycombos]), createPredicateKeycomboDownOptions = { toDownKeys }, downPredicatesByKeycombo = (() => {
-    const predicates = [];
-    for (const keycombo of narrowedKeycombos) {
-      predicates.push([
-        keycombo,
-        createPredicateKeycomboDown(
-          keycombo,
-          createPredicateKeycomboDownOptions
+function createPath(directedAcyclicAsync, config) {
+  const { predicatePathable, toTraversalCandidates } = config, firstRoot = lazyCollections.pipe(
+    createRoots(),
+    lazyCollections.at(0)
+  )(directedAcyclicAsync);
+  return async (state) => {
+    const path = [firstRoot], getLastPathable = () => predicatePathable(path.at(-1)), getLastStatus = () => state[path.at(-1)].status;
+    while (getLastPathable() && getLastStatus() === "set") {
+      const edge = await lazyCollections.pipe(
+        toTraversalCandidates,
+        lazyCollections.toArray(),
+        createFindAsync(
+          async ({ predicateShouldTraverse }) => await predicateShouldTraverse(state)
         )
-      ]);
-    }
-    return predicates;
-  })(), createPredicateKeycomboMatchOptions = { ...createPredicateKeycomboDownOptions, toAliases }, matchPredicatesByKeycombo = (() => {
-    const predicates = {};
-    for (const keycombo of narrowedKeycombos) {
-      predicates[keycombo] = createPredicateKeycomboMatch$1(
-        keycombo,
-        createPredicateKeycomboMatchOptions
-      );
+      )(path);
+      path.push(edge.to);
     }
-    return predicates;
-  })(), validAliases = lazyCollections.pipe(
-    lazyCollections.flatMap(fromComboToAliases),
-    lazyCollections.unique(),
-    lazyCollections.toArray()
-  )(narrowedKeycombos), getDownCombos = () => lazyCollections.pipe(
-    lazyCollections.filter(([, predicate]) => predicate(statuses)),
-    lazyCollections.map(([keycombo]) => [keycombo, fromComboToAliases(keycombo)]),
-    lazyCollections.sort(([, aliasesA], [, aliasesB]) => aliasesB.length - aliasesA.length),
-    lazyCollections.map(([keycombo]) => keycombo),
-    lazyCollections.toArray()
-  )(downPredicatesByKeycombo), predicateValid = (event) => {
-    const aliases = toAliases(event);
-    return lazyCollections.some(
-      (validAlias) => lazyCollections.includes(validAlias)(aliases)
-    )(validAliases);
-  }, cleanup = () => {
-    window.cancelAnimationFrame(getRequest());
-  }, statuses = createKeyStatuses();
-  return {
-    narrowedKeycombos,
-    createPredicateKeycomboDownOptions,
-    downPredicatesByKeycombo,
-    createPredicateKeycomboMatchOptions,
-    matchPredicatesByKeycombo,
-    validAliases,
-    getDownCombos,
-    predicateValid,
-    cleanup,
-    statuses
+    return path;
   };
 }
 
-function toLength() {
-  return function toLengthFn(data) {
-    return [...data].length;
+function createLayers(options = {}) {
+  const toSteps = createDepthFirstSteps(options.createDepthFirstSteps);
+  return async function toLayers(directedAcyclicAsync) {
+    const layers = [];
+    for await (const { path } of toSteps(directedAcyclicAsync)) {
+      const node = path.at(-1), depth = path.length - 1;
+      (layers[depth] || (layers[depth] = [])).push(node);
+    }
+    return layers;
   };
 }
-
-const fromComboToAliasesLength = lazyCollections.pipe(
-  fromComboToAliases,
-  toLength()
-);
-
-function fromEventToKeyStatusKey({ key, code }) {
-  return lazyCollections.includes(key)(modifiers) ? { key } : { code };
+function createTree(options = {}) {
+  const toSteps = createDepthFirstSteps(options.createDepthFirstSteps);
+  return async function toTree(directedAcyclicAsync) {
+    const firstRoot = lazyCollections.pipe(
+      createRoots(),
+      lazyCollections.at(0)
+    )(directedAcyclicAsync), tree = [];
+    tree.push({
+      node: firstRoot,
+      children: []
+    });
+    for await (const { path } of toSteps(directedAcyclicAsync)) {
+      const node = path.at(-1), parent = path.at(-2);
+      if (parent) {
+        const parentTreeNode = createFind(parent)(tree);
+        if (parentTreeNode) {
+          parentTreeNode.children.push({
+            node,
+            children: []
+          });
+        }
+      }
+    }
+    return tree;
+  };
 }
-const modifiers = ["Alt", "Control", "Meta", "Shift"];
-
-function toDirection(angle, unit = "degrees") {
-  return Object.keys(directions).find((direction) => directions[direction][unit](angle));
+function createDepthFirstSteps(options = {}) {
+  return createSteps(
+    createConfigureDepthFirstSteps(options),
+    options
+  );
 }
-const directions = {
-  up: {
-    degrees: (degrees) => degrees >= 67.5 && degrees <= 112.5,
-    radians: (radians) => radians >= 0.375 * Math.PI && radians <= 0.625 * Math.PI
-  },
-  upRight: {
-    degrees: (degrees) => degrees >= 22.5 && degrees < 67.5,
-    radians: (radians) => radians >= 0.125 * Math.PI && radians < 0.375 * Math.PI
-  },
-  right: {
-    degrees: (degrees) => degrees > 337.5 && degrees <= 360 || degrees < 22.5 && degrees >= 0,
-    radians: (radians) => radians > 1.875 * Math.PI && radians <= 2 * Math.PI || radians < 0.125 * Math.PI && radians >= 0
-  },
-  downRight: {
-    degrees: (degrees) => degrees > 292.5 && degrees <= 337.5,
-    radians: (radians) => radians > 1.625 * Math.PI && radians <= 1.875 * Math.PI
-  },
-  down: {
-    degrees: (degrees) => degrees >= 247.5 && degrees <= 292.5,
-    radians: (radians) => radians >= 1.375 * Math.PI && radians <= 1.625 * Math.PI
-  },
-  downLeft: {
-    degrees: (degrees) => degrees >= 202.5 && degrees < 247.5,
-    radians: (radians) => radians >= 1.125 * Math.PI && radians < 1.375 * Math.PI
-  },
-  left: {
-    degrees: (degrees) => degrees > 157.5 && degrees < 202.5,
-    radians: (radians) => radians > 0.875 * Math.PI && radians < 1.125 * Math.PI
-  },
-  upLeft: {
-    degrees: (degrees) => degrees > 112.5 && degrees <= 157.5,
-    radians: (radians) => radians > 0.625 * Math.PI && radians <= 0.875 * Math.PI
-  }
-};
-
-function toHookApi({
-  getSequence,
-  getStatus,
-  getMetadata
-}) {
-  return {
-    sequence: getSequence(),
-    status: getStatus(),
-    metadata: getMetadata()
+function createSteps(configure, options = {}) {
+  return async function* (directedAcyclicAsync) {
+    const {
+      getSetStateValue,
+      stepFromEffect,
+      predicateSteppable,
+      predicateExhausted,
+      createPath: createPathConfig
+    } = configure(directedAcyclicAsync), { kind, root } = { ...defaultCreateStepsOptions$1, ...options }, { nodes } = directedAcyclicAsync, toPath = createPath(directedAcyclicAsync, createPathConfig), roots = lazyCollections.pipe(
+      createRoots({ kind }),
+      lazyCollections.toArray()
+    )(directedAcyclicAsync), state = {};
+    for (const node of nodes) {
+      state[node] = {
+        status: "unset",
+        value: void 0
+      };
+    }
+    let location = root || lazyCollections.at(0)(roots);
+    const path = await toPath(state);
+    yield { path, state: JSON.parse(JSON.stringify(state)) };
+    async function* toStep() {
+      if (predicateExhausted(location)) {
+        if (lazyCollections.includes(location)(roots))
+          return;
+        state[location].status = "unset";
+        delete state[location].value;
+        const path3 = await toPath(state);
+        location = path3.at(-2);
+        yield* await toStep();
+        return;
+      }
+      state[location].status = "set";
+      state[location].value = getSetStateValue(location);
+      const path2 = await toPath(state);
+      yield { path: path2, state: JSON.parse(JSON.stringify(state)) };
+      stepFromEffect(location);
+      const newLocation = path2.at(-1);
+      if (predicateSteppable(newLocation))
+        location = newLocation;
+      yield* await toStep();
+    }
+    yield* await toStep();
   };
 }
 
-function toMousePoint(event) {
-  return {
-    x: event.clientX,
-    y: event.clientY
+function createCommonAncestors(directedAcyclicAsync) {
+  const toNodeDepthFirstSteps = createNodeDepthFirstSteps(directedAcyclicAsync);
+  return async function* (a, b) {
+    for await (const { path: aPath } of toNodeDepthFirstSteps(a)) {
+      for await (const { path: bPath } of toNodeDepthFirstSteps(b)) {
+        for (let aPathIndex = aPath.length - 1; aPathIndex >= 0; aPathIndex--) {
+          for (let bPathIndex = bPath.length - 1; bPathIndex >= 0; bPathIndex--) {
+            if (aPath[aPathIndex] === bPath[bPathIndex] && !lazyCollections.includes(aPath[aPathIndex])([a, b])) {
+              yield {
+                node: aPath[aPathIndex],
+                distances: {
+                  [a]: aPath.length - aPathIndex - 1,
+                  [b]: bPath.length - bPathIndex - 1
+                }
+              };
+            }
+          }
+        }
+      }
+    }
   };
 }
-function toTouchMovePoint(event) {
-  return {
-    x: event.touches.item(0).clientX,
-    y: event.touches.item(0).clientY
+function createAncestor(directedAcyclicAsync) {
+  const toNodeDepthFirstSteps = createNodeDepthFirstSteps(directedAcyclicAsync);
+  return async function(descendant, ancestor) {
+    return await lazyCollections.pipe(
+      toNodeDepthFirstSteps,
+      lazyCollections.some(({ path }) => lazyCollections.includes(ancestor)(path))
+    )(descendant);
   };
 }
-function toTouchEndPoint(event) {
-  return {
-    x: event.changedTouches.item(0).clientX,
-    y: event.changedTouches.item(0).clientY
+function createNodeDepthFirstSteps(directedAcyclicAsync, options = {}) {
+  const toSteps = createDepthFirstSteps(options.createDepthFirstSteps);
+  return async function* (node) {
+    yield* await lazyCollections.pipe(
+      toSteps,
+      lazyCollections.filter(({ path }) => path.at(-1) === node)
+    )(directedAcyclicAsync);
   };
 }
 
-function toPolarCoordinates({ xA, xB, yA, yB }) {
-  const distance = Math.hypot(xB - xA, yB - yA), angle = Math.atan2(yA - yB, xB - xA), radians = angle >= 0 ? angle : 2 * Math.PI + angle, degrees = radians * 180 / Math.PI;
-  return {
-    distance,
-    angle: { radians, degrees }
+const defaultOptions$d = {
+  predicatesElement: 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"]),')([
+    "input:not([disabled]):not([type=hidden])",
+    "select:not([disabled])",
+    "textarea:not([disabled])",
+    "button:not([disabled])",
+    "a[href]",
+    "area[href]",
+    "summary",
+    "iframe",
+    "object",
+    "embed",
+    "audio[controls]",
+    "video[controls]",
+    "[contenteditable]",
+    "[tabindex]:not([disabled])"
+  ])
+};
+function createFocusable(order, options = {}) {
+  const { predicatesElement, tabbableSelector } = { ...defaultOptions$d, ...options }, predicateFocusable = (element) => element.matches(tabbableSelector);
+  return (element) => {
+    if (predicatesElement && predicateFocusable(element))
+      return element;
+    switch (order) {
+      case "first":
+        for (let i = 0; i < element.children.length; i++) {
+          const focusable = createFocusable(order, { predicatesElement: true })(element.children[i]);
+          if (focusable)
+            return focusable;
+        }
+        break;
+      case "last":
+        for (let i = element.children.length - 1; i > -1; i--) {
+          const focusable = createFocusable(order, { predicatesElement: true })(element.children[i]);
+          if (focusable)
+            return focusable;
+        }
+        break;
+    }
   };
 }
+function createComputedStyle(pseudoElement) {
+  return (element) => getComputedStyle(element, pseudoElement);
+}
 
-const initialMetadata$3 = {
-  times: {
-    start: 0,
-    end: 0
-  },
-  duration: 0
+const defaultOptions$c = {
+  toCode: (alias) => fromAliasToCode(alias),
+  toAliases: (descriptor) => fromKeyboardEventDescriptorToAliases(descriptor)
 };
-function storeKeyboardTimeMetadata({
-  event,
-  api,
-  getTimeMetadata,
-  getShouldStore,
-  setRequest,
-  recognize
-}) {
-  if (!getShouldStore())
-    return;
-  const { getStatus, onRecognized } = api, timeMetadata = getTimeMetadata();
-  if (!timeMetadata.times)
-    timeMetadata.times = createClone()(initialMetadata$3.times);
-  timeMetadata.times.start = Math.round(event.timeStamp);
-  timeMetadata.times.end = Math.round(event.timeStamp);
-  const storeDuration = () => {
-    const request = requestAnimationFrame((timestamp) => {
-      if (!getShouldStore())
-        return;
-      timeMetadata.times.end = Math.round(timestamp);
-      timeMetadata.duration = Math.max(0, timeMetadata.times.end - timeMetadata.times.start);
-      if (recognize) {
-        recognize(event, api);
-        if (getStatus() === "recognized")
-          onRecognized(event);
+const createKeycomboMatch$1 = (keycombo, options = {}) => {
+  const { toLonghand, toCode, toAliases: fromDescriptorToAliases } = { ...defaultOptions$c, ...options }, fromComboToAliases = createAliases({ toLonghand }), aliases = fromComboToAliases(keycombo), codes = createMap(toCode)(aliases), implicitModifierAliases = (() => {
+    const implicitModifierAliases2 = [];
+    for (const code of codes) {
+      const implicitModifier = lazyCollections.find(
+        (modifier) => code.includes(modifier)
+      )(modifiers);
+      if (implicitModifier)
+        implicitModifierAliases2.push(implicitModifier.toLowerCase());
+    }
+    return implicitModifierAliases2;
+  })();
+  return (event) => {
+    const statuses = [];
+    createSet(fromEventToKeyStatusCode(event), "down")(statuses);
+    for (const modifier of modifiers) {
+      if (event[`${modifier.toLowerCase()}Key`])
+        createSet(modifier, "down")(statuses);
+    }
+    const events = createMap(
+      ([code]) => {
+        const e = { code };
+        for (const modifier of modifiers) {
+          e[`${modifier.toLowerCase()}Key`] = event[`${modifier.toLowerCase()}Key`];
+        }
+        return e;
       }
-      storeDuration();
-    });
-    setRequest(request);
+    )(statuses);
+    return lazyCollections.every(
+      (code) => createValue(
+        code,
+        { predicateKey: createCode(code) }
+      )(statuses) === "down"
+    )(codes) && lazyCollections.every(
+      (e) => lazyCollections.pipe(
+        fromDescriptorToAliases,
+        lazyCollections.map(fromComboToAliases),
+        lazyCollections.some(
+          (longhandAliases) => lazyCollections.every(
+            (longhandAlias) => lazyCollections.includes(longhandAlias)(aliases) || lazyCollections.includes(longhandAlias)(implicitModifierAliases)
+          )(longhandAliases)
+        )
+      )(e)
+    )(events);
   };
-  storeDuration();
-}
-
-const initialMetadata$2 = {
-  points: {
-    start: { x: 0, y: 0 },
-    end: { x: 0, y: 0 }
-  }
 };
-function storePointerStartMetadata(event, api) {
-  const { getMetadata } = api, metadata = getMetadata();
-  const point = event instanceof MouseEvent ? toMousePoint(event) : toTouchMovePoint(event);
-  if (!metadata.points)
-    metadata.points = createClone()(initialMetadata$2.points);
-  metadata.points.start = point;
-  metadata.points.end = point;
+
+function createClamp(min, max) {
+  return (number) => {
+    const maxed = Math.max(number, min);
+    return Math.min(maxed, max);
+  };
+}
+function createDetermine(potentialities) {
+  const predicates = createMap(
+    ({ outcome, probability }, index) => {
+      const lowerBound = index === 0 ? 0 : lazyCollections.pipe(
+        lazyCollections.slice(0, index - 1),
+        lazyCollections.reduce(
+          (lowerBound2, { probability: probability2 }) => lowerBound2 + probability2,
+          0
+        )
+      )(potentialities), upperBound = lowerBound + probability;
+      return {
+        outcome,
+        predicate: (determinant) => determinant >= lowerBound && determinant < upperBound || determinant < 0 && index === 0 || index === predicates.length - 1
+      };
+    }
+  )(potentialities);
+  return (determinant) => lazyCollections.find(
+    ({ predicate }) => predicate(determinant)
+  )(predicates).outcome;
+}
+function createGreater(threshold) {
+  return (number) => number > threshold;
+}
+function createGreaterOrEqual(threshold) {
+  return (number) => number >= threshold;
+}
+function createLessOrEqual(threshold) {
+  return (number) => number <= threshold;
+}
+function createLess(threshold) {
+  return (number) => number < threshold;
 }
 
-const initialMetadata$1 = {
-  distance: {
-    straight: {
-      fromStart: 0,
-      fromPrevious: 0
-    },
-    horizontal: {
-      fromStart: 0,
-      fromPrevious: 0
-    },
-    vertical: {
-      fromStart: 0,
-      fromPrevious: 0
+function createValue$1(key) {
+  return (object) => object[key];
+}
+function createHas(key) {
+  return (object) => key in object;
+}
+function createKeys() {
+  return (object) => {
+    const keys = [];
+    for (const key in object) {
+      keys.push(key);
     }
-  },
-  angle: {
-    fromPrevious: { radians: 0, degrees: 0 },
-    fromStart: { radians: 0, degrees: 0 }
-  },
-  direction: {
-    fromPrevious: "up",
-    fromStart: "up"
-  }
-};
-function storePointerMoveMetadata(event, api) {
-  const { getMetadata } = api, metadata = getMetadata();
-  if (!metadata.distance) {
-    metadata.distance = createClone()(initialMetadata$1.distance);
-    metadata.angle = createClone()(initialMetadata$1.angle);
-    metadata.direction = createClone()(initialMetadata$1.direction);
-  }
-  const { x: previousX, y: previousY } = metadata.points.end, { x: startX, y: startY } = metadata.points.start, { x: newX, y: newY } = (() => {
-    if (event instanceof MouseEvent) {
-      return toMousePoint(event);
+    return keys;
+  };
+}
+function createEntries() {
+  return (object) => {
+    const entries = [];
+    for (const key in object) {
+      entries.push([key, object[key]]);
     }
-    if (event instanceof TouchEvent) {
-      if (event.type === "touchmove") {
-        return toTouchMovePoint(event);
+    return entries;
+  };
+}
+function createEvery(predicate) {
+  return (object) => {
+    for (const key in object) {
+      if (!predicate(key, object[key])) {
+        return false;
       }
-      return toTouchEndPoint(event);
     }
-  })(), { distance: distanceFromPrevious, angle: angleFromPrevious } = toPolarCoordinates({
-    xA: previousX,
-    xB: newX,
-    yA: previousY,
-    yB: newY
-  }), { distance: distanceFromStart, angle: angleFromStart } = toPolarCoordinates({
-    xA: startX,
-    xB: newX,
-    yA: startY,
-    yB: newY
-  });
-  metadata.distance.straight.fromPrevious = distanceFromPrevious;
-  metadata.distance.horizontal.fromPrevious = newX - previousX;
-  metadata.distance.vertical.fromPrevious = newY - previousY;
-  metadata.angle.fromPrevious = angleFromPrevious;
-  metadata.direction.fromPrevious = toDirection(angleFromPrevious.degrees);
-  metadata.distance.straight.fromStart = distanceFromStart;
-  metadata.distance.horizontal.fromStart = newX - startX;
-  metadata.distance.vertical.fromStart = newY - startY;
-  metadata.angle.fromStart = angleFromStart;
-  metadata.direction.fromStart = toDirection(angleFromStart.degrees);
-  metadata.points.end = { x: newX, y: newY };
+    return true;
+  };
+}
+function createSome(predicate) {
+  return (object) => {
+    for (const key in object) {
+      if (predicate(key, object[key]))
+        return true;
+    }
+    return false;
+  };
+}
+function createDeepMerge(override) {
+  return (object) => {
+    const merged = createClone()(object);
+    return merge.merge(merged, override || {});
+  };
 }
 
-const initialMetadata = {
-  times: {
-    start: 0,
-    end: 0
-  },
-  duration: 0,
-  velocity: 0
+let totalGraphNodes = -1;
+const defaultOptions$b = {
+  toId: () => `${totalGraphNodes++}`,
+  toChildren: (node) => node.children
 };
-function storePointerTimeMetadata(event, api, getShouldStore, setRequest, recognize) {
-  const { getSequence, getMetadata, getStatus, onRecognized } = api, metadata = getMetadata();
-  if (!metadata.times) {
-    metadata.times = createClone()(initialMetadata.times);
-  }
-  metadata.times.start = Math.round(event.timeStamp);
-  metadata.times.end = Math.round(event.timeStamp);
-  let previousTime = metadata.times.start;
-  const storeDuration = () => {
-    const request = requestAnimationFrame((timestamp) => {
-      if (getShouldStore()) {
-        previousTime = metadata.times.end;
-        metadata.times.end = Math.round(timestamp);
-        metadata.duration = Math.max(0, metadata.times.end - metadata.times.start);
-        const durationFromPrevious = Math.max(0, metadata.times.end - previousTime);
-        metadata.velocity = metadata.distance.straight.fromPrevious / durationFromPrevious;
-        const event2 = getSequence().at(-1);
-        recognize?.(event2, api);
-        if (getStatus() === "recognized")
-          onRecognized(event2);
-        storeDuration();
+function createGraph(options = {}) {
+  const { toId, toChildren } = { ...defaultOptions$b, ...options };
+  return function* (tree) {
+    const root = tree[0], rootId = toId(root);
+    function* toPair(node, id) {
+      const children = toChildren(node) || [];
+      for (const child of children) {
+        const childId = toId(child);
+        yield {
+          node: childId,
+          edge: { from: id, to: childId }
+        };
+        yield* toPair(child, childId);
       }
-    });
-    setRequest(request);
+    }
+    yield { node: rootId };
+    yield* toPair(root, rootId);
   };
-  storeDuration();
 }
 
-function defineGraph(nodes, edges) {
-  return { nodes, edges };
+function createSet$2(key, value, options = {}) {
+  const { predicateKey = createEqual(key) } = options;
+  return (associativeArray) => {
+    const index = lazyCollections.findIndex(
+      ([candidate]) => predicateKey(candidate)
+    )(associativeArray);
+    if (index === -1) {
+      associativeArray.push([key, value]);
+      return;
+    }
+    associativeArray[index][1] = value;
+    return associativeArray;
+  };
 }
-function defineGraphNodes(nodes) {
-  return nodes;
+function createClear$2() {
+  return (associativeArray) => {
+    associativeArray.length = 0;
+    return associativeArray;
+  };
 }
-function defineGraphEdges(edges) {
-  return edges;
+function createDelete$2(key, options = {}) {
+  const { predicateKey = createEqual(key) } = options;
+  return (associativeArray) => {
+    const index = lazyCollections.findIndex(
+      ([candidate]) => predicateKey(candidate)
+    )(associativeArray);
+    if (index === -1)
+      return associativeArray;
+    associativeArray.splice(index, 1);
+    return associativeArray;
+  };
 }
-function defineGraphNode(node) {
-  return node;
+
+function createSet$1(key, value) {
+  return (object) => {
+    object[key] = value;
+    return object;
+  };
 }
-function defineGraphEdge(from, to, predicateTraversable) {
-  return { from, to, predicateTraversable };
+function createDelete$1(key) {
+  return (object) => {
+    delete object[key];
+    return object;
+  };
 }
-function defineAsyncGraph(nodes, edges) {
-  return { nodes, edges };
+function createClear$1() {
+  return (object) => {
+    for (const key in object) {
+      delete object[key];
+    }
+    return object;
+  };
 }
-function defineAsyncGraphEdges(edges) {
-  return edges;
+
+function fromEventToKeyStatusCode({ code }) {
+  const modifier = lazyCollections.find(
+    (modifier2) => code.includes(modifier2)
+  )(modifiers);
+  return modifier || code;
+}
+const modifiers = ["Alt", "Control", "Meta", "Shift"];
+
+const createValue = createValue$2;
+function createSet(code, value) {
+  return createSet$2(code, value);
+}
+const createClear = createClear$2;
+function createDelete(code) {
+  return createDelete$2(code);
+}
+function createCode(query) {
+  return function(candidate) {
+    return query === candidate || lazyCollections.includes(query)(modifiers) && candidate.includes(query) || lazyCollections.includes(candidate)(modifiers) && query.includes(candidate);
+  };
 }
-function defineAsyncGraphEdge(from, to, predicateTraversable) {
-  return { from, to, predicateTraversable };
+const createValues = createValues$1;
+function predicateSomeKeyDown(statuses) {
+  return lazyCollections.includes("down")(createValues()(statuses));
+}
+
+const defaultOptions$a = {
+  toCode: (alias) => fromAliasToCode(alias)
+};
+const createKeycomboDown = (keycombo, options = {}) => {
+  const { toLonghand, toCode } = { ...defaultOptions$a, ...options }, codes = lazyCollections.pipe(
+    createAliases({ toLonghand }),
+    lazyCollections.map(toCode)
+  )(keycombo);
+  return (statuses) => lazyCollections.every(
+    (code) => createValue(
+      code,
+      { predicateKey: createCode(code) }
+    )(statuses) === "down"
+  )(codes);
+};
+
+function fromKeyboardEventDescriptorToAliases(event) {
+  if (event.shiftKey && event.code in aliasesByShiftCode)
+    return [aliasesByShiftCode[event.code]];
+  const withoutModifierSide = toWithoutModifierSide(event.code);
+  if (withoutModifierSide in aliasListsByModifier)
+    return aliasListsByModifier[withoutModifierSide];
+  return event.code in aliasesByCode ? [aliasesByCode[event.code]] : [event.code.match(aliasCaptureRE)?.[1].toLowerCase() || "unsupported"];
 }
+const toWithoutModifierSide = createClip(/(?:Left|Right)$/);
+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"]
+};
 
-function defineAssociativeArrayEntries(entries) {
-  return entries;
+function fromCodeToAliases(code) {
+  return fromKeyboardEventDescriptorToAliases({ code });
 }
 
-function createExceptAndOnlyEffect(type, effect, options) {
-  const { except = [], only = [] } = options;
-  if (type === "keydown" || type === "keyup") {
-    return (event) => {
-      const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => lazyCollections.some((selector) => target.matches(selector))(selectors))([only, except]) : [false, false];
-      if (matchesOnly) {
-        effect(event);
-        return;
-      }
-      if (only.length === 0 && !matchesExcept) {
-        effect(event);
-        return;
-      }
-    };
-  }
-  if (type === "click" || type === "dblclick" || type === "contextmenu" || type.startsWith("mouse")) {
-    return (event) => {
-      const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => lazyCollections.some((selector) => target.matches(selector))(selectors))([only, except]) : [false, false];
-      if (matchesOnly) {
-        effect(event);
-        return;
-      }
-      if (only.length === 0 && !matchesExcept) {
-        effect(event);
-        return;
-      }
-    };
-  }
-  if (type.startsWith("pointer")) {
-    return (event) => {
-      const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => lazyCollections.some((selector) => target.matches(selector))(selectors))([only, except]) : [false, false];
-      if (matchesOnly) {
-        effect(event);
-        return;
-      }
-      if (only.length === 0 && !matchesExcept) {
-        effect(event);
-        return;
-      }
-    };
-  }
-  return (event) => {
-    const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => lazyCollections.some((selector) => target.matches(selector))(selectors))([only, except]) : [false, false];
-    if (matchesOnly) {
-      effect(event, {});
-      return;
+const defaultOptions$9 = {
+  toCode: (alias) => fromAliasToCode(alias),
+  toAliases: (code) => fromCodeToAliases(code)
+};
+const createKeycomboMatch = (keycombo, options = {}) => {
+  const { toLonghand, toCode, toAliases } = { ...defaultOptions$9, ...options }, aliases = createAliases({ toLonghand })(keycombo), codes = lazyCollections.map(toCode)(aliases);
+  return (statuses) => lazyCollections.every(
+    (code) => createValue(
+      code,
+      { predicateKey: createCode(code) }
+    )(statuses) === "down"
+  )(codes) && lazyCollections.every(
+    ([code, value]) => value === "up" || lazyCollections.pipe(
+      toAliases,
+      lazyCollections.some((alias) => lazyCollections.includes(alias)(aliases))
+    )(code)
+  )(statuses);
+};
+
+function createKeyState({
+  keycomboOrKeycombos,
+  toLonghand,
+  toCode,
+  toAliases,
+  getRequest
+}) {
+  const fromComboToAliases = createAliases({ toLonghand }), narrowedKeycombos = createFilter(
+    (keycombo) => !lazyCollections.some(
+      (alias) => lazyCollections.includes(alias)(unsupportedAliases)
+    )(fromComboToAliases(keycombo))
+  )(Array.isArray(keycomboOrKeycombos) ? keycomboOrKeycombos : [keycomboOrKeycombos]), createKeycomboDownOptions = { toLonghand, toCode }, downPredicatesByKeycombo = (() => {
+    const predicates = [];
+    for (const keycombo of narrowedKeycombos) {
+      predicates.push([
+        keycombo,
+        createKeycomboDown(
+          keycombo,
+          createKeycomboDownOptions
+        )
+      ]);
     }
-    if (only.length === 0 && !matchesExcept) {
-      effect(event, {});
-      return;
+    return predicates;
+  })(), createKeycomboMatchOptions = { ...createKeycomboDownOptions, toAliases }, matchPredicatesByKeycombo = (() => {
+    const predicates = {};
+    for (const keycombo of narrowedKeycombos) {
+      predicates[keycombo] = createKeycomboMatch(
+        keycombo,
+        createKeycomboMatchOptions
+      );
     }
+    return predicates;
+  })(), validAliases = lazyCollections.pipe(
+    lazyCollections.flatMap(fromComboToAliases),
+    lazyCollections.unique(),
+    lazyCollections.toArray()
+  )(narrowedKeycombos), getDownCombos = () => lazyCollections.pipe(
+    lazyCollections.filter(([, predicate]) => predicate(statuses)),
+    lazyCollections.map(([keycombo]) => [keycombo, fromComboToAliases(keycombo)]),
+    lazyCollections.sort(([, aliasesA], [, aliasesB]) => aliasesB.length - aliasesA.length),
+    lazyCollections.map(([keycombo]) => keycombo),
+    lazyCollections.toArray()
+  )(downPredicatesByKeycombo), predicateValid = (event) => {
+    const aliases = toAliases(event.code);
+    return lazyCollections.some(
+      (validAlias) => lazyCollections.includes(validAlias)(aliases)
+    )(validAliases);
+  }, cleanup = () => {
+    window.cancelAnimationFrame(getRequest());
+  }, statuses = [], toStatus = (...params) => createValue(...params)(statuses), setStatus = (...params) => createSet(...params)(statuses), clearStatuses = (...params) => createClear(...params)(statuses), deleteStatus = (...params) => createDelete(...params)(statuses);
+  return {
+    narrowedKeycombos,
+    createKeycomboDownOptions,
+    downPredicatesByKeycombo,
+    createKeycomboMatchOptions,
+    matchPredicatesByKeycombo,
+    validAliases,
+    getDownCombos,
+    predicateValid,
+    cleanup,
+    statuses,
+    toStatus,
+    setStatus,
+    clearStatuses,
+    deleteStatus
   };
 }
+const unsupportedAliases = ["meta", "command", "cmd"];
+const unsupportedKeys = ["Meta"];
 
-function getDomAvailability() {
-  try {
-    return !!window ? "available" : "unavailable";
-  } catch (error) {
-    return "unavailable";
-  }
+function createAliasesLength(options) {
+  return lazyCollections.pipe(
+    createAliases(options),
+    lazyCollections.toLength()
+  );
 }
 
-function predicateArray(value) {
-  return Array.isArray(value);
-}
-function predicateUndefined(value) {
-  return value === void 0;
-}
-function predicateFunction(value) {
-  return typeof value === "function";
+function toDirection(angle, unit = "degrees") {
+  return Object.keys(directions).find((direction) => directions[direction][unit](angle));
 }
-function predicateNull(value) {
-  return value === null;
+const directions = {
+  up: {
+    degrees: (degrees) => degrees >= 67.5 && degrees <= 112.5,
+    radians: (radians) => radians >= 0.375 * Math.PI && radians <= 0.625 * Math.PI
+  },
+  upRight: {
+    degrees: (degrees) => degrees >= 22.5 && degrees < 67.5,
+    radians: (radians) => radians >= 0.125 * Math.PI && radians < 0.375 * Math.PI
+  },
+  right: {
+    degrees: (degrees) => degrees > 337.5 && degrees <= 360 || degrees < 22.5 && degrees >= 0,
+    radians: (radians) => radians > 1.875 * Math.PI && radians <= 2 * Math.PI || radians < 0.125 * Math.PI && radians >= 0
+  },
+  downRight: {
+    degrees: (degrees) => degrees > 292.5 && degrees <= 337.5,
+    radians: (radians) => radians > 1.625 * Math.PI && radians <= 1.875 * Math.PI
+  },
+  down: {
+    degrees: (degrees) => degrees >= 247.5 && degrees <= 292.5,
+    radians: (radians) => radians >= 1.375 * Math.PI && radians <= 1.625 * Math.PI
+  },
+  downLeft: {
+    degrees: (degrees) => degrees >= 202.5 && degrees < 247.5,
+    radians: (radians) => radians >= 1.125 * Math.PI && radians < 1.375 * Math.PI
+  },
+  left: {
+    degrees: (degrees) => degrees > 157.5 && degrees < 202.5,
+    radians: (radians) => radians > 0.875 * Math.PI && radians < 1.125 * Math.PI
+  },
+  upLeft: {
+    degrees: (degrees) => degrees > 112.5 && degrees <= 157.5,
+    radians: (radians) => radians > 0.625 * Math.PI && radians <= 0.875 * Math.PI
+  }
+};
+
+function toHookApi({
+  getSequence,
+  getStatus,
+  getMetadata
+}) {
+  return {
+    sequence: getSequence(),
+    status: getStatus(),
+    metadata: getMetadata()
+  };
 }
-function predicateNumber(value) {
-  return typeof value === "number";
+
+function toMousePoint(event) {
+  return {
+    x: event.clientX,
+    y: event.clientY
+  };
 }
-function predicateString(value) {
-  return typeof value === "string";
+function toTouchMovePoint(event) {
+  return {
+    x: event.touches.item(0).clientX,
+    y: event.touches.item(0).clientY
+  };
 }
-function predicateObject(value) {
-  return typeof value === "object";
+function toTouchEndPoint(event) {
+  return {
+    x: event.changedTouches.item(0).clientX,
+    y: event.changedTouches.item(0).clientY
+  };
 }
 
-class Recognizeable {
-  maxSequenceLength;
-  effects;
-  effectApi;
-  constructor(sequence, options = {}) {
-    const defaultOptions = {
-      maxSequenceLength: true,
-      effects: {}
-    };
-    this.maxSequenceLength = options?.maxSequenceLength || defaultOptions.maxSequenceLength;
-    this.effects = options?.effects || defaultOptions.effects;
-    this.resetComputedMetadata();
-    this.setSequence(sequence);
-    this.effectApi = {
-      getStatus: () => this.status,
-      getMetadata: () => this.metadata,
-      setMetadata: (metadata) => this.computedMetadata = metadata,
-      recognized: () => this.recognized(),
-      denied: () => this.denied(),
-      ready: () => this.ready()
-    };
-    this.ready();
-  }
-  computedMetadata;
-  resetComputedMetadata() {
-    this.computedMetadata = {};
-  }
-  recognized() {
-    this.computedStatus = "recognized";
-  }
-  denied() {
-    this.computedStatus = "denied";
-  }
-  computedStatus;
-  ready() {
-    this.computedStatus = "ready";
-  }
-  get sequence() {
-    return this.computedSequence;
-  }
-  set sequence(sequence) {
-    this.setSequence(sequence);
-  }
-  get status() {
-    return this.computedStatus;
-  }
-  get metadata() {
-    return this.computedMetadata;
-  }
-  computedSequence;
-  setSequence(sequence) {
-    this.computedSequence = sequence;
-    return this;
-  }
-  recognize(sequenceItem, { onRecognized } = {}) {
-    this.recognizing();
-    const type = this.toType(sequenceItem), pushSequence = (sequenceItem2) => {
-      newSequence.push(sequenceItem2);
-      if (this.maxSequenceLength !== true && newSequence.length > this.maxSequenceLength) {
-        newSequence.shift();
-      }
-    }, newSequence = [];
-    for (const sequenceItem2 of this.sequence) {
-      pushSequence(sequenceItem2);
-    }
-    pushSequence(sequenceItem);
-    this.effectApi.getSequence = () => newSequence;
-    this.effectApi.pushSequence = pushSequence;
-    this.effectApi.onRecognized = onRecognized || (() => {
-    });
-    this.effects[type]?.(sequenceItem, { ...this.effectApi });
-    switch (this.status) {
-      case "ready":
-      case "denied":
-        this.resetComputedMetadata();
-        this.setSequence([]);
-        break;
-      case "recognizing":
-      case "recognized":
-        this.setSequence(newSequence);
-        break;
-    }
-    return this;
-  }
-  recognizing() {
-    this.computedStatus = "recognizing";
-  }
-  toType(sequenceItem) {
-    if (predicateArray(sequenceItem)) {
-      if (sequenceItem[0] instanceof IntersectionObserverEntry) {
-        return "intersect";
-      }
-      if (sequenceItem[0] instanceof MutationRecord) {
-        return "mutate";
-      }
-      if (sequenceItem[0] instanceof ResizeObserverEntry) {
-        return "resize";
-      }
-    } else {
-      if (sequenceItem instanceof MediaQueryListEvent) {
-        return sequenceItem.media;
-      }
-      if ("didTimeout" in sequenceItem) {
-        return "idle";
-      }
-      return sequenceItem.type;
-    }
-  }
+function toPolarCoordinates({ xA, xB, yA, yB }) {
+  const distance = Math.hypot(xB - xA, yB - yA), angle = Math.atan2(yA - yB, xB - xA), radians = angle >= 0 ? angle : 2 * Math.PI + angle, degrees = radians * 180 / Math.PI;
+  return {
+    distance,
+    angle: { radians, degrees }
+  };
 }
 
-class Listenable {
-  computedRecognizeable;
-  recognizeableEffectsKeys;
-  computedActive;
-  constructor(type, options) {
-    if (type === "recognizeable") {
-      this.computedRecognizeable = new Recognizeable([], options?.recognizeable);
-      this.recognizeableEffectsKeys = Object.keys(options?.recognizeable?.effects);
-    }
-    this.computedActive = /* @__PURE__ */ new Set();
-    this.setType(type);
-    this.ready();
-  }
-  computedStatus;
-  ready() {
-    this.computedStatus = "ready";
-  }
-  get type() {
-    return this.computedType;
-  }
-  set type(type) {
-    this.setType(type);
-  }
-  get status() {
-    return this.computedStatus;
-  }
-  get active() {
-    return this.computedActive;
-  }
-  get recognizeable() {
-    return this.computedRecognizeable;
-  }
-  computedType;
-  implementation;
-  setType(type) {
-    this.stop();
-    this.computedType = type;
-    this.implementation = toImplementation(type);
-    return this;
+const initialMetadata$3 = {
+  times: {
+    start: 0,
+    end: 0
+  },
+  duration: 0
+};
+function storeKeyboardTimeMetadata({
+  event,
+  api,
+  getTimeMetadata,
+  getShouldStore,
+  setRequest,
+  recognize
+}) {
+  if (!getShouldStore())
+    return;
+  const { getStatus, listenInjection: { effect } } = api, timeMetadata = getTimeMetadata();
+  if (!timeMetadata.times)
+    timeMetadata.times = createClone()(initialMetadata$3.times);
+  timeMetadata.times.start = Math.round(event.timeStamp);
+  timeMetadata.times.end = Math.round(event.timeStamp);
+  const storeDuration = () => {
+    const request = requestAnimationFrame((timestamp) => {
+      if (!getShouldStore())
+        return;
+      timeMetadata.times.end = Math.round(timestamp);
+      timeMetadata.duration = Math.max(0, timeMetadata.times.end - timeMetadata.times.start);
+      if (recognize) {
+        recognize(event, api);
+        if (getStatus() === "recognized")
+          effect(event);
+      }
+      storeDuration();
+    });
+    setRequest(request);
+  };
+  storeDuration();
+}
+
+const initialMetadata$2 = {
+  points: {
+    start: { x: 0, y: 0 },
+    end: { x: 0, y: 0 }
   }
-  listen(effect, options = {}) {
-    switch (this.implementation) {
-      case "intersection":
-        this.intersectionListen(effect, options);
-        break;
-      case "mutation":
-        this.mutationListen(effect, options);
-        break;
-      case "resize":
-        this.resizeListen(effect, options);
-        break;
-      case "mediaquery":
-        this.mediaQueryListen(effect, options);
-        break;
-      case "idle":
-        this.idleListen(effect, options);
-        break;
-      case "message":
-        this.messageListen(effect, options);
-        break;
-      case "recognizeable":
-        this.recognizeableListen(effect, options);
-        break;
-      case "documentevent":
-        this.documentEventListen(effect, options);
-        break;
-      case "event":
-        this.eventListen(effect, options);
-        break;
+};
+function storePointerStartMetadata(event, api) {
+  const { getMetadata } = api, metadata = getMetadata();
+  const point = event instanceof MouseEvent ? toMousePoint(event) : toTouchMovePoint(event);
+  if (!metadata.points)
+    metadata.points = createClone()(initialMetadata$2.points);
+  metadata.points.start = point;
+  metadata.points.end = point;
+}
+
+const initialMetadata$1 = {
+  distance: {
+    straight: {
+      fromStart: 0,
+      fromPrevious: 0
+    },
+    horizontal: {
+      fromStart: 0,
+      fromPrevious: 0
+    },
+    vertical: {
+      fromStart: 0,
+      fromPrevious: 0
     }
-    this.listening();
-    return this;
-  }
-  intersectionListen(effect, options) {
-    const { target = document.querySelector("html"), observer } = options, id = new IntersectionObserver(effect, observer);
-    id.observe(target);
-    this.active.add({ target, id });
-  }
-  mutationListen(effect, options) {
-    const { target = document.querySelector("html"), observe } = options, id = new MutationObserver(effect);
-    id.observe(target, observe);
-    this.active.add({ target, id });
+  },
+  angle: {
+    fromPrevious: { radians: 0, degrees: 0 },
+    fromStart: { radians: 0, degrees: 0 }
+  },
+  direction: {
+    fromPrevious: "up",
+    fromStart: "up"
   }
-  resizeListen(effect, options) {
-    const { target = document.querySelector("html"), observe } = options, id = new ResizeObserver(effect);
-    id.observe(target, observe);
-    this.active.add({ target, id });
+};
+function storePointerMoveMetadata(event, api) {
+  const { getMetadata } = api, metadata = getMetadata();
+  if (!metadata.distance) {
+    metadata.distance = createClone()(initialMetadata$1.distance);
+    metadata.angle = createClone()(initialMetadata$1.angle);
+    metadata.direction = createClone()(initialMetadata$1.direction);
   }
-  mediaQueryListen(effect, options) {
-    const target = window.matchMedia(this.type);
-    if (predicateFunction(options.instantEffect)) {
-      options.instantEffect(target);
+  const { x: previousX, y: previousY } = metadata.points.end, { x: startX, y: startY } = metadata.points.start, { x: newX, y: newY } = (() => {
+    if (event instanceof MouseEvent) {
+      return toMousePoint(event);
     }
-    const withApi = (event) => effect(event);
-    target.addEventListener("change", withApi);
-    this.active.add({ target, id: ["change", withApi] });
-  }
-  idleListen(effect, options) {
-    const { requestIdleCallback } = options, id = window.requestIdleCallback((deadline) => effect(deadline), requestIdleCallback);
-    this.active.add({ target: window, id });
-  }
-  messageListen(effect, options) {
-    const { target = new BroadcastChannel("baleada") } = options;
-    target.addEventListener(this.type, (event) => effect(event));
-    this.active.add({ target, id: [this.type, effect] });
-  }
-  recognizeableListen(effect, options) {
-    const guardedEffect = (sequenceItem) => {
-      this.recognizeable.recognize(sequenceItem, { onRecognized: (sequenceItem2) => effect(sequenceItem2) });
-      if (this.recognizeable.status === "recognized")
-        effect(sequenceItem);
-    };
-    for (const type of this.recognizeableEffectsKeys) {
-      const listenable = new Listenable(type);
-      listenable.listen(guardedEffect, options);
-      this.active.add({ id: listenable });
+    if (event instanceof TouchEvent) {
+      if (event.type === "touchmove") {
+        return toTouchMovePoint(event);
+      }
+      return toTouchEndPoint(event);
     }
+  })(), { distance: distanceFromPrevious, angle: angleFromPrevious } = toPolarCoordinates({
+    xA: previousX,
+    xB: newX,
+    yA: previousY,
+    yB: newY
+  }), { distance: distanceFromStart, angle: angleFromStart } = toPolarCoordinates({
+    xA: startX,
+    xB: newX,
+    yA: startY,
+    yB: newY
+  });
+  metadata.distance.straight.fromPrevious = distanceFromPrevious;
+  metadata.distance.horizontal.fromPrevious = newX - previousX;
+  metadata.distance.vertical.fromPrevious = newY - previousY;
+  metadata.angle.fromPrevious = angleFromPrevious;
+  metadata.direction.fromPrevious = toDirection(angleFromPrevious.degrees);
+  metadata.distance.straight.fromStart = distanceFromStart;
+  metadata.distance.horizontal.fromStart = newX - startX;
+  metadata.distance.vertical.fromStart = newY - startY;
+  metadata.angle.fromStart = angleFromStart;
+  metadata.direction.fromStart = toDirection(angleFromStart.degrees);
+  metadata.points.end = { x: newX, y: newY };
+}
+
+const initialMetadata = {
+  times: {
+    start: 0,
+    end: 0
+  },
+  duration: 0,
+  velocity: 0
+};
+function storePointerTimeMetadata(event, api, getShouldStore, setRequest, recognize) {
+  const { getSequence, getMetadata, getStatus, listenInjection: { effect } } = api, metadata = getMetadata();
+  if (!metadata.times) {
+    metadata.times = createClone()(initialMetadata.times);
   }
-  documentEventListen(effect, options) {
-    const narrowedOptions = {
-      ...options,
-      target: document
+  metadata.times.start = Math.round(event.timeStamp);
+  metadata.times.end = Math.round(event.timeStamp);
+  let previousTime = metadata.times.start;
+  const storeDuration = () => {
+    const request = requestAnimationFrame((timestamp) => {
+      if (getShouldStore()) {
+        previousTime = metadata.times.end;
+        metadata.times.end = Math.round(timestamp);
+        metadata.duration = Math.max(0, metadata.times.end - metadata.times.start);
+        const durationFromPrevious = Math.max(0, metadata.times.end - previousTime);
+        metadata.velocity = metadata.distance.straight.fromPrevious / durationFromPrevious;
+        const event2 = getSequence().at(-1);
+        recognize?.(event2, api);
+        if (getStatus() === "recognized")
+          effect(event2);
+        storeDuration();
+      }
+    });
+    setRequest(request);
+  };
+  storeDuration();
+}
+
+function defineGraph(nodes, edges) {
+  return { nodes, edges };
+}
+function defineGraphNodes(nodes) {
+  return nodes;
+}
+function defineGraphEdges(edges) {
+  return edges;
+}
+function defineGraphNode(node) {
+  return node;
+}
+function defineGraphEdge(from, to, predicateShouldTraverse) {
+  return { from, to, predicateShouldTraverse };
+}
+function defineGraphAsync(nodes, edges) {
+  return { nodes, edges };
+}
+function defineGraphAsyncEdges(edges) {
+  return edges;
+}
+function defineGraphAsyncEdge(from, to, predicateShouldTraverse) {
+  return { from, to, predicateShouldTraverse };
+}
+
+function defineAssociativeArray(associativeArray) {
+  return associativeArray;
+}
+
+function createExceptAndOnlyEffect(type, effect, options) {
+  const { except = [], only = [] } = options;
+  if (type === "keydown" || type === "keyup") {
+    return (event) => {
+      const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => lazyCollections.some((selector) => target.matches(selector))(selectors))([only, except]) : [false, false];
+      if (matchesOnly) {
+        effect(event);
+        return;
+      }
+      if (only.length === 0 && !matchesExcept) {
+        effect(event);
+        return;
+      }
     };
-    this.eventListen(effect, narrowedOptions);
-  }
-  eventListen(effect, options) {
-    const { exceptAndOnlyEffect, effectOptions } = toAddEventListenerParams(this.type, effect, options), eventListeners = [[this.type, exceptAndOnlyEffect, ...effectOptions]];
-    this.addEventListeners(eventListeners, options);
-  }
-  addEventListeners(eventListeners, options) {
-    const { target = document } = options;
-    for (const eventListener of eventListeners) {
-      target.addEventListener(eventListener[0], eventListener[1], eventListener[2]);
-      this.active.add({ target, id: eventListener });
-    }
   }
-  listening() {
-    this.computedStatus = "listening";
-  }
-  stop(options = {}) {
-    const { target } = options;
-    switch (this.status) {
-      case "ready":
-      case void 0:
-        break;
-      default:
-        const stoppables = [...this.active].filter((active) => !target || ("target" in active ? active.target === target : false)), shouldUpdateStatus = stoppables.length === this.active.size;
-        for (const stoppable of stoppables) {
-          stop(stoppable);
-          this.active.delete(stoppable);
-        }
-        if (shouldUpdateStatus) {
-          this.stopped();
-        }
-        break;
-    }
-    return this;
+  if (type === "click" || type === "dblclick" || type === "contextmenu" || type.startsWith("mouse")) {
+    return (event) => {
+      const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => lazyCollections.some((selector) => target.matches(selector))(selectors))([only, except]) : [false, false];
+      if (matchesOnly) {
+        effect(event);
+        return;
+      }
+      if (only.length === 0 && !matchesExcept) {
+        effect(event);
+        return;
+      }
+    };
   }
-  stopped() {
-    this.computedStatus = "stopped";
+  if (type.startsWith("pointer")) {
+    return (event) => {
+      const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => lazyCollections.some((selector) => target.matches(selector))(selectors))([only, except]) : [false, false];
+      if (matchesOnly) {
+        effect(event);
+        return;
+      }
+      if (only.length === 0 && !matchesExcept) {
+        effect(event);
+        return;
+      }
+    };
   }
+  return (event) => {
+    const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => lazyCollections.some((selector) => target.matches(selector))(selectors))([only, except]) : [false, false];
+    if (matchesOnly) {
+      effect(event, {});
+      return;
+    }
+    if (only.length === 0 && !matchesExcept) {
+      effect(event, {});
+      return;
+    }
+  };
 }
-function stop(stoppable) {
-  if (stoppable.id instanceof Listenable) {
-    stoppable.id.stop();
-    return;
+
+function getDomAvailability() {
+  try {
+    return !!window ? "available" : "unavailable";
+  } catch (error) {
+    return "unavailable";
   }
-  if (lazyCollections.some((type) => observerAssertionsByType[type](stoppable.id))(["intersect", "mutate", "resize"])) {
-    const { id: id2 } = stoppable;
-    id2.disconnect();
-    return;
+}
+
+function predicateArray(value) {
+  return Array.isArray(value);
+}
+function predicateUndefined(value) {
+  return value === void 0;
+}
+function predicateFunction(value) {
+  return typeof value === "function";
+}
+function predicateNull(value) {
+  return value === null;
+}
+function predicateNumber(value) {
+  return typeof value === "number";
+}
+function predicateString(value) {
+  return typeof value === "string";
+}
+function predicateObject(value) {
+  return typeof value === "object";
+}
+
+function toInterpolated({ previous, next, progress }, options = {}) {
+  if (predicateUndefined(previous)) {
+    return next;
   }
-  if ("target" in stoppable && stoppable.target instanceof MediaQueryList) {
-    const { target: target2, id: id2 } = stoppable;
-    target2.removeEventListener(id2[0], id2[1]);
-    return;
+  if (predicateNumber(previous) && predicateNumber(next)) {
+    return (next - previous) * progress + previous;
   }
-  if (predicateNumber(stoppable.id)) {
-    const { target: target2, id: id2 } = stoppable;
-    target2.cancelIdleCallback(id2);
-    return;
+  if (predicateString(previous) && predicateString(next)) {
+    const { color: createMixOptions } = options;
+    return createMix(`${next} ${progress * 100}%`, createMixOptions)(previous);
   }
-  if ("target" in stoppable && stoppable.target instanceof BroadcastChannel) {
-    const { target: target2, id: id2 } = stoppable;
-    target2.removeEventListener(id2[0], id2[1]);
-    return;
+  if (predicateArray(previous) && predicateArray(next)) {
+    const exactSliceEnd = (next.length - previous.length) * progress + previous.length, nextIsLonger = next.length > previous.length, sliceEnd = nextIsLonger ? Math.floor(exactSliceEnd) : Math.ceil(exactSliceEnd), sliceTarget = nextIsLonger ? next : previous;
+    return createSlice(0, sliceEnd)(sliceTarget);
   }
-  const { target, id } = stoppable;
-  target.removeEventListener(id[0], id[1], id[2]);
-}
-function toImplementation(type) {
-  return lazyCollections.find((implementation) => predicatesByImplementation.get(implementation)(type))(predicatesByImplementation.keys());
-}
-const predicatesByImplementation = /* @__PURE__ */ new Map([
-  [
-    "recognizeable",
-    (type) => type === "recognizeable"
-  ],
-  [
-    "intersection",
-    (type) => type === "intersect"
-  ],
-  [
-    "mutation",
-    (type) => type === "mutate"
-  ],
-  [
-    "resize",
-    (type) => type === "resize"
-  ],
-  [
-    "mediaquery",
-    (type) => implementationREs.mediaquery.test(type)
-  ],
-  [
-    "idle",
-    (type) => type === "idle"
-  ],
-  [
-    "message",
-    (type) => type === "message" || type === "messageerror"
-  ],
-  [
-    "documentevent",
-    (type) => documentEvents.has(type)
-  ],
-  [
-    "event",
-    () => true
-  ]
-]);
-const documentEvents = /* @__PURE__ */ new Set([
-  "fullscreenchange",
-  "fullscreenerror",
-  "pointerlockchange",
-  "pointerlockerror",
-  "readystatechange",
-  "visibilitychange"
-]);
-const implementationREs = {
-  mediaquery: /^\(.+\)$/
-};
-function toAddEventListenerParams(type, effect, options) {
-  const { addEventListener, useCapture } = options, exceptAndOnlyEffect = createExceptAndOnlyEffect(type, effect, options), effectOptions = [addEventListener || useCapture];
-  return { exceptAndOnlyEffect, effectOptions };
 }
-const observerAssertionsByType = {
-  intersect: (observer) => observer instanceof IntersectionObserver,
-  mutate: (observer) => observer instanceof MutationObserver,
-  resize: (observer) => observer instanceof ResizeObserver
-};
 
 const defaultOptions$8 = {
   duration: 0,
@@ -2605,6 +3010,14 @@ const defaultOptions$8 = {
   iterations: 1,
   alternates: false
 };
+const defaultAnimateOptions = {
+  interpolate: {
+    color: {
+      method: "oklch",
+      ...defaultCreateMixOptions
+    }
+  }
+};
 class Animateable {
   initialDuration;
   iterationLimit;
@@ -2627,8 +3040,8 @@ class Animateable {
     this.iterationLimit = options?.iterations || defaultOptions$8.iterations;
     this.alternates = options?.alternates || defaultOptions$8.alternates;
     this.reversedControlPoints = fromControlPointsToReversedControlPoints(this.controlPoints);
-    this.toAnimationProgress = createToAnimationProgress(this.controlPoints);
-    this.reversedToAnimationProgress = createToAnimationProgress(this.reversedControlPoints);
+    this.toAnimationProgress = createAnimationProgress(this.controlPoints);
+    this.reversedToAnimationProgress = createAnimationProgress(this.reversedControlPoints);
     this.playCache = {};
     this.reverseCache = {};
     this.pauseCache = {};
@@ -2878,7 +3291,7 @@ class Animateable {
   computedRequest;
   createAnimate(type) {
     return (effect, options = {}) => {
-      const { interpolate: interpolateOptions } = options;
+      const { interpolate: interpolateOptions } = createDeepMerge(options)(defaultAnimateOptions);
       this.computedRequest = window.requestAnimationFrame((timestamp) => {
         this.setStartTimeAndStatus(type, timestamp);
         const timeElapsed = Math.min(timestamp - this.startTime - this.totalTimeInvisible, this.duration), timeRemaining = this.duration - timeElapsed, timeProgress = timeElapsed / this.duration, toAnimationProgress = this.getToAnimationProgress(type), animationProgress = toAnimationProgress(timeProgress);
@@ -3249,7 +3662,7 @@ function createGetEaseables(fromKeyframeToControlPoints) {
       (easeables, property) => {
         const propertyKeyframes = createFilter(({ properties: properties2 }) => properties2.hasOwnProperty(property))(keyframes), fromKeyframesToEaseables = createReduce(
           (propertyEaseables2, keyframe, index) => {
-            const previous = keyframe.properties[property], next = index === propertyKeyframes.length - 1 ? previous : propertyKeyframes[index + 1].properties[property], start = keyframe.progress, end = index === propertyKeyframes.length - 1 ? 2 : propertyKeyframes[index + 1].progress, hasCustomTiming = !!keyframe.timing, toAnimationProgress = index === propertyKeyframes.length - 1 ? () => 1 : createToAnimationProgress(fromKeyframeToControlPoints({ keyframe, index, propertyKeyframes }));
+            const previous = keyframe.properties[property], next = index === propertyKeyframes.length - 1 ? previous : propertyKeyframes[index + 1].properties[property], start = keyframe.progress, end = index === propertyKeyframes.length - 1 ? 2 : propertyKeyframes[index + 1].progress, hasCustomTiming = !!keyframe.timing, toAnimationProgress = index === propertyKeyframes.length - 1 ? () => 1 : createAnimationProgress(fromKeyframeToControlPoints({ keyframe, index, propertyKeyframes }));
             propertyEaseables2.push({
               property,
               value: { previous, next },
@@ -3302,32 +3715,10 @@ function fromControlPointsToReversedControlPoints(points) {
     { x: 1 - points[0].x, y: 1 - points[0].y }
   ];
 }
-function createToAnimationProgress(points) {
+function createAnimationProgress(points) {
   const { 0: { x: point1x, y: point1y }, 1: { x: point2x, y: point2y } } = points;
   return BezierEasing(point1x, point1y, point2x, point2y);
 }
-function toInterpolated({ previous, next, progress }, options = {}) {
-  if (predicateUndefined(previous)) {
-    return next;
-  }
-  if (predicateNumber(previous) && predicateNumber(next)) {
-    return (next - previous) * progress + previous;
-  }
-  if (predicateString(previous) && predicateString(next)) {
-    return color.mix(
-      options.colorModel,
-      {
-        start: previous,
-        end: next,
-        alpha: progress
-      }
-    ).toRgb().toRgbString();
-  }
-  if (predicateArray(previous) && predicateArray(next)) {
-    const exactSliceEnd = (next.length - previous.length) * progress + previous.length, nextIsLonger = next.length > previous.length, sliceEnd = nextIsLonger ? Math.floor(exactSliceEnd) : Math.ceil(exactSliceEnd), sliceTarget = nextIsLonger ? next : previous;
-    return createSlice(0, sliceEnd)(sliceTarget);
-  }
-}
 const linear = [
   0,
   0,
@@ -3726,7 +4117,6 @@ class Completeable {
     }
     return this;
   }
-  // TODO: Support array of selections for multi cursor editing
   computedSelection;
   setSelection(selection) {
     this.computedSelection = selection;
@@ -4104,22 +4494,32 @@ class Drawable {
   }
 }
 function toD(stroke) {
-  return createReduce((d, [x0, y0], index) => {
-    const [x1, y1] = stroke[(index + 1) % stroke.length];
-    return `${d} ${x0} ${y0} ${(x0 + x1) / 2} ${(y0 + y1) / 2}`;
-  }, `M ${stroke[0][0]} ${stroke[0][1]} Q`)(stroke) + "Z";
+  if (stroke.length < 4)
+    return "";
+  let a = stroke[0];
+  let b = stroke[1];
+  const c = stroke[2];
+  let result = `M${a[0].toFixed(2)},${a[1].toFixed(2)} Q${b[0].toFixed(2)},${b[1].toFixed(2)} ${lazyCollections.average()([b[0], c[0]]).toFixed(2)},${lazyCollections.average()([b[1], c[1]]).toFixed(2)} T`;
+  for (let i = 2; i < stroke.length - 1; i++) {
+    a = stroke[i];
+    b = stroke[i + 1];
+    result += `${lazyCollections.average()([a[0], b[0]]).toFixed(2)},${lazyCollections.average()([a[1], b[1]]).toFixed(2)} `;
+  }
+  return `${result}Z`;
 }
 function toFlattenedD(stroke) {
-  if (stroke.length === 0) {
+  if (stroke.length === 0)
     return "";
+  const faces = polygonClipping.union([stroke]);
+  const flattenedD = [];
+  for (const face of faces) {
+    for (const ring of face) {
+      flattenedD.push(toD(ring));
+    }
   }
-  const multiPolygon = polygonClipping.union([stroke]);
-  return createReduce((dFromMultiPolygon, polygon) => {
-    return dFromMultiPolygon + createReduce((dFromRing, points) => {
-      return dFromRing + toD(points);
-    }, "")(polygon);
-  }, "")(multiPolygon);
+  return toSpaceSeparated(flattenedD);
 }
+const toSpaceSeparated = lazyCollections.join(" ");
 
 class Resolveable {
   constructor(getPromise, options = {}) {
@@ -4142,20 +4542,23 @@ class Resolveable {
   get value() {
     return this.computedValue;
   }
+  get error() {
+    return this.computedError;
+  }
   computedGetPromise;
   setGetPromise(getPromise) {
     this.computedGetPromise = getPromise;
     return this;
   }
   computedValue;
-  async resolve(...args) {
+  computedError;
+  async resolve() {
     this.resolving();
     try {
-      const promises = this.getPromise(...args);
-      this.computedValue = predicateArray(promises) ? await createMapAsync(async (promise) => await promise)(promises) : await promises;
+      this.computedValue = await this.getPromise();
       this.resolved();
     } catch (error) {
-      this.computedValue = error;
+      this.computedError = error;
       this.errored();
     }
     return this;
@@ -4197,27 +4600,26 @@ class Fetchable {
   set resource(resource) {
     this.setResource(resource);
   }
+  get status() {
+    return this.computedStatus;
+  }
   computedKy;
   get ky() {
     return this.computedKy;
   }
   computedAbortController;
   get abortController() {
-    if (!this.computedAbortController) {
+    if (!this.computedAbortController)
       this.computedAbortController = new AbortController();
-    }
     return this.computedAbortController;
   }
-  get status() {
-    return this.computedStatus;
-  }
-  get response() {
-    return this.computedResponse;
-  }
   computedRetryCount = 0;
   get retryCount() {
     return this.computedRetryCount;
   }
+  get response() {
+    return this.computedResponse;
+  }
   get error() {
     return this.computedError;
   }
@@ -4289,27 +4691,27 @@ class Fetchable {
     this.computedStatus = "errored";
   }
   async get(options = {}) {
-    await this.fetch({ signal: this.abortController.signal, ...options, method: "get" });
+    await this.fetch({ ...options, method: "get" });
     return this;
   }
   async patch(options = {}) {
-    await this.fetch({ signal: this.abortController.signal, ...options, method: "patch" });
+    await this.fetch({ ...options, method: "patch" });
     return this;
   }
   async post(options = {}) {
-    await this.fetch({ signal: this.abortController.signal, ...options, method: "post" });
+    await this.fetch({ ...options, method: "post" });
     return this;
   }
   async put(options = {}) {
-    await this.fetch({ signal: this.abortController.signal, ...options, method: "put" });
+    await this.fetch({ ...options, method: "put" });
     return this;
   }
   async delete(options = {}) {
-    await this.fetch({ signal: this.abortController.signal, ...options, method: "delete" });
+    await this.fetch({ ...options, method: "delete" });
     return this;
   }
   async head(options = {}) {
-    await this.fetch({ signal: this.abortController.signal, ...options, method: "head" });
+    await this.fetch({ ...options, method: "head" });
     return this;
   }
   abort() {
@@ -4406,6 +4808,9 @@ class Grantable {
   get permission() {
     return this.computedPermission;
   }
+  get error() {
+    return this.computedError;
+  }
   get status() {
     return this.computedStatus;
   }
@@ -4415,22 +4820,23 @@ class Grantable {
     return this;
   }
   computedPermission;
-  async query() {
-    this.querying();
+  computedError;
+  async grant() {
+    this.granting();
     try {
       this.computedPermission = await navigator.permissions.query(this.descriptor);
-      this.queried();
+      this.granted();
     } catch (error) {
-      this.computedPermission = error;
+      this.computedError = error;
       this.errored();
     }
     return this;
   }
-  querying() {
-    this.computedStatus = "querying";
+  granting() {
+    this.computedStatus = "granting";
   }
-  queried() {
-    this.computedStatus = "queried";
+  granted() {
+    this.computedStatus = "granted";
   }
   errored() {
     this.computedStatus = "errored";
@@ -4626,9 +5032,6 @@ class Pickable {
   get newest() {
     return this.picks[this.picks.length - 1];
   }
-  get status() {
-    return this.computedStatus;
-  }
   get items() {
     return this.toItems(this.picks);
   }
@@ -4637,6 +5040,9 @@ class Pickable {
   get multiple() {
     return this.computedMultiple;
   }
+  get status() {
+    return this.computedStatus;
+  }
   toPossiblePicks;
   setArray(array) {
     this.computedArray = array;
@@ -4730,112 +5136,20 @@ function narrowIndices(indexOrIndices) {
 }
 const toUnique = createUnique();
 
-class Sanitizeable {
-  domPurifyConfig;
-  constructor(html, options) {
-    this.computedHtml = html;
-    this.domPurifyConfig = options;
-    this.ready();
-  }
-  computedDompurify;
-  computedStatus;
-  ready() {
-    if (getDomAvailability() === "available") {
-      this.computedDompurify = createDOMPurify();
-      this.computedDompurify.setConfig(this.domPurifyConfig);
-    }
-    this.computedStatus = "ready";
-  }
-  get html() {
-    return this.computedHtml;
-  }
-  set html(html) {
-    this.setHtml(html);
-  }
-  get dompurify() {
-    if (!this.computedDompurify && getDomAvailability() === "available") {
-      this.computedDompurify = createDOMPurify();
-      this.computedDompurify.setConfig(this.domPurifyConfig);
-    }
-    return this.computedDompurify;
-  }
-  get status() {
-    return this.computedStatus;
-  }
-  computedHtml;
-  setHtml(html) {
-    this.computedHtml = html;
-    return this;
-  }
-  sanitize() {
-    this.setHtml(this.dompurify.sanitize(this.html));
-    this.sanitized();
-    return this;
-  }
-  sanitized() {
-    this.computedStatus = "sanitized";
-  }
-}
-
-class Searchable {
-  searcherOptions;
-  computedResults;
-  constructor(candidates, options = {}) {
-    this.searcherOptions = options;
-    this.setCandidates(candidates);
-    this.computedResults = [];
-    this.ready();
-  }
-  computedStatus;
-  ready() {
-    this.computedStatus = "ready";
-  }
-  computedCandidates;
-  get candidates() {
-    return this.computedCandidates;
-  }
-  set candidates(candidates) {
-    this.setCandidates(candidates);
-  }
-  get results() {
-    return this.computedResults;
-  }
-  get searcher() {
-    return this.computedSearcher;
-  }
-  get status() {
-    return this.computedStatus;
-  }
-  computedSearcher;
-  setCandidates(candidates) {
-    this.computedCandidates = Array.from(candidates);
-    this.computedSearcher = new fastFuzzy.Searcher(candidates, this.searcherOptions);
-    return this;
-  }
-  search(query, options) {
-    this.computedResults = this.searcher.search(query, options);
-    this.searched();
-    return this;
-  }
-  searched() {
-    this.computedStatus = "searched";
-  }
-}
-
 class Shareable {
-  constructor(state, options = {}) {
-    this.setState(state);
+  constructor(shareData, options = {}) {
+    this.setShareData(shareData);
     this.ready();
   }
   computedStatus;
   ready() {
     this.computedStatus = "ready";
   }
-  get state() {
+  get shareData() {
     return this.computedState;
   }
-  set state(state) {
-    this.setState(state);
+  set shareData(shareData) {
+    this.setShareData(shareData);
   }
   get status() {
     return this.computedStatus;
@@ -4849,15 +5163,15 @@ class Shareable {
     return this.computedError;
   }
   computedState;
-  setState(state) {
-    this.computedState = state;
-    this.computedCan = new Resolveable(async () => await navigator.canShare(state));
+  setShareData(shareData) {
+    this.computedState = shareData;
+    this.computedCan = new Resolveable(async () => await navigator.canShare(shareData));
     return this;
   }
   async share() {
     this.sharing();
     try {
-      await navigator.share(this.state);
+      await navigator.share(this.shareData);
       this.shared();
     } catch (error) {
       this.computedError = error;
@@ -5007,42 +5321,62 @@ exports.Drawable = Drawable;
 exports.Fetchable = Fetchable;
 exports.Fullscreenable = Fullscreenable;
 exports.Grantable = Grantable;
+exports.Keychord = Keychord;
+exports.Keypress = Keypress;
+exports.Keyrelease = Keyrelease;
+exports.Konami = Konami;
 exports.Listenable = Listenable;
+exports.Mousepress = Mousepress;
+exports.Mouserelease = Mouserelease;
 exports.Navigateable = Navigateable;
 exports.Pickable = Pickable;
 exports.Recognizeable = Recognizeable;
 exports.Resolveable = Resolveable;
-exports.Sanitizeable = Sanitizeable;
-exports.Searchable = Searchable;
 exports.Shareable = Shareable;
 exports.Storeable = Storeable;
-exports.createAssociativeArray = createAssociativeArray;
-exports.createAsyncDirectedAcyclicPredicateAncestor = createPredicateAncestor$1;
-exports.createAsyncDirectedAcyclicToCommonAncestors = createToCommonAncestors$1;
-exports.createAsyncDirectedAcyclicToLayers = createToLayers;
-exports.createAsyncDirectedAcyclicToNodeSteps = createToNodeSteps$1;
-exports.createAsyncDirectedAcyclicToPath = createToPath$1;
-exports.createAsyncDirectedAcyclicToSteps = createToSteps$1;
-exports.createAsyncDirectedAcyclicToTree = createToTree$1;
+exports.Touchpress = Touchpress;
+exports.Touchrelease = Touchrelease;
+exports.createAssociativeArrayClear = createClear$2;
+exports.createAssociativeArrayDelete = createDelete$2;
+exports.createAssociativeArrayHas = createHas$1;
+exports.createAssociativeArrayKeys = createKeys$1;
+exports.createAssociativeArraySet = createSet$2;
+exports.createAssociativeArrayValue = createValue$2;
+exports.createAssociativeArrayValues = createValues$1;
+exports.createBreadthPathConfig = createBreadthPathConfig;
+exports.createChildren = createChildren;
 exports.createClamp = createClamp;
+exports.createClear = createClear$1;
 exports.createClip = createClip;
 exports.createClone = createClone;
+exports.createComputedStyle = createComputedStyle;
 exports.createConcat = createConcat;
-exports.createDecisionTreePredicateAncestor = createPredicateAncestor;
-exports.createDecisionTreeToCommonAncestors = createToCommonAncestors;
-exports.createDecisionTreeToNodeSteps = createToNodeSteps;
-exports.createDecisionTreeToPath = createToPath;
-exports.createDecisionTreeToSteps = createToSteps;
-exports.createDecisionTreeToTree = createToTree;
+exports.createDecisionTreeAncestor = createAncestor$1;
+exports.createDecisionTreeCommonAncestors = createCommonAncestors$1;
+exports.createDecisionTreeNodeDepthFirstSteps = createNodeDepthFirstSteps$1;
+exports.createDecisionTreePath = createPath$1;
+exports.createDecisionTreeSteps = createDepthFirstSteps$1;
+exports.createDecisionTreeTree = createTree$1;
+exports.createDeepEqual = createDeepEqual;
+exports.createDeepMerge = createDeepMerge;
+exports.createDelete = createDelete$1;
+exports.createDepthPathConfig = createDepthPathConfig;
 exports.createDetermine = createDetermine;
-exports.createDirectedAcyclicPredicateAncestor = createPredicateAncestor$2;
-exports.createDirectedAcyclicToCommonAncestors = createToCommonAncestors$2;
-exports.createDirectedAcyclicToLayers = createToLayers$1;
-exports.createDirectedAcyclicToNodeSteps = createToNodeSteps$2;
-exports.createDirectedAcyclicToPath = createToPath$2;
-exports.createDirectedAcyclicToRoots = createToRoots;
-exports.createDirectedAcyclicToSteps = createToSteps$2;
-exports.createDirectedAcyclicToTree = createToTree$2;
+exports.createDirectedAcyclicAncestor = createAncestor$2;
+exports.createDirectedAcyclicAsyncAncestor = createAncestor;
+exports.createDirectedAcyclicAsyncCommonAncestors = createCommonAncestors;
+exports.createDirectedAcyclicAsyncDepthFirstSteps = createDepthFirstSteps;
+exports.createDirectedAcyclicAsyncLayers = createLayers;
+exports.createDirectedAcyclicAsyncNodeDepthFirstSteps = createNodeDepthFirstSteps;
+exports.createDirectedAcyclicAsyncPath = createPath;
+exports.createDirectedAcyclicAsyncTree = createTree;
+exports.createDirectedAcyclicCommonAncestors = createCommonAncestors$2;
+exports.createDirectedAcyclicDepthFirstSteps = createDepthFirstSteps$2;
+exports.createDirectedAcyclicLayers = createLayers$1;
+exports.createDirectedAcyclicNodeDepthFirstSteps = createNodeDepthFirstSteps$2;
+exports.createDirectedAcyclicPath = createPath$2;
+exports.createDirectedAcyclicRoots = createRoots;
+exports.createDirectedAcyclicTree = createTree$2;
 exports.createEntries = createEntries;
 exports.createEqual = createEqual;
 exports.createEvery = createEvery;
@@ -5052,45 +5386,60 @@ exports.createFindAsync = createFindAsync;
 exports.createFindIndexAsync = createFindIndexAsync;
 exports.createFocusable = createFocusable;
 exports.createForEachAsync = createForEachAsync;
+exports.createGraph = createGraph;
+exports.createGreater = createGreater;
+exports.createGreaterOrEqual = createGreaterOrEqual;
+exports.createHas = createHas;
+exports.createIncoming = createIncoming;
+exports.createIndegree = createIndegree;
 exports.createInsert = createInsert;
 exports.createKeychord = createKeychord;
+exports.createKeycomboMatch = createKeycomboMatch$1;
 exports.createKeypress = createKeypress;
 exports.createKeyrelease = createKeyrelease;
 exports.createKeys = createKeys;
 exports.createKonami = createKonami;
+exports.createLess = createLess;
+exports.createLessOrEqual = createLessOrEqual;
 exports.createList = createList;
 exports.createMap = createMap;
 exports.createMapAsync = createMapAsync;
+exports.createMix = createMix;
 exports.createMousepress = createMousepress;
 exports.createMouserelease = createMouserelease;
-exports.createPredicateKeycomboMatch = createPredicateKeycomboMatch;
-exports.createPredicateRoot = createPredicateRoot;
+exports.createNumber = createNumber;
+exports.createOnlyChild = createOnlyChild;
+exports.createOutdegree = createOutdegree;
+exports.createOutgoing = createOutgoing;
 exports.createReduce = createReduce;
 exports.createReduceAsync = createReduceAsync;
 exports.createRemove = createRemove;
-exports.createRename = createRename;
 exports.createReorder = createReorder;
 exports.createReplace = createReplace;
+exports.createResults = createResults;
 exports.createReverse = createReverse;
+exports.createRoot = createRoot;
+exports.createSanitize = createSanitize;
+exports.createSet = createSet$1;
+exports.createShuffle = createShuffle;
+exports.createSiblings = createSiblings;
 exports.createSlice = createSlice;
 exports.createSlug = createSlug;
 exports.createSome = createSome;
 exports.createSort = createSort;
 exports.createSwap = createSwap;
-exports.createToGraph = createToGraph;
-exports.createToIncoming = createToIncoming;
-exports.createToIndegree = createToIndegree;
-exports.createToOutdegree = createToOutdegree;
-exports.createToOutgoing = createToOutgoing;
+exports.createTerminal = createTerminal;
+exports.createTotalSiblings = createTotalSiblings;
 exports.createTouchpress = createTouchpress;
 exports.createTouchrelease = createTouchrelease;
 exports.createTreeFind = createFind;
 exports.createUnique = createUnique;
-exports.defineAssociativeArrayEntries = defineAssociativeArrayEntries;
-exports.defineAsyncGraph = defineAsyncGraph;
-exports.defineAsyncGraphEdge = defineAsyncGraphEdge;
-exports.defineAsyncGraphEdges = defineAsyncGraphEdges;
+exports.createValue = createValue$1;
+exports.defineAssociativeArray = defineAssociativeArray;
 exports.defineGraph = defineGraph;
+exports.defineGraphAsync = defineGraphAsync;
+exports.defineGraphAsyncEdge = defineGraphAsyncEdge;
+exports.defineGraphAsyncEdges = defineGraphAsyncEdges;
 exports.defineGraphEdge = defineGraphEdge;
 exports.defineGraphEdges = defineGraphEdges;
 exports.defineGraphNode = defineGraphNode;
@@ -5117,6 +5466,10 @@ exports.easingsNetOutExpo = easingsNetOutExpo;
 exports.easingsNetOutQuad = easingsNetOutQuad;
 exports.easingsNetOutQuint = easingsNetOutQuint;
 exports.easingsNetOutSine = easingsNetOutSine;
+exports.fromAliasToCode = fromAliasToCode;
+exports.fromCodeToAliases = fromCodeToAliases;
+exports.fromKeyboardEventDescriptorToAliases = fromKeyboardEventDescriptorToAliases;
+exports.fromShorthandAliasToLonghandAlias = fromShorthandAliasToLonghandAlias;
 exports.linear = linear;
 exports.materialAccelerated = materialAccelerated;
 exports.materialDecelerated = materialDecelerated;