@baleada/logic 0.22.4 → 0.22.6

package/lib/index.cjs

@@ -47,7 +47,7 @@ function createFilterAsync(condition) {
     return createFilter((_, index) => transformedAsync[index])(array);
   };
 }
-function createDelete(index) {
+function createRemove(index) {
   return (array) => {
     return createConcat(
       createSlice(0, index)(array),
@@ -66,7 +66,7 @@ function createInsert(item, index) {
 }
 function createReorder(from, to) {
   return (array) => {
-    const [itemsToMoveStartIndex, itemsToMoveCount] = isObject(from) ? [from.start, from.itemCount] : [from, 1], insertIndex = to;
+    const [itemsToMoveStartIndex, itemsToMoveCount] = predicateObject(from) ? [from.start, from.itemCount] : [from, 1], insertIndex = to;
     if (insertIndex > itemsToMoveStartIndex && insertIndex < itemsToMoveStartIndex + itemsToMoveCount) {
       return array;
     }
@@ -92,7 +92,7 @@ function createReorder(from, to) {
     return array;
   };
 }
-function isObject(value) {
+function predicateObject(value) {
   return typeof value === "object";
 }
 function createSwap(indices) {
@@ -220,6 +220,46 @@ function createToEntries() {
     return entries;
   };
 }
+function createToKeys() {
+  return (object) => {
+    const keys = [];
+    for (const key in object) {
+      keys.push(key);
+    }
+    return keys;
+  };
+}
+function createMatchesKeycombo(keycombo) {
+  return (event) => eventMatchesKeycombo(event, narrowKeycombo(keycombo));
+}
+function createMatchesMousecombo(mousecombo) {
+  return (event) => eventMatchesMousecombo(event, narrowMousecombo(mousecombo));
+}
+function createMatchesPointercombo(pointercombo) {
+  return (event) => eventMatchesPointercombo(event, narrowPointercombo(pointercombo));
+}
+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;
+    }
+  };
+}
 class Pipeable {
   constructor(state) {
     this.state = state;
@@ -287,16 +327,16 @@ const keysByName = {
   f20: "F20"
 };
 const toListenableKeycomboItems = createMap((name) => ({ name, type: fromComboItemNameToType(name) }));
-function ensureKeycombo(type) {
+function narrowKeycombo(type) {
   return new Pipeable(type).pipe(
     toCombo,
     toListenableKeycomboItems
   );
 }
-function ensureClickcombo(type) {
+function narrowMousecombo(type) {
   return toCombo(type);
 }
-function ensurePointercombo(type) {
+function narrowPointercombo(type) {
   return toCombo(type);
 }
 const toUnique$1 = lazyCollections.unique();
@@ -343,45 +383,39 @@ 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], api = {
-        matches: (keycombo) => eventMatchesKeycombo(event, ensureKeycombo(keycombo))
-      };
+      const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => lazyCollections.some((selector) => target.matches(selector))(selectors))([only, except]) : [false, true];
       if (matchesOnly) {
-        effect(event, api);
+        effect(event);
         return;
       }
       if (only.length === 0 && !matchesExcept) {
-        effect(event, api);
+        effect(event);
         return;
       }
     };
   }
   if (type === "click" || type === "dblclick" || type === "contextmenu" || type.startsWith("mouse")) {
     return (event) => {
-      const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => lazyCollections.some((selector) => target.matches(selector))(selectors))([only, except]) : [false, true], api = {
-        matches: (clickcombo) => eventMatchesClickcombo(event, ensureClickcombo(clickcombo))
-      };
+      const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => lazyCollections.some((selector) => target.matches(selector))(selectors))([only, except]) : [false, true];
       if (matchesOnly) {
-        effect(event, api);
+        effect(event);
         return;
       }
       if (only.length === 0 && !matchesExcept) {
-        effect(event, api);
+        effect(event);
         return;
       }
     };
   }
   if (type.startsWith("pointer")) {
     return (event) => {
-      const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => lazyCollections.some((selector) => target.matches(selector))(selectors))([only, except]) : [false, true], api = {
-        matches: (pointercombo) => eventMatchesPointercombo(event, ensurePointercombo(pointercombo))
-      };
+      const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => lazyCollections.some((selector) => target.matches(selector))(selectors))([only, except]) : [false, true];
       if (matchesOnly) {
-        effect(event, api);
+        effect(event);
         return;
       }
       if (only.length === 0 && !matchesExcept) {
-        effect(event, api);
+        effect(event);
         return;
       }
     };
@@ -398,7 +432,7 @@ function createExceptAndOnlyEffect(type, effect, options) {
     }
   };
 }
