@baleada/logic 0.23.4 → 0.24.1

package/lib/index.js

@@ -1,97 +1,150 @@
 import BezierEasing from 'bezier-easing';
-import { mix } from '@snigo.dev/color';
-import { pipe, unique, map, toArray, every, some, includes, concat, filter, reduce, slice, sort, find, findIndex, join, at, flatMap, reverse as reverse$1 } from 'lazy-collections';
-import { getStroke } from 'perfect-freehand';
-import polygonClipping from 'polygon-clipping';
-import ky from 'ky';
+import { pipe, flatMap, unique, map, toArray, concat, filter, reduce, slice, sort, find, findIndex, at, some, includes, toLength, join, every, reverse as reverse$1, average } from 'lazy-collections';
+import { sortKind, Searcher } from 'fast-fuzzy';
 import createDOMPurify from 'dompurify';
-import { Searcher } from 'fast-fuzzy';
+import slugify from '@sindresorhus/slugify';
+import arrayShuffle from 'array-shuffle';
 import { klona } from 'klona';
 import { dequal } from 'dequal';
-import slugify from '@sindresorhus/slugify';
+import { merge } from 'dset/merge';
+import { getStroke } from 'perfect-freehand';
+import polygonClipping from 'polygon-clipping';
+import ky from 'ky';
 import clsx from 'clsx';
 
