@baleada/logic 0.22.7 → 0.23.0

package/lib/index.js

@@ -1,50 +1,55 @@
-import { reduce, pipe, unique, toArray, slice, filter, map, concat, find, findIndex, join, some, every } from 'lazy-collections';
-import slugify from '@sindresorhus/slugify';
 import BezierEasing from 'bezier-easing';
 import { mix } from '@snigo.dev/color';
+import { pipe, concat, toArray, filter, map, reduce, slice, sort, unique, find, findIndex, join, at, includes, some, every, flatMap, reverse as reverse$1 } from 'lazy-collections';
 import { getStroke } from 'perfect-freehand';
 import polygonClipping from 'polygon-clipping';
+import ky from 'ky';
 import createDOMPurify from 'dompurify';
 import { Searcher } from 'fast-fuzzy';
+import { klona } from 'klona';
+import { dequal } from 'dequal';
+import slugify from '@sindresorhus/slugify';
+import clsx from 'clsx';
 
-function createReduceAsync(accumulate, initialValue) {
-  return async (array) => {
-    return await reduce(
-      async (accumulatorPromise, item, index) => {
-        const accumulator = await accumulatorPromise;
-        return accumulate(accumulator, item, index);
-      },
-      Promise.resolve(initialValue)
-    )(array);
+function createClone() {
+  return (any) => {
+    return klona(any);
   };
 }
-function createReduce(accumulate, initialValue) {
-  return (array) => reduce(accumulate, initialValue)(array);
+function createEqual(compared) {
+  return (any) => dequal(any, compared);
 }
-function createForEachAsync(forEach) {
-  return async (array) => {
-    await createReduceAsync(async (_, item, index) => await forEach(item, index))(array);
-    return array;
-  };
+
+function createConcat(...arrays) {
+  return (array) => pipe(
+    concat(array, ...arrays),
+    toArray()
+  )();
 }
-function createMapAsync(transform) {
-  return async (array) => {
-    return await createReduceAsync(
-      async (resolvedMaps, item, index) => {
-        const transformed = await transform(item, index);
-        resolvedMaps.push(transformed);
-        return resolvedMaps;
-      },
-      []
-    )(array);
-  };
+function createFilter(predicate) {
+  return (array) => pipe(
+    filter(predicate),
+    toArray()
+  )(array);
 }
-function createFilterAsync(predicate) {
-  return async (array) => {
-    const transformedAsync = await createMapAsync(predicate)(array);
-    return createFilter((_, index) => transformedAsync[index])(array);
+function createInsert(item, index) {
+  return (array) => {
+    const withItems = createConcat(array, [item])([]);
+    return createReorder(
+      { start: array.length, itemCount: 1 },
+      index
+    )(withItems);
   };
 }
+function createMap(transform) {
+  return (array) => pipe(
+    map(transform),
+    toArray()
+  )(array);
+}
+function createReduce(accumulate, initialValue) {
+  return (array) => reduce(accumulate, initialValue)(array);
+}
 function createRemove(index) {
   return (array) => {
     return createConcat(
@@ -53,15 +58,6 @@ function createRemove(index) {
     )([]);
   };
 }
-function createInsert(item, index) {
-  return (array) => {
-    const withItems = createConcat(array, [item])([]);
-    return createReorder(
-      { start: array.length, itemCount: 1 },
-      index
-    )(withItems);
-  };
-}
 function createReorder(from, to) {
   return (array) => {
     const [itemsToMoveStartIndex, itemsToMoveCount] = predicateObject(from) ? [from.start, from.itemCount] : [from, 1], insertIndex = to;
@@ -90,8 +86,34 @@ function createReorder(from, to) {
     return array;
   };
 }
-function predicateObject(value) {
-  return typeof value === "object";
+function createReplace(index, replacement) {
+  return createMap((item, i) => i === index ? replacement : item);
+}
+function createReverse() {
+  return (array) => {
+    const reversed = [];
+    for (let i = array.length - 1; i > -1; i--) {
+      reversed.push(array[i]);
+    }
+    return reversed;
+  };
+}
+function createSlice(from, to) {
+  const toSliced = to ? slice(from, to - 1) : slice(from);
+  return (array) => {
+    return from === to ? [] : pipe(
+      toSliced,
+      toArray()
+    )(array);
+  };
+}
+function createSort(compare) {
+  return (array) => {
+    return pipe(
+      sort(compare),
+      toArray()
+    )(array);
+  };
 }
 function createSwap(indices) {
   return (array) => {
@@ -113,16 +135,7 @@ function createSwap(indices) {
         reorderTo: (array2) => array2
       };
     })();
-    return new Pipeable(array).pipe(reorderFrom, reorderTo);
-  };
-}
-function createReplace(index, item) {
-  return (array) => {
-    return createConcat(
-      createSlice(0, index)(array),
-      [item],
-      createSlice(index + 1)(array)
-    )([]);
+    return pipe(reorderFrom, reorderTo)(array);
   };
 }
 function createUnique() {
@@ -131,277 +144,1986 @@ function createUnique() {
     toArray()
   )(array);
 }
-function createSlice(from, to) {
-  return (array) => {
-    return from === to ? [] : pipe(
-      slice(from, to - 1),
-      toArray()
+
+function createFilterAsync(predicate) {
+  return async (array) => {
+    const transformedAsync = await createMapAsync(predicate)(array);
+    return createFilter((_, index) => transformedAsync[index])(array);
+  };
+}
+function createFindAsync(predicate) {
+  return async (array) => {
+    for (let i = 0; i < array.length; i++) {
+      const item = array[i], is = await predicate(item, i);
+      if (is)
+        return item;
+    }
+  };
+}
+function createFindIndexAsync(predicate) {
+  return async (array) => {
+    for (let i = 0; i < array.length; i++) {
+      const item = array[i], is = await predicate(item, i);
+      if (is)
+        return i;
+    }
+  };
+}
+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(
+      async (resolvedMaps, item, index) => {
+        const transformed = await transform(item, index);
+        resolvedMaps.push(transformed);
+        return resolvedMaps;
+      },
+      []
     )(array);
   };
 }
-function createFilter(predicate) {
-  return (array) => pipe(
-    filter(predicate),
-    toArray()
-  )(array);
+function createReduceAsync(accumulate, initialValue) {
+  return async (array) => {
+    return await reduce(
+      async (accumulatorPromise, item, index) => {
+        const accumulator = await accumulatorPromise;
+        return accumulate(accumulator, item, index);
+      },
+      Promise.resolve(initialValue)
+    )(array);
+  };
 }
-function createMap(transform) {
-  return (array) => pipe(
-    map(transform),
-    toArray()
-  )(array);
+
+function createClip(required) {
+  return (string) => {
+    return string.replace(required, "");
+  };
 }
-function createConcat(...arrays) {
-  return (array) => pipe(
-    concat(array, ...arrays),
-    toArray()
-  )();
+function createSlug(options) {
+  return (string) => {
+    return slugify(string, options);
+  };
 }
-function createReverse() {
-  return (array) => {
-    const reversed = [];
-    for (let i = array.length - 1; i > -1; i--) {
-      reversed.push(array[i]);
+
+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 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;
+  };
+}
+
+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);
+  };
+}
+
+const defaultOptions$m = {
+  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$m, ...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 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
+                }
+              };
+            }
+          }
+        }
+      }
+    }
+  };
+}
+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);
+    };
+    for (const node of nodes) {
+      state[node] = {
+        status: "unset",
+        metadata: toUnsetMetadata(node)
+      };
+    }
+    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;
+      }
+      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;
+    }
+  };
+}
+
+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: []
+          });
+        }
+      }
+    }
+    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
+                }
+              };
+            }
+          }
+        }
+      }
+    }
+  };
+}
+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)
+      };
+    }
+    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);
+    }
+    return path;
+  };
+}
+
+const defaultCreateToStepsOptions = {
+  priorityBranch: false,
+  kind: "directed acyclic"
+};
+function createToTree(options = {}) {
+  const withDefaults = {
+    ...options,
+    createToSteps: {
+      ...defaultCreateToStepsOptions,
+      ...options.createToSteps
+    }
+  };
+  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
+    }
+  };
+  return createToNodeSteps$2(
+    decisionTree,
+    {
+      ...withDefaults,
+      createToSteps: toCreateDirectedAcyclicToStepsOptions(withDefaults.createToSteps)
+    }
+  );
+}
+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 createList() {
+  return (...classValues) => clsx(...classValues);
+}
+
+const defaultOptions$l = {
+  toId: (node) => node.id,
+  toChildren: (node) => node.children
+};
+function createToGraph(options = {}) {
+  const { toId, toChildren } = { ...defaultOptions$l, ...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);
+  };
+}
+
+const defaultOptions$k = {
+  toKey: (alias) => fromAliasToKeyStatusKey(alias)
+};
+const createPredicateKeycomboMatch$1 = (keycombo, options = {}) => {
+  const { toKey } = { ...defaultOptions$k, ...options }, keys = pipe(
+    fromComboToAliases,
+    map(toKey)
+  )(keycombo);
+  return (event) => {
+    const { toValue, set } = createKeyStatuses();
+    set(fromEventToKeyStatusKey(event), "down");
+    for (const modifier of modifiers) {
+      if (event[`${modifier.toLowerCase()}Key`])
+        set({ key: modifier }, "down");
+    }
+    return every(pipe(
+      toValue,
+      predicateDown
+    ))(keys);
+  };
+};
+
+const defaultOptions$j = {
+  initial: [],
+  createPredicateKey: (query) => (candidate) => query === candidate
+};
+function createAssociativeArray(options = {}) {
+  const { initial, createPredicateKey } = { ...defaultOptions$j, ...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$i = {
+  minDuration: 0,
+  preventsDefaultUnlessDenied: true,
+  toKey: (alias) => fromAliasToKeyStatusKey(alias),
+  toAliases: (event) => fromEventToAliases(event)
+};
+function createKeypress(keycomboOrKeycombos, options = {}) {
+  const {
+    minDuration,
+    preventsDefaultUnlessDenied,
+    toKey,
+    toAliases,
+    onDown,
+    onUp,
+    onVisibilitychange
+  } = { ...defaultOptions$i, ...options }, {
+    matchPredicatesByKeycombo,
+    getDownCombos,
+    predicateValid,
+    cleanup,
+    statuses
+  } = createKeyState({
+    keycomboOrKeycombos,
+    unsupportedAliases: unsupportedAliases$2,
+    toKey,
+    toAliases,
+    getRequest: () => request
+  });
+  let request;
+  let localStatus;
+  const keydown = (event, api) => {
+    const { denied, getStatus } = api, key = fromEventToKeyStatusKey(event);
+    if (statuses.toValue(key) === "down") {
+      onDown?.(toHookApi(api));
+      return;
+    }
+    statuses.set(key, "down");
+    if (localStatus === "denied") {
+      denied();
+      onDown?.(toHookApi(api));
+      return;
+    }
+    const downCombos = getDownCombos();
+    if (
+      // NOT BUILDING VALID COMBO
+      !predicateValid(event) || downCombos.length > 1 && fromComboToAliasesLength(downCombos[0]) === fromComboToAliasesLength(downCombos[1])
+    ) {
+      denied();
+      localStatus = getStatus();
+      if (includes(event.key)(unsupportedKeys$2))
+        statuses.clear();
+      onDown?.(toHookApi(api));
+      return;
+    }
+    if (preventsDefaultUnlessDenied)
+      event.preventDefault();
+    const { getMetadata } = api, metadata = getMetadata();
+    metadata.pressed = downCombos[0];
+    localStatus = "recognizing";
+    cleanup();
+    storeKeyboardTimeMetadata({
+      event,
+      api,
+      getTimeMetadata: getMetadata,
+      getShouldStore: () => downCombos.length && getDownCombos()[0] === downCombos[0],
+      setRequest: (newRequest) => request = newRequest,
+      recognize
+    });
+    onDown?.(toHookApi(api));
+  };
+  const recognize = (event, api) => {
+    const { getMetadata, recognized } = api, metadata = getMetadata();
+    if (metadata.duration >= minDuration) {
+      recognized();
+      localStatus = "recognized";
+      return;
+    }
+  };
+  const keyup = (event, api) => {
+    const { denied } = api, key = fromEventToKeyStatusKey(event);
+    if (localStatus === "denied") {
+      denied();
+      if (includes(event.key)(unsupportedKeys$2))
+        statuses.clear();
+      else
+        statuses.delete(key);
+      if (!predicateSomeKeyDown(statuses))
+        localStatus = "recognizing";
+      onUp?.(toHookApi(api));
+      return;
+    }
+    statuses.delete(key);
+    const downCombos = getDownCombos(), matches = matchPredicatesByKeycombo[downCombos[0]]?.(statuses);
+    if (downCombos.length && matches) {
+      const { getMetadata } = api, metadata = getMetadata();
+      metadata.pressed = downCombos[0];
+      if (preventsDefaultUnlessDenied)
+        event.preventDefault();
+      localStatus = "recognizing";
+      onUp?.(toHookApi(api));
+      return;
+    }
+    denied();
+    cleanup();
+    onUp?.(toHookApi(api));
+  };
+  const visibilitychange = (event, api) => {
+    if (document.visibilityState === "hidden") {
+      statuses.clear();
+      localStatus = "recognizing";
+      cleanup();
+    }
+    onVisibilitychange?.(toHookApi(api));
+  };
+  return {
+    keydown,
+    keyup,
+    visibilitychange
+  };
+}
+const unsupportedAliases$2 = ["meta", "command", "cmd"];
+const unsupportedKeys$2 = ["Meta"];
+
+const defaultOptions$h = {
+  minDuration: 0,
+  preventsDefaultUnlessDenied: true,
+  toKey: (alias) => fromAliasToKeyStatusKey(alias),
+  toAliases: (event) => fromEventToAliases(event)
+};
+function createKeyrelease(keycomboOrKeycombos, options = {}) {
+  const {
+    minDuration,
+    preventsDefaultUnlessDenied,
+    toKey,
+    toAliases,
+    onDown,
+    onUp,
+    onVisibilitychange
+  } = { ...defaultOptions$h, ...options }, {
+    matchPredicatesByKeycombo,
+    getDownCombos,
+    predicateValid,
+    cleanup,
+    statuses
+  } = createKeyState({
+    keycomboOrKeycombos,
+    unsupportedAliases: unsupportedAliases$1,
+    toKey,
+    toAliases,
+    getRequest: () => request
+  });
+  let request, localStatus;
+  const keydown = (event, api) => {
+    const { denied, getStatus } = api, key = fromEventToKeyStatusKey(event);
+    if (statuses.toValue(key) === "down") {
+      onDown?.(toHookApi(api));
+      return;
+    }
+    statuses.set(key, "down");
+    if (localStatus === "denied") {
+      denied();
+      onDown?.(toHookApi(api));
+      return;
+    }
+    const downCombos = getDownCombos();
+    if (
+      // NOT BUILDING VALID COMBO
+      !predicateValid(event) || downCombos.length > 1 && fromComboToAliasesLength(downCombos[0]) === fromComboToAliasesLength(downCombos[1])
+    ) {
+      denied();
+      localStatus = getStatus();
+      if (includes(event.key)(unsupportedKeys$1))
+        statuses.clear();
+      onDown?.(toHookApi(api));
+      return;
+    }
+    if (preventsDefaultUnlessDenied)
+      event.preventDefault();
+    const { getMetadata } = api;
+    localStatus = "recognizing";
+    cleanup();
+    storeKeyboardTimeMetadata({
+      event,
+      api,
+      getTimeMetadata: getMetadata,
+      getShouldStore: () => downCombos.length && getDownCombos()[0] === downCombos[0],
+      setRequest: (newRequest) => request = newRequest
+    });
+    onDown?.(toHookApi(api));
+  };
+  const keyup = (event, api) => {
+    const {
+      getStatus,
+      getMetadata,
+      denied
+    } = api, metadata = getMetadata(), key = fromEventToKeyStatusKey(event);
+    if (["denied", "recognized"].includes(localStatus)) {
+      if (localStatus === "denied")
+        denied();
+      if (includes(event.key)(unsupportedKeys$1))
+        statuses.clear();
+      else
+        statuses.delete(key);
+      if (!predicateSomeKeyDown(statuses))
+        localStatus = "recognizing";
+      onUp?.(toHookApi(api));
+      return;
+    }
+    const downCombos = getDownCombos(), matches = matchPredicatesByKeycombo[downCombos[0]]?.(statuses);
+    statuses.delete(key);
+    if (!downCombos.length || !matches) {
+      onUp?.(toHookApi(api));
+      return;
+    }
+    recognize(event, api);
+    const status = getStatus();
+    if (status === "recognized") {
+      localStatus = status;
+      metadata.released = downCombos[0];
+    }
+    if (preventsDefaultUnlessDenied)
+      event.preventDefault();
+    onUp?.(toHookApi(api));
+  };
+  const recognize = (event, api) => {
+    const { getMetadata, recognized, denied } = api, metadata = getMetadata();
+    if (metadata.duration < minDuration) {
+      denied();
+      return;
+    }
+    recognized();
+  };
+  const visibilitychange = (event, api) => {
+    if (document.visibilityState === "hidden") {
+      statuses.clear();
+      localStatus = "recognizing";
+      cleanup();
+    }
+    onVisibilitychange?.(toHookApi(api));
+  };
+  return {
+    keydown,
+    keyup,
+    visibilitychange
+  };
+}
+const unsupportedAliases$1 = ["meta", "command", "cmd"];
+const unsupportedKeys$1 = ["Meta"];
+
+const defaultOptions$g = {
+  minDuration: 0,
+  maxInterval: 5e3,
+  // VS Code default
+  preventsDefaultUnlessDenied: true,
+  toKey: (alias) => fromAliasToKeyStatusKey(alias),
+  toAliases: (event) => fromEventToAliases(event)
+};
+function createKeychord(keychord, options = {}) {
+  const {
+    minDuration,
+    maxInterval,
+    preventsDefaultUnlessDenied,
+    toKey,
+    toAliases,
+    onDown,
+    onUp,
+    onVisibilitychange
+  } = { ...defaultOptions$g, ...options }, narrowedKeychord = keychord.split(" "), keyStates = createMap((keycombo) => createKeyState({
+    keycomboOrKeycombos: keycombo,
+    unsupportedAliases,
+    toKey,
+    toAliases,
+    getRequest: () => request
+  }))(narrowedKeychord), localStatuses = createMap(
+    () => "recognizing"
+  )(keyStates);
+  let request, playedIndex = 0;
+  const keydown = (event, api) => {
+    const { denied, getStatus } = api, key = fromEventToKeyStatusKey(event);
+    if (keyStates[playedIndex].statuses.toValue(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);
+      }
+    }
+    keyStates[playedIndex].statuses.set(key, "down");
+    if (localStatuses[playedIndex] === "denied") {
+      denied();
+      onDown?.(toHookApi(api));
+      return;
+    }
+    const { getMetadata } = api, metadata = getMetadata(), downCombos = keyStates[playedIndex].getDownCombos();
+    if (playedIndex === 0)
+      metadata.played = [];
+    if (
+      // NOT BUILDING VALID COMBO
+      !keyStates[playedIndex].predicateValid(event) || downCombos.length > 1 && fromComboToAliasesLength(downCombos[0]) === fromComboToAliasesLength(downCombos[1]) || playedIndex > 0 && event.timeStamp - metadata.played[playedIndex - 1].times.end > maxInterval
+    ) {
+      denied();
+      localStatuses[playedIndex] = getStatus();
+      if (includes(event.key)(unsupportedKeys)) {
+        for (const { statuses } of keyStates)
+          statuses.clear();
+      }
+      onDown?.(toHookApi(api));
+      return;
+    }
+    if (preventsDefaultUnlessDenied)
+      event.preventDefault();
+    localStatuses[playedIndex] = "recognizing";
+    keyStates[playedIndex].cleanup();
+    storeKeyboardTimeMetadata({
+      event,
+      api,
+      getTimeMetadata: () => {
+        const metadata2 = getMetadata();
+        return metadata2.played[playedIndex] || (metadata2.played[playedIndex] = {});
+      },
+      getShouldStore: () => downCombos.length && keyStates[playedIndex].getDownCombos()[0] === downCombos[0],
+      setRequest: (newRequest) => request = newRequest
+    });
+    onDown?.(toHookApi(api));
+  };
+  const keyup = (event, api) => {
+    const {
+      getStatus,
+      getMetadata,
+      denied
+    } = api, metadata = getMetadata(), key = fromEventToKeyStatusKey(event);
+    if (["denied", "recognized"].includes(localStatuses[playedIndex])) {
+      if (localStatuses[playedIndex] === "denied")
+        denied();
+      for (const { statuses } of keyStates) {
+        if (includes(event.key)(unsupportedKeys))
+          statuses.clear();
+        else
+          statuses.delete(key);
+      }
+      if (!predicateSomeKeyDown(keyStates[playedIndex].statuses)) {
+        if (localStatuses[playedIndex] === "denied" || playedIndex === narrowedKeychord.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();
+        }
+      }
+      onUp?.(toHookApi(api));
+      return;
+    }
+    const downCombos = keyStates[playedIndex].getDownCombos(), matches = keyStates[playedIndex].matchPredicatesByKeycombo[downCombos[0]]?.(keyStates[playedIndex].statuses);
+    keyStates[playedIndex].statuses.delete(key);
+    if (!downCombos.length || !matches) {
+      onUp?.(toHookApi(api));
+      return;
+    }
+    recognize(event, api);
+    const status = getStatus();
+    if (status === "recognizing" && localStatuses[playedIndex] === "recognized" || status === "recognized") {
+      metadata.played[playedIndex] = {
+        ...metadata.played[playedIndex],
+        released: downCombos[0]
+      };
+    }
+    if (preventsDefaultUnlessDenied)
+      event.preventDefault();
+    if (playedIndex === narrowedKeychord.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();
+    }
+    onUp?.(toHookApi(api));
+  };
+  const recognize = (event, api) => {
+    const { getMetadata, recognized, denied } = api, metadata = getMetadata();
+    if (metadata.played[playedIndex].duration < minDuration) {
+      denied();
+      return;
+    }
+    if (playedIndex === narrowedKeychord.length - 1) {
+      recognized();
+      localStatuses[playedIndex] = "recognized";
+      return;
+    }
+    localStatuses[playedIndex] = "recognized";
+  };
+  const visibilitychange = (event, api) => {
+    if (document.visibilityState === "hidden") {
+      for (const { statuses } of keyStates)
+        statuses.clear();
+      localStatuses[playedIndex] = "recognizing";
+      keyStates[playedIndex].cleanup();
+      playedIndex = 0;
+    }
+    onVisibilitychange?.(toHookApi(api));
+  };
+  return {
+    keydown,
+    keyup,
+    visibilitychange
+  };
+}
+const unsupportedAliases = ["meta", "command", "cmd"];
+const unsupportedKeys = ["Meta"];
+
+const defaultOptions$f = {
+  minDuration: 0,
+  minDistance: 0,
+  getMousemoveTarget: (event) => event.target
+};
+function createMousepress(options = {}) {
+  const {
+    minDuration,
+    minDistance,
+    getMousemoveTarget,
+    onDown,
+    onLeave,
+    onMove,
+    onUp
+  } = { ...defaultOptions$f, ...options }, cleanup = (event) => {
+    window.cancelAnimationFrame(request);
+    getMousemoveTarget(event).removeEventListener("mousemove", mousemoveEffect);
+  };
+  let request;
+  let mousemoveEffect;
+  let mouseStatus;
+  const mousedown = (event, api) => {
+    mouseStatus = "down";
+    mousemoveEffect = (event2) => mousemove(event2, api);
+    storePointerStartMetadata(event, api);
+    storePointerMoveMetadata(event, api);
+    storePointerTimeMetadata(
+      event,
+      api,
+      () => mouseStatus === "down",
+      (newRequest) => request = newRequest,
+      recognize
+    );
+    getMousemoveTarget(event).addEventListener("mousemove", mousemoveEffect);
+    onDown?.(toHookApi(api));
+  };
+  const mousemove = (event, api) => {
+    storePointerMoveMetadata(event, api);
+    recognize(event, api);
+    onMove?.(toHookApi(api));
+  };
+  const recognize = (event, api) => {
+    const { getMetadata, recognized } = api, metadata = getMetadata();
+    if (metadata.duration >= minDuration && metadata.distance.straight.fromStart >= minDistance) {
+      recognized();
+    }
+  };
+  const mouseleave = (event, api) => {
+    const { denied } = api;
+    if (mouseStatus === "down") {
+      denied();
+      cleanup(event);
+      mouseStatus = "leave";
+    }
+    onLeave?.(toHookApi(api));
+  };
+  const mouseup = (event, api) => {
+    const { denied } = api;
+    if (mouseStatus !== "down")
+      return;
+    denied();
+    cleanup(event);
+    mouseStatus = "up";
+    onUp?.(toHookApi(api));
+  };
+  return {
+    mousedown,
+    mouseleave,
+    mouseup
+  };
+}
+
+const defaultOptions$e = {
+  minDuration: 0,
+  minDistance: 0,
+  minVelocity: 0,
+  getMousemoveTarget: (event) => event.target
+};
+function createMouserelease(options = {}) {
+  const {
+    minDuration,
+    minDistance,
+    minVelocity,
+    getMousemoveTarget,
+    onDown,
+    onLeave,
+    onMove,
+    onUp
+  } = { ...defaultOptions$e, ...options }, cleanup = (event) => {
+    window.cancelAnimationFrame(request);
+    getMousemoveTarget(event).removeEventListener("mousemove", mousemoveEffect);
+  };
+  let request;
+  let mousemoveEffect;
+  let mouseStatus;
+  const mousedown = (event, api) => {
+    mouseStatus = "down";
+    mousemoveEffect = (event2) => mousemove(event2, api);
+    storePointerStartMetadata(event, api);
+    storePointerMoveMetadata(event, api);
+    storePointerTimeMetadata(
+      event,
+      api,
+      () => mouseStatus === "down",
+      (newRequest) => request = newRequest
+    );
+    getMousemoveTarget(event).addEventListener("mousemove", mousemoveEffect);
+    onDown?.(toHookApi(api));
+  };
+  const mousemove = (event, api) => {
+    storePointerMoveMetadata(event, api);
+    onMove?.(toHookApi(api));
+  };
+  const mouseleave = (event, api) => {
+    const { denied } = api;
+    if (mouseStatus === "down") {
+      denied();
+      cleanup(event);
+      mouseStatus = "leave";
+    }
+    onLeave?.(toHookApi(api));
+  };
+  const mouseup = (event, api) => {
+    if (mouseStatus !== "down")
+      return;
+    storePointerMoveMetadata(event, api);
+    cleanup(event);
+    mouseStatus = "up";
+    recognize(event, api);
+    onUp?.(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 {
+    mousedown,
+    mouseleave,
+    mouseup
+  };
+}
+
+const defaultOptions$d = {
+  minDuration: 0,
+  minDistance: 0
+};
+function createTouchpress(options = {}) {
+  const {
+    minDuration,
+    minDistance,
+    onStart,
+    onCancel,
+    onMove,
+    onEnd
+  } = { ...defaultOptions$d, ...options }, cleanup = () => {
+    window.cancelAnimationFrame(request);
+  };
+  let request;
+  let totalTouches = 0;
+  const touchstart = (event, api) => {
+    const { denied } = api;
+    totalTouches++;
+    if (totalTouches > 1) {
+      cleanup();
+      denied();
+      onStart?.(toHookApi(api));
+      return;
+    }
+    storePointerStartMetadata(event, api);
+    storePointerMoveMetadata(event, api);
+    storePointerTimeMetadata(
+      event,
+      api,
+      () => totalTouches === 1,
+      (newRequest) => request = newRequest,
+      recognize
+    );
+    onStart?.(toHookApi(api));
+  };
+  const touchmove = (event, api) => {
+    const { getStatus } = api;
+    if (getStatus() !== "denied") {
+      storePointerMoveMetadata(event, api);
+      recognize(event, api);
+    }
+    onMove?.(toHookApi(api));
+  };
+  const recognize = (event, api) => {
+    const { getMetadata, recognized } = api, metadata = getMetadata();
+    if (metadata.duration >= minDuration && metadata.distance.straight.fromStart >= minDistance) {
+      recognized();
+    }
+  };
+  const touchcancel = (event, api) => {
+    const { denied } = api;
+    cleanup();
+    denied();
+    totalTouches--;
+    onCancel?.(toHookApi(api));
+  };
+  const touchend = (event, api) => {
+    const { denied } = api;
+    cleanup();
+    denied();
+    totalTouches--;
+    onEnd?.(toHookApi(api));
+  };
+  return {
+    touchstart,
+    touchmove,
+    touchcancel,
+    touchend
+  };
+}
+
+const defaultOptions$c = {
+  minDuration: 0,
+  minDistance: 0,
+  minVelocity: 0
+};
+function createTouchrelease(options = {}) {
+  const {
+    minDuration,
+    minDistance,
+    minVelocity,
+    onStart,
+    onCancel,
+    onMove,
+    onEnd
+  } = { ...defaultOptions$c, ...options }, cleanup = () => {
+    window.cancelAnimationFrame(request);
+  };
+  let request;
+  let totalTouches = 0;
+  const touchstart = (event, api) => {
+    const { denied } = api;
+    totalTouches++;
+    if (totalTouches > 1) {
+      cleanup();
+      denied();
+      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));
+  };
+  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
+  };
+}
+
+const defaultOptions$b = {
+  initial: []
+};
+function createKeyStatuses(options = {}) {
+  return createAssociativeArray({
+    ...defaultOptions$b,
+    ...options,
+    createPredicateKey: (query) => (key) => {
+      for (const prop in query) {
+        if (query[prop] !== key[prop]) {
+          return false;
+        }
+      }
+      return true;
+    }
+  });
+}
+function predicateDown(status) {
+  return status === "down";
+}
+function predicateSomeKeyDown(statuses) {
+  return includes("down")(statuses.toValues());
+}
+
+function fromComboToAliases(combo) {
+  const delimiter = "+";
+  return pipe(
+    unique(),
+    map((name) => name === "" ? delimiter : name.toLowerCase()),
+    toArray()
+  )(combo.split(delimiter));
+}
+
+function fromAliasToKeyStatusKey(alias) {
+  if (alias in keysByAlias) {
+    return { key: keysByAlias[alias] };
+  }
+  return {
+    code: (() => {
+      if (alias in codesByAlias)
+        return codesByAlias[alias];
+      if (letterRE.test(alias))
+        return `Key${alias.toUpperCase()}`;
+      if (digitRE.test(alias))
+        return `Digit${alias}`;
+      if (functionRE.test(alias))
+        return alias.toUpperCase();
+      return "unsupported";
+    })()
+  };
+}
+const digitRE = /^[0-9]$/;
+const letterRE = /^[a-zA-Z]$/;
+const functionRE = /^[fF][0-9]{1,2}$/;
+const codesByAlias = {
+  "`": "Backquote",
+  "~": "Backquote",
+  "-": "Minus",
+  _: "Minus",
+  "=": "Equal",
+  "+": "Equal",
+  "[": "BracketLeft",
+  "{": "BracketLeft",
+  "]": "BracketRight",
+  "}": "BracketRight",
+  "\\": "Backslash",
+  "|": "Backslash",
+  ";": "Semicolon",
+  ":": "Semicolon",
+  "'": "Quote",
+  '"': "Quote",
+  ",": "Comma",
+  "<": "Comma",
+  ".": "Period",
+  ">": "Period",
+  "/": "Slash",
+  "?": "Slash",
+  "!": "Digit1",
+  "@": "Digit2",
+  "#": "Digit3",
+  $: "Digit4",
+  "%": "Digit5",
+  "^": "Digit6",
+  "&": "Digit7",
+  "*": "Digit8",
+  "(": "Digit9",
+  ")": "Digit0",
+  up: "ArrowUp",
+  down: "ArrowDown",
+  left: "ArrowLeft",
+  right: "ArrowRight",
+  enter: "Enter",
+  space: "Space",
+  tab: "Tab",
+  esc: "Escape",
+  backspace: "Backspace",
+  delete: "Delete",
+  home: "Home",
+  end: "End",
+  pagedown: "PageDown",
+  pageup: "PageUp",
+  capslock: "CapsLock",
+  camera: "Camera"
+};
+const keysByAlias = {
+  alt: "Alt",
+  opt: "Alt",
+  option: "Alt",
+  ctrl: "Control",
+  control: "Control",
+  meta: "Meta",
+  cmd: "Meta",
+  command: "Meta",
+  shift: "Shift"
+};
+
+const defaultOptions$a = {
+  toKey: (alias) => fromAliasToKeyStatusKey(alias)
+};
+const createPredicateKeycomboDown = (keycombo, options = {}) => {
+  const { toKey } = { ...defaultOptions$a, ...options }, keys = pipe(
+    fromComboToAliases,
+    map(toKey)
+  )(keycombo);
+  return (statuses) => {
+    const { toValue } = statuses;
+    return every(pipe(
+      toValue,
+      predicateDown
+    ))(keys);
+  };
+};
+
+function fromEventToAliases(event) {
+  if (event.shiftKey && event.code in aliasesByShiftCode) {
+    return [aliasesByShiftCode[event.code]];
+  }
+  if (event.key in aliasListsByModifier) {
+    return aliasListsByModifier[event.key];
+  }
+  return event.code in aliasesByCode ? [aliasesByCode[event.code]] : [event.code.match(aliasCaptureRE)?.[1].toLowerCase() || "unsupported"];
+}
+const aliasCaptureRE = /^(?:Digit|Key)?(F[0-9]{1,2}|[0-9]|[A-Z])$/;
+const aliasesByCode = {
+  Backquote: "`",
+  Minus: "-",
+  Equal: "=",
+  BracketLeft: "[",
+  BracketRight: "]",
+  Backslash: "\\",
+  Semicolon: ";",
+  Quote: "'",
+  Comma: ",",
+  Period: ".",
+  Slash: "/",
+  ArrowUp: "up",
+  ArrowDown: "down",
+  ArrowLeft: "left",
+  ArrowRight: "right",
+  Enter: "enter",
+  Space: "space",
+  Tab: "tab",
+  Escape: "esc",
+  Backspace: "backspace",
+  Delete: "delete",
+  Home: "home",
+  End: "end",
+  PageDown: "pagedown",
+  PageUp: "pageup",
+  CapsLock: "capslock",
+  Camera: "camera"
+};
+const aliasesByShiftCode = {
+  Backquote: "~",
+  Minus: "_",
+  Equal: "+",
+  BracketLeft: "{",
+  BracketRight: "}",
+  Backslash: "|",
+  Semicolon: ":",
+  Quote: '"',
+  Comma: "<",
+  Period: ">",
+  Slash: "?",
+  Digit1: "!",
+  Digit2: "@",
+  Digit3: "#",
+  Digit4: "$",
+  Digit5: "%",
+  Digit6: "^",
+  Digit7: "&",
+  Digit8: "*",
+  Digit9: "(",
+  Digit0: ")"
+};
+const aliasListsByModifier = {
+  Alt: ["alt", "option", "opt"],
+  Control: ["control", "ctrl"],
+  Meta: ["meta", "command", "cmd"],
+  Shift: ["shift"]
+};
+
+const defaultOptions$9 = {
+  toKey: (alias) => fromAliasToKeyStatusKey(alias),
+  toAliases: (event) => fromEventToAliases(event)
+};
+const createPredicateKeycomboMatch = (keycombo, options = {}) => {
+  const { toKey, toAliases } = { ...defaultOptions$9, ...options }, aliases = fromComboToAliases(keycombo), keys = map(toKey)(aliases);
+  return (statuses) => {
+    const { toValue } = statuses;
+    return every(pipe(
+      toValue,
+      predicateDown
+    ))(keys) && every(
+      ([key, value]) => value === "up" || some(
+        (alias) => includes(alias)(aliases)
+      )(toAliases(key))
+    )(statuses.toEntries());
+  };
+};
+
+function createKeyState({
+  keycomboOrKeycombos,
+  unsupportedAliases,
+  toKey,
+  toAliases,
+  getRequest
+}) {
+  const narrowedKeycombos = createFilter(
+    (keycombo) => !some(
+      (alias) => includes(alias)(unsupportedAliases)
+    )(fromComboToAliases(keycombo))
+  )(Array.isArray(keycomboOrKeycombos) ? keycomboOrKeycombos : [keycomboOrKeycombos]), createPredicateKeycomboDownOptions = { toKey }, downPredicatesByKeycombo = (() => {
+    const predicates = [];
+    for (const keycombo of narrowedKeycombos) {
+      predicates.push([
+        keycombo,
+        createPredicateKeycomboDown(
+          keycombo,
+          createPredicateKeycomboDownOptions
+        )
+      ]);
     }
-    return reversed;
+    return predicates;
+  })(), createPredicateKeycomboMatchOptions = { ...createPredicateKeycomboDownOptions, toAliases }, matchPredicatesByKeycombo = (() => {
+    const predicates = {};
+    for (const keycombo of narrowedKeycombos) {
+      predicates[keycombo] = createPredicateKeycomboMatch(
+        keycombo,
+        createPredicateKeycomboMatchOptions
+      );
+    }
+    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
   };
 }
-function createSort(compare) {
-  return (array) => {
-    return new Pipeable(array).pipe(
-      createSlice(0),
-      (sliced) => compare ? sliced.sort(compare) : sliced.sort()
-    );
+
+function toLength() {
+  return function toLengthFn(data) {
+    return [...data].length;
   };
 }
-function createSlug(options) {
-  return (string) => {
-    return slugify(string, options);
-  };
+
+const fromComboToAliasesLength = pipe(
+  fromComboToAliases,
+  toLength()
+);
+
+function fromEventToKeyStatusKey({ key, code }) {
+  return includes(key)(modifiers) ? { key } : { code };
 }
-function createClip(required) {
-  return (string) => {
-    return string.replace(required, "");
-  };
+const modifiers = ["Alt", "Control", "Meta", "Shift"];
+
+function toDirection(angle, unit = "degrees") {
+  return Object.keys(directions).find((direction) => directions[direction][unit](angle));
 }
-function createClamp(min, max) {
-  return (number) => {
-    const maxed = Math.max(number, min);
-    return Math.min(maxed, max);
+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 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 toMousePoint(event) {
+  return {
+    x: event.clientX,
+    y: event.clientY
+  };
 }
-function createRename(from, to) {
-  return (map2) => {
-    const keys = [...map2.keys()], keyToRenameIndex = findIndex((k) => k === from)(keys), newKeys = createReplace(keyToRenameIndex, to)(keys), values = [...map2.values()];
-    return createReduce((renamed, key, index) => renamed.set(key, values[index]), /* @__PURE__ */ new Map())(newKeys);
+function toTouchMovePoint(event) {
+  return {
+    x: event.touches.item(0).clientX,
+    y: event.touches.item(0).clientY
   };
 }
-function createToEntries() {
-  return (object) => {
-    const entries = [];
-    for (const key in object) {
-      entries.push([key, object[key]]);
-    }
-    return entries;
+function toTouchEndPoint(event) {
+  return {
+    x: event.changedTouches.item(0).clientX,
+    y: event.changedTouches.item(0).clientY
   };
 }
-function createToKeys() {
-  return (object) => {
-    const keys = [];
-    for (const key in object) {
-      keys.push(key);
-    }
-    return keys;
+
+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 }
   };
 }
-function createToSome(predicate) {
-  return (object) => {
-    for (const key in object) {
-      if (predicate(key, object[key])) {
-        return true;
+
+const initialMetadata$3 = {
+  times: {
+    start: 0,
+    end: 0
+  },
+  duration: 0
+};
+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);
       }
-    }
-    return false;
+      storeDuration();
+    });
+    setRequest(request);
   };
+  storeDuration();
 }
-function createToEvery(predicate) {
-  return (object) => {
-    for (const key in object) {
-      if (!predicate(key, object[key])) {
-        return false;
+
+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;
+}
+
+const initialMetadata$1 = {
+  distance: {
+    straight: {
+      fromStart: 0,
+      fromPrevious: 0
+    },
+    horizontal: {
+      fromStart: 0,
+      fromPrevious: 0
+    },
+    vertical: {
+      fromStart: 0,
+      fromPrevious: 0
+    }
+  },
+  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);
+    }
+    if (event instanceof TouchEvent) {
+      if (event.type === "touchmove") {
+        return toTouchMovePoint(event);
       }
+      return toTouchEndPoint(event);
     }
-    return true;
+  })(), { 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 { 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;
+        recognize?.(event, api);
+        if (getStatus() === "recognized")
+          onRecognized(event);
+        storeDuration();
+      }
+    });
+    setRequest(request);
   };
+  storeDuration();
 }
-function createMatchesKeycombo(keycombo) {
-  return (event) => eventMatchesKeycombo(event, narrowKeycombo(keycombo));
+
+function defineGraph(nodes, edges) {
+  return { nodes, edges };
 }
-function createMatchesMousecombo(mousecombo) {
-  return (event) => eventMatchesMousecombo(event, narrowMousecombo(mousecombo));
+function defineGraphNodes(nodes) {
+  return nodes;
 }
-function createMatchesPointercombo(pointercombo) {
-  return (event) => eventMatchesPointercombo(event, narrowPointercombo(pointercombo));
+function defineGraphEdges(edges) {
+  return edges;
 }
-function createToFocusable(order, elementIsCandidate) {
-  return (element) => {
-    if (elementIsCandidate && predicateFocusable(element))
-      return element;
-    switch (order) {
-      case "first":
-        for (let i = 0; i < element.children.length; i++) {
-          const focusable = createToFocusable(order, true)(element.children[i]);
-          if (focusable)
-            return focusable;
-        }
-        break;
-      case "last":
-        for (let i = element.children.length - 1; i > -1; i--) {
-          const focusable = createToFocusable(order, true)(element.children[i]);
-          if (focusable)
-            return focusable;
-        }
-        break;
-    }
-  };
+function defineGraphNode(node) {
+  return node;
 }
-class Pipeable {
-  constructor(state) {
-    this.state = state;
-  }
-  pipe(...fns) {
-    return createReduce((piped, fn, index) => fn(piped, index), this.state)(fns);
-  }
-  async pipeAsync(...fns) {
-    return await createReduceAsync(
-      async (piped, fn, index) => await fn(piped, index),
-      this.state
-    )(fns);
-  }
+function defineGraphEdge(from, to, predicateTraversable) {
+  return { from, to, predicateTraversable };
 }
-
-function toKey(name) {
-  return name in keysByName ? keysByName[name] : name;
+function defineAsyncGraph(nodes, edges) {
+  return { nodes, edges };
 }
-const keysByName = {
-  up: "ArrowUp",
-  right: "ArrowRight",
-  down: "ArrowDown",
-  left: "ArrowLeft",
-  enter: "Enter",
-  backspace: "Backspace",
-  tab: "Tab",
-  space: " ",
-  shift: "Shift",
-  meta: "Meta",
-  command: "Meta",
-  cmd: "Meta",
-  control: "Control",
-  ctrl: "Control",
-  alt: "Alt",
-  opt: "Alt",
-  option: "Alt",
-  fn: "Fn",
-  capslock: "CapsLock",
-  end: "End",
-  home: "Home",
-  pagedown: "PageDown",
-  pageup: "PageUp",
-  esc: "Escape",
-  camera: "Camera",
-  delete: "Delete",
-  f1: "F1",
-  f2: "F2",
-  f3: "F3",
-  f4: "F4",
-  f5: "F5",
-  f6: "F6",
-  f7: "F7",
-  f8: "F8",
-  f9: "F9",
-  f10: "F10",
-  f11: "F11",
-  f12: "F12",
-  f13: "F13",
-  f14: "F14",
-  f15: "F15",
-  f16: "F16",
-  f17: "F17",
-  f18: "F18",
-  f19: "F19",
-  f20: "F20"
-};
-const toListenableKeycomboItems = createMap((name) => ({ name, type: fromComboItemNameToType(name) }));
-function narrowKeycombo(type) {
-  return new Pipeable(type).pipe(
-    toCombo,
-    toListenableKeycomboItems
-  );
+function defineAsyncGraphEdges(edges) {
+  return edges;
 }
-function narrowMousecombo(type) {
-  return toCombo(type);
+function defineAsyncGraphEdge(from, to, predicateTraversable) {
+  return { from, to, predicateTraversable };
 }
-function narrowPointercombo(type) {
-  return toCombo(type);
+
+function defineAssociativeArrayEntries(entries) {
+  return entries;
 }
-const toUnique$1 = unique();
-const toComboItems = map((name) => name === "" ? delimiter : name);
-const delimiter = "+";
-function toCombo(type) {
-  return pipe(
-    toUnique$1,
-    toComboItems,
-    toArray()
-  )(type.split(delimiter));
-}
-function fromComboItemNameToType(name) {
-  return find((type) => predicatesByType[type](name))(listenableComboItemTypes) ?? "custom";
-}
-const listenableComboItemTypes = /* @__PURE__ */ new Set(["singleCharacter", "arrow", "other", "modifier", "click", "pointer"]);
-const predicatesByType = {
-  singleCharacter: (name) => typeREs["singleCharacter"].test(name),
-  arrow: (name) => typeREs["arrow"].test(name),
-  other: (name) => typeREs["other"].test(name),
-  modifier: (name) => typeREs["modifier"].test(name),
-  click: (name) => typeREs["click"].test(name),
-  pointer: (name) => typeREs["pointer"].test(name)
-};
-const typeREs = {
-  singleCharacter: /^!?[a-zA-Z0-9,<.>/?;:'"[{\]}\\|`~!@#$%^&*()-_=+]$/,
-  arrow: /^!?(arrow|vertical|horizontal|up|down|right|left)$/,
-  other: /^!?(enter|backspace|space|tab|esc|home|end|pagedown|pageup|capslock|f[0-9]{1,2}|camera|delete)$/,
-  modifier: /^!?(cmd|command|meta|shift|ctrl|control|alt|opt|option)$/,
-  click: /^!?(rightclick|contextmenu|click|mousedown|mouseup|dblclick)$/,
-  pointer: /^!?(pointerdown|pointerup|pointermove|pointerover|pointerout|pointerenter|pointerleave|pointercancel|gotpointercapture|lostpointercapture)$/
-};
-function toModifier(modifierOrAlias) {
-  return modifierOrAlias in modifiersByAlias ? modifiersByAlias[modifierOrAlias] : modifierOrAlias;
-}
-const modifiersByAlias = {
-  cmd: "meta",
-  command: "meta",
-  ctrl: "control",
-  opt: "alt",
-  option: "alt"
-};
+
 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, true];
+      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;
@@ -414,7 +2136,7 @@ function createExceptAndOnlyEffect(type, effect, options) {
   }
   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, true];
+      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;
@@ -427,7 +2149,7 @@ function createExceptAndOnlyEffect(type, effect, options) {
   }
   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, true];
+      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;
@@ -439,7 +2161,7 @@ function createExceptAndOnlyEffect(type, effect, options) {
     };
   }
   return (event) => {
-    const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => some((selector) => target.matches(selector))(selectors))([only, except]) : [false, true];
+    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;
@@ -450,27 +2172,15 @@ function createExceptAndOnlyEffect(type, effect, options) {
     }
   };
 }
-function predicateModified({ event, alias }) {
-  return predicatesByModifier[alias]?.(event);
-}
-const predicatesByModifier = {
-  shift: (event) => event.shiftKey,
-  cmd: (event) => event.metaKey,
-  command: (event) => event.metaKey,
-  meta: (event) => event.metaKey,
-  ctrl: (event) => event.ctrlKey,
-  control: (event) => event.ctrlKey,
-  alt: (event) => event.altKey,
-  opt: (event) => event.altKey,
-  option: (event) => event.altKey
-};
-function domIsAvailable() {
+
+function getDomAvailability() {
   try {
-    return !!window;
+    return !!window ? "available" : "unavailable";
   } catch (error) {
-    return false;
+    return "unavailable";
   }
 }
+
 function predicateArray(value) {
   return Array.isArray(value);
 }
@@ -489,24 +2199,8 @@ function predicateNumber(value) {
 function predicateString(value) {
   return typeof value === "string";
 }
-const 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 predicateFocusable(element) {
-  return element.matches(tabbableSelector);
+function predicateObject(value) {
+  return typeof value === "object";
 }
 
 class Recognizeable {
@@ -519,7 +2213,7 @@ class Recognizeable {
       effects: {}
     };
     this.maxSequenceLength = options?.maxSequenceLength || defaultOptions.maxSequenceLength;
-    this.effects = new Map(Object.entries(options?.effects || defaultOptions.effects));
+    this.effects = options?.effects || defaultOptions.effects;
     this.resetComputedMetadata();
     this.setSequence(sequence);
     this.effectApi = {
@@ -528,8 +2222,6 @@ class Recognizeable {
       setMetadata: (metadata) => this.computedMetadata = metadata,
       recognized: () => this.recognized(),
       denied: () => this.denied(),
-      recognizedUntilReady: () => this.recognizedUntilReady(),
-      deniedUntilReady: () => this.deniedUntilReady(),
       ready: () => this.ready()
     };
     this.ready();
@@ -544,12 +2236,6 @@ class Recognizeable {
   denied() {
     this.computedStatus = "denied";
   }
-  recognizedUntilReady() {
-    this.computedStatus = "recognized until ready";
-  }
-  deniedUntilReady() {
-    this.computedStatus = "denied until ready";
-  }
   computedStatus;
   ready() {
     this.computedStatus = "ready";
@@ -572,8 +2258,7 @@ class Recognizeable {
     return this;
   }
   recognize(sequenceItem, { onRecognized } = {}) {
-    if (!this.status.includes("until ready"))
-      this.recognizing();
+    this.recognizing();
     const type = this.toType(sequenceItem), excess = predicateNumber(this.maxSequenceLength) ? Math.max(0, this.sequence.length - this.maxSequenceLength) : 0, newSequence = createConcat(
       createSlice(excess)(this.sequence),
       [sequenceItem]
@@ -581,11 +2266,10 @@ class Recognizeable {
     this.effectApi.getSequence = () => newSequence;
     this.effectApi.onRecognized = onRecognized || (() => {
     });
-    this.effects.get(type)?.(sequenceItem, { ...this.effectApi });
+    this.effects[type]?.(sequenceItem, { ...this.effectApi });
     switch (this.status) {
       case "ready":
       case "denied":
-      case "denied until ready":
         this.resetComputedMetadata();
         this.setSequence([]);
         break;
@@ -628,8 +2312,8 @@ class Listenable {
   computedActive;
   constructor(type, options) {
     if (type === "recognizeable") {
-      this.computedRecognizeable = new Recognizeable([], options?.recognizeable || {});
-      this.recognizeableEffectsKeys = Object.keys(options?.recognizeable?.effects || {});
+      this.computedRecognizeable = new Recognizeable([], options?.recognizeable);
+      this.recognizeableEffectsKeys = Object.keys(options?.recognizeable?.effects);
     }
     this.computedActive = /* @__PURE__ */ new Set();
     this.setType(type);
@@ -729,24 +2413,10 @@ class Listenable {
     this.active.add({ target, id: [this.type, effect] });
   }
   recognizeableListen(effect, options) {
-    let effectStatus = "ready";
     const guardedEffect = (sequenceItem) => {
       this.recognizeable.recognize(sequenceItem, { onRecognized: (sequenceItem2) => effect(sequenceItem2) });
-      switch (this.recognizeable.status) {
-        case "recognized until ready":
-          if (effectStatus === "ready") {
-            effect(sequenceItem);
-            effectStatus = "performed";
-          }
-          break;
-        case "recognized":
-          effect(sequenceItem);
-          effectStatus = "ready";
-          break;
-        default:
-          effectStatus = "ready";
-          break;
-      }
+      if (this.recognizeable.status === "recognized")
+        effect(sequenceItem);
     };
     for (const type of this.recognizeableEffectsKeys) {
       const listenable = new Listenable(type);
@@ -767,10 +2437,10 @@ class Listenable {
   }
   addEventListeners(eventListeners, options) {
     const { target = document } = options;
-    eventListeners.forEach((eventListener) => {
+    for (const eventListener of eventListeners) {
       target.addEventListener(eventListener[0], eventListener[1], eventListener[2]);
       this.active.add({ target, id: eventListener });
-    });
+    }
   }
   listening() {
     this.computedStatus = "listening";
@@ -882,109 +2552,22 @@ function toAddEventListenerParams(type, effect, options) {
   const { addEventListener, useCapture } = options, exceptAndOnlyEffect = createExceptAndOnlyEffect(type, effect, options), effectOptions = [addEventListener || useCapture];
   return { exceptAndOnlyEffect, effectOptions };
 }
-function eventMatchesKeycombo(event, keycombo) {
-  return every(({ name, type }, index) => {
-    switch (type) {
-      case "singleCharacter":
-        if (name === "!")
-          return event.key === "!";
-        const keyToTest = event.altKey && fromComboItemNameToType(event.key) === "custom" ? fromCodeToSingleCharacter(event.code) : event.key.toLowerCase();
-        return name.startsWith("!") ? keyToTest !== toKey(name.slice(1)).toLowerCase() : keyToTest === toKey(name).toLowerCase();
-      case "other":
-        if (name === "!") {
-          return event.key === "!";
-        }
-        return name.startsWith("!") ? event.key.toLowerCase() !== toKey(name.slice(1)).toLowerCase() : event.key.toLowerCase() === toKey(name).toLowerCase();
-      case "arrow":
-        return predicatesByArrow.get(name)?.({ event, name }) ?? predicatesByArrow.get("default")({ event, name });
-      case "modifier":
-        if (index === keycombo.length - 1) {
-          return name.startsWith("!") ? event.key.toLowerCase() !== toModifier(name.slice(1)).toLowerCase() : event.key.toLowerCase() === toModifier(name).toLowerCase();
-        }
-        return name.startsWith("!") ? !predicateModified({ event, alias: name.slice(1) }) : predicateModified({ event, alias: name });
-    }
-  })(keycombo);
-}
-function fromCodeToSingleCharacter(code) {
-  for (const c in aliasesByCode) {
-    if (c === code) {
-      return aliasesByCode[c];
-    }
-  }
-  for (const prefix of ["Key", "Digit"]) {
-    const re = new RegExp(`^${prefix}`);
-    if (re.test(code)) {
-      return createClip(re)(code).toLowerCase();
-    }
-  }
-  return code;
-}
-const aliasesByCode = {
-  "Backquote": "`",
-  "Minus": "-",
-  "Equal": "=",
-  "BracketLeft": "[",
-  "BracketRight": "]",
-  "Backslash": "\\",
-  "Semicolon": ";",
-  "Quote": "'",
-  "Comma": ",",
-  "Period": ".",
-  "Slash": "/"
-};
-const predicatesByArrow = /* @__PURE__ */ new Map([
-  [
-    "arrow",
-    ({ event }) => arrows.has(event.key.toLowerCase())
-  ],
-  [
-    "!arrow",
-    ({ event }) => !arrows.has(event.key.toLowerCase())
-  ],
-  [
-    "vertical",
-    ({ event }) => verticalArrows.has(event.key.toLowerCase())
-  ],
-  [
-    "!vertical",
-    ({ event }) => !verticalArrows.has(event.key.toLowerCase())
-  ],
-  [
-    "horizontal",
-    ({ event }) => horizontalArrows.has(event.key.toLowerCase())
-  ],
-  [
-    "!horizontal",
-    ({ event }) => !horizontalArrows.has(event.key.toLowerCase())
-  ],
-  [
-    "default",
-    ({ event, name }) => name.startsWith("!") ? event.key.toLowerCase() !== `arrow${name.toLowerCase()}` : event.key.toLowerCase() === `arrow${name.toLowerCase()}`
-  ]
-]);
-const arrows = /* @__PURE__ */ new Set(["arrowup", "arrowright", "arrowdown", "arrowleft"]);
-const verticalArrows = /* @__PURE__ */ new Set(["arrowup", "arrowdown"]);
-const horizontalArrows = /* @__PURE__ */ new Set(["arrowright", "arrowleft"]);
-function eventMatchesMousecombo(event, Mousecombo) {
-  return every((name) => fromComboItemNameToType(name) === "click" || name.startsWith("!") && !predicateModified({ alias: name.slice(1), event }) || !name.startsWith("!") && predicateModified({ alias: name, event }))(Mousecombo);
-}
-function eventMatchesPointercombo(event, pointercombo) {
-  return every((name) => fromComboItemNameToType(name) === "pointer" || name.startsWith("!") && !predicateModified({ alias: name.slice(1), event }) || !name.startsWith("!") && predicateModified({ alias: name, event }))(pointercombo);
-}
 const observerAssertionsByType = {
   intersect: (observer) => observer instanceof IntersectionObserver,
   mutate: (observer) => observer instanceof MutationObserver,
   resize: (observer) => observer instanceof ResizeObserver
 };
 
-const defaultOptions$7 = {
+const defaultOptions$8 = {
   duration: 0,
+  // delay not supported, because it can be effectd by delayable
   timing: [
     0,
     0,
     1,
     1
   ],
+  // linear by default
   iterations: 1,
   alternates: false
 };
@@ -1005,10 +2588,10 @@ class Animateable {
   getEaseables;
   getReversedEaseables;
   constructor(keyframes, options = {}) {
-    this.initialDuration = options?.duration || defaultOptions$7.duration;
-    this.controlPoints = fromTimingToControlPoints(options?.timing || defaultOptions$7.timing);
-    this.iterationLimit = options?.iterations || defaultOptions$7.iterations;
-    this.alternates = options?.alternates || defaultOptions$7.alternates;
+    this.initialDuration = options?.duration || defaultOptions$8.duration;
+    this.controlPoints = fromTimingToControlPoints(options?.timing || defaultOptions$8.timing);
+    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);
@@ -1084,10 +2667,11 @@ class Animateable {
   setKeyframes(keyframes) {
     this.stop();
     this.computedKeyframes = Array.from(keyframes).sort(({ progress: progressA }, { progress: progressB }) => progressA - progressB);
-    this.reversedKeyframes = new Pipeable(this.keyframes).pipe(
-      createReverse(),
-      createMap(({ progress, properties }) => ({ progress: 1 - progress, properties }))
-    );
+    this.reversedKeyframes = pipe(
+      reverse$1(),
+      map(({ progress, properties }) => ({ progress: 1 - progress, properties })),
+      toArray()
+    )(this.keyframes);
     this.properties = toProperties(this.keyframes);
     this.easeables = this.getEaseables({ keyframes: this.keyframes, properties: this.properties });
     this.reversedEaseables = this.getReversedEaseables({ keyframes: this.reversedKeyframes, properties: this.properties });
@@ -1385,7 +2969,7 @@ class Animateable {
                 break;
               case "reversing":
                 this.computedIterations += 1;
-                if (this.iterations < this.iterationLimit || this.iterationLimit === true) {
+                if (this.iterationLimit === true || this.iterations < this.iterationLimit) {
                   this.createAnimate("reverse")(effect, options);
                 } else {
                   this.alternateCache.status = "ready";
@@ -1394,7 +2978,7 @@ class Animateable {
             }
           } else {
             this.computedIterations += 1;
-            if (this.iterations < this.iterationLimit || this.iterationLimit === true) {
+            if (this.iterationLimit === true || this.iterations < this.iterationLimit) {
               this.createAnimate("play")(effect, options);
             }
           }
@@ -1410,7 +2994,7 @@ class Animateable {
             switch (this.alternateCache.status) {
               case "playing":
                 this.computedIterations += 1;
-                if (this.iterations < this.iterationLimit || this.iterationLimit === true) {
+                if (this.iterationLimit === true || this.iterations < this.iterationLimit) {
                   this.createAnimate("play")(effect, options);
                 } else {
                   this.alternateCache.status = "ready";
@@ -1422,7 +3006,7 @@ class Animateable {
             }
           } else {
             this.computedIterations += 1;
-            if (this.iterations < this.iterationLimit) {
+            if (this.iterationLimit === true || this.iterations < this.iterationLimit) {
               this.createAnimate("reverse")(effect, options);
             }
           }
@@ -1631,7 +3215,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 ? (timeProgress) => 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 : createToAnimationProgress(fromKeyframeToControlPoints({ keyframe, index, propertyKeyframes }));
             propertyEaseables2.push({
               property,
               value: { previous, next },
@@ -1646,7 +3230,7 @@ function createGetEaseables(fromKeyframeToControlPoints) {
           property,
           value: { previous: propertyEaseables[0].value.previous, next: propertyEaseables[0].value.previous },
           progress: { start: -1, end: propertyEaseables[0].progress.start },
-          toAnimationProgress: (timeProgress) => 1,
+          toAnimationProgress: () => 1,
           hasCustomTiming: false
         };
         return createConcat(
@@ -1891,14 +3475,14 @@ const easingsNetInOutBack = [
   1.6
 ];
 
-const defaultOptions$6 = {
+const defaultOptions$7 = {
   name: "baleada"
 };
 class Broadcastable {
   name;
   constructor(state, options = {}) {
     this.setState(state);
-    this.name = options.name ?? defaultOptions$6.name;
+    this.name = options.name ?? defaultOptions$7.name;
     this.ready();
   }
   computedStatus;
@@ -1963,12 +3547,69 @@ function toMessageListenParams(instance, effect) {
   ];
 }
 
+const defaultOptions$6 = {
+  locales: "en",
+  collator: { sensitivity: "base" }
+};
+class Compareable {
+  constructor(string, options = {}) {
+    const locales = options.locales || defaultOptions$6.locales, collatorOptions = { ...defaultOptions$6.collator, ...options.collator }, key = locales + pipe(
+      createEntries(),
+      sort((a, b) => a[0] < b[0] ? -1 : 1),
+      join()
+    )(collatorOptions);
+    this.computedCollator = cache[key] || (cache[key] = new Intl.Collator(locales, collatorOptions));
+    this.setString(string);
+    this.ready();
+  }
+  computedStatus;
+  ready() {
+    this.computedStatus = "ready";
+  }
+  get string() {
+    return this.computedString;
+  }
+  set string(string) {
+    this.setString(string);
+  }
+  get status() {
+    return this.computedStatus;
+  }
+  computedCollator;
+  get collator() {
+    return this.computedCollator;
+  }
+  computedComparison;
+  get comparison() {
+    return this.computedComparison;
+  }
+  computedString;
+  setString(string) {
+    this.computedString = string;
+    return this;
+  }
+  compare(compared) {
+    this.comparing();
+    this.computedComparison = this.computedCollator.compare(this.string, compared);
+    this.compared();
+    return this;
+  }
+  comparing() {
+    this.computedStatus = "comparing";
+  }
+  compared() {
+    this.computedStatus = "compared";
+  }
+}
+const cache = {};
+
 const defaultOptions$5 = {
   segment: {
     from: "start",
     to: "end"
   },
   divider: /\s/
+  // Keep an eye out for use cases where a { before, after } object would be needed, or where multi-character dividers need to be used
 };
 const defaultCompleteOptions = {
   select: "completionEnd"
@@ -2051,6 +3692,7 @@ class Completeable {
     }
     return this;
   }
+  // TODO: Support array of selections for multi cursor editing
   computedSelection;
   setSelection(selection) {
     this.computedSelection = selection;
@@ -2127,12 +3769,12 @@ function toPreviousMatch({ string, re, from }) {
   if (!re.test(string.slice(0, from)) || from === 0) {
     indexOf = -1;
   } else {
-    const reversedStringBeforeFrom = new Pipeable(string).pipe(
+    const reversedStringBeforeFrom = pipe(
       (string2) => string2.slice(0, from),
       (sliced) => sliced.split(""),
       reverse,
       toString
-    ), toNextMatchIndex = toNextMatch({ string: reversedStringBeforeFrom, re, from: 0 });
+    )(string), toNextMatchIndex = toNextMatch({ string: reversedStringBeforeFrom, re, from: 0 });
     indexOf = toNextMatchIndex === -1 ? -1 : reversedStringBeforeFrom.length - 1 - toNextMatchIndex;
   }
   return indexOf;
@@ -2503,11 +4145,12 @@ class Fetchable {
   computedText;
   constructor(resource, options = {}) {
     this.setResource(resource);
-    this.computedArrayBuffer = new Resolveable(async () => "arrayBuffer" in this.response ? await this.response.arrayBuffer() : await void 0);
-    this.computedBlob = new Resolveable(async () => "blob" in this.response ? await this.response.blob() : await void 0);
-    this.computedFormData = new Resolveable(async () => "formData" in this.response ? await this.response.formData() : await void 0);
-    this.computedJson = new Resolveable(async () => "json" in this.response ? await this.response.json() : await void 0);
-    this.computedText = new Resolveable(async () => "text" in this.response ? await this.response.text() : await void 0);
+    this.computedKy = ky.create(narrowOptions(options.ky));
+    this.computedArrayBuffer = new Resolveable(async () => "arrayBuffer" in this.response ? await this.response.arrayBuffer() : void 0);
+    this.computedBlob = new Resolveable(async () => "blob" in this.response ? await this.response.blob() : void 0);
+    this.computedFormData = new Resolveable(async () => "formData" in this.response ? await this.response.formData() : void 0);
+    this.computedJson = new Resolveable(async () => "json" in this.response ? await this.response.json() : void 0);
+    this.computedText = new Resolveable(async () => "text" in this.response ? await this.response.text() : void 0);
     this.ready();
   }
   computedStatus;
@@ -2520,6 +4163,10 @@ class Fetchable {
   set resource(resource) {
     this.setResource(resource);
   }
+  computedKy;
+  get ky() {
+    return this.computedKy;
+  }
   computedAbortController;
   get abortController() {
     if (!this.computedAbortController) {
@@ -2533,6 +4180,10 @@ class Fetchable {
   get response() {
     return this.computedResponse;
   }
+  computedRetryCount = 0;
+  get retryCount() {
+    return this.computedRetryCount;
+  }
   get error() {
     return this.computedError;
   }
@@ -2561,7 +4212,23 @@ class Fetchable {
   async fetch(options = {}) {
     this.fetching();
     try {
-      this.computedResponse = await fetch(this.resource, { signal: this.abortController.signal, ...narrowOptions(options) });
+      this.computedResponse = await this.ky(
+        this.resource,
+        {
+          ...options,
+          signal: this.abortController.signal,
+          hooks: {
+            ...options.hooks,
+            beforeRetry: [
+              ...options.hooks?.beforeRetry || [],
+              ({ retryCount }) => {
+                this.retrying();
+                this.computedRetryCount = retryCount;
+              }
+            ]
+          }
+        }
+      );
       this.fetched();
     } catch (error) {
       this.computedError = error;
@@ -2575,6 +4242,9 @@ class Fetchable {
   fetching() {
     this.computedStatus = "fetching";
   }
+  retrying() {
+    this.computedStatus = "retrying";
+  }
   fetched() {
     this.computedStatus = "fetched";
   }
@@ -2585,23 +4255,27 @@ class Fetchable {
     this.computedStatus = "errored";
   }
   async get(options = {}) {
-    await this.fetch({ signal: this.abortController.signal, ...narrowOptions(options), method: "get" });
+    await this.fetch({ signal: this.abortController.signal, ...options, method: "get" });
     return this;
   }
   async patch(options = {}) {
-    await this.fetch({ signal: this.abortController.signal, ...narrowOptions(options), method: "patch" });
+    await this.fetch({ signal: this.abortController.signal, ...options, method: "patch" });
     return this;
   }
   async post(options = {}) {
-    await this.fetch({ signal: this.abortController.signal, ...narrowOptions(options), method: "post" });
+    await this.fetch({ signal: this.abortController.signal, ...options, method: "post" });
     return this;
   }
   async put(options = {}) {
-    await this.fetch({ signal: this.abortController.signal, ...narrowOptions(options), method: "put" });
+    await this.fetch({ signal: this.abortController.signal, ...options, method: "put" });
     return this;
   }
   async delete(options = {}) {
-    await this.fetch({ signal: this.abortController.signal, ...narrowOptions(options), method: "delete" });
+    await this.fetch({ signal: this.abortController.signal, ...options, method: "delete" });
+    return this;
+  }
+  async head(options = {}) {
+    await this.fetch({ signal: this.abortController.signal, ...options, method: "head" });
     return this;
   }
   abort() {
@@ -2610,16 +4284,9 @@ class Fetchable {
   }
 }
 function narrowOptions(options) {
-  return predicateFunction(options) ? options({ withJson }) : options;
-}
-function withJson(data) {
-  return {
-    body: JSON.stringify(data),
-    headers: {
-      "Accept": "application/json",
-      "Content-Type": "application/json"
-    }
-  };
+  if (!options)
+    return {};
+  return predicateFunction(options) ? options({ stop: ky.stop }) : options;
 }
 
 class Fullscreenable {
@@ -2947,13 +4614,12 @@ class Pickable {
   }
   pick(indexOrIndices, options = {}) {
     const { replace, allowsDuplicates } = { ...defaultPickOptions, ...options };
-    this.computedPicks = new Pipeable(indexOrIndices).pipe(
+    this.computedPicks = pipe(
       narrowIndices,
       this.toPossiblePicks,
       (possiblePicks) => {
-        if (replace === "all") {
+        if (replace === "all")
           return allowsDuplicates ? possiblePicks : toUnique(possiblePicks);
-        }
         const maybeWithoutDuplicates = allowsDuplicates ? possiblePicks : createFilter(
           (possiblePick) => typeof find((pick) => pick === possiblePick)(this.picks || []) !== "number"
         )(possiblePicks);
@@ -2970,10 +4636,11 @@ class Pickable {
             if (maybeWithoutDuplicates.length > this.picks.length) {
               return createSlice(maybeWithoutDuplicates.length - this.picks.length)(maybeWithoutDuplicates);
             }
-            return new Pipeable(this.picks).pipe(
-              createSlice(maybeWithoutDuplicates.length),
-              createConcat(maybeWithoutDuplicates)
-            );
+            return pipe(
+              slice(maybeWithoutDuplicates.length),
+              (array) => concat(array, maybeWithoutDuplicates),
+              toArray()
+            )(this.picks);
           case "lifo":
             if (maybeWithoutDuplicates.length === 0) {
               return this.picks;
@@ -2984,13 +4651,14 @@ class Pickable {
             if (maybeWithoutDuplicates.length > this.picks.length) {
               return createSlice(0, maybeWithoutDuplicates.length - this.picks.length + 1)(maybeWithoutDuplicates);
             }
-            return new Pipeable(this.picks).pipe(
-              createSlice(0, this.picks.length - maybeWithoutDuplicates.length),
-              createConcat(maybeWithoutDuplicates)
-            );
+            return pipe(
+              slice(0, this.picks.length - maybeWithoutDuplicates.length - 1),
+              (array) => concat(array, maybeWithoutDuplicates),
+              toArray()
+            )(this.picks);
         }
       }
-    );
+    )(indexOrIndices);
     this.computedFirst = Math.min(...this.picks);
     this.computedLast = Math.max(...this.picks);
     this.computedMultiple = toUnique(this.picks).length > 1;
@@ -3038,7 +4706,7 @@ class Sanitizeable {
   computedDompurify;
   computedStatus;
   ready() {
-    if (domIsAvailable()) {
+    if (getDomAvailability() === "available") {
       this.computedDompurify = createDOMPurify();
       this.computedDompurify.setConfig(this.domPurifyConfig);
     }
@@ -3051,7 +4719,7 @@ class Sanitizeable {
     this.setHtml(html);
   }
   get dompurify() {
-    if (!this.computedDompurify && domIsAvailable()) {
+    if (!this.computedDompurify && getDomAvailability() === "available") {
       this.computedDompurify = createDOMPurify();
       this.computedDompurify.setConfig(this.domPurifyConfig);
     }
@@ -3194,7 +4862,7 @@ class Storeable {
   computedStatus;
   ready() {
     this.computedStatus = "ready";
-    if (domIsAvailable()) {
+    if (getDomAvailability() === "available") {
       if (predicateNull(this.storage.getItem(this.computedStatusKey))) {
         this.storeStatus();
       }
@@ -3207,7 +4875,7 @@ class Storeable {
     this.setKey(key);
   }
   get status() {
-    if (domIsAvailable()) {
+    if (getDomAvailability() === "available") {
       const storedStatus = this.storage.getItem(this.computedStatusKey);
       if (this.computedStatus !== storedStatus && predicateString(storedStatus)) {
         this.computedStatus = storedStatus;
@@ -3295,4 +4963,4 @@ class Storeable {
   }
 }
 
-export { Animateable, Broadcastable, Completeable, Copyable, Delayable, Drawable, Fetchable, Fullscreenable, Grantable, Listenable, Navigateable, Pickable, Pipeable, Recognizeable, Resolveable, Sanitizeable, Searchable, Shareable, Storeable, createClamp, createClip, createConcat, createDetermine, createFilter, createFilterAsync, createForEachAsync, createInsert, createMap, createMapAsync, createMatchesKeycombo, createMatchesMousecombo, createMatchesPointercombo, createReduce, createReduceAsync, createRemove, createRename, createReorder, createReplace, createReverse, createSlice, createSlug, createSort, createSwap, createToEntries, createToEvery, createToFocusable, createToKeys, createToSome, createUnique, 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, 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, createList, createMap, createMapAsync, createMousepress, createMouserelease, createPredicateKeycomboMatch$1 as 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 };