@baleada/logic 0.22.4 → 0.22.6

package/lib/index.js

@@ -1,4 +1,4 @@
-import { reduce, pipe, unique, toArray, slice, filter, map, concat, find, findIndex, some, every, join } from 'lazy-collections';
+import { reduce, pipe, unique, toArray, slice, filter, map, concat, find, findIndex, join, some, every } from 'lazy-collections';
 import slugify from '@sindresorhus/slugify';
 import BezierEasing from 'bezier-easing';
 import { mix } from '@snigo.dev/color';
@@ -45,7 +45,7 @@ function createFilterAsync(condition) {
     return createFilter((_, index) => transformedAsync[index])(array);
   };
 }
-function createDelete(index) {
+function createRemove(index) {
   return (array) => {
     return createConcat(
       createSlice(0, index)(array),
@@ -64,7 +64,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;
     }
@@ -90,7 +90,7 @@ function createReorder(from, to) {
     return array;
   };
 }
-function isObject(value) {
+function predicateObject(value) {
   return typeof value === "object";
 }
 function createSwap(indices) {
@@ -218,6 +218,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;
@@ -285,16 +325,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 = unique();
@@ -341,45 +381,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) => 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) => 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) => 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) => 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) => 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) => 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;
       }
     };
@@ -396,7 +430,7 @@ function createExceptAndOnlyEffect(type, effect, options) {
     }
   };
 }