-function isModified({ event, alias }) {
+function predicateModified({ event, alias }) {
   return predicatesByModifier[alias]?.(event);
 }
 const predicatesByModifier = {
@@ -419,24 +453,43 @@ function domIsAvailable() {
     return false;
   }
 }
-function isArray(value) {
+function predicateArray(value) {
   return Array.isArray(value);
 }
-function isUndefined(value) {
+function predicateUndefined(value) {
   return value === void 0;
 }
-function isFunction(value) {
+function predicateFunction(value) {
   return typeof value === "function";
 }
-function isNull(value) {
+function predicateNull(value) {
   return value === null;
 }
-function isNumber(value) {
+function predicateNumber(value) {
   return typeof value === "number";
 }
-function isString(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);
+}
 
 class Recognizeable {
   maxSequenceLength;
@@ -456,7 +509,10 @@ class Recognizeable {
       getMetadata: () => this.metadata,
       setMetadata: (metadata) => this.computedMetadata = metadata,
       recognized: () => this.recognized(),
-      denied: () => this.denied()
+      denied: () => this.denied(),
+      recognizedUntilReady: () => this.recognizedUntilReady(),
+      deniedUntilReady: () => this.deniedUntilReady(),
+      ready: () => this.ready()
     };
     this.ready();
   }
@@ -470,6 +526,12 @@ class Recognizeable {
   denied() {
     this.computedStatus = "denied";
   }
+  recognizedUntilReady() {
+    this.computedStatus = "recognized until ready";
+  }
+  deniedUntilReady() {
+    this.computedStatus = "denied until ready";
+  }
   computedStatus;
   ready() {
     this.computedStatus = "ready";
@@ -491,18 +553,21 @@ class Recognizeable {
     this.computedSequence = sequence;
     return this;
   }
-  recognize(sequenceItem, api, { onRecognized } = {}) {
-    this.recognizing();
-    const type = this.toType(sequenceItem), excess = isNumber(this.maxSequenceLength) ? Math.max(0, this.sequence.length - this.maxSequenceLength) : 0, newSequence = createConcat(
+  recognize(sequenceItem, { onRecognized } = {}) {
+    if (!this.status.includes("until ready"))
+      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]
     )([]);
     this.effectApi.getSequence = () => newSequence;
     this.effectApi.onRecognized = onRecognized || (() => {
     });
-    this.effects.get(type)?.(sequenceItem, { ...api, ...this.effectApi });
+    this.effects.get(type)?.(sequenceItem, { ...this.effectApi });
     switch (this.status) {
+      case "ready":
       case "denied":
+      case "denied until ready":
         this.resetComputedMetadata();
         this.setSequence([]);
         break;
@@ -517,7 +582,7 @@ class Recognizeable {
     this.computedStatus = "recognizing";
   }
   toType(sequenceItem) {
-    if (isArray(sequenceItem)) {
+    if (predicateArray(sequenceItem)) {
       if (sequenceItem[0] instanceof IntersectionObserverEntry) {
         return "intersect";
       }
@@ -629,27 +694,40 @@ class Listenable {
   }
   mediaQueryListen(effect, options) {
     const target = window.matchMedia(this.type);
-    if (isFunction(options.instantEffect)) {
+    if (predicateFunction(options.instantEffect)) {
       options.instantEffect(target);
     }
-    const withApi = (event) => effect(event, {});
+    const withApi = (event) => effect(event);
     target.addEventListener("change", withApi);
     this.active.add({ target, id: ["change", withApi] });
   }
   idleListen(effect, options) {
-    const { requestIdleCallback } = options, id = window.requestIdleCallback((deadline) => effect(deadline, {}), requestIdleCallback);
+    const { requestIdleCallback } = options, id = window.requestIdleCallback((deadline) => effect(deadline), requestIdleCallback);
     this.active.add({ target: window, id });
   }
   messageListen(effect, options) {
     const { target = new BroadcastChannel("baleada") } = options;
-    target.addEventListener(this.type, (event) => effect(event, {}));
+    target.addEventListener(this.type, (event) => effect(event));
     this.active.add({ target, id: [this.type, effect] });
   }
   recognizeableListen(effect, options) {
-    const guardedEffect = (sequenceItem, api) => {
-      this.recognizeable.recognize(sequenceItem, api, { onRecognized: (sequenceItem2) => effect(sequenceItem2, api) });
-      if (this.recognizeable.status === "recognized") {
-        effect(sequenceItem, api);
+    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;
       }
     };
     for (const type of this.recognizeableEffectsKeys) {
@@ -659,11 +737,11 @@ class Listenable {
     }
   }
   documentEventListen(effect, options) {
-    const ensuredOptions = {
+    const narrowedOptions = {
       ...options,
       target: document
     };
-    this.eventListen(effect, ensuredOptions);
+    this.eventListen(effect, narrowedOptions);
   }
   eventListen(effect, options) {
     const { exceptAndOnlyEffect, effectOptions } = toAddEventListenerParams(this.type, effect, options), eventListeners = [[this.type, exceptAndOnlyEffect, ...effectOptions]];
@@ -717,7 +795,7 @@ function stop(stoppable) {
     target2.removeEventListener(id2[0], id2[1]);
     return;
   }
-  if (isNumber(stoppable.id)) {
+  if (predicateNumber(stoppable.id)) {
     const { target: target2, id: id2 } = stoppable;
     target2.cancelIdleCallback(id2);
     return;
@@ -790,9 +868,8 @@ function eventMatchesKeycombo(event, keycombo) {
   return lazyCollections.every(({ name, type }, index) => {
     switch (type) {
       case "singleCharacter":
-        if (name === "!") {
+        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":
@@ -806,7 +883,7 @@ function eventMatchesKeycombo(event, keycombo) {
         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("!") ? !isModified({ event, alias: name.slice(1) }) : isModified({ event, alias: name });
+        return name.startsWith("!") ? !predicateModified({ event, alias: name.slice(1) }) : predicateModified({ event, alias: name });
     }
   })(keycombo);
 }
@@ -870,11 +947,11 @@ const predicatesByArrow = /* @__PURE__ */ new Map([
 const arrows = /* @__PURE__ */ new Set(["arrowup", "arrowright", "arrowdown", "arrowleft"]);
 const verticalArrows = /* @__PURE__ */ new Set(["arrowup", "arrowdown"]);
 const horizontalArrows = /* @__PURE__ */ new Set(["arrowright", "arrowleft"]);
-function eventMatchesClickcombo(event, clickcombo) {
-  return lazyCollections.every((name) => fromComboItemNameToType(name) === "click" || name.startsWith("!") && !isModified({ alias: name.slice(1), event }) || !name.startsWith("!") && isModified({ alias: name, event }))(clickcombo);
+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("!") && !isModified({ alias: name.slice(1), event }) || !name.startsWith("!") && isModified({ alias: name, 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,
@@ -1002,13 +1079,13 @@ class Animateable {
   duration;
   totalTimeInvisible;
   setPlaybackRate(playbackRate) {
-    const ensuredPlaybackRate = Math.max(0, playbackRate);
-    this.computedPlaybackRate = ensuredPlaybackRate;
-    this.duration = 1 / ensuredPlaybackRate * this.initialDuration;
+    const narrowedPlaybackRate = Math.max(0, playbackRate);
+    this.computedPlaybackRate = narrowedPlaybackRate;
+    this.duration = 1 / narrowedPlaybackRate * this.initialDuration;
     switch (this.status) {
       case "playing":
       case "reversing":
-        this.totalTimeInvisible = 1 / ensuredPlaybackRate * this.totalTimeInvisible;
+        this.totalTimeInvisible = 1 / narrowedPlaybackRate * this.totalTimeInvisible;
         this.seek(this.progress.time);
         break;
     }
@@ -1397,51 +1474,51 @@ class Animateable {
   seek(timeProgress, options = {}) {
     const iterations = Math.floor(timeProgress), naiveIterationProgress = timeProgress - iterations, { effect: naiveEffect } = options;
     this.computedIterations = iterations;
-    let ensuredTimeProgress, effect;
+    let narrowedTimeProgress, effect;
     if (this.alternates) {
       if (naiveIterationProgress <= 0.5) {
-        ensuredTimeProgress = naiveIterationProgress * 2;
+        narrowedTimeProgress = naiveIterationProgress * 2;
         switch (this.alternateCache.status) {
           case "playing":
             this.cancelAnimate();
-            this.seekCache = { timeProgress: ensuredTimeProgress };
+            this.seekCache = { timeProgress: narrowedTimeProgress };
             this.sought();
-            effect = isFunction(naiveEffect) ? naiveEffect : this.playCache.effect;
+            effect = predicateFunction(naiveEffect) ? naiveEffect : this.playCache.effect;
             this.play(effect, this.playCache.options);
             break;
           case "reversing":
             this.cancelAnimate();
-            this.seekCache = { timeProgress: ensuredTimeProgress };
+            this.seekCache = { timeProgress: narrowedTimeProgress };
             this.sought();
-            effect = isFunction(naiveEffect) ? naiveEffect : this.reverseCache.effect;
+            effect = predicateFunction(naiveEffect) ? naiveEffect : this.reverseCache.effect;
             this.reverse(effect, this.reverseCache.options);
             break;
           default:
-            this.seekCache = { timeProgress: ensuredTimeProgress };
+            this.seekCache = { timeProgress: narrowedTimeProgress };
             this.sought();
             effect = naiveEffect;
             this.createAnimate("seek")(effect, options);
             break;
         }
       } else {
-        ensuredTimeProgress = (naiveIterationProgress - 0.5) * 2;
+        narrowedTimeProgress = (naiveIterationProgress - 0.5) * 2;
         switch (this.alternateCache.status) {
           case "playing":
             this.cancelAnimate();
-            this.seekCache = { timeProgress: ensuredTimeProgress };
+            this.seekCache = { timeProgress: narrowedTimeProgress };
             this.sought();
-            effect = isFunction(naiveEffect) ? naiveEffect : this.reverseCache.effect;
+            effect = predicateFunction(naiveEffect) ? naiveEffect : this.reverseCache.effect;
             this.reverse(effect, this.reverseCache.options);
             break;
           case "reversing":
             this.cancelAnimate();
-            this.seekCache = { timeProgress: ensuredTimeProgress };
+            this.seekCache = { timeProgress: narrowedTimeProgress };
             this.sought();
-            effect = isFunction(naiveEffect) ? naiveEffect : this.playCache.effect;
+            effect = predicateFunction(naiveEffect) ? naiveEffect : this.playCache.effect;
             this.play(effect, this.playCache.options);
             break;
           default:
-            this.seekCache = { timeProgress: ensuredTimeProgress };
+            this.seekCache = { timeProgress: narrowedTimeProgress };
             this.sought();
             effect = naiveEffect;
             if (effect) {
@@ -1451,24 +1528,24 @@ class Animateable {
         }
       }
     } else {
-      ensuredTimeProgress = naiveIterationProgress;
+      narrowedTimeProgress = naiveIterationProgress;
       switch (this.status) {
         case "playing":
           this.cancelAnimate();
-          this.seekCache = { timeProgress: ensuredTimeProgress };
+          this.seekCache = { timeProgress: narrowedTimeProgress };
           this.sought();
-          effect = isFunction(naiveEffect) ? naiveEffect : this.playCache.effect;
+          effect = predicateFunction(naiveEffect) ? naiveEffect : this.playCache.effect;
           this.play(effect, this.playCache.options);
           break;
         case "reversing":
           this.cancelAnimate();
-          this.seekCache = { timeProgress: ensuredTimeProgress };
+          this.seekCache = { timeProgress: narrowedTimeProgress };
           this.sought();
-          effect = isFunction(naiveEffect) ? naiveEffect : this.reverseCache.effect;
+          effect = predicateFunction(naiveEffect) ? naiveEffect : this.reverseCache.effect;
           this.reverse(effect, this.reverseCache.options);
           break;
         default:
-          this.seekCache = { timeProgress: ensuredTimeProgress };
+          this.seekCache = { timeProgress: narrowedTimeProgress };
           this.sought();
           effect = naiveEffect;
           if (effect) {
@@ -1594,13 +1671,13 @@ function createToAnimationProgress(points) {
   return BezierEasing(point1x, point1y, point2x, point2y);
 }
 function toInterpolated({ previous, next, progress }, options = {}) {
-  if (isUndefined(previous)) {
+  if (predicateUndefined(previous)) {
     return next;
   }
-  if (isNumber(previous) && isNumber(next)) {
+  if (predicateNumber(previous) && predicateNumber(next)) {
     return (next - previous) * progress + previous;
   }
-  if (isString(previous) && isString(next)) {
+  if (predicateString(previous) && predicateString(next)) {
     return color.mix(
       options.colorModel,
       {
@@ -1610,7 +1687,7 @@ function toInterpolated({ previous, next, progress }, options = {}) {
       }
     ).toRgb().toRgbString();
   }
-  if (isArray(previous) && isArray(next)) {
+  if (predicateArray(previous) && predicateArray(next)) {
     const exactSliceEnd = (next.length - previous.length) * progress + previous.length, nextIsLonger = next.length > previous.length, sliceEnd = nextIsLonger ? Math.floor(exactSliceEnd) : Math.ceil(exactSliceEnd), sliceTarget = nextIsLonger ? next : previous;
     return createSlice(0, sliceEnd)(sliceTarget);
   }
@@ -1976,7 +2053,7 @@ class Completeable {
   complete(completion, options = {}) {
     this.completing();
     const { select } = { ...defaultCompleteOptions, ...options }, before = this.getBefore(), after = this.getAfter(), completedString = before + completion + after, completedSelection = (() => {
-      if (isFunction(select)) {
+      if (predicateFunction(select)) {
         return select({ before, completion, after });
       }
       switch (select) {
@@ -2381,7 +2458,7 @@ class Resolveable {
     this.resolving();
     try {
       const promises = this.getPromise(...args);
-      this.computedValue = isArray(promises) ? await createMapAsync(async (promise) => await promise)(promises) : await promises;
+      this.computedValue = predicateArray(promises) ? await createMapAsync(async (promise) => await promise)(promises) : await promises;
       this.resolved();
     } catch (error) {
       this.computedValue = error;
@@ -2466,7 +2543,7 @@ class Fetchable {
   async fetch(options = {}) {
     this.fetching();
     try {
-      this.computedResponse = await fetch(this.resource, { signal: this.abortController.signal, ...ensureOptions(options) });
+      this.computedResponse = await fetch(this.resource, { signal: this.abortController.signal, ...narrowOptions(options) });
       this.fetched();
     } catch (error) {
       this.computedError = error;
@@ -2490,23 +2567,23 @@ class Fetchable {
     this.computedStatus = "errored";
   }
   async get(options = {}) {
-    await this.fetch({ signal: this.abortController.signal, ...ensureOptions(options), method: "get" });
+    await this.fetch({ signal: this.abortController.signal, ...narrowOptions(options), method: "get" });
     return this;
   }
   async patch(options = {}) {
-    await this.fetch({ signal: this.abortController.signal, ...ensureOptions(options), method: "patch" });
+    await this.fetch({ signal: this.abortController.signal, ...narrowOptions(options), method: "patch" });
     return this;
   }
   async post(options = {}) {
-    await this.fetch({ signal: this.abortController.signal, ...ensureOptions(options), method: "post" });
+    await this.fetch({ signal: this.abortController.signal, ...narrowOptions(options), method: "post" });
     return this;
   }
   async put(options = {}) {
-    await this.fetch({ signal: this.abortController.signal, ...ensureOptions(options), method: "put" });
+    await this.fetch({ signal: this.abortController.signal, ...narrowOptions(options), method: "put" });
     return this;
   }
   async delete(options = {}) {
-    await this.fetch({ signal: this.abortController.signal, ...ensureOptions(options), method: "delete" });
+    await this.fetch({ signal: this.abortController.signal, ...narrowOptions(options), method: "delete" });
     return this;
   }
   abort() {
@@ -2514,8 +2591,8 @@ class Fetchable {
     return this;
   }
 }
-function ensureOptions(options) {
-  return isFunction(options) ? options({ withJson }) : options;
+function narrowOptions(options) {
+  return predicateFunction(options) ? options({ withJson }) : options;
 }
 function withJson(data) {
   return {
@@ -2698,7 +2775,7 @@ class Navigateable {
   }
   _navigate(location, options = {}) {
     const { allow } = { ...defaultNavigateOptions, ...options };
-    const ensuredLocation = (() => {
+    const narrowedLocation = (() => {
       if (allow === "possible") {
         if (location < 0 && allow === "possible") {
           return 0;
@@ -2709,7 +2786,7 @@ class Navigateable {
       }
       return location;
     })();
-    this.computedLocation = ensuredLocation;
+    this.computedLocation = narrowedLocation;
   }
   next(options = {}) {
     const { distance, loops } = { ...defaultNextAndPreviousOptions, ...options }, newLocation = (() => {
@@ -2853,7 +2930,7 @@ class Pickable {
   pick(indexOrIndices, options = {}) {
     const { replace, allowsDuplicates } = { ...defaultPickOptions, ...options };
     this.computedPicks = new Pipeable(indexOrIndices).pipe(
-      ensureIndices,
+      narrowIndices,
       this.toPossiblePicks,
       (possiblePicks) => {
         if (replace === "all") {
@@ -2906,7 +2983,7 @@ class Pickable {
     this.computedStatus = "picked";
   }
   omit(indexOrIndices, options = { reference: "array" }) {
-    if (isUndefined(indexOrIndices)) {
+    if (predicateUndefined(indexOrIndices)) {
       this.computedPicks = [];
       this.computedFirst = void 0;
       this.computedLast = void 0;
@@ -2914,9 +2991,9 @@ class Pickable {
       this.omitted();
       return this;
     }
-    const omits = ensureIndices(indexOrIndices);
+    const omits = narrowIndices(indexOrIndices);
     this.computedPicks = createFilter(
-      (pick, index) => options.reference === "array" ? isUndefined(lazyCollections.find((omit) => pick === omit)(omits)) : isUndefined(lazyCollections.find((omit) => index === omit)(omits))
+      (pick, index) => options.reference === "array" ? predicateUndefined(lazyCollections.find((omit) => pick === omit)(omits)) : predicateUndefined(lazyCollections.find((omit) => index === omit)(omits))
     )(this.computedPicks);
     this.computedFirst = Math.min(...this.picks);
     this.computedLast = Math.max(...this.picks);
@@ -2928,7 +3005,7 @@ class Pickable {
     this.computedStatus = "omitted";
   }
 }
-function ensureIndices(indexOrIndices) {
+function narrowIndices(indexOrIndices) {
   return Array.isArray(indexOrIndices) ? indexOrIndices : [indexOrIndices];
 }
 const toUnique = createUnique();
@@ -3100,7 +3177,7 @@ class Storeable {
   ready() {
     this.computedStatus = "ready";
     if (domIsAvailable()) {
-      if (isNull(this.storage.getItem(this.computedStatusKey))) {
+      if (predicateNull(this.storage.getItem(this.computedStatusKey))) {
         this.storeStatus();
       }
     }
@@ -3114,7 +3191,7 @@ class Storeable {
   get status() {
     if (domIsAvailable()) {
       const storedStatus = this.storage.getItem(this.computedStatusKey);
-      if (this.computedStatus !== storedStatus && isString(storedStatus)) {
+      if (this.computedStatus !== storedStatus && predicateString(storedStatus)) {
         this.computedStatus = storedStatus;
       }
     }
@@ -3222,7 +3299,6 @@ exports.Storeable = Storeable;
 exports.createClamp = createClamp;
 exports.createClip = createClip;
 exports.createConcat = createConcat;
-exports.createDelete = createDelete;
 exports.createDetermine = createDetermine;
 exports.createFilter = createFilter;
 exports.createFilterAsync = createFilterAsync;
@@ -3230,8 +3306,12 @@ exports.createForEachAsync = createForEachAsync;
 exports.createInsert = createInsert;
 exports.createMap = createMap;
 exports.createMapAsync = createMapAsync;
+exports.createMatchesKeycombo = createMatchesKeycombo;
+exports.createMatchesMousecombo = createMatchesMousecombo;
+exports.createMatchesPointercombo = createMatchesPointercombo;
 exports.createReduce = createReduce;
 exports.createReduceAsync = createReduceAsync;
+exports.createRemove = createRemove;
 exports.createRename = createRename;
 exports.createReorder = createReorder;
 exports.createReplace = createReplace;
@@ -3241,6 +3321,8 @@ exports.createSlug = createSlug;
 exports.createSort = createSort;
 exports.createSwap = createSwap;
 exports.createToEntries = createToEntries;
+exports.createToFocusable = createToFocusable;
+exports.createToKeys = createToKeys;
 exports.createUnique = createUnique;
 exports.easingsNetInBack = easingsNetInBack;
 exports.easingsNetInCirc = easingsNetInCirc;