@baleada/logic 0.22.7 → 0.23.1

package/lib/index.cjs

@@ -1,52 +1,57 @@
 'use strict';
 
-var lazyCollections = require('lazy-collections');
-var slugify = require('@sindresorhus/slugify');
 var BezierEasing = require('bezier-easing');
 var color = require('@snigo.dev/color');
+var lazyCollections = require('lazy-collections');
 var perfectFreehand = require('perfect-freehand');
 var polygonClipping = require('polygon-clipping');
+var ky = require('ky');
 var createDOMPurify = require('dompurify');
 var fastFuzzy = require('fast-fuzzy');
+var klona = require('klona');
+var dequal = require('dequal');
+var slugify = require('@sindresorhus/slugify');
+var clsx = require('clsx');
 
-function createReduceAsync(accumulate, initialValue) {
-  return async (array) => {
-    return await lazyCollections.reduce(
-      async (accumulatorPromise, item, index) => {
-        const accumulator = await accumulatorPromise;
-        return accumulate(accumulator, item, index);
-      },
-      Promise.resolve(initialValue)
-    )(array);
+function createClone() {
+  return (any) => {
+    return klona.klona(any);
   };
 }
-function createReduce(accumulate, initialValue) {
-  return (array) => lazyCollections.reduce(accumulate, initialValue)(array);
+function createEqual(compared) {
+  return (any) => dequal.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) => lazyCollections.pipe(
+    lazyCollections.concat(array, ...arrays),
+    lazyCollections.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) => lazyCollections.pipe(
+    lazyCollections.filter(predicate),
+    lazyCollections.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) => lazyCollections.pipe(
+    lazyCollections.map(transform),
+    lazyCollections.toArray()
+  )(array);
+}
+function createReduce(accumulate, initialValue) {
+  return (array) => lazyCollections.reduce(accumulate, initialValue)(array);
+}
 function createRemove(index) {
   return (array) => {
     return createConcat(
@@ -55,15 +60,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;
@@ -92,8 +88,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 ? lazyCollections.slice(from, to - 1) : lazyCollections.slice(from);
+  return (array) => {
+    return from === to ? [] : lazyCollections.pipe(
+      toSliced,
+      lazyCollections.toArray()
+    )(array);
+  };
+}
+function createSort(compare) {
+  return (array) => {
+    return lazyCollections.pipe(
+      lazyCollections.sort(compare),
+      lazyCollections.toArray()
+    )(array);
+  };
 }
 function createSwap(indices) {
   return (array) => {
@@ -115,16 +137,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 lazyCollections.pipe(reorderFrom, reorderTo)(array);
   };
 }
 function createUnique() {
@@ -133,277 +146,1990 @@ function createUnique() {
     lazyCollections.toArray()
   )(array);
 }
-function createSlice(from, to) {
-  return (array) => {
-    return from === to ? [] : lazyCollections.pipe(
-      lazyCollections.slice(from, to - 1),
-      lazyCollections.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) => lazyCollections.pipe(
-    lazyCollections.filter(predicate),
-    lazyCollections.toArray()
-  )(array);
+function createReduceAsync(accumulate, initialValue) {
+  return async (array) => {
+    return await lazyCollections.reduce(
+      async (accumulatorPromise, item, index) => {
+        const accumulator = await accumulatorPromise;
+        return accumulate(accumulator, item, index);
+      },
+      Promise.resolve(initialValue)
+    )(array);
+  };
 }
-function createMap(transform) {
-  return (array) => lazyCollections.pipe(
-    lazyCollections.map(transform),
-    lazyCollections.toArray()
-  )(array);
+
+function createClip(required) {
+  return (string) => {
+    return string.replace(required, "");
+  };
 }
-function createConcat(...arrays) {
-  return (array) => lazyCollections.pipe(
-    lazyCollections.concat(array, ...arrays),
-    lazyCollections.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 : lazyCollections.pipe(
+      lazyCollections.slice(0, index - 1),
+      lazyCollections.reduce((lowerBound2, { probability: probability2 }) => lowerBound2 + probability2, 0)
+    )(potentialities), upperBound = lowerBound + probability;
+    return {
+      outcome,
+      predicate: (determinant) => determinant >= lowerBound && determinant < upperBound || determinant < 0 && index === 0 || index === predicates.length - 1
+    };
+  })(potentialities);
+  return (determinant) => lazyCollections.find(({ predicate }) => predicate(determinant))(predicates).outcome;
+}
+
+function 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 = lazyCollections.findIndex((k) => k === from)(keys), newKeys = createReplace(keyToRenameIndex, to)(keys), values = [...map.values()];
+    return createReduce((renamed, key, index) => renamed.set(key, values[index]), /* @__PURE__ */ new Map())(newKeys);
+  };
+}
+
+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: lazyCollections.join(':not([hidden]):not([tabindex="-1"]),')([
+    "input:not([disabled]):not([type=hidden])",
+    "select:not([disabled])",
+    "textarea:not([disabled])",
+    "button:not([disabled])",
+    "a[href]",
+    "area[href]",
+    "summary",
+    "iframe",
+    "object",
+    "embed",
+    "audio[controls]",
+    "video[controls]",
+    "[contenteditable]",
+    "[tabindex]:not([disabled])"
+  ])
+};
+function createFocusable(order, options = {}) {
+  const { elementIsCandidate, tabbableSelector } = { ...defaultOptions$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) => lazyCollections.pipe(
+    toIncoming,
+    toLength()
+  )(node);
+}
+function createToOutdegree(graph) {
+  const toOutgoing = createToOutgoing(graph);
+  return (node) => lazyCollections.pipe(
+    toOutgoing,
+    toLength()
+  )(node);
+}
+function createToIncoming(graph) {
+  const { edges } = graph;
+  return function* (node) {
+    yield* lazyCollections.filter(
+      ({ to }) => to === node
+    )(edges);
+  };
+}
+function createToOutgoing(graph) {
+  const { edges } = graph;
+  return function* (node) {
+    yield* lazyCollections.filter(
+      ({ from }) => from === node
+    )(edges);
+  };
+}
+function createPredicateRoot(graph) {
+  const toIndegree = createToIndegree(graph);
+  return (node) => toIndegree(node) === 0;
+}
+
+function createFind(node) {
+  return (tree) => {
+    for (const treeNode of tree) {
+      if (treeNode.node === node)
+        return treeNode;
+      const found = createFind(node)(treeNode.children);
+      if (found)
+        return found;
+    }
+  };
+}
+
+function createToLayers$1(options = {}) {
+  const toSteps = createToSteps$2(options.createToSteps);
+  return function toLayers(directedAcyclic) {
+    const layers = [];
+    for (const { path } of toSteps(directedAcyclic)) {
+      const node = path.at(-1), depth = path.length - 1;
+      (layers[depth] || (layers[depth] = [])).push(node);
+    }
+    return layers;
+  };
+}
+function createToTree$2(options = {}) {
+  const toSteps = createToSteps$2(options.createToSteps);
+  return function toTree(directedAcyclic) {
+    const firstRoot = lazyCollections.pipe(
+      createToRoots(),
+      lazyCollections.at(0)
+    )(directedAcyclic), tree = [];
+    tree.push({
+      node: firstRoot,
+      children: []
+    });
+    for (const { path } of toSteps(directedAcyclic)) {
+      const node = path.at(-1), parent = path.at(-2);
+      if (parent) {
+        const parentTreeNode = createFind(parent)(tree);
+        if (parentTreeNode) {
+          parentTreeNode.children.push({
+            node,
+            children: []
+          });
+        }
+      }
+    }
+    return tree;
+  };
+}
+function createToCommonAncestors$2(directedAcyclic) {
+  const toNodeSteps = createToNodeSteps$2(directedAcyclic);
+  return function* (a, b) {
+    for (const { path: aPath } of toNodeSteps(a)) {
+      for (const { path: bPath } of toNodeSteps(b)) {
+        for (let aPathIndex = aPath.length - 1; aPathIndex >= 0; aPathIndex--) {
+          for (let bPathIndex = bPath.length - 1; bPathIndex >= 0; bPathIndex--) {
+            if (aPath[aPathIndex] === bPath[bPathIndex] && !lazyCollections.includes(aPath[aPathIndex])([a, b])) {
+              yield {
+                node: aPath[aPathIndex],
+                distances: {
+                  [a]: aPath.length - aPathIndex - 1,
+                  [b]: bPath.length - bPathIndex - 1
+                }
+              };
+            }
+          }
+        }
+      }
+    }
+  };
+}
+function createPredicateAncestor$2(directedAcyclic) {
+  const toNodeSteps = createToNodeSteps$2(directedAcyclic);
+  return function(descendant, ancestor) {
+    return lazyCollections.pipe(
+      toNodeSteps,
+      lazyCollections.some(({ path }) => lazyCollections.includes(ancestor)(path))
+    )(descendant);
+  };
+}
+function createToNodeSteps$2(directedAcyclic, options = {}) {
+  const toSteps = createToSteps$2(options.createToSteps);
+  return function* (node) {
+    yield* lazyCollections.pipe(
+      toSteps,
+      lazyCollections.filter(({ path }) => path.at(-1) === node)
+    )(directedAcyclic);
+  };
+}
+const defaultCreateToStepsOptions$1 = {
+  toUnsetMetadata: () => 0,
+  toMockMetadata: (node, totalConnectionsFollowed) => totalConnectionsFollowed,
+  kind: "directed acyclic"
+};
+function createToSteps$2(options = {}) {
+  const { toUnsetMetadata, toMockMetadata, root, kind } = { ...defaultCreateToStepsOptions$1, ...options };
+  return function* (directedAcyclic) {
+    const { nodes } = directedAcyclic, toOutdegree = createToOutdegree(directedAcyclic), toPath = createToPath$2(directedAcyclic), roots = lazyCollections.pipe(
+      createToRoots({ kind }),
+      lazyCollections.toArray()
+    )(directedAcyclic), state = {}, totalConnectionsFollowedByNode = {}, predicateExhausted = (node) => {
+      return totalConnectionsFollowedByNode[node] === toOutdegree(node);
+    };
+    for (const node of nodes) {
+      state[node] = {
+        status: "unset",
+        metadata: toUnsetMetadata(node)
+      };
+    }
+    let location = root || lazyCollections.at(0)(roots);
+    const path = toPath(state);
+    yield { path, state: JSON.parse(JSON.stringify(state)) };
+    function* toStep() {
+      if (predicateExhausted(location)) {
+        if (lazyCollections.includes(location)(roots))
+          return;
+        state[location].status = "unset";
+        state[location].metadata = toUnsetMetadata(location);
+        const path3 = toPath(state);
+        location = path3.at(-2);
+        yield* toStep();
+        return;
+      }
+      if (!(location in totalConnectionsFollowedByNode))
+        totalConnectionsFollowedByNode[location] = 0;
+      state[location].status = "set";
+      state[location].metadata = toMockMetadata(location, totalConnectionsFollowedByNode[location]);
+      const path2 = toPath(state);
+      yield { path: path2, state: JSON.parse(JSON.stringify(state)) };
+      totalConnectionsFollowedByNode[location]++;
+      const newLocation = path2.at(-1);
+      if (toOutdegree(newLocation) > 0)
+        location = newLocation;
+      yield* toStep();
+    }
+    yield* toStep();
+  };
+}
+function createToPath$2(directedAcyclic) {
+  const toOutdegree = createToOutdegree(directedAcyclic), toOutgoing = createToOutgoing(directedAcyclic), firstRoot = lazyCollections.pipe(
+    createToRoots(),
+    lazyCollections.at(0)
+  )(directedAcyclic);
+  return (state) => {
+    const path = [firstRoot], getLastOutdegree = () => toOutdegree(path.at(-1)), getLastStatus = () => state[path.at(-1)].status;
+    while (getLastOutdegree() > 0 && getLastStatus() === "set") {
+      const edge = lazyCollections.pipe(
+        toOutgoing,
+        lazyCollections.find(
+          ({ predicateTraversable }) => predicateTraversable(state)
+        )
+      )(path.at(-1));
+      path.push(edge.to);
+    }
+    return path;
+  };
+}
+function createToRoots(options = {}) {
+  return function* (directedAcyclic) {
+    const { nodes } = directedAcyclic;
+    for (const node of nodes) {
+      if (createPredicateRoot(directedAcyclic)(node))
+        yield node;
+      if (options.kind === "arborescence")
+        break;
+    }
+  };
+}
+
+function createToLayers(options = {}) {
+  const toSteps = createToSteps$1(options.createToSteps);
+  return async function toLayers(directedAcyclic) {
+    const layers = [];
+    for await (const { path } of toSteps(directedAcyclic)) {
+      const node = path.at(-1), depth = path.length - 1;
+      (layers[depth] || (layers[depth] = [])).push(node);
+    }
+    return layers;
+  };
+}
+function createToTree$1(options = {}) {
+  const toSteps = createToSteps$1(options.createToSteps);
+  return async function toTree(directedAcyclic) {
+    const firstRoot = lazyCollections.pipe(
+      createToRoots(),
+      lazyCollections.at(0)
+    )(directedAcyclic), tree = [];
+    tree.push({
+      node: firstRoot,
+      children: []
+    });
+    for await (const { path } of toSteps(directedAcyclic)) {
+      const node = path.at(-1), parent = path.at(-2);
+      if (parent) {
+        const parentTreeNode = createFind(parent)(tree);
+        if (parentTreeNode) {
+          parentTreeNode.children.push({
+            node,
+            children: []
+          });
+        }
+      }
+    }
+    return tree;
+  };
+}
+function createToCommonAncestors$1(directedAcyclic) {
+  const toNodeSteps = createToNodeSteps$1(directedAcyclic);
+  return async function* (a, b) {
+    for await (const { path: aPath } of toNodeSteps(a)) {
+      for await (const { path: bPath } of toNodeSteps(b)) {
+        for (let aPathIndex = aPath.length - 1; aPathIndex >= 0; aPathIndex--) {
+          for (let bPathIndex = bPath.length - 1; bPathIndex >= 0; bPathIndex--) {
+            if (aPath[aPathIndex] === bPath[bPathIndex] && !lazyCollections.includes(aPath[aPathIndex])([a, b])) {
+              yield {
+                node: aPath[aPathIndex],
+                distances: {
+                  [a]: aPath.length - aPathIndex - 1,
+                  [b]: bPath.length - bPathIndex - 1
+                }
+              };
+            }
+          }
+        }
+      }
+    }
+  };
+}
+function createPredicateAncestor$1(directedAcyclic) {
+  const toNodeSteps = createToNodeSteps$1(directedAcyclic);
+  return async function(descendant, ancestor) {
+    return await lazyCollections.pipe(
+      toNodeSteps,
+      lazyCollections.some(({ path }) => lazyCollections.includes(ancestor)(path))
+    )(descendant);
+  };
+}
+function createToNodeSteps$1(directedAcyclic, options = {}) {
+  const toSteps = createToSteps$1(options.createToSteps);
+  return async function* (node) {
+    yield* await lazyCollections.pipe(
+      toSteps,
+      lazyCollections.filter(({ path }) => path.at(-1) === node)
+    )(directedAcyclic);
+  };
+}
+function createToSteps$1(options = {}) {
+  const { toUnsetMetadata, toMockMetadata, root, kind } = { ...defaultCreateToStepsOptions$1, ...options };
+  return async function* (directedAcyclic) {
+    const { nodes } = directedAcyclic, toOutdegree = createToOutdegree(directedAcyclic), toPath = createToPath$1(directedAcyclic), roots = lazyCollections.pipe(
+      createToRoots({ kind }),
+      lazyCollections.toArray()
+    )(directedAcyclic), state = {}, totalConnectionsFollowedByNode = {}, predicateExhausted = (node) => {
+      return totalConnectionsFollowedByNode[node] === toOutdegree(node);
+    };
+    for (const node of nodes) {
+      state[node] = {
+        status: "unset",
+        metadata: toUnsetMetadata(node)
+      };
+    }
+    let location = root || lazyCollections.at(0)(roots);
+    const path = await toPath(state);
+    yield { path, state: JSON.parse(JSON.stringify(state)) };
+    async function* toStep() {
+      if (predicateExhausted(location)) {
+        if (lazyCollections.includes(location)(roots))
+          return;
+        state[location].status = "unset";
+        state[location].metadata = toUnsetMetadata(location);
+        const path3 = await toPath(state);
+        location = path3.at(-2);
+        yield* await toStep();
+        return;
+      }
+      if (!(location in totalConnectionsFollowedByNode))
+        totalConnectionsFollowedByNode[location] = 0;
+      state[location].status = "set";
+      state[location].metadata = toMockMetadata(location, totalConnectionsFollowedByNode[location]);
+      const path2 = await toPath(state);
+      yield { path: path2, state: JSON.parse(JSON.stringify(state)) };
+      totalConnectionsFollowedByNode[location]++;
+      const newLocation = path2.at(-1);
+      if (toOutdegree(newLocation) > 0)
+        location = newLocation;
+      yield* await toStep();
+    }
+    yield* await toStep();
+  };
+}
+function createToPath$1(directedAcyclic) {
+  const toOutdegree = createToOutdegree(directedAcyclic), toOutgoing = createToOutgoing(directedAcyclic), firstRoot = lazyCollections.pipe(
+    createToRoots(),
+    lazyCollections.at(0)
+  )(directedAcyclic);
+  return async (state) => {
+    const path = [firstRoot], getLastOutdegree = () => toOutdegree(path.at(-1)), getLastStatus = () => state[path.at(-1)].status;
+    while (getLastOutdegree() > 0 && getLastStatus() === "set") {
+      const edge = await lazyCollections.pipe(
+        toOutgoing,
+        lazyCollections.toArray(),
+        createFindAsync(
+          async ({ predicateTraversable }) => await predicateTraversable(state)
+        )
+      )(path.at(-1));
+      path.push(edge.to);
+    }
+    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 = lazyCollections.pipe(
+    fromComboToAliases,
+    lazyCollections.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 lazyCollections.every(lazyCollections.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 lazyCollections.find(
+      ([candidate]) => predicateKey(candidate)
+    )(entries)?.[1];
+  };
+  const set = (key, value) => {
+    const predicateKey = createPredicateKey(key), index = lazyCollections.findIndex(
+      ([candidate]) => predicateKey(candidate)
+    )(entries);
+    if (index === -1) {
+      entries.push([key, value]);
+      return;
+    }
+    entries[index][1] = value;
+  };
+  const predicateHas = (key) => {
+    const predicateKey = createPredicateKey(key);
+    return lazyCollections.findIndex(
+      ([candidate]) => predicateKey(candidate)
+    )(entries) !== -1;
+  };
+  const clear = () => {
+    entries.length = 0;
+  };
+  const del = (key) => {
+    const predicateKey = createPredicateKey(key), index = lazyCollections.findIndex(
+      ([candidate]) => predicateKey(candidate)
+    )(entries);
+    if (index === -1) {
+      return false;
+    }
+    entries.splice(index, 1);
+    return true;
+  };
+  const toKeys = () => {
+    return createMap(([key]) => key)(entries);
+  };
+  const toValues = () => {
+    return createMap(([, value]) => value)(entries);
+  };
+  const toEntries = () => {
+    return entries;
+  };
+  return {
+    toValue,
+    set,
+    predicateHas,
+    clear,
+    delete: del,
+    toKeys,
+    toValues,
+    toEntries
+    // get: toValue,
+    // has: predicateHas,
+    // keys: toKeys,
+    // values: toValues,
+  };
+}
+
+const defaultOptions$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 (lazyCollections.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 (lazyCollections.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 (lazyCollections.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 (lazyCollections.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 (lazyCollections.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 (lazyCollections.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"];
+
+function createKonami(options = {}) {
+  return createKeychord("up up down down left right left right b a enter", options);
+}
+
+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 lazyCollections.includes("down")(statuses.toValues());
+}
+
+function fromComboToAliases(combo) {
+  const delimiter = "+";
+  return lazyCollections.pipe(
+    lazyCollections.unique(),
+    lazyCollections.map((name) => name === "" ? delimiter : name.toLowerCase()),
+    lazyCollections.toArray()
+  )(combo.split(delimiter));
+}
+
+function fromAliasToKeyStatusKey(alias) {
+  if (alias in keysByAlias) {
+    return { key: keysByAlias[alias] };
+  }
+  return {
+    code: (() => {
+      if (alias in codesByAlias)
+        return codesByAlias[alias];
+      if (letterRE.test(alias))
+        return `Key${alias.toUpperCase()}`;
+      if (digitRE.test(alias))
+        return `Digit${alias}`;
+      if (functionRE.test(alias))
+        return alias.toUpperCase();
+      return "unsupported";
+    })()
+  };
+}
+const digitRE = /^[0-9]$/;
+const letterRE = /^[a-zA-Z]$/;
+const functionRE = /^[fF][0-9]{1,2}$/;
+const codesByAlias = {
+  "`": "Backquote",
+  "~": "Backquote",
+  "-": "Minus",
+  _: "Minus",
+  "=": "Equal",
+  "+": "Equal",
+  "[": "BracketLeft",
+  "{": "BracketLeft",
+  "]": "BracketRight",
+  "}": "BracketRight",
+  "\\": "Backslash",
+  "|": "Backslash",
+  ";": "Semicolon",
+  ":": "Semicolon",
+  "'": "Quote",
+  '"': "Quote",
+  ",": "Comma",
+  "<": "Comma",
+  ".": "Period",
+  ">": "Period",
+  "/": "Slash",
+  "?": "Slash",
+  "!": "Digit1",
+  "@": "Digit2",
+  "#": "Digit3",
+  $: "Digit4",
+  "%": "Digit5",
+  "^": "Digit6",
+  "&": "Digit7",
+  "*": "Digit8",
+  "(": "Digit9",
+  ")": "Digit0",
+  up: "ArrowUp",
+  down: "ArrowDown",
+  left: "ArrowLeft",
+  right: "ArrowRight",
+  enter: "Enter",
+  space: "Space",
+  tab: "Tab",
+  esc: "Escape",
+  backspace: "Backspace",
+  delete: "Delete",
+  home: "Home",
+  end: "End",
+  pagedown: "PageDown",
+  pageup: "PageUp",
+  capslock: "CapsLock",
+  camera: "Camera"
+};
+const keysByAlias = {
+  alt: "Alt",
+  opt: "Alt",
+  option: "Alt",
+  ctrl: "Control",
+  control: "Control",
+  meta: "Meta",
+  cmd: "Meta",
+  command: "Meta",
+  shift: "Shift"
+};
+
+const defaultOptions$a = {
+  toKey: (alias) => fromAliasToKeyStatusKey(alias)
+};
+const createPredicateKeycomboDown = (keycombo, options = {}) => {
+  const { toKey } = { ...defaultOptions$a, ...options }, keys = lazyCollections.pipe(
+    fromComboToAliases,
+    lazyCollections.map(toKey)
+  )(keycombo);
+  return (statuses) => {
+    const { toValue } = statuses;
+    return lazyCollections.every(lazyCollections.pipe(
+      toValue,
+      predicateDown
+    ))(keys);
+  };
+};
+
+function fromEventToAliases(event) {
+  if (event.shiftKey && event.code in aliasesByShiftCode) {
+    return [aliasesByShiftCode[event.code]];
+  }
+  if (event.key in aliasListsByModifier) {
+    return aliasListsByModifier[event.key];
+  }
+  return event.code in aliasesByCode ? [aliasesByCode[event.code]] : [event.code.match(aliasCaptureRE)?.[1].toLowerCase() || "unsupported"];
+}
+const aliasCaptureRE = /^(?:Digit|Key)?(F[0-9]{1,2}|[0-9]|[A-Z])$/;
+const aliasesByCode = {
+  Backquote: "`",
+  Minus: "-",
+  Equal: "=",
+  BracketLeft: "[",
+  BracketRight: "]",
+  Backslash: "\\",
+  Semicolon: ";",
+  Quote: "'",
+  Comma: ",",
+  Period: ".",
+  Slash: "/",
+  ArrowUp: "up",
+  ArrowDown: "down",
+  ArrowLeft: "left",
+  ArrowRight: "right",
+  Enter: "enter",
+  Space: "space",
+  Tab: "tab",
+  Escape: "esc",
+  Backspace: "backspace",
+  Delete: "delete",
+  Home: "home",
+  End: "end",
+  PageDown: "pagedown",
+  PageUp: "pageup",
+  CapsLock: "capslock",
+  Camera: "camera"
+};
+const aliasesByShiftCode = {
+  Backquote: "~",
+  Minus: "_",
+  Equal: "+",
+  BracketLeft: "{",
+  BracketRight: "}",
+  Backslash: "|",
+  Semicolon: ":",
+  Quote: '"',
+  Comma: "<",
+  Period: ">",
+  Slash: "?",
+  Digit1: "!",
+  Digit2: "@",
+  Digit3: "#",
+  Digit4: "$",
+  Digit5: "%",
+  Digit6: "^",
+  Digit7: "&",
+  Digit8: "*",
+  Digit9: "(",
+  Digit0: ")"
+};
+const aliasListsByModifier = {
+  Alt: ["alt", "option", "opt"],
+  Control: ["control", "ctrl"],
+  Meta: ["meta", "command", "cmd"],
+  Shift: ["shift"]
+};
+
+const defaultOptions$9 = {
+  toKey: (alias) => fromAliasToKeyStatusKey(alias),
+  toAliases: (event) => fromEventToAliases(event)
+};
+const createPredicateKeycomboMatch = (keycombo, options = {}) => {
+  const { toKey, toAliases } = { ...defaultOptions$9, ...options }, aliases = fromComboToAliases(keycombo), keys = lazyCollections.map(toKey)(aliases);
+  return (statuses) => {
+    const { toValue } = statuses;
+    return lazyCollections.every(lazyCollections.pipe(
+      toValue,
+      predicateDown
+    ))(keys) && lazyCollections.every(
+      ([key, value]) => value === "up" || lazyCollections.some(
+        (alias) => lazyCollections.includes(alias)(aliases)
+      )(toAliases(key))
+    )(statuses.toEntries());
+  };
+};
+
+function createKeyState({
+  keycomboOrKeycombos,
+  unsupportedAliases,
+  toKey,
+  toAliases,
+  getRequest
+}) {
+  const narrowedKeycombos = createFilter(
+    (keycombo) => !lazyCollections.some(
+      (alias) => lazyCollections.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 = lazyCollections.pipe(
+    lazyCollections.flatMap(fromComboToAliases),
+    lazyCollections.unique(),
+    lazyCollections.toArray()
+  )(narrowedKeycombos), getDownCombos = () => lazyCollections.pipe(
+    lazyCollections.filter(([, predicate]) => predicate(statuses)),
+    lazyCollections.map(([keycombo]) => [keycombo, fromComboToAliases(keycombo)]),
+    lazyCollections.sort(([, aliasesA], [, aliasesB]) => aliasesB.length - aliasesA.length),
+    lazyCollections.map(([keycombo]) => keycombo),
+    lazyCollections.toArray()
+  )(downPredicatesByKeycombo), predicateValid = (event) => {
+    const aliases = toAliases(event);
+    return lazyCollections.some(
+      (validAlias) => lazyCollections.includes(validAlias)(aliases)
+    )(validAliases);
+  }, cleanup = () => {
+    window.cancelAnimationFrame(getRequest());
+  }, statuses = createKeyStatuses();
+  return {
+    narrowedKeycombos,
+    createPredicateKeycomboDownOptions,
+    downPredicatesByKeycombo,
+    createPredicateKeycomboMatchOptions,
+    matchPredicatesByKeycombo,
+    validAliases,
+    getDownCombos,
+    predicateValid,
+    cleanup,
+    statuses
   };
 }
-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 = lazyCollections.pipe(
+  fromComboToAliases,
+  toLength()
+);
+
+function fromEventToKeyStatusKey({ key, code }) {
+  return lazyCollections.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 : lazyCollections.pipe(
-      lazyCollections.slice(0, index - 1),
-      lazyCollections.reduce((lowerBound2, { probability: probability2 }) => lowerBound2 + probability2, 0)
-    )(potentialities), upperBound = lowerBound + probability;
-    return {
-      outcome,
-      predicate: (determinant) => determinant >= lowerBound && determinant < upperBound || determinant < 0 && index === 0 || index === predicates.length - 1
-    };
-  })(potentialities);
-  return (determinant) => lazyCollections.find(({ predicate }) => predicate(determinant))(predicates).outcome;
+
+function toMousePoint(event) {
+  return {
+    x: event.clientX,
+    y: event.clientY
+  };
 }
-function createRename(from, to) {
-  return (map2) => {
-    const keys = [...map2.keys()], keyToRenameIndex = lazyCollections.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 = lazyCollections.unique();
-const toComboItems = lazyCollections.map((name) => name === "" ? delimiter : name);
-const delimiter = "+";
-function toCombo(type) {
-  return lazyCollections.pipe(
-    toUnique$1,
-    toComboItems,
-    lazyCollections.toArray()
-  )(type.split(delimiter));
-}
-function fromComboItemNameToType(name) {
-  return lazyCollections.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) => lazyCollections.some((selector) => target.matches(selector))(selectors))([only, except]) : [false, true];
+      const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => lazyCollections.some((selector) => target.matches(selector))(selectors))([only, except]) : [false, false];
       if (matchesOnly) {
         effect(event);
         return;
@@ -416,7 +2142,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) => lazyCollections.some((selector) => target.matches(selector))(selectors))([only, except]) : [false, true];
+      const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => lazyCollections.some((selector) => target.matches(selector))(selectors))([only, except]) : [false, false];
       if (matchesOnly) {
         effect(event);
         return;
@@ -429,7 +2155,7 @@ function createExceptAndOnlyEffect(type, effect, options) {
   }
   if (type.startsWith("pointer")) {
     return (event) => {
-      const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => lazyCollections.some((selector) => target.matches(selector))(selectors))([only, except]) : [false, true];
+      const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => lazyCollections.some((selector) => target.matches(selector))(selectors))([only, except]) : [false, false];
       if (matchesOnly) {
         effect(event);
         return;
@@ -441,7 +2167,7 @@ function createExceptAndOnlyEffect(type, effect, options) {
     };
   }
   return (event) => {
-    const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => lazyCollections.some((selector) => target.matches(selector))(selectors))([only, except]) : [false, true];
+    const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => lazyCollections.some((selector) => target.matches(selector))(selectors))([only, except]) : [false, false];
     if (matchesOnly) {
       effect(event, {});
       return;
@@ -452,27 +2178,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);
 }
@@ -491,24 +2205,8 @@ function predicateNumber(value) {
 function predicateString(value) {
   return typeof value === "string";
 }
-const tabbableSelector = lazyCollections.join(':not([hidden]):not([tabindex="-1"]),')([
-  "input:not([disabled]):not([type=hidden])",
-  "select:not([disabled])",
-  "textarea:not([disabled])",
-  "button:not([disabled])",
-  "a[href]",
-  "area[href]",
-  "summary",
-  "iframe",
-  "object",
-  "embed",
-  "audio[controls]",
-  "video[controls]",
-  "[contenteditable]",
-  "[tabindex]:not([disabled])"
-]);
-function predicateFocusable(element) {
-  return element.matches(tabbableSelector);
+function predicateObject(value) {
+  return typeof value === "object";
 }
 
 class Recognizeable {
@@ -521,7 +2219,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 = {
@@ -530,8 +2228,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();
@@ -546,12 +2242,6 @@ class Recognizeable {
   denied() {
     this.computedStatus = "denied";
   }
-  recognizedUntilReady() {
-    this.computedStatus = "recognized until ready";
-  }
-  deniedUntilReady() {
-    this.computedStatus = "denied until ready";
-  }
   computedStatus;
   ready() {
     this.computedStatus = "ready";
@@ -574,8 +2264,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]
@@ -583,11 +2272,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;
@@ -630,8 +2318,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);
@@ -731,24 +2419,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);
@@ -769,10 +2443,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";
@@ -884,109 +2558,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 lazyCollections.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 lazyCollections.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 lazyCollections.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
 };
@@ -1007,10 +2594,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);
@@ -1086,10 +2673,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 = lazyCollections.pipe(
+      lazyCollections.reverse(),
+      lazyCollections.map(({ progress, properties }) => ({ progress: 1 - progress, properties })),
+      lazyCollections.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 });
@@ -1387,7 +2975,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";
@@ -1396,7 +2984,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);
             }
           }
@@ -1412,7 +3000,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";
@@ -1424,7 +3012,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);
             }
           }
@@ -1633,7 +3221,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 },
@@ -1648,7 +3236,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(
@@ -1893,14 +3481,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;
@@ -1965,12 +3553,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 + lazyCollections.pipe(
+      createEntries(),
+      lazyCollections.sort((a, b) => a[0] < b[0] ? -1 : 1),
+      lazyCollections.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"
@@ -2053,6 +3698,7 @@ class Completeable {
     }
     return this;
   }
+  // TODO: Support array of selections for multi cursor editing
   computedSelection;
   setSelection(selection) {
     this.computedSelection = selection;
@@ -2129,12 +3775,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 = lazyCollections.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;
@@ -2505,11 +4151,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;
@@ -2522,6 +4169,10 @@ class Fetchable {
   set resource(resource) {
     this.setResource(resource);
   }
+  computedKy;
+  get ky() {
+    return this.computedKy;
+  }
   computedAbortController;
   get abortController() {
     if (!this.computedAbortController) {
@@ -2535,6 +4186,10 @@ class Fetchable {
   get response() {
     return this.computedResponse;
   }
+  computedRetryCount = 0;
+  get retryCount() {
+    return this.computedRetryCount;
+  }
   get error() {
     return this.computedError;
   }
@@ -2563,7 +4218,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;
@@ -2577,6 +4248,9 @@ class Fetchable {
   fetching() {
     this.computedStatus = "fetching";
   }
+  retrying() {
+    this.computedStatus = "retrying";
+  }
   fetched() {
     this.computedStatus = "fetched";
   }
@@ -2587,23 +4261,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() {
@@ -2612,16 +4290,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 {
@@ -2949,13 +4620,12 @@ class Pickable {
   }
   pick(indexOrIndices, options = {}) {
     const { replace, allowsDuplicates } = { ...defaultPickOptions, ...options };
-    this.computedPicks = new Pipeable(indexOrIndices).pipe(
+    this.computedPicks = lazyCollections.pipe(
       narrowIndices,
       this.toPossiblePicks,
       (possiblePicks) => {
-        if (replace === "all") {
+        if (replace === "all")
           return allowsDuplicates ? possiblePicks : toUnique(possiblePicks);
-        }
         const maybeWithoutDuplicates = allowsDuplicates ? possiblePicks : createFilter(
           (possiblePick) => typeof lazyCollections.find((pick) => pick === possiblePick)(this.picks || []) !== "number"
         )(possiblePicks);
@@ -2972,10 +4642,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 lazyCollections.pipe(
+              lazyCollections.slice(maybeWithoutDuplicates.length),
+              (array) => lazyCollections.concat(array, maybeWithoutDuplicates),
+              lazyCollections.toArray()
+            )(this.picks);
           case "lifo":
             if (maybeWithoutDuplicates.length === 0) {
               return this.picks;
@@ -2986,13 +4657,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 lazyCollections.pipe(
+              lazyCollections.slice(0, this.picks.length - maybeWithoutDuplicates.length - 1),
+              (array) => lazyCollections.concat(array, maybeWithoutDuplicates),
+              lazyCollections.toArray()
+            )(this.picks);
         }
       }
-    );
+    )(indexOrIndices);
     this.computedFirst = Math.min(...this.picks);
     this.computedLast = Math.max(...this.picks);
     this.computedMultiple = toUnique(this.picks).length > 1;
@@ -3040,7 +4712,7 @@ class Sanitizeable {
   computedDompurify;
   computedStatus;
   ready() {
-    if (domIsAvailable()) {
+    if (getDomAvailability() === "available") {
       this.computedDompurify = createDOMPurify();
       this.computedDompurify.setConfig(this.domPurifyConfig);
     }
@@ -3053,7 +4725,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);
     }
@@ -3196,7 +4868,7 @@ class Storeable {
   computedStatus;
   ready() {
     this.computedStatus = "ready";
-    if (domIsAvailable()) {
+    if (getDomAvailability() === "available") {
       if (predicateNull(this.storage.getItem(this.computedStatusKey))) {
         this.storeStatus();
       }
@@ -3209,7 +4881,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;
@@ -3299,6 +4971,7 @@ class Storeable {
 
 exports.Animateable = Animateable;
 exports.Broadcastable = Broadcastable;
+exports.Compareable = Compareable;
 exports.Completeable = Completeable;
 exports.Copyable = Copyable;
 exports.Delayable = Delayable;
@@ -3309,26 +4982,61 @@ exports.Grantable = Grantable;
 exports.Listenable = Listenable;
 exports.Navigateable = Navigateable;
 exports.Pickable = Pickable;
-exports.Pipeable = Pipeable;
 exports.Recognizeable = Recognizeable;
 exports.Resolveable = Resolveable;
 exports.Sanitizeable = Sanitizeable;
 exports.Searchable = Searchable;
 exports.Shareable = Shareable;
 exports.Storeable = Storeable;
+exports.createAssociativeArray = createAssociativeArray;
+exports.createAsyncDirectedAcyclicPredicateAncestor = createPredicateAncestor$1;
+exports.createAsyncDirectedAcyclicToCommonAncestors = createToCommonAncestors$1;
+exports.createAsyncDirectedAcyclicToLayers = createToLayers;
+exports.createAsyncDirectedAcyclicToNodeSteps = createToNodeSteps$1;
+exports.createAsyncDirectedAcyclicToPath = createToPath$1;
+exports.createAsyncDirectedAcyclicToSteps = createToSteps$1;
+exports.createAsyncDirectedAcyclicToTree = createToTree$1;
 exports.createClamp = createClamp;
 exports.createClip = createClip;
+exports.createClone = createClone;
 exports.createConcat = createConcat;
+exports.createDecisionTreePredicateAncestor = createPredicateAncestor;
+exports.createDecisionTreeToCommonAncestors = createToCommonAncestors;
+exports.createDecisionTreeToNodeSteps = createToNodeSteps;
+exports.createDecisionTreeToPath = createToPath;
+exports.createDecisionTreeToSteps = createToSteps;
+exports.createDecisionTreeToTree = createToTree;
 exports.createDetermine = createDetermine;
+exports.createDirectedAcyclicPredicateAncestor = createPredicateAncestor$2;
+exports.createDirectedAcyclicToCommonAncestors = createToCommonAncestors$2;
+exports.createDirectedAcyclicToLayers = createToLayers$1;
+exports.createDirectedAcyclicToNodeSteps = createToNodeSteps$2;
+exports.createDirectedAcyclicToPath = createToPath$2;
+exports.createDirectedAcyclicToRoots = createToRoots;
+exports.createDirectedAcyclicToSteps = createToSteps$2;
+exports.createDirectedAcyclicToTree = createToTree$2;
+exports.createEntries = createEntries;
+exports.createEqual = createEqual;
+exports.createEvery = createEvery;
 exports.createFilter = createFilter;
 exports.createFilterAsync = createFilterAsync;
+exports.createFindAsync = createFindAsync;
+exports.createFindIndexAsync = createFindIndexAsync;
+exports.createFocusable = createFocusable;
 exports.createForEachAsync = createForEachAsync;
 exports.createInsert = createInsert;
+exports.createKeychord = createKeychord;
+exports.createKeypress = createKeypress;
+exports.createKeyrelease = createKeyrelease;
+exports.createKeys = createKeys;
+exports.createKonami = createKonami;
+exports.createList = createList;
 exports.createMap = createMap;
 exports.createMapAsync = createMapAsync;
-exports.createMatchesKeycombo = createMatchesKeycombo;
-exports.createMatchesMousecombo = createMatchesMousecombo;
-exports.createMatchesPointercombo = createMatchesPointercombo;
+exports.createMousepress = createMousepress;
+exports.createMouserelease = createMouserelease;
+exports.createPredicateKeycomboMatch = createPredicateKeycomboMatch$1;
+exports.createPredicateRoot = createPredicateRoot;
 exports.createReduce = createReduce;
 exports.createReduceAsync = createReduceAsync;
 exports.createRemove = createRemove;
@@ -3338,14 +5046,27 @@ exports.createReplace = createReplace;
 exports.createReverse = createReverse;
 exports.createSlice = createSlice;
 exports.createSlug = createSlug;
+exports.createSome = createSome;
 exports.createSort = createSort;
 exports.createSwap = createSwap;
-exports.createToEntries = createToEntries;
-exports.createToEvery = createToEvery;
-exports.createToFocusable = createToFocusable;
-exports.createToKeys = createToKeys;
-exports.createToSome = createToSome;
+exports.createToGraph = createToGraph;
+exports.createToIncoming = createToIncoming;
+exports.createToIndegree = createToIndegree;
+exports.createToOutdegree = createToOutdegree;
+exports.createToOutgoing = createToOutgoing;
+exports.createTouchpress = createTouchpress;
+exports.createTouchrelease = createTouchrelease;
+exports.createTreeFind = createFind;
 exports.createUnique = createUnique;
+exports.defineAssociativeArrayEntries = defineAssociativeArrayEntries;
+exports.defineAsyncGraph = defineAsyncGraph;
+exports.defineAsyncGraphEdge = defineAsyncGraphEdge;
+exports.defineAsyncGraphEdges = defineAsyncGraphEdges;
+exports.defineGraph = defineGraph;
+exports.defineGraphEdge = defineGraphEdge;
+exports.defineGraphEdges = defineGraphEdges;
+exports.defineGraphNode = defineGraphNode;
+exports.defineGraphNodes = defineGraphNodes;
 exports.easingsNetInBack = easingsNetInBack;
 exports.easingsNetInCirc = easingsNetInCirc;
 exports.easingsNetInCubic = easingsNetInCubic;