@baleada/logic 0.22.2 → 0.22.4

package/lib/index.cjs

@@ -1,7 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var lazyCollections = require('lazy-collections');
 var slugify = require('@sindresorhus/slugify');
 var BezierEasing = require('bezier-easing');
@@ -11,19 +9,15 @@ var polygonClipping = require('polygon-clipping');
 var createDOMPurify = require('dompurify');
 var fastFuzzy = require('fast-fuzzy');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var slugify__default = /*#__PURE__*/_interopDefaultLegacy(slugify);
-var BezierEasing__default = /*#__PURE__*/_interopDefaultLegacy(BezierEasing);
-var polygonClipping__default = /*#__PURE__*/_interopDefaultLegacy(polygonClipping);
-var createDOMPurify__default = /*#__PURE__*/_interopDefaultLegacy(createDOMPurify);
-
 function createReduceAsync(accumulate, initialValue) {
   return async (array) => {
-    return await lazyCollections.reduce(async (accumulatorPromise, item, index) => {
-      const accumulator = await accumulatorPromise;
-      return accumulate(accumulator, item, index);
-    }, Promise.resolve(initialValue))(array);
+    return await lazyCollections.reduce(
+      async (accumulatorPromise, item, index) => {
+        const accumulator = await accumulatorPromise;
+        return accumulate(accumulator, item, index);
+      },
+      Promise.resolve(initialValue)
+    )(array);
   };
 }
 function createReduce(accumulate, initialValue) {
@@ -37,11 +31,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) {
@@ -52,13 +49,19 @@ function createFilterAsync(condition) {
 }
 function createDelete(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) {
@@ -70,11 +73,21 @@ function createReorder(from, to) {
     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;
   };
@@ -107,25 +120,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) => lazyCollections.pipe(lazyCollections.unique(), lazyCollections.toArray())(array);
+  return (array) => lazyCollections.pipe(
+    lazyCollections.unique(),
+    lazyCollections.toArray()
+  )(array);
 }
 function createSlice(from, to) {
   return (array) => {
-    return from === to ? [] : lazyCollections.pipe(lazyCollections.slice(from, to - 1), lazyCollections.toArray())(array);
+    return from === to ? [] : lazyCollections.pipe(
+      lazyCollections.slice(from, to - 1),
+      lazyCollections.toArray()
+    )(array);
   };
 }
 function createFilter(condition) {
-  return (array) => lazyCollections.pipe(lazyCollections.filter(condition), lazyCollections.toArray())(array);
+  return (array) => lazyCollections.pipe(
+    lazyCollections.filter(condition),
+    lazyCollections.toArray()
+  )(array);
 }
 function createMap(transform) {
-  return (array) => lazyCollections.pipe(lazyCollections.map(transform), lazyCollections.toArray())(array);
+  return (array) => lazyCollections.pipe(
+    lazyCollections.map(transform),
+    lazyCollections.toArray()
+  )(array);
 }
 function createConcat(...arrays) {
-  return (array) => lazyCollections.pipe(lazyCollections.concat(array, ...arrays), lazyCollections.toArray())();
+  return (array) => lazyCollections.pipe(
+    lazyCollections.concat(array, ...arrays),
+    lazyCollections.toArray()
+  )();
 }
 function createReverse() {
   return (array) => {
@@ -138,12 +170,15 @@ 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) {
   return (string) => {
-    return slugify__default["default"](string, options);
+    return slugify(string, options);
   };
 }
 function createClip(required) {
@@ -159,7 +194,10 @@ function createClamp(min, max) {
 }
 function createDetermine(potentialities) {
   const predicates = createMap(({ outcome, probability }, index) => {
-    const lowerBound = index === 0 ? 0 : lazyCollections.pipe(lazyCollections.slice(0, index - 1), lazyCollections.reduce((lowerBound2, { probability: probability2 }) => lowerBound2 + probability2, 0))(potentialities), upperBound = lowerBound + probability;
+    const lowerBound = index === 0 ? 0 : lazyCollections.pipe(
+      lazyCollections.slice(0, index - 1),
+      lazyCollections.reduce((lowerBound2, { probability: probability2 }) => lowerBound2 + probability2, 0)
+    )(potentialities), upperBound = lowerBound + probability;
     return {
       outcome,
       predicate: (determinant) => determinant >= lowerBound && determinant < upperBound || determinant < 0 && index === 0 || index === predicates.length - 1
@@ -190,7 +228,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);
   }
 }
 
@@ -247,7 +288,10 @@ const keysByName = {
 };
 const toListenableKeycomboItems = createMap((name) => ({ name, type: fromComboItemNameToType(name) }));
 function ensureKeycombo(type) {
-  return new Pipeable(type).pipe(toCombo, toListenableKeycomboItems);
+  return new Pipeable(type).pipe(
+    toCombo,
+    toListenableKeycomboItems
+  );
 }
 function ensureClickcombo(type) {
   return toCombo(type);
@@ -259,7 +303,11 @@ const toUnique$1 = lazyCollections.unique();
 const toComboItems = lazyCollections.map((name) => name === "" ? delimiter : name);
 const delimiter = "+";
 function toCombo(type) {
-  return lazyCollections.pipe(toUnique$1, toComboItems, lazyCollections.toArray())(type.split(delimiter));
+  return lazyCollections.pipe(
+    toUnique$1,
+    toComboItems,
+    lazyCollections.toArray()
+  )(type.split(delimiter));
 }
 function fromComboItemNameToType(name) {
   return lazyCollections.find((type) => predicatesByType[type](name))(listenableComboItemTypes) ?? "custom";
@@ -296,7 +344,7 @@ function createExceptAndOnlyEffect(type, effect, 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 = {
-        is: (keycombo) => eventMatchesKeycombo(event, ensureKeycombo(keycombo))
+        matches: (keycombo) => eventMatchesKeycombo(event, ensureKeycombo(keycombo))
       };
       if (matchesOnly) {
         effect(event, api);
@@ -308,10 +356,10 @@ function createExceptAndOnlyEffect(type, effect, options) {
       }
     };
   }
-  if (type === "click" || type === "mousedown" || type === "mouseup" || type === "dblclick" || type === "contextmenu") {
+  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 = {
-        is: (clickcombo) => eventMatchesClickcombo(event, ensureClickcombo(clickcombo))
+        matches: (clickcombo) => eventMatchesClickcombo(event, ensureClickcombo(clickcombo))
       };
       if (matchesOnly) {
         effect(event, api);
@@ -323,10 +371,10 @@ function createExceptAndOnlyEffect(type, effect, options) {
       }
     };
   }
-  if (type === "pointerdown" || type === "pointerup") {
+  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 = {
-        is: (pointercombo) => eventMatchesPointercombo(event, ensurePointercombo(pointercombo))
+        matches: (pointercombo) => eventMatchesPointercombo(event, ensurePointercombo(pointercombo))
       };
       if (matchesOnly) {
         effect(event, api);
@@ -445,7 +493,10 @@ class Recognizeable {
   }
   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(createSlice(excess)(this.sequence), [sequenceItem])([]);
+    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]
+    )([]);
     this.effectApi.getSequence = () => newSequence;
     this.effectApi.onRecognized = onRecognized || (() => {
     });
@@ -545,6 +596,9 @@ class Listenable {
       case "idle":
         this.idleListen(effect, options);
         break;
+      case "message":
+        this.messageListen(effect, options);
+        break;
       case "recognizeable":
         this.recognizeableListen(effect, options);
         break;
@@ -586,6 +640,11 @@ class Listenable {
     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) });
@@ -653,7 +712,7 @@ 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;
@@ -663,6 +722,11 @@ function stop(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]);
 }
@@ -694,6 +758,10 @@ const predicatesByImplementation = /* @__PURE__ */ new Map([
     "idle",
     (type) => type === "idle"
   ],
+  [
+    "message",
+    (type) => type === "message" || type === "messageerror"
+  ],
   [
     "documentevent",
     (type) => documentEvents.has(type)
@@ -814,7 +882,7 @@ const observerAssertionsByType = {
   resize: (observer) => observer instanceof ResizeObserver
 };
 
-const defaultOptions$6 = {
+const defaultOptions$7 = {
   duration: 0,
   timing: [
     0,
@@ -842,10 +910,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);
@@ -921,7 +989,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 });
@@ -1191,14 +1262,20 @@ class Animateable {
           return this.reversedEaseables;
       }
     })();
-    return lazyCollections.pipe(lazyCollections.filter(({ progress: { start, end } }) => start < naiveTimeProgress && end >= naiveTimeProgress), lazyCollections.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 lazyCollections.pipe(
+      lazyCollections.filter(({ progress: { start, end } }) => start < naiveTimeProgress && end >= naiveTimeProgress),
+      lazyCollections.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) {
@@ -1455,26 +1532,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);
   };
 }
@@ -1504,7 +1591,7 @@ function fromControlPointsToReversedControlPoints(points) {
 }
 function createToAnimationProgress(points) {
   const { 0: { x: point1x, y: point1y }, 1: { x: point2x, y: point2y } } = points;
-  return BezierEasing__default["default"](point1x, point1y, point2x, point2y);
+  return BezierEasing(point1x, point1y, point2x, point2y);
 }
 function toInterpolated({ previous, next, progress }, options = {}) {
   if (isUndefined(previous)) {
@@ -1514,11 +1601,14 @@ function toInterpolated({ previous, next, progress }, options = {}) {
     return (next - previous) * progress + previous;
   }
   if (isString(previous) && isString(next)) {
-    return color.mix(options.colorModel, {
-      start: previous,
-      end: next,
-      alpha: progress
-    }).toRgb().toRgbString();
+    return color.mix(
+      options.colorModel,
+      {
+        start: previous,
+        end: next,
+        alpha: progress
+      }
+    ).toRgb().toRgbString();
   }
   if (isArray(previous) && isArray(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;
@@ -1706,6 +1796,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",
@@ -1754,7 +1916,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;
@@ -1867,7 +2032,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;
@@ -1959,7 +2129,7 @@ class Copyable {
   errored() {
     this.computedStatus = "errored";
   }
-  effectClipboardTextChanges() {
+  listenForClipboardEvents() {
     this.copyListenable.listen(this.copyAndCutEffect);
     this.cutListenable.listen(this.copyAndCutEffect);
   }
@@ -1976,13 +2146,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();
   }
@@ -2169,7 +2342,7 @@ function toFlattenedD(stroke) {
   if (stroke.length === 0) {
     return "";
   }
-  const multiPolygon = polygonClipping__default["default"].union([stroke]);
+  const multiPolygon = polygonClipping.union([stroke]);
   return createReduce((dFromMultiPolygon, polygon) => {
     return dFromMultiPolygon + createReduce((dFromRing, points) => {
       return dFromRing + toD(points);
@@ -2269,34 +2442,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) {
@@ -2306,16 +2464,31 @@ 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.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" });
     return this;
@@ -2679,38 +2852,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 lazyCollections.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(
+      ensureIndices,
+      this.toPossiblePicks,
+      (possiblePicks) => {
+        if (replace === "all") {
+          return allowsDuplicates ? possiblePicks : toUnique(possiblePicks);
+        }
+        const maybeWithoutDuplicates = allowsDuplicates ? possiblePicks : createFilter(
+          (possiblePick) => typeof lazyCollections.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;
@@ -2730,7 +2915,9 @@ class Pickable {
       return this;
     }
     const omits = ensureIndices(indexOrIndices);
-    this.computedPicks = createFilter((pick, index) => options.reference === "array" ? isUndefined(lazyCollections.find((omit) => pick === omit)(omits)) : isUndefined(lazyCollections.find((omit) => index === omit)(omits)))(this.computedPicks);
+    this.computedPicks = createFilter(
+      (pick, index) => options.reference === "array" ? isUndefined(lazyCollections.find((omit) => pick === omit)(omits)) : isUndefined(lazyCollections.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;
@@ -2757,7 +2944,7 @@ class Sanitizeable {
   computedStatus;
   ready() {
     if (domIsAvailable()) {
-      this.computedDompurify = createDOMPurify__default["default"]();
+      this.computedDompurify = createDOMPurify();
       this.computedDompurify.setConfig(this.domPurifyConfig);
     }
     this.computedStatus = "ready";
@@ -2770,7 +2957,7 @@ class Sanitizeable {
   }
   get dompurify() {
     if (!this.computedDompurify && domIsAvailable()) {
-      this.computedDompurify = createDOMPurify__default["default"]();
+      this.computedDompurify = createDOMPurify();
       this.computedDompurify.setConfig(this.domPurifyConfig);
     }
     return this.computedDompurify;
@@ -2838,6 +3025,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"
@@ -2960,6 +3201,7 @@ class Storeable {
 }
 
 exports.Animateable = Animateable;
+exports.Broadcastable = Broadcastable;
 exports.Completeable = Completeable;
 exports.Copyable = Copyable;
 exports.Delayable = Delayable;
@@ -2975,6 +3217,7 @@ exports.Recognizeable = Recognizeable;
 exports.Resolveable = Resolveable;
 exports.Sanitizeable = Sanitizeable;
 exports.Searchable = Searchable;
+exports.Shareable = Shareable;
 exports.Storeable = Storeable;
 exports.createClamp = createClamp;
 exports.createClip = createClip;
@@ -3027,6 +3270,7 @@ exports.materialDecelerated = materialDecelerated;
 exports.materialStandard = materialStandard;
 exports.toD = toD;
 exports.toFlattenedD = toFlattenedD;
+exports.toMessageListenParams = toMessageListenParams;
 exports.verouEase = verouEase;
 exports.verouEaseIn = verouEaseIn;
 exports.verouEaseInOut = verouEaseInOut;