-function isModified({ event, alias }) {
+function predicateModified({ event, alias }) {
   return predicatesByModifier[alias]?.(event);
 }
 const predicatesByModifier = {
@@ -417,24 +451,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 = 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;
@@ -454,7 +507,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();
   }
@@ -468,6 +524,12 @@ class Recognizeable {
   denied() {
     this.computedStatus = "denied";
   }
+  recognizedUntilReady() {
+    this.computedStatus = "recognized until ready";
+  }
+  deniedUntilReady() {
+    this.computedStatus = "denied until ready";
+  }
   computedStatus;
   ready() {
     this.computedStatus = "ready";
@@ -489,18 +551,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;
@@ -515,7 +580,7 @@ class Recognizeable {
     this.computedStatus = "recognizing";
   }
   toType(sequenceItem) {
-    if (isArray(sequenceItem)) {
+    if (predicateArray(sequenceItem)) {
       if (sequenceItem[0] instanceof IntersectionObserverEntry) {
         return "intersect";
       }
@@ -627,27 +692,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) {
@@ -657,11 +735,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]];
@@ -715,7 +793,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;
@@ -788,9 +866,8 @@ function eventMatchesKeycombo(event, keycombo) {
   return 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":
@@ -804,7 +881,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);
 }
@@ -868,11 +945,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 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 every((name) => fromComboItemNameToType(name) === "click" || name.startsWith("!") && !predicateModified({ alias: name.slice(1), event }) || !name.startsWith("!") && predicateModified({ alias: name, event }))(Mousecombo);
 }
 function eventMatchesPointercombo(event, pointercombo) {
-  return every((name) => fromComboItemNameToType(name) === "pointer" || name.startsWith("!") && !isModified({ alias: name.slice(1), event }) || !name.startsWith("!") && isModified({ alias: name, event }))(pointercombo);
+  return every((name) => fromComboItemNameToType(name) === "pointer" || name.startsWith("!") && !predicateModified({ alias: name.slice(1), event }) || !name.startsWith("!") && predicateModified({ alias: name, event }))(pointercombo);
 }
 const observerAssertionsByType = {
   intersect: (observer) => observer instanceof IntersectionObserver,
@@ -1000,13 +1077,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;
     }
@@ -1395,51 +1472,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) {
@@ -1449,24 +1526,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) {
@@ -1592,13 +1669,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 mix(
       options.colorModel,
       {
@@ -1608,7 +1685,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);
   }
@@ -1974,7 +2051,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) {
@@ -2379,7 +2456,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;
@@ -2464,7 +2541,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;
@@ -2488,23 +2565,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() {
@@ -2512,8 +2589,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 {
@@ -2696,7 +2773,7 @@ class Navigateable {
   }
   _navigate(location, options = {}) {
     const { allow } = { ...defaultNavigateOptions, ...options };
-    const ensuredLocation = (() => {
+    const narrowedLocation = (() => {
       if (allow === "possible") {
         if (location < 0 && allow === "possible") {
           return 0;
@@ -2707,7 +2784,7 @@ class Navigateable {
       }
       return location;
     })();
-    this.computedLocation = ensuredLocation;
+    this.computedLocation = narrowedLocation;
   }
   next(options = {}) {
     const { distance, loops } = { ...defaultNextAndPreviousOptions, ...options }, newLocation = (() => {
@@ -2851,7 +2928,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") {
@@ -2904,7 +2981,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;
@@ -2912,9 +2989,9 @@ class Pickable {
       this.omitted();
       return this;
     }
-    const omits = ensureIndices(indexOrIndices);
+    const omits = narrowIndices(indexOrIndices);
     this.computedPicks = createFilter(
-      (pick, index) => options.reference === "array" ? isUndefined(find((omit) => pick === omit)(omits)) : isUndefined(find((omit) => index === omit)(omits))
+      (pick, index) => options.reference === "array" ? predicateUndefined(find((omit) => pick === omit)(omits)) : predicateUndefined(find((omit) => index === omit)(omits))
     )(this.computedPicks);
     this.computedFirst = Math.min(...this.picks);
     this.computedLast = Math.max(...this.picks);
@@ -2926,7 +3003,7 @@ class Pickable {
     this.computedStatus = "omitted";
   }
 }
-function ensureIndices(indexOrIndices) {
+function narrowIndices(indexOrIndices) {
   return Array.isArray(indexOrIndices) ? indexOrIndices : [indexOrIndices];
 }
 const toUnique = createUnique();
@@ -3098,7 +3175,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();
       }
     }
@@ -3112,7 +3189,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;
       }
     }
@@ -3198,4 +3275,4 @@ class Storeable {
   }
 }
 
-export { Animateable, Broadcastable, Completeable, Copyable, Delayable, Drawable, Fetchable, Fullscreenable, Grantable, Listenable, Navigateable, Pickable, Pipeable, Recognizeable, Resolveable, Sanitizeable, Searchable, Shareable, Storeable, createClamp, createClip, createConcat, createDelete, createDetermine, createFilter, createFilterAsync, createForEachAsync, createInsert, createMap, createMapAsync, createReduce, createReduceAsync, createRename, createReorder, createReplace, createReverse, createSlice, createSlug, createSort, createSwap, createToEntries, createUnique, easingsNetInBack, easingsNetInCirc, easingsNetInCubic, easingsNetInExpo, easingsNetInOutBack, easingsNetInOutCirc, easingsNetInOutCubic, easingsNetInOutExpo, easingsNetInOutQuad, easingsNetInOutQuint, easingsNetInOutSine, easingsNetInQuad, easingsNetInQuart, easingsNetInQuint, easingsNetInSine, easingsNetOutBack, easingsNetOutCirc, easingsNetOutCubic, easingsNetOutExpo, easingsNetOutQuad, easingsNetOutQuint, easingsNetOutSine, linear, materialAccelerated, materialDecelerated, materialStandard, toD, toFlattenedD, toMessageListenParams, verouEase, verouEaseIn, verouEaseInOut, verouEaseOut };
+export { Animateable, Broadcastable, Completeable, Copyable, Delayable, Drawable, Fetchable, Fullscreenable, Grantable, Listenable, Navigateable, Pickable, Pipeable, Recognizeable, Resolveable, Sanitizeable, Searchable, Shareable, Storeable, createClamp, createClip, createConcat, createDetermine, createFilter, createFilterAsync, createForEachAsync, createInsert, createMap, createMapAsync, createMatchesKeycombo, createMatchesMousecombo, createMatchesPointercombo, createReduce, createReduceAsync, createRemove, createRename, createReorder, createReplace, createReverse, createSlice, createSlug, createSort, createSwap, createToEntries, createToFocusable, createToKeys, createUnique, easingsNetInBack, easingsNetInCirc, easingsNetInCubic, easingsNetInExpo, easingsNetInOutBack, easingsNetInOutCirc, easingsNetInOutCubic, easingsNetInOutExpo, easingsNetInOutQuad, easingsNetInOutQuint, easingsNetInOutSine, easingsNetInQuad, easingsNetInQuart, easingsNetInQuint, easingsNetInSine, easingsNetOutBack, easingsNetOutCirc, easingsNetOutCubic, easingsNetOutExpo, easingsNetOutQuad, easingsNetOutQuint, easingsNetOutSine, linear, materialAccelerated, materialDecelerated, materialStandard, toD, toFlattenedD, toMessageListenParams, verouEase, verouEaseIn, verouEaseInOut, verouEaseOut };