@baleada/logic 0.22.3 → 0.22.5

package/lib/index.js

@@ -1,4 +1,4 @@
-import { reduce, pipe, filter, toArray, slice, concat, unique, map, 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';
@@ -9,10 +9,13 @@ import { Searcher } from 'fast-fuzzy';
 
 function createReduceAsync(accumulate, initialValue) {
   return async (array) => {
-    return await reduce(async (accumulatorPromise, item, index) => {
-      const accumulator = await accumulatorPromise;
-      return accumulate(accumulator, item, index);
-    }, Promise.resolve(initialValue))(array);
+    return await reduce(
+      async (accumulatorPromise, item, index) => {
+        const accumulator = await accumulatorPromise;
+        return accumulate(accumulator, item, index);
+      },
+      Promise.resolve(initialValue)
+    )(array);
   };
 }
 function createReduce(accumulate, initialValue) {
@@ -26,11 +29,14 @@ function createForEachAsync(forEach) {
 }
 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);
+    return await createReduceAsync(
+      async (resolvedMaps, item, index) => {
+        const transformed = await transform(item, index);
+        resolvedMaps.push(transformed);
+        return resolvedMaps;
+      },
+      []
+    )(array);
   };
 }
 function createFilterAsync(condition) {
@@ -39,36 +45,52 @@ function createFilterAsync(condition) {
     return createFilter((_, index) => transformedAsync[index])(array);
   };
 }
-function createDelete(index) {
+function createRemove(index) {
   return (array) => {
-    return createConcat(createSlice(0, index)(array), createSlice(index + 1)(array))([]);
+    return createConcat(
+      createSlice(0, index)(array),
+      createSlice(index + 1)(array)
+    )([]);
   };
 }
 function createInsert(item, index) {
   return (array) => {
     const withItems = createConcat(array, [item])([]);
-    return createReorder({ start: array.length, itemCount: 1 }, index)(withItems);
+    return createReorder(
+      { start: array.length, itemCount: 1 },
+      index
+    )(withItems);
   };
 }
 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;
     }
     const itemsToMove = createSlice(itemsToMoveStartIndex, itemsToMoveStartIndex + itemsToMoveCount)(array);
     if (itemsToMoveStartIndex < insertIndex) {
       const beforeItemsToMove = itemsToMoveStartIndex === 0 ? [] : createSlice(0, itemsToMoveStartIndex)(array), betweenItemsToMoveAndInsertIndex = createSlice(itemsToMoveStartIndex + itemsToMoveCount, insertIndex + 1)(array), afterInsertIndex = createSlice(insertIndex + 1)(array);
-      return createConcat(beforeItemsToMove, betweenItemsToMoveAndInsertIndex, itemsToMove, afterInsertIndex)([]);
+      return createConcat(
+        beforeItemsToMove,
+        betweenItemsToMoveAndInsertIndex,
+        itemsToMove,
+        afterInsertIndex
+      )([]);
     }
     if (itemsToMoveStartIndex > insertIndex) {
       const beforeInsertion = insertIndex === 0 ? [] : createSlice(0, insertIndex)(array), betweenInsertionAndItemsToMove = createSlice(insertIndex, itemsToMoveStartIndex)(array), afterItemsToMove = createSlice(itemsToMoveStartIndex + itemsToMoveCount)(array);
-      return createConcat(beforeInsertion, itemsToMove, betweenInsertionAndItemsToMove, afterItemsToMove)([]);
+      return createConcat(
+        beforeInsertion,
+        itemsToMove,
+        betweenInsertionAndItemsToMove,
+        afterItemsToMove
+      )([]);
     }
     return array;
   };
 }