-function fromComboToAliases(combo) {
-  const delimiter = "+";
-  return pipe(
-    unique(),
-    map((name) => name === "" ? delimiter : name.toLowerCase()),
-    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 }) : options, searcher = new 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 pipe(
+      splitByPlus,
+      flatMap(
+        (alias) => 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.
+      unique(),
+      map((name) => name === "" ? separator : name.toLowerCase()),
+      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",
@@ -103,119 +156,6 @@ const keysByAlias = {
   shift: "Shift"
 };
 
-const defaultOptions$m = {
-  toDownKeys: (alias) => fromAliasToDownKeys(alias)
-};
-const createPredicateKeycomboDown = (keycombo, options = {}) => {
-  const { toDownKeys } = { ...defaultOptions$m, ...options }, downKeys = pipe(
-    fromComboToAliases,
-    map(toDownKeys)
-  )(keycombo);
-  return (statuses) => {
-    const predicateAliasEntriesDown = every(
-      (key) => statuses.toValue(key) === "down"
-    );
-    return 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 = map(toDownKeys)(aliases);
-  return (statuses) => {
-    const predicateAliasDown = every(
-      (key) => statuses.toValue(key) === "down"
-    );
-    return every(predicateAliasDown)(downKeys) && every(
-      ([key, value]) => value === "up" || pipe(
-        toAliases,
-        some((alias) => includes(alias)(aliases))
-      )(key)
-    )(statuses.toEntries());
-  };
-};
-
-function createClone() {
-  return (any) => {
-    return klona(any);
-  };
-}
-function createEqual(compared) {
-  return (any) => dequal(any, compared);
-}
-
 function createConcat(...arrays) {
   return (array) => pipe(
     concat(array, ...arrays),
@@ -295,6 +235,8 @@ function createReverse() {
   };
 }
 function createSlice(from, to) {
+  if (from < 0 || to && to < 0)
+    return (array) => array.slice(from, to);
   const toSliced = to ? slice(from, to - 1) : slice(from);
   return (array) => {
     return from === to ? [] : pipe(
@@ -303,6 +245,11 @@ function createSlice(from, to) {
     )(array);
   };
 }
+function createShuffle() {
+  return (array) => {
+    return arrayShuffle(array);
+  };
+}
 function createSort(compare) {
   return (array) => {
     return pipe(
@@ -311,19 +258,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 {
@@ -341,6 +288,55 @@ function createUnique() {
   )(array);
 }
 
+function createClone() {
+  return (any) => {
+    return klona(any);
+  };
+}
+function createDeepEqual(compared) {
+  return (any) => dequal(any, compared);
+}
+function createEqual(compared) {
+  return (any) => any === compared;
+}
+
+function createValue$2(key, options = {}) {
+  const { predicateKey = createEqual(key) } = options;
+  return (associativeArray) => {
+    return find(
+      ([candidate]) => predicateKey(candidate)
+    )(associativeArray)?.[1];
+  };
+}
+function createHas$1(key, options = {}) {
+  const { predicateKey = createEqual(key) } = options;
+  return (associativeArray) => {
+    return 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);
@@ -365,15 +361,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(
@@ -398,709 +385,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 : pipe(
-      slice(0, index - 1),
-      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) => 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 = 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) => pipe(
+    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: 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) => pipe(
+    at(-2),
+    createOutgoing(directedAcyclic)
+  )(path);
+  return { predicatePathable, toTraversalCandidates };
 }
 
-function createToIndegree(graph) {
-  const toIncoming = createToIncoming(graph);
-  return (node) => pipe(
-    toIncoming,
-    toLength()
-  )(node);
-}
-function createToOutdegree(graph) {
-  const toOutgoing = createToOutgoing(graph);
-  return (node) => pipe(
-    toOutgoing,
-    toLength()
-  )(node);
-}
-function createToIncoming(graph) {
-  const { edges } = graph;
-  return function* (node) {
-    yield* filter(
-      ({ to }) => to === node
-    )(edges);
-  };
-}
-function createToOutgoing(graph) {
-  const { edges } = graph;
-  return function* (node) {
-    yield* 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 = pipe(
-      createToRoots(),
-      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] && !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 pipe(
-      toNodeSteps,
-      some(({ path }) => includes(ancestor)(path))
-    )(descendant);
-  };
-}
-function createToNodeSteps$2(directedAcyclic, options = {}) {
-  const toSteps = createToSteps$2(options.createToSteps);
-  return function* (node) {
-    yield* pipe(
-      toSteps,
-      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 = pipe(
-      createToRoots({ kind }),
-      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 || at(0)(roots);
-    const path = toPath(state);
-    yield { path, state: JSON.parse(JSON.stringify(state)) };
-    function* toStep() {
-      if (predicateExhausted(location)) {
-        if (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 = pipe(
-    createToRoots(),
-    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 = pipe(
-        toOutgoing,
-        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 = pipe(
-      createToRoots(),
-      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] && !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 pipe(
-      toNodeSteps,
-      some(({ path }) => includes(ancestor)(path))
-    )(descendant);
-  };
-}
-function createToNodeSteps$1(directedAcyclic, options = {}) {
-  const toSteps = createToSteps$1(options.createToSteps);
-  return async function* (node) {
-    yield* await pipe(
-      toSteps,
-      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 = pipe(
-      createToRoots({ kind }),
-      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 || at(0)(roots);
-    const path = await toPath(state);
-    yield { path, state: JSON.parse(JSON.stringify(state)) };
-    async function* toStep() {
-      if (predicateExhausted(location)) {
-        if (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 = pipe(
-    createToRoots(),
-    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 pipe(
-        toOutgoing,
-        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 (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 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 (includes(key)(modifiers))
-          implicitModifierAliases2.push(key.toLowerCase());
-      }
-    }
-    return implicitModifierAliases2;
-  })();
-  return (event) => {
-    const statuses = createKeyStatuses(), predicateAliasDown = 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 every(predicateAliasDown)(downKeys) && every(
-      (e) => pipe(
-        toAliases,
-        some(
-          (alias) => includes(alias)(aliases) || 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 find(
-      ([candidate]) => predicateKey(candidate)
-    )(entries)?.[1];
-  };
-  const set = (key, value) => {
-    const predicateKey = createPredicateKey(key), index = 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 findIndex(
-      ([candidate]) => predicateKey(candidate)
-    )(entries) !== -1;
-  };
-  const clear = () => {
-    entries.length = 0;
-  };
-  const del = (key) => {
-    const predicateKey = createPredicateKey(key), index = 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));
@@ -1113,15 +886,15 @@ function createKeypress(keycomboOrKeycombos, options = {}) {
     ) {
       denied();
       localStatus = getStatus();
-      if (includes(event.key)(unsupportedKeys$2))
-        statuses.clear();
+      if (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({
@@ -1130,6 +903,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));
@@ -1143,23 +917,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 (includes(event.key)(unsupportedKeys$2))
-        statuses.clear();
+      if (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";
@@ -1172,7 +946,7 @@ function createKeypress(keycomboOrKeycombos, options = {}) {
   };
   const visibilitychange = (event, api) => {
     if (document.visibilityState === "hidden") {
-      statuses.clear();
+      clearStatuses();
       localStatus = "recognizing";
       cleanup();
     }
@@ -1184,45 +958,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));
@@ -1235,8 +1027,8 @@ function createKeyrelease(keycomboOrKeycombos, options = {}) {
     ) {
       denied();
       localStatus = getStatus();
-      if (includes(event.key)(unsupportedKeys$1))
-        statuses.clear();
+      if (includes(event.key)(unsupportedKeys))
+        clearStatuses();
       onDown?.(toHookApi(api));
       return;
     }
@@ -1259,21 +1051,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 (includes(event.key)(unsupportedKeys$1))
-        statuses.clear();
+      if (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;
@@ -1282,7 +1074,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();
@@ -1298,7 +1090,7 @@ function createKeyrelease(keycomboOrKeycombos, options = {}) {
   };
   const visibilitychange = (event, api) => {
     if (document.visibilityState === "hidden") {
-      statuses.clear();
+      clearStatuses();
       localStatus = "recognizing";
       cleanup();
     }
@@ -1310,50 +1102,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));
@@ -1369,8 +1175,8 @@ function createKeychord(keychord, options = {}) {
       denied();
       localStatuses[playedIndex] = getStatus();
       if (includes(event.key)(unsupportedKeys)) {
-        for (const { statuses } of keyStates)
-          statuses.clear();
+        for (const { clearStatuses } of keyStates)
+          clearStatuses();
       }
       onDown?.(toHookApi(api));
       return;
@@ -1396,30 +1202,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 (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;
@@ -1429,17 +1235,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));
   };
@@ -1449,7 +1255,7 @@ function createKeychord(keychord, options = {}) {
       denied();
       return;
     }
-    if (playedIndex === narrowedKeychord.length - 1) {
+    if (playedIndex === narrowedKeycombos.length - 1) {
       recognized();
       localStatuses[playedIndex] = "recognized";
       return;
@@ -1458,8 +1264,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;
@@ -1472,30 +1278,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;
@@ -1510,9 +1342,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) => {
@@ -1529,20 +1363,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));
   };
@@ -1552,26 +1386,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;
@@ -1587,7 +1434,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) => {
@@ -1595,10 +1443,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));
@@ -1607,7 +1455,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));
@@ -1626,8 +1475,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
 };
@@ -1639,7 +1503,7 @@ function createTouchpress(options = {}) {
     onCancel,
     onMove,
     onEnd
-  } = { ...defaultOptions$b, ...options }, cleanup = () => {
+  } = { ...defaultOptions$f, ...options }, cleanup = () => {
     window.cancelAnimationFrame(request);
   };
   let request;
@@ -1660,6 +1524,7 @@ function createTouchpress(options = {}) {
       api,
       () => totalTouches === 1,
       (newRequest) => request = newRequest,
+      // @ts-expect-error
       recognize
     );
     onStart?.(toHookApi(api));
@@ -1699,8 +1564,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
@@ -1714,7 +1594,7 @@ function createTouchrelease(options = {}) {
     onCancel,
     onMove,
     onEnd
-  } = { ...defaultOptions$a, ...options }, cleanup = () => {
+  } = { ...defaultOptions$e, ...options }, cleanup = () => {
     window.cancelAnimationFrame(request);
   };
   let request;
@@ -1728,867 +1608,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) => pipe(
+    toIncoming,
+    toLength()
+  )(node);
+}
+function createOutdegree(graph) {
+  const toOutgoing = createOutgoing(graph);
+  return (node) => pipe(
+    toOutgoing,
+    toLength()
+  )(node);
+}
+function createIncoming(graph) {
+  const { edges } = graph;
+  return function* (node) {
+    yield* filter(
+      ({ to }) => to === node
+    )(edges);
+  };
+}
+function createOutgoing(graph) {
+  const { edges } = graph;
+  return function* (node) {
+    yield* 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) => pipe(
+    toSiblings,
+    toLength()
+  )(node);
+}
+function createSiblings(graph) {
+  const { edges } = graph;
+  return function* (node) {
+    const parents = pipe(
+      filter(
+        ({ to }) => to === node
+      ),
+      map(
+        ({ from }) => from
+      )
+    )(edges);
+    for (const parent of parents) {
+      yield* pipe(
+        filter(
+          ({ from, to }) => from === parent && to !== node
+        ),
+        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 = pipe(
+    createRoots(),
+    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 = pipe(
+        toTraversalCandidates,
+        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 = pipe(
+      createRoots(),
+      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 = pipe(
+      createRoots({ kind }),
+      toArray()
+    )(directedAcyclic), state = {};
+    for (const node of nodes) {
+      state[node] = {
+        status: "unset",
+        value: void 0
+      };
+    }
+    let location = root || at(0)(roots);
+    const path = toPath(state);
+    yield { path, state: JSON.parse(JSON.stringify(state)) };
+    function* toStep() {
+      if (predicateExhausted(location)) {
+        if (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] && !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 pipe(
+      toNodeDepthFirstSteps,
+      some(({ path }) => includes(ancestor)(path))
+    )(descendant);
+  };
+}
+function createNodeDepthFirstSteps$2(directedAcyclic, options = {}) {
+  const toSteps = createDepthFirstSteps$2(options.createDepthFirstSteps);
+  return function* (node) {
+    yield* pipe(
+      toSteps,
+      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 includes("down")(statuses.toValues());
+function createPath$1(...params) {
+  return createPath$2(...params);
 }
 
-function createKeyState({
-  keycomboOrKeycombos,
-  unsupportedAliases,
-  toDownKeys,
-  toAliases,
-  getRequest
-}) {
-  const narrowedKeycombos = createFilter(
-    (keycombo) => !some(
-      (alias) => 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 = pipe(
+    createRoots(),
+    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 pipe(
+        toTraversalCandidates,
+        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 = pipe(
-    flatMap(fromComboToAliases),
-    unique(),
-    toArray()
-  )(narrowedKeycombos), getDownCombos = () => pipe(
-    filter(([, predicate]) => predicate(statuses)),
-    map(([keycombo]) => [keycombo, fromComboToAliases(keycombo)]),
-    sort(([, aliasesA], [, aliasesB]) => aliasesB.length - aliasesA.length),
-    map(([keycombo]) => keycombo),
-    toArray()
-  )(downPredicatesByKeycombo), predicateValid = (event) => {
-    const aliases = toAliases(event);
-    return some(
-      (validAlias) => 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 = pipe(
-  fromComboToAliases,
-  toLength()
-);
-
-function fromEventToKeyStatusKey({ key, code }) {
-  return includes(key)(modifiers) ? { key } : { code };
+function createTree(options = {}) {
+  const toSteps = createDepthFirstSteps(options.createDepthFirstSteps);
+  return async function toTree(directedAcyclicAsync) {
+    const firstRoot = pipe(
+      createRoots(),
+      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 = pipe(
+      createRoots({ kind }),
+      toArray()
+    )(directedAcyclicAsync), state = {};
+    for (const node of nodes) {
+      state[node] = {
+        status: "unset",
+        value: void 0
+      };
+    }
+    let location = root || at(0)(roots);
+    const path = await toPath(state);
+    yield { path, state: JSON.parse(JSON.stringify(state)) };
+    async function* toStep() {
+      if (predicateExhausted(location)) {
+        if (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] && !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 pipe(
+      toNodeDepthFirstSteps,
+      some(({ path }) => 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 pipe(
+      toSteps,
+      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: 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 = 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 every(
+      (code) => createValue(
+        code,
+        { predicateKey: createCode(code) }
+      )(statuses) === "down"
+    )(codes) && every(
+      (e) => pipe(
+        fromDescriptorToAliases,
+        map(fromComboToAliases),
+        some(
+          (longhandAliases) => every(
+            (longhandAlias) => includes(longhandAlias)(aliases) || 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 : pipe(
+        slice(0, index - 1),
+        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) => 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(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 = 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 = 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 = 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 || includes(query)(modifiers) && candidate.includes(query) || includes(candidate)(modifiers) && query.includes(candidate);
+  };
+}
+const createValues = createValues$1;
+function predicateSomeKeyDown(statuses) {
+  return includes("down")(createValues()(statuses));
 }
-function defineAsyncGraphEdge(from, to, predicateTraversable) {
-  return { from, to, predicateTraversable };
+
+const defaultOptions$a = {
+  toCode: (alias) => fromAliasToCode(alias)
+};
+const createKeycomboDown = (keycombo, options = {}) => {
+  const { toLonghand, toCode } = { ...defaultOptions$a, ...options }, codes = pipe(
+    createAliases({ toLonghand }),
+    map(toCode)
+  )(keycombo);
+  return (statuses) => 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) => 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) => 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) => 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) => 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 = map(toCode)(aliases);
+  return (statuses) => every(
+    (code) => createValue(
+      code,
+      { predicateKey: createCode(code) }
+    )(statuses) === "down"
+  )(codes) && every(
+    ([code, value]) => value === "up" || pipe(
+      toAliases,
+      some((alias) => includes(alias)(aliases))
+    )(code)
+  )(statuses);
+};
+
+function createKeyState({
+  keycomboOrKeycombos,
+  toLonghand,
+  toCode,
+  toAliases,
+  getRequest
+}) {
+  const fromComboToAliases = createAliases({ toLonghand }), narrowedKeycombos = createFilter(
+    (keycombo) => !some(
+      (alias) => 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 = pipe(
+    flatMap(fromComboToAliases),
+    unique(),
+    toArray()
+  )(narrowedKeycombos), getDownCombos = () => pipe(
+    filter(([, predicate]) => predicate(statuses)),
+    map(([keycombo]) => [keycombo, fromComboToAliases(keycombo)]),
+    sort(([, aliasesA], [, aliasesB]) => aliasesB.length - aliasesA.length),
+    map(([keycombo]) => keycombo),
+    toArray()
+  )(downPredicatesByKeycombo), predicateValid = (event) => {
+    const aliases = toAliases(event.code);
+    return some(
+      (validAlias) => 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 pipe(
+    createAliases(options),
+    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) => 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) => 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) => 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) => 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 (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 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,
@@ -2603,6 +3008,14 @@ const defaultOptions$8 = {
   iterations: 1,
   alternates: false
 };
+const defaultAnimateOptions = {
+  interpolate: {
+    color: {
+      method: "oklch",
+      ...defaultCreateMixOptions
+    }
+  }
+};
 class Animateable {
   initialDuration;
   iterationLimit;
@@ -2625,8 +3038,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 = {};
@@ -2876,7 +3289,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);
@@ -3247,7 +3660,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 },
@@ -3300,32 +3713,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 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,
@@ -3724,7 +4115,6 @@ class Completeable {
     }
     return this;
   }
-  // TODO: Support array of selections for multi cursor editing
   computedSelection;
   setSelection(selection) {
     this.computedSelection = selection;
@@ -4102,22 +4492,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)} ${average()([b[0], c[0]]).toFixed(2)},${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 += `${average()([a[0], b[0]]).toFixed(2)},${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 = join(" ");
 
 class Resolveable {
   constructor(getPromise, options = {}) {
@@ -4140,20 +4540,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;
@@ -4195,27 +4598,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;
   }
@@ -4287,27 +4689,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() {
@@ -4404,6 +4806,9 @@ class Grantable {
   get permission() {
     return this.computedPermission;
   }
+  get error() {
+    return this.computedError;
+  }
   get status() {
     return this.computedStatus;
   }
@@ -4413,22 +4818,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";
@@ -4624,9 +5030,6 @@ class Pickable {
   get newest() {
     return this.picks[this.picks.length - 1];
   }
-  get status() {
-    return this.computedStatus;
-  }
   get items() {
     return this.toItems(this.picks);
   }
@@ -4635,6 +5038,9 @@ class Pickable {
   get multiple() {
     return this.computedMultiple;
   }
+  get status() {
+    return this.computedStatus;
+  }
   toPossiblePicks;
   setArray(array) {
     this.computedArray = array;
@@ -4728,112 +5134,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 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;
@@ -4847,15 +5161,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;
@@ -4995,4 +5309,4 @@ class Storeable {
   }
 }
 
-export { Animateable, Broadcastable, Compareable, Completeable, Copyable, Delayable, Drawable, Fetchable, Fullscreenable, Grantable, Listenable, Navigateable, Pickable, Recognizeable, Resolveable, Sanitizeable, Searchable, Shareable, Storeable, createAssociativeArray, createPredicateAncestor$1 as createAsyncDirectedAcyclicPredicateAncestor, createToCommonAncestors$1 as createAsyncDirectedAcyclicToCommonAncestors, createToLayers as createAsyncDirectedAcyclicToLayers, createToNodeSteps$1 as createAsyncDirectedAcyclicToNodeSteps, createToPath$1 as createAsyncDirectedAcyclicToPath, createToSteps$1 as createAsyncDirectedAcyclicToSteps, createToTree$1 as createAsyncDirectedAcyclicToTree, createClamp, createClip, createClone, createConcat, createPredicateAncestor as createDecisionTreePredicateAncestor, createToCommonAncestors as createDecisionTreeToCommonAncestors, createToNodeSteps as createDecisionTreeToNodeSteps, createToPath as createDecisionTreeToPath, createToSteps as createDecisionTreeToSteps, createToTree as createDecisionTreeToTree, createDetermine, createPredicateAncestor$2 as createDirectedAcyclicPredicateAncestor, createToCommonAncestors$2 as createDirectedAcyclicToCommonAncestors, createToLayers$1 as createDirectedAcyclicToLayers, createToNodeSteps$2 as createDirectedAcyclicToNodeSteps, createToPath$2 as createDirectedAcyclicToPath, createToRoots as createDirectedAcyclicToRoots, createToSteps$2 as createDirectedAcyclicToSteps, createToTree$2 as createDirectedAcyclicToTree, createEntries, createEqual, createEvery, createFilter, createFilterAsync, createFindAsync, createFindIndexAsync, createFocusable, createForEachAsync, createInsert, createKeychord, createKeypress, createKeyrelease, createKeys, createKonami, createList, createMap, createMapAsync, createMousepress, createMouserelease, createPredicateKeycomboMatch, createPredicateRoot, createReduce, createReduceAsync, createRemove, createRename, createReorder, createReplace, createReverse, createSlice, createSlug, createSome, createSort, createSwap, createToGraph, createToIncoming, createToIndegree, createToOutdegree, createToOutgoing, createTouchpress, createTouchrelease, createFind as createTreeFind, createUnique, defineAssociativeArrayEntries, defineAsyncGraph, defineAsyncGraphEdge, defineAsyncGraphEdges, defineGraph, defineGraphEdge, defineGraphEdges, defineGraphNode, defineGraphNodes, easingsNetInBack, easingsNetInCirc, easingsNetInCubic, easingsNetInExpo, easingsNetInOutBack, easingsNetInOutCirc, easingsNetInOutCubic, easingsNetInOutExpo, easingsNetInOutQuad, easingsNetInOutQuint, easingsNetInOutSine, easingsNetInQuad, easingsNetInQuart, easingsNetInQuint, easingsNetInSine, easingsNetOutBack, easingsNetOutCirc, easingsNetOutCubic, easingsNetOutExpo, easingsNetOutQuad, easingsNetOutQuint, easingsNetOutSine, linear, materialAccelerated, materialDecelerated, materialStandard, toD, toFlattenedD, toMessageListenParams, verouEase, verouEaseIn, verouEaseInOut, verouEaseOut };
+export { Animateable, Broadcastable, Compareable, Completeable, Copyable, Delayable, Drawable, Fetchable, Fullscreenable, Grantable, Keychord, Keypress, Keyrelease, Konami, Listenable, Mousepress, Mouserelease, Navigateable, Pickable, Recognizeable, Resolveable, Shareable, Storeable, Touchpress, Touchrelease, createClear$2 as createAssociativeArrayClear, createDelete$2 as createAssociativeArrayDelete, createHas$1 as createAssociativeArrayHas, createKeys$1 as createAssociativeArrayKeys, createSet$2 as createAssociativeArraySet, createValue$2 as createAssociativeArrayValue, createValues$1 as createAssociativeArrayValues, createBreadthPathConfig, createChildren, createClamp, createClear$1 as createClear, createClip, createClone, createComputedStyle, createConcat, createAncestor$1 as createDecisionTreeAncestor, createCommonAncestors$1 as createDecisionTreeCommonAncestors, createNodeDepthFirstSteps$1 as createDecisionTreeNodeDepthFirstSteps, createPath$1 as createDecisionTreePath, createDepthFirstSteps$1 as createDecisionTreeSteps, createTree$1 as createDecisionTreeTree, createDeepEqual, createDeepMerge, createDelete$1 as createDelete, createDepthPathConfig, createDetermine, createAncestor$2 as createDirectedAcyclicAncestor, createAncestor as createDirectedAcyclicAsyncAncestor, createCommonAncestors as createDirectedAcyclicAsyncCommonAncestors, createDepthFirstSteps as createDirectedAcyclicAsyncDepthFirstSteps, createLayers as createDirectedAcyclicAsyncLayers, createNodeDepthFirstSteps as createDirectedAcyclicAsyncNodeDepthFirstSteps, createPath as createDirectedAcyclicAsyncPath, createTree as createDirectedAcyclicAsyncTree, createCommonAncestors$2 as createDirectedAcyclicCommonAncestors, createDepthFirstSteps$2 as createDirectedAcyclicDepthFirstSteps, createLayers$1 as createDirectedAcyclicLayers, createNodeDepthFirstSteps$2 as createDirectedAcyclicNodeDepthFirstSteps, createPath$2 as createDirectedAcyclicPath, createRoots as createDirectedAcyclicRoots, createTree$2 as createDirectedAcyclicTree, createEntries, createEqual, createEvery, createFilter, createFilterAsync, createFindAsync, createFindIndexAsync, createFocusable, createForEachAsync, createGraph, createGreater, createGreaterOrEqual, createHas, createIncoming, createIndegree, createInsert, createKeychord, createKeycomboMatch$1 as createKeycomboMatch, createKeypress, createKeyrelease, createKeys, createKonami, createLess, createLessOrEqual, createList, createMap, createMapAsync, createMix, createMousepress, createMouserelease, createNumber, createOnlyChild, createOutdegree, createOutgoing, createReduce, createReduceAsync, createRemove, createReorder, createReplace, createResults, createReverse, createRoot, createSanitize, createSet$1 as createSet, createShuffle, createSiblings, createSlice, createSlug, createSome, createSort, createSwap, createTerminal, createTotalSiblings, createTouchpress, createTouchrelease, createFind as createTreeFind, createUnique, createValue$1 as createValue, defineAssociativeArray, defineGraph, defineGraphAsync, defineGraphAsyncEdge, defineGraphAsyncEdges, defineGraphEdge, defineGraphEdges, defineGraphNode, defineGraphNodes, easingsNetInBack, easingsNetInCirc, easingsNetInCubic, easingsNetInExpo, easingsNetInOutBack, easingsNetInOutCirc, easingsNetInOutCubic, easingsNetInOutExpo, easingsNetInOutQuad, easingsNetInOutQuint, easingsNetInOutSine, easingsNetInQuad, easingsNetInQuart, easingsNetInQuint, easingsNetInSine, easingsNetOutBack, easingsNetOutCirc, easingsNetOutCubic, easingsNetOutExpo, easingsNetOutQuad, easingsNetOutQuint, easingsNetOutSine, fromAliasToCode, fromCodeToAliases, fromKeyboardEventDescriptorToAliases, fromShorthandAliasToLonghandAlias, linear, materialAccelerated, materialDecelerated, materialStandard, toD, toFlattenedD, toMessageListenParams, verouEase, verouEaseIn, verouEaseInOut, verouEaseOut };