-function isObject(value) {
+function predicateObject(value) {
   return typeof value === "object";
 }
 function createSwap(indices) {
@@ -96,25 +118,44 @@ function createSwap(indices) {
 }
 function createReplace(index, item) {
   return (array) => {
-    return createConcat(createSlice(0, index)(array), [item], createSlice(index + 1)(array))([]);
+    return createConcat(
+      createSlice(0, index)(array),
+      [item],
+      createSlice(index + 1)(array)
+    )([]);
   };
 }
 function createUnique() {
-  return (array) => pipe(unique(), toArray())(array);
+  return (array) => pipe(
+    unique(),
+    toArray()
+  )(array);
 }
 function createSlice(from, to) {
   return (array) => {
-    return from === to ? [] : pipe(slice(from, to - 1), toArray())(array);
+    return from === to ? [] : pipe(
+      slice(from, to - 1),
+      toArray()
+    )(array);
   };
 }
 function createFilter(condition) {
-  return (array) => pipe(filter(condition), toArray())(array);
+  return (array) => pipe(
+    filter(condition),
+    toArray()
+  )(array);
 }
 function createMap(transform) {
-  return (array) => pipe(map(transform), toArray())(array);
+  return (array) => pipe(
+    map(transform),
+    toArray()
+  )(array);
 }
 function createConcat(...arrays) {
-  return (array) => pipe(concat(array, ...arrays), toArray())();
+  return (array) => pipe(
+    concat(array, ...arrays),
+    toArray()
+  )();
 }
 function createReverse() {
   return (array) => {
@@ -127,7 +168,10 @@ function createReverse() {
 }
 function createSort(compare) {
   return (array) => {
-    return new Pipeable(array).pipe(createSlice(0), (sliced) => sliced.sort(compare));
+    return new Pipeable(array).pipe(
+      createSlice(0),
+      (sliced) => compare ? sliced.sort(compare) : sliced.sort()
+    );
   };
 }
 function createSlug(options) {
@@ -148,7 +192,10 @@ function createClamp(min, max) {
 }
 function createDetermine(potentialities) {
   const predicates = createMap(({ outcome, probability }, index) => {
-    const lowerBound = index === 0 ? 0 : pipe(slice(0, index - 1), reduce((lowerBound2, { probability: probability2 }) => lowerBound2 + probability2, 0))(potentialities), upperBound = lowerBound + probability;
+    const lowerBound = index === 0 ? 0 : pipe(
+      slice(0, index - 1),
+      reduce((lowerBound2, { probability: probability2 }) => lowerBound2 + probability2, 0)
+    )(potentialities), upperBound = lowerBound + probability;
     return {
       outcome,
       predicate: (determinant) => determinant >= lowerBound && determinant < upperBound || determinant < 0 && index === 0 || index === predicates.length - 1
@@ -171,6 +218,37 @@ function createToEntries() {
     return entries;
   };
 }
+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;
@@ -179,7 +257,10 @@ class Pipeable {
     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);
+    return await createReduceAsync(
+      async (piped, fn, index) => await fn(piped, index),
+      this.state
+    )(fns);
   }
 }
 
@@ -235,20 +316,27 @@ const keysByName = {
   f20: "F20"
 };
 const toListenableKeycomboItems = createMap((name) => ({ name, type: fromComboItemNameToType(name) }));
-function ensureKeycombo(type) {
-  return new Pipeable(type).pipe(toCombo, toListenableKeycomboItems);
+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();
 const toComboItems = map((name) => name === "" ? delimiter : name);
 const delimiter = "+";
 function toCombo(type) {
-  return pipe(toUnique$1, toComboItems, toArray())(type.split(delimiter));
+  return pipe(
+    toUnique$1,
+    toComboItems,
+    toArray()
+  )(type.split(delimiter));
 }
 function fromComboItemNameToType(name) {
   return find((type) => predicatesByType[type](name))(listenableComboItemTypes) ?? "custom";
@@ -284,45 +372,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 = {
-        is: (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 = {
-        is: (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 = {
-        is: (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;
       }
     };
@@ -339,7 +421,7 @@ function createExceptAndOnlyEffect(type, effect, options) {
     }
   };
 }
-function isModified({ event, alias }) {
+function predicateModified({ event, alias }) {
   return predicatesByModifier[alias]?.(event);
 }
 const predicatesByModifier = {
@@ -360,24 +442,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;
@@ -432,13 +533,16 @@ class Recognizeable {
     this.computedSequence = sequence;
     return this;
   }
-  recognize(sequenceItem, api, { onRecognized } = {}) {
+  recognize(sequenceItem, { onRecognized } = {}) {
     this.recognizing();
-    const type = this.toType(sequenceItem), excess = isNumber(this.maxSequenceLength) ? Math.max(0, this.sequence.length - this.maxSequenceLength) : 0, newSequence = createConcat(createSlice(excess)(this.sequence), [sequenceItem])([]);
+    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 "denied":
         this.resetComputedMetadata();
@@ -455,7 +559,7 @@ class Recognizeable {
     this.computedStatus = "recognizing";
   }
   toType(sequenceItem) {
-    if (isArray(sequenceItem)) {
+    if (predicateArray(sequenceItem)) {
       if (sequenceItem[0] instanceof IntersectionObserverEntry) {
         return "intersect";
       }
@@ -534,6 +638,9 @@ class Listenable {
       case "idle":
         this.idleListen(effect, options);
         break;
+      case "message":
+        this.messageListen(effect, options);
+        break;
       case "recognizeable":
         this.recognizeableListen(effect, options);
         break;
@@ -564,22 +671,27 @@ 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));
+    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) });
+    const guardedEffect = (sequenceItem) => {
+      this.recognizeable.recognize(sequenceItem, { onRecognized: (sequenceItem2) => effect(sequenceItem2) });
       if (this.recognizeable.status === "recognized") {
-        effect(sequenceItem, api);
+        effect(sequenceItem);
       }
     };
     for (const type of this.recognizeableEffectsKeys) {
@@ -589,11 +701,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]];
@@ -642,16 +754,21 @@ function stop(stoppable) {
     id2.disconnect();
     return;
   }
-  if (isArray(stoppable.id)) {
+  if ("target" in stoppable && stoppable.target instanceof MediaQueryList) {
     const { target: target2, id: id2 } = 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;
   }
+  if ("target" in stoppable && stoppable.target instanceof BroadcastChannel) {
+    const { target: target2, id: id2 } = stoppable;
+    target2.removeEventListener(id2[0], id2[1]);
+    return;
+  }
   const { target, id } = stoppable;
   target.removeEventListener(id[0], id[1], id[2]);
 }
@@ -683,6 +800,10 @@ const predicatesByImplementation = /* @__PURE__ */ new Map([
     "idle",
     (type) => type === "idle"
   ],
+  [
+    "message",
+    (type) => type === "message" || type === "messageerror"
+  ],
   [
     "documentevent",
     (type) => documentEvents.has(type)
@@ -727,7 +848,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);
 }
@@ -791,11 +912,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,
@@ -803,7 +924,7 @@ const observerAssertionsByType = {
   resize: (observer) => observer instanceof ResizeObserver
 };
 
-const defaultOptions$6 = {
+const defaultOptions$7 = {
   duration: 0,
   timing: [
     0,
@@ -831,10 +952,10 @@ class Animateable {
   getEaseables;
   getReversedEaseables;
   constructor(keyframes, options = {}) {
-    this.initialDuration = options?.duration || defaultOptions$6.duration;
-    this.controlPoints = fromTimingToControlPoints(options?.timing || defaultOptions$6.timing);
-    this.iterationLimit = options?.iterations || defaultOptions$6.iterations;
-    this.alternates = options?.alternates || defaultOptions$6.alternates;
+    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.reversedControlPoints = fromControlPointsToReversedControlPoints(this.controlPoints);
     this.toAnimationProgress = createToAnimationProgress(this.controlPoints);
     this.reversedToAnimationProgress = createToAnimationProgress(this.reversedControlPoints);
@@ -910,7 +1031,10 @@ 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 = new Pipeable(this.keyframes).pipe(
+      createReverse(),
+      createMap(({ progress, properties }) => ({ progress: 1 - progress, properties }))
+    );
     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 });
@@ -920,13 +1044,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;
     }
@@ -1180,14 +1304,20 @@ class Animateable {
           return this.reversedEaseables;
       }
     })();
-    return pipe(filter(({ progress: { start, end } }) => start < naiveTimeProgress && end >= naiveTimeProgress), reduce((frame, { property, progress, value: { previous, next }, toAnimationProgress }) => {
-      const timeProgress = (naiveTimeProgress - progress.start) / (progress.end - progress.start), animationProgress = toAnimationProgress(timeProgress);
-      frame.properties[property] = {
-        progress: { time: timeProgress, animation: animationProgress },
-        interpolated: toInterpolated({ previous, next, progress: animationProgress }, interpolateOptions)
-      };
-      return frame;
-    }, { properties: {}, timestamp }))(easeables);
+    return pipe(
+      filter(({ progress: { start, end } }) => start < naiveTimeProgress && end >= naiveTimeProgress),
+      reduce(
+        (frame, { property, progress, value: { previous, next }, toAnimationProgress }) => {
+          const timeProgress = (naiveTimeProgress - progress.start) / (progress.end - progress.start), animationProgress = toAnimationProgress(timeProgress);
+          frame.properties[property] = {
+            progress: { time: timeProgress, animation: animationProgress },
+            interpolated: toInterpolated({ previous, next, progress: animationProgress }, interpolateOptions)
+          };
+          return frame;
+        },
+        { properties: {}, timestamp }
+      )
+    )(easeables);
   }
   recurse(type, timeRemaining, effect, options) {
     switch (type) {
@@ -1309,51 +1439,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) {
@@ -1363,24 +1493,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) {
@@ -1444,26 +1574,36 @@ class Animateable {
 }
 function createGetEaseables(fromKeyframeToControlPoints) {
   return ({ properties, keyframes }) => {
-    const fromPropertiesToEasables = createReduce((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 }));
-        propertyEaseables2.push({
+    const fromPropertiesToEasables = createReduce(
+      (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 }));
+            propertyEaseables2.push({
+              property,
+              value: { previous, next },
+              progress: { start, end },
+              hasCustomTiming,
+              toAnimationProgress
+            });
+            return propertyEaseables2;
+          },
+          []
+        ), propertyEaseables = fromKeyframesToEaseables(propertyKeyframes), firstEaseable = {
           property,
-          value: { previous, next },
-          progress: { start, end },
-          hasCustomTiming,
-          toAnimationProgress
-        });
-        return propertyEaseables2;
-      }, []), propertyEaseables = fromKeyframesToEaseables(propertyKeyframes), firstEaseable = {
-        property,
-        value: { previous: propertyEaseables[0].value.previous, next: propertyEaseables[0].value.previous },
-        progress: { start: -1, end: propertyEaseables[0].progress.start },
-        toAnimationProgress: (timeProgress) => 1,
-        hasCustomTiming: false
-      };
-      return createConcat(easeables, [firstEaseable], propertyEaseables)([]);
-    }, []);
+          value: { previous: propertyEaseables[0].value.previous, next: propertyEaseables[0].value.previous },
+          progress: { start: -1, end: propertyEaseables[0].progress.start },
+          toAnimationProgress: (timeProgress) => 1,
+          hasCustomTiming: false
+        };
+        return createConcat(
+          easeables,
+          [firstEaseable],
+          propertyEaseables
+        )([]);
+      },
+      []
+    );
     return fromPropertiesToEasables(properties);
   };
 }
@@ -1496,20 +1636,23 @@ 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)) {
-    return mix(options.colorModel, {
-      start: previous,
-      end: next,
-      alpha: progress
-    }).toRgb().toRgbString();
+  if (predicateString(previous) && predicateString(next)) {
+    return mix(
+      options.colorModel,
+      {
+        start: previous,
+        end: next,
+        alpha: progress
+      }
+    ).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);
   }
@@ -1695,6 +1838,78 @@ const easingsNetInOutBack = [
   1.6
 ];
 
+const defaultOptions$6 = {
+  name: "baleada"
+};
+class Broadcastable {
+  name;
+  constructor(state, options = {}) {
+    this.setState(state);
+    this.name = options.name ?? defaultOptions$6.name;
+    this.ready();
+  }
+  computedStatus;
+  ready() {
+    this.computedStatus = "ready";
+  }
+  get state() {
+    return this.computedState;
+  }
+  set state(state) {
+    this.setState(state);
+  }
+  get status() {
+    return this.computedStatus;
+  }
+  computedChannel;
+  get channel() {
+    return this.computedChannel || (this.computedChannel = new BroadcastChannel(this.name));
+  }
+  computedError;
+  get error() {
+    return this.computedError;
+  }
+  computedState;
+  setState(state) {
+    this.computedState = state;
+    return this;
+  }
+  broadcast() {
+    this.broadcasting();
+    try {
+      this.channel.postMessage(this.state);
+      this.broadcasted();
+    } catch (error) {
+      this.computedError = error;
+      this.errored();
+    }
+    return this;
+  }
+  broadcasting() {
+    this.computedStatus = "broadcasting";
+  }
+  broadcasted() {
+    this.computedStatus = "broadcasted";
+  }
+  errored() {
+    this.computedStatus = "errored";
+  }
+  stop() {
+    this.channel.close();
+    this.stopped();
+    return this;
+  }
+  stopped() {
+    this.computedStatus = "stopped";
+  }
+}
+function toMessageListenParams(instance, effect) {
+  return [
+    effect,
+    { target: instance.channel }
+  ];
+}
+
 const defaultOptions$5 = {
   segment: {
     from: "start",
@@ -1743,7 +1958,10 @@ class Completeable {
     return this.computedStatus;
   }
   get segment() {
-    return this.string.slice(this.getSegmentStartIndex(), this.getSegmentEndIndex());
+    return this.string.slice(
+      this.getSegmentStartIndex(),
+      this.getSegmentEndIndex()
+    );
   }
   get dividerIndices() {
     return this.computedDividerIndices;
@@ -1800,7 +2018,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) {
@@ -1856,7 +2074,12 @@ function toPreviousMatch({ string, re, from }) {
   if (!re.test(string.slice(0, from)) || from === 0) {
     indexOf = -1;
   } else {
-    const reversedStringBeforeFrom = new Pipeable(string).pipe((string2) => string2.slice(0, from), (sliced) => sliced.split(""), reverse, toString), toNextMatchIndex = toNextMatch({ string: reversedStringBeforeFrom, re, from: 0 });
+    const reversedStringBeforeFrom = new Pipeable(string).pipe(
+      (string2) => string2.slice(0, from),
+      (sliced) => sliced.split(""),
+      reverse,
+      toString
+    ), toNextMatchIndex = toNextMatch({ string: reversedStringBeforeFrom, re, from: 0 });
     indexOf = toNextMatchIndex === -1 ? -1 : reversedStringBeforeFrom.length - 1 - toNextMatchIndex;
   }
   return indexOf;
@@ -1948,7 +2171,7 @@ class Copyable {
   errored() {
     this.computedStatus = "errored";
   }
-  effectClipboardTextChanges() {
+  listenForClipboardEvents() {
     this.copyListenable.listen(this.copyAndCutEffect);
     this.cutListenable.listen(this.copyAndCutEffect);
   }
@@ -1965,13 +2188,16 @@ const defaultOptions$4 = {
 class Delayable {
   animateable;
   constructor(effect, options = {}) {
-    this.animateable = new Animateable([
-      { progress: 0, properties: { progress: 0 } },
-      { progress: 1, properties: { progress: 1 } }
-    ], {
-      duration: options?.delay ?? defaultOptions$4.delay,
-      iterations: options?.executions ?? defaultOptions$4.executions
-    });
+    this.animateable = new Animateable(
+      [
+        { progress: 0, properties: { progress: 0 } },
+        { progress: 1, properties: { progress: 1 } }
+      ],
+      {
+        duration: options?.delay ?? defaultOptions$4.delay,
+        iterations: options?.executions ?? defaultOptions$4.executions
+      }
+    );
     this.setEffect(effect);
     this.ready();
   }
@@ -2197,7 +2423,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;
@@ -2258,34 +2484,19 @@ class Fetchable {
     return this.computedError;
   }
   get arrayBuffer() {
-    return this.getUsedBody(this.computedArrayBuffer);
+    return this.computedArrayBuffer;
   }
   get blob() {
-    return this.getUsedBody(this.computedBlob);
+    return this.computedBlob;
   }
   get formData() {
-    return this.getUsedBody(this.computedFormData);
+    return this.computedFormData;
   }
   get json() {
-    return this.getUsedBody(this.computedJson);
+    return this.computedJson;
   }
   get text() {
-    return this.getUsedBody(this.computedText);
-  }
-  getUsedBody(resolveable) {
-    const bodyUsed = "bodyUsed" in this.response ? this.response.bodyUsed : false;
-    if (!bodyUsed) {
-      return resolveable.resolve();
-    }
-    switch (resolveable.status) {
-      case "ready":
-        break;
-      case "resolving":
-        break;
-      case "resolved":
-      case "errored":
-        return resolveable;
-    }
+    return this.computedText;
   }
   computedResource;
   setResource(resource) {
@@ -2295,34 +2506,49 @@ class Fetchable {
   computedResponse;
   computedError;
   async fetch(options = {}) {
-    this.computedStatus = "fetching";
+    this.fetching();
     try {
-      this.computedResponse = await fetch(this.resource, { signal: this.abortController.signal, ...ensureOptions(options) });
-      this.computedStatus = "fetched";
+      this.computedResponse = await fetch(this.resource, { signal: this.abortController.signal, ...narrowOptions(options) });
+      this.fetched();
     } catch (error) {
       this.computedError = error;
-      this.computedStatus = error.name === "AbortError" ? "aborted" : "errored";
+      if (error.name === "AbortError")
+        this.aborted();
+      else
+        this.errored();
     }
     return this;
   }
+  fetching() {
+    this.computedStatus = "fetching";
+  }
+  fetched() {
+    this.computedStatus = "fetched";
+  }
+  aborted() {
+    this.computedStatus = "aborted";
+  }
+  errored() {
+    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() {
@@ -2330,8 +2556,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 {
@@ -2514,7 +2740,7 @@ class Navigateable {
   }
   _navigate(location, options = {}) {
     const { allow } = { ...defaultNavigateOptions, ...options };
-    const ensuredLocation = (() => {
+    const narrowedLocation = (() => {
       if (allow === "possible") {
         if (location < 0 && allow === "possible") {
           return 0;
@@ -2525,7 +2751,7 @@ class Navigateable {
       }
       return location;
     })();
-    this.computedLocation = ensuredLocation;
+    this.computedLocation = narrowedLocation;
   }
   next(options = {}) {
     const { distance, loops } = { ...defaultNextAndPreviousOptions, ...options }, newLocation = (() => {
@@ -2668,38 +2894,50 @@ class Pickable {
   }
   pick(indexOrIndices, options = {}) {
     const { replace, allowsDuplicates } = { ...defaultPickOptions, ...options };
-    this.computedPicks = new Pipeable(indexOrIndices).pipe(ensureIndices, this.toPossiblePicks, (possiblePicks) => {
-      if (replace === "all") {
-        return allowsDuplicates ? possiblePicks : toUnique(possiblePicks);
-      }
-      const maybeWithoutDuplicates = allowsDuplicates ? possiblePicks : createFilter((possiblePick) => typeof find((pick) => pick === possiblePick)(this.picks || []) !== "number")(possiblePicks);
-      switch (replace) {
-        case "none":
-          return createConcat(this.picks || [], maybeWithoutDuplicates)([]);
-        case "fifo":
-          if (maybeWithoutDuplicates.length === 0) {
-            return this.picks;
-          }
-          if (maybeWithoutDuplicates.length === this.picks.length) {
-            return maybeWithoutDuplicates;
-          }
-          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));
-        case "lifo":
-          if (maybeWithoutDuplicates.length === 0) {
-            return this.picks;
-          }
-          if (maybeWithoutDuplicates.length === this.picks.length) {
-            return maybeWithoutDuplicates;
-          }
-          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));
+    this.computedPicks = new Pipeable(indexOrIndices).pipe(
+      narrowIndices,
+      this.toPossiblePicks,
+      (possiblePicks) => {
+        if (replace === "all") {
+          return allowsDuplicates ? possiblePicks : toUnique(possiblePicks);
+        }
+        const maybeWithoutDuplicates = allowsDuplicates ? possiblePicks : createFilter(
+          (possiblePick) => typeof find((pick) => pick === possiblePick)(this.picks || []) !== "number"
+        )(possiblePicks);
+        switch (replace) {
+          case "none":
+            return createConcat(this.picks || [], maybeWithoutDuplicates)([]);
+          case "fifo":
+            if (maybeWithoutDuplicates.length === 0) {
+              return this.picks;
+            }
+            if (maybeWithoutDuplicates.length === this.picks.length) {
+              return maybeWithoutDuplicates;
+            }
+            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)
+            );
+          case "lifo":
+            if (maybeWithoutDuplicates.length === 0) {
+              return this.picks;
+            }
+            if (maybeWithoutDuplicates.length === this.picks.length) {
+              return maybeWithoutDuplicates;
+            }
+            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)
+            );
+        }
       }
-    });
+    );
     this.computedFirst = Math.min(...this.picks);
     this.computedLast = Math.max(...this.picks);
     this.computedMultiple = toUnique(this.picks).length > 1;
@@ -2710,7 +2948,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;
@@ -2718,8 +2956,10 @@ class Pickable {
       this.omitted();
       return this;
     }
-    const omits = ensureIndices(indexOrIndices);
-    this.computedPicks = createFilter((pick, index) => options.reference === "array" ? isUndefined(find((omit) => pick === omit)(omits)) : isUndefined(find((omit) => index === omit)(omits)))(this.computedPicks);
+    const omits = narrowIndices(indexOrIndices);
+    this.computedPicks = createFilter(
+      (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);
     this.computedMultiple = toUnique(this.picks).length > 1;
@@ -2730,7 +2970,7 @@ class Pickable {
     this.computedStatus = "omitted";
   }
 }
-function ensureIndices(indexOrIndices) {
+function narrowIndices(indexOrIndices) {
   return Array.isArray(indexOrIndices) ? indexOrIndices : [indexOrIndices];
 }
 const toUnique = createUnique();
@@ -2827,6 +3067,60 @@ class Searchable {
   }
 }
 
+class Shareable {
+  constructor(state, options = {}) {
+    this.setState(state);
+    this.ready();
+  }
+  computedStatus;
+  ready() {
+    this.computedStatus = "ready";
+  }
+  get state() {
+    return this.computedState;
+  }
+  set state(state) {
+    this.setState(state);
+  }
+  get status() {
+    return this.computedStatus;
+  }
+  computedCan;
+  get can() {
+    return this.computedCan;
+  }
+  computedError;
+  get error() {
+    return this.computedError;
+  }
+  computedState;
+  setState(state) {
+    this.computedState = state;
+    this.computedCan = new Resolveable(async () => await navigator.canShare(state));
+    return this;
+  }
+  async share() {
+    this.sharing();
+    try {
+      await navigator.share(this.state);
+      this.shared();
+    } catch (error) {
+      this.computedError = error;
+      this.errored();
+    }
+    return this;
+  }
+  sharing() {
+    this.computedStatus = "sharing";
+  }
+  shared() {
+    this.computedStatus = "shared";
+  }
+  errored() {
+    this.computedStatus = "errored";
+  }
+}
+
 const defaultOptions = {
   kind: "local",
   statusKeySuffix: " status"
@@ -2848,7 +3142,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();
       }
     }
@@ -2862,7 +3156,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;
       }
     }
@@ -2948,4 +3242,4 @@ class Storeable {
   }
 }
 
-export { Animateable, Completeable, Copyable, Delayable, Drawable, Fetchable, Fullscreenable, Grantable, Listenable, Navigateable, Pickable, Pipeable, Recognizeable, Resolveable, Sanitizeable, Searchable, 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, 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, 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 };