@baleada/logic 0.20.34 → 0.21.2

package/lib/index.cjs

@@ -50,34 +50,30 @@ function createFilterAsync(condition) {
     return createFilter((_, index) => transformedAsync[index])(array);
   };
 }
-function createDelete(required) {
+function createDelete(index) {
   return (array) => {
-    const deleteIndex = "index" in required ? required.index : lazyCollections.findIndex((element) => element === required?.item)(array);
-    return createConcat(createSlice({ from: 0, to: deleteIndex })(array), createSlice({ from: deleteIndex + 1 })(array))([]);
+    return createConcat(createSlice(0, index)(array), createSlice(index + 1)(array))([]);
   };
 }
-function createInsert(required) {
+function createInsert(item, index) {
   return (array) => {
-    const itemsToInsert = "items" in required ? required.items : [required.item], withItems = createConcat(array, itemsToInsert)([]);
-    return createReorder({
-      from: { start: array.length, itemCount: itemsToInsert.length },
-      to: required.index
-    })(withItems);
+    const withItems = createConcat(array, [item])([]);
+    return createReorder({ start: array.length, itemCount: 1 }, index)(withItems);
   };
 }
-function createReorder({ from, to }) {
+function createReorder(from, to) {
   return (array) => {
     const [itemsToMoveStartIndex, itemsToMoveCount] = isObject(from) ? [from.start, from.itemCount] : [from, 1], insertIndex = to;
     if (insertIndex > itemsToMoveStartIndex && insertIndex < itemsToMoveStartIndex + itemsToMoveCount) {
       return array;
     }
-    const itemsToMove = createSlice({ from: itemsToMoveStartIndex, to: itemsToMoveStartIndex + itemsToMoveCount })(array);
+    const itemsToMove = createSlice(itemsToMoveStartIndex, itemsToMoveStartIndex + itemsToMoveCount)(array);
     if (itemsToMoveStartIndex < insertIndex) {
-      const beforeItemsToMove = itemsToMoveStartIndex === 0 ? [] : createSlice({ from: 0, to: itemsToMoveStartIndex })(array), betweenItemsToMoveAndInsertIndex = createSlice({ from: itemsToMoveStartIndex + itemsToMoveCount, to: insertIndex + 1 })(array), afterInsertIndex = createSlice({ from: insertIndex + 1 })(array);
+      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)([]);
     }
     if (itemsToMoveStartIndex > insertIndex) {
-      const beforeInsertion = insertIndex === 0 ? [] : createSlice({ from: 0, to: insertIndex })(array), betweenInsertionAndItemsToMove = createSlice({ from: insertIndex, to: itemsToMoveStartIndex })(array), afterItemsToMove = createSlice({ from: itemsToMoveStartIndex + itemsToMoveCount })(array);
+      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 array;
@@ -86,19 +82,19 @@ function createReorder({ from, to }) {
 function isObject(value) {
   return typeof value === "object";
 }
-function createSwap({ indices }) {
+function createSwap(indices) {
   return (array) => {
     const { 0: from, 1: to } = indices, { reorderFrom, reorderTo } = (() => {
       if (from < to) {
         return {
-          reorderFrom: createReorder({ from, to }),
-          reorderTo: createReorder({ from: to - 1, to: from })
+          reorderFrom: createReorder(from, to),
+          reorderTo: createReorder(to - 1, from)
         };
       }
       if (from > to) {
         return {
-          reorderFrom: createReorder({ from, to }),
-          reorderTo: createReorder({ from: to + 1, to: from })
+          reorderFrom: createReorder(from, to),
+          reorderTo: createReorder(to + 1, from)
         };
       }
       return {
@@ -109,15 +105,15 @@ function createSwap({ indices }) {
     return new Pipeable(array).pipe(reorderFrom, reorderTo);
   };
 }
-function createReplace({ index, item }) {
+function createReplace(index, item) {
   return (array) => {
-    return createConcat(createSlice({ from: 0, to: index })(array), [item], createSlice({ from: 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);
 }
-function createSlice({ from, to }) {
+function createSlice(from, to) {
   return (array) => {
     return from === to ? [] : lazyCollections.pipe(lazyCollections.slice(from, to - 1), lazyCollections.toArray())(array);
   };
@@ -142,7 +138,7 @@ function createReverse() {
 }
 function createSort(compare) {
   return (array) => {
-    return new Pipeable(array).pipe(createSlice({ from: 0 }), (sliced) => sliced.sort(compare));
+    return new Pipeable(array).pipe(createSlice(0), (sliced) => sliced.sort(compare));
   };
 }
 function createSlug(options) {
@@ -155,7 +151,7 @@ function createClip(required) {
     return string.replace(required, "");
   };
 }
-function createClamp({ min, max }) {
+function createClamp(min, max) {
   return (number) => {
     const maxed = Math.max(number, min);
     return Math.min(maxed, max);
@@ -171,9 +167,9 @@ function createDetermine(potentialities) {
   })(potentialities);
   return (determinant) => lazyCollections.find(({ predicate }) => predicate(determinant))(predicates).outcome;
 }
-function createRename({ from, to }) {
+function createRename(from, to) {
   return (map2) => {
-    const keys = [...map2.keys()], keyToRenameIndex = lazyCollections.findIndex((k) => k === from)(keys), newKeys = createReplace({ index: keyToRenameIndex, item: to })(keys), values = [...map2.values()];
+    const keys = [...map2.keys()], keyToRenameIndex = lazyCollections.findIndex((k) => k === from)(keys), newKeys = createReplace(keyToRenameIndex, to)(keys), values = [...map2.values()];
     return createReduce((renamed, key, index) => renamed.set(key, values[index]), /* @__PURE__ */ new Map())(newKeys);
   };
 }
@@ -198,239 +194,6 @@ class Pipeable {
   }
 }
 
-function toEvent(eventType, options) {
-  const implementation = toImplementation(eventType);
-  switch (implementation) {
-    case "keycombo": {
-      const combo = toCombo(eventType), modifiers = createSlice({ from: 0, to: combo.length - 1 })(combo), { 0: name } = createSlice({ from: combo.length - 1 })(combo);
-      return new KeyboardEvent("keyDirection" in options ? `key${options.keyDirection}` : "keydown", {
-        ...options.init || {},
-        key: toKey(name),
-        ...createReduce((flags, alias) => {
-          flags[toModifierFlag(alias)] = true;
-          return flags;
-        }, {})(modifiers)
-      });
-    }
-    case "leftclickcombo":
-    case "rightclickcombo": {
-      const combo = toCombo(eventType), modifiers = createSlice({ from: 0, to: combo.length - 1 })(combo), { 0: name } = createSlice({ from: combo.length - 1 })(combo);
-      return new MouseEvent(name === "rightclick" ? "contextmenu" : name, {
-        ...options.init || {},
-        ...createReduce((flags, alias) => {
-          flags[toModifierFlag(alias)] = true;
-          return flags;
-        }, {})(modifiers)
-      });
-    }
-    case "pointercombo": {
-      const combo = toCombo(eventType), modifiers = createSlice({ from: 0, to: combo.length - 1 })(combo), { 0: name } = createSlice({ from: combo.length - 1 })(combo);
-      return new PointerEvent(name === "rightclick" ? "contextmenu" : name, {
-        ...options.init || {},
-        ...createReduce((flags, alias) => {
-          flags[toModifierFlag(alias)] = true;
-          return flags;
-        }, {})(modifiers)
-      });
-    }
-    case "documentevent":
-    case "event":
-      if (eventType === "abort")
-        return new UIEvent(eventType, options.init);
-      if (eventType === "animationcancel")
-        return new AnimationEvent(eventType, options.init);
-      if (eventType === "animationend")
-        return new AnimationEvent(eventType, options.init);
-      if (eventType === "animationiteration")
-        return new AnimationEvent(eventType, options.init);
-      if (eventType === "animationstart")
-        return new AnimationEvent(eventType, options.init);
-      if (eventType === "auxclick")
-        return new MouseEvent(eventType, options.init);
-      if (eventType === "beforeinput")
-        return new InputEvent(eventType, options.init);
-      if (eventType === "blur")
-        return new FocusEvent(eventType, options.init);
-      if (eventType === "canplay")
-        return new Event(eventType, options.init);
-      if (eventType === "canplaythrough")
-        return new Event(eventType, options.init);
-      if (eventType === "change")
-        return new Event(eventType, options.init);
-      if (eventType === "click")
-        return new MouseEvent(eventType, options.init);
-      if (eventType === "close")
-        return new Event(eventType, options.init);
-      if (eventType === "compositionend")
-        return new CompositionEvent(eventType, options.init);
-      if (eventType === "compositionstart")
-        return new CompositionEvent(eventType, options.init);
-      if (eventType === "compositionupdate")
-        return new CompositionEvent(eventType, options.init);
-      if (eventType === "contextmenu")
-        return new MouseEvent(eventType, options.init);
-      if (eventType === "cuechange")
-        return new Event(eventType, options.init);
-      if (eventType === "dblclick")
-        return new MouseEvent(eventType, options.init);
-      if (eventType === "drag")
-        return new DragEvent(eventType, options.init);
-      if (eventType === "dragend")
-        return new DragEvent(eventType, options.init);
-      if (eventType === "dragenter")
-        return new DragEvent(eventType, options.init);
-      if (eventType === "dragleave")
-        return new DragEvent(eventType, options.init);
-      if (eventType === "dragover")
-        return new DragEvent(eventType, options.init);
-      if (eventType === "dragstart")
-        return new DragEvent(eventType, options.init);
-      if (eventType === "drop")
-        return new DragEvent(eventType, options.init);
-      if (eventType === "durationchange")
-        return new Event(eventType, options.init);
-      if (eventType === "emptied")
-        return new Event(eventType, options.init);
-      if (eventType === "ended")
-        return new Event(eventType, options.init);
-      if (eventType === "error")
-        return new ErrorEvent(eventType, options.init);
-      if (eventType === "focus")
-        return new FocusEvent(eventType, options.init);
-      if (eventType === "focusin")
-        return new FocusEvent(eventType, options.init);
-      if (eventType === "focusout")
-        return new FocusEvent(eventType, options.init);
-      if (eventType === "gotpointercapture")
-        return new PointerEvent(eventType, options.init);
-      if (eventType === "input")
-        return new Event(eventType, options.init);
-      if (eventType === "invalid")
-        return new Event(eventType, options.init);
-      if (eventType === "keydown")
-        return new KeyboardEvent(eventType, options.init);
-      if (eventType === "keypress")
-        return new KeyboardEvent(eventType, options.init);
-      if (eventType === "keyup")
-        return new KeyboardEvent(eventType, options.init);
-      if (eventType === "load")
-        return new Event(eventType, options.init);
-      if (eventType === "loadeddata")
-        return new Event(eventType, options.init);
-      if (eventType === "loadedmetadata")
-        return new Event(eventType, options.init);
-      if (eventType === "loadstart")
-        return new Event(eventType, options.init);
-      if (eventType === "lostpointercapture")
-        return new PointerEvent(eventType, options.init);
-      if (eventType === "mousedown")
-        return new MouseEvent(eventType, options.init);
-      if (eventType === "mouseenter")
-        return new MouseEvent(eventType, options.init);
-      if (eventType === "mouseleave")
-        return new MouseEvent(eventType, options.init);
-      if (eventType === "mousemove")
-        return new MouseEvent(eventType, options.init);
-      if (eventType === "mouseout")
-        return new MouseEvent(eventType, options.init);
-      if (eventType === "mouseover")
-        return new MouseEvent(eventType, options.init);
-      if (eventType === "mouseup")
-        return new MouseEvent(eventType, options.init);
-      if (eventType === "pause")
-        return new Event(eventType, options.init);
-      if (eventType === "play")
-        return new Event(eventType, options.init);
-      if (eventType === "playing")
-        return new Event(eventType, options.init);
-      if (eventType === "pointercancel")
-        return new PointerEvent(eventType, options.init);
-      if (eventType === "pointerdown")
-        return new PointerEvent(eventType, options.init);
-      if (eventType === "pointerenter")
-        return new PointerEvent(eventType, options.init);
-      if (eventType === "pointerleave")
-        return new PointerEvent(eventType, options.init);
-      if (eventType === "pointermove")
-        return new PointerEvent(eventType, options.init);
-      if (eventType === "pointerout")
-        return new PointerEvent(eventType, options.init);
-      if (eventType === "pointerover")
-        return new PointerEvent(eventType, options.init);
-      if (eventType === "pointerup")
-        return new PointerEvent(eventType, options.init);
-      if (eventType === "progress")
-        return new ProgressEvent(eventType, options.init);
-      if (eventType === "ratechange")
-        return new Event(eventType, options.init);
-      if (eventType === "reset")
-        return new Event(eventType, options.init);
-      if (eventType === "scroll")
-        return new Event(eventType, options.init);
-      if (eventType === "securitypolicyviolation")
-        return new SecurityPolicyViolationEvent(eventType, options.init);
-      if (eventType === "seeked")
-        return new Event(eventType, options.init);
-      if (eventType === "seeking")
-        return new Event(eventType, options.init);
-      if (eventType === "select")
-        return new Event(eventType, options.init);
-      if (eventType === "selectionchange")
-        return new Event(eventType, options.init);
-      if (eventType === "selectstart")
-        return new Event(eventType, options.init);
-      if (eventType === "stalled")
-        return new Event(eventType, options.init);
-      if (eventType === "submit")
-        return new Event(eventType, options.init);
-      if (eventType === "suspend")
-        return new Event(eventType, options.init);
-      if (eventType === "timeupdate")
-        return new Event(eventType, options.init);
-      if (eventType === "toggle")
-        return new Event(eventType, options.init);
-      if (eventType === "touchcancel")
-        return new TouchEvent(eventType, options.init);
-      if (eventType === "touchend")
-        return new TouchEvent(eventType, options.init);
-      if (eventType === "touchmove")
-        return new TouchEvent(eventType, options.init);
-      if (eventType === "touchstart")
-        return new TouchEvent(eventType, options.init);
-      if (eventType === "transitioncancel")
-        return new TransitionEvent(eventType, options.init);
-      if (eventType === "transitionend")
-        return new TransitionEvent(eventType, options.init);
-      if (eventType === "transitionrun")
-        return new TransitionEvent(eventType, options.init);
-      if (eventType === "transitionstart")
-        return new TransitionEvent(eventType, options.init);
-      if (eventType === "volumechange")
-        return new Event(eventType, options.init);
-      if (eventType === "waiting")
-        return new Event(eventType, options.init);
-      if (eventType === "wheel")
-        return new WheelEvent(eventType, options.init);
-      if (eventType === "copy")
-        return new ClipboardEvent(eventType, options.init);
-      if (eventType === "cut")
-        return new ClipboardEvent(eventType, options.init);
-      if (eventType === "paste")
-        return new ClipboardEvent(eventType, options.init);
-      if (eventType === "fullscreenchange")
-        return new Event(eventType, options.init);
-      if (eventType === "fullscreenerror")
-        return new Event(eventType, options.init);
-      if (eventType === "pointerlockchange")
-        return new Event(eventType, options.init);
-      if (eventType === "pointerlockerror")
-        return new Event(eventType, options.init);
-      if (eventType === "readystatechange")
-        return new Event(eventType, options.init);
-      if (eventType === "visibilitychange")
-        return new Event(eventType, options.init);
-  }
-}
 function toKey(name) {
   return name in keysByName ? keysByName[name] : name;
 }
@@ -528,20 +291,6 @@ const modifiersByAlias = {
   opt: "alt",
   option: "alt"
 };
-function toModifierFlag(modifierOrAlias) {
-  return flagsByModifierOrAlias[modifierOrAlias];
-}
-const flagsByModifierOrAlias = {
-  shift: "shiftKey",
-  cmd: "metaKey",
-  command: "metaKey",
-  meta: "metaKey",
-  ctrl: "ctrlKey",
-  control: "ctrlKey",
-  alt: "altKey",
-  opt: "altKey",
-  option: "altKey"
-};
 function createExceptAndOnlyEffect(effect, options) {
   const { except = [], only = [] } = options;
   return (event) => {
@@ -657,7 +406,7 @@ class Recognizeable {
   }
   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({ from: 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.sequenceItem = sequenceItem;
     this.effectApi.getSequence = () => newSequence;
     this.effectApi.onRecognized = onRecognized || (() => {
@@ -1862,7 +1611,7 @@ function toInterpolated({ previous, next, progress }, options = {}) {
   }
   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;
-    return createSlice({ from: 0, to: sliceEnd })(sliceTarget);
+    return createSlice(0, sliceEnd)(sliceTarget);
   }
 }
 const linear = [
@@ -2262,10 +2011,10 @@ class Copyable {
   }
   computedResponse;
   computedError;
-  async copy(options = { type: "clipboard" }) {
+  async copy(options = { kind: "clipboard" }) {
     this.copying();
-    const { type } = options;
-    switch (type) {
+    const { kind } = options;
+    switch (kind) {
       case "clipboard":
         try {
           this.computedResponse = await navigator.clipboard.writeText(this.string);
@@ -2453,44 +2202,6 @@ class Delayable {
   }
 }
 
-class Dispatchable {
-  constructor(type, options = {}) {
-    this.setType(type);
-    this.ready();
-  }
-  computedStatus;
-  ready() {
-    this.computedStatus = "ready";
-  }
-  get type() {
-    return this.computedType;
-  }
-  set type(type) {
-    this.setType(type);
-  }
-  get cancelled() {
-    return this.computedCancelled;
-  }
-  get status() {
-    return this.computedStatus;
-  }
-  computedType;
-  setType(type) {
-    this.computedType = type;
-    return this;
-  }
-  computedCancelled;
-  dispatch(options = {}) {
-    const { target = window, ...rest } = options, event = toEvent(this.type, rest);
-    this.computedCancelled = !target.dispatchEvent(event);
-    this.dispatched();
-    return this;
-  }
-  dispatched() {
-    this.computedStatus = "dispatched";
-  }
-}
-
 const defaultOptions$3 = {
   toD: (stroke) => stroke.length === 0 ? "" : toD(stroke)
 };
@@ -2993,6 +2704,10 @@ class Navigateable {
 const defaultOptions$1 = {
   initialPicks: []
 };
+const defaultPickOptions = {
+  replace: "none",
+  allowsDuplicates: false
+};
 class Pickable {
   constructor(array, options = {}) {
     this.setArray(array);
@@ -3051,37 +2766,37 @@ class Pickable {
     return this.pick(indexOrIndices);
   }
   pick(indexOrIndices, options = {}) {
-    const { replace = "none" } = options;
+    const { replace, allowsDuplicates } = { ...defaultPickOptions, ...options };
     this.computedPicks = new Pipeable(indexOrIndices).pipe(ensureIndices, this.toPossiblePicks, (possiblePicks) => {
       if (replace === "all") {
-        return toUnique(possiblePicks);
+        return allowsDuplicates ? possiblePicks : toUnique(possiblePicks);
       }
-      const possibleWithoutDuplicates = createFilter((possiblePick) => typeof lazyCollections.find((pick) => pick === possiblePick)(this.picks || []) !== "number")(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 || [], possibleWithoutDuplicates)([]);
+          return createConcat(this.picks || [], maybeWithoutDuplicates)([]);
         case "fifo":
-          if (possibleWithoutDuplicates.length === 0) {
+          if (maybeWithoutDuplicates.length === 0) {
             return this.picks;
           }
-          if (possibleWithoutDuplicates.length === this.picks.length) {
-            return possibleWithoutDuplicates;
+          if (maybeWithoutDuplicates.length === this.picks.length) {
+            return maybeWithoutDuplicates;
           }
-          if (possibleWithoutDuplicates.length > this.picks.length) {
-            return createSlice({ from: possibleWithoutDuplicates.length - this.picks.length })(possibleWithoutDuplicates);
+          if (maybeWithoutDuplicates.length > this.picks.length) {
+            return createSlice(maybeWithoutDuplicates.length - this.picks.length)(maybeWithoutDuplicates);
           }
-          return new Pipeable(this.picks).pipe(createSlice({ from: possibleWithoutDuplicates.length }), createConcat(possibleWithoutDuplicates));
+          return new Pipeable(this.picks).pipe(createSlice(maybeWithoutDuplicates.length), createConcat(maybeWithoutDuplicates));
         case "lifo":
-          if (possibleWithoutDuplicates.length === 0) {
+          if (maybeWithoutDuplicates.length === 0) {
             return this.picks;
           }
-          if (possibleWithoutDuplicates.length === this.picks.length) {
-            return possibleWithoutDuplicates;
+          if (maybeWithoutDuplicates.length === this.picks.length) {
+            return maybeWithoutDuplicates;
           }
-          if (possibleWithoutDuplicates.length > this.picks.length) {
-            return createSlice({ from: 0, to: possibleWithoutDuplicates.length - this.picks.length + 1 })(possibleWithoutDuplicates);
+          if (maybeWithoutDuplicates.length > this.picks.length) {
+            return createSlice(0, maybeWithoutDuplicates.length - this.picks.length + 1)(maybeWithoutDuplicates);
           }
-          return new Pipeable(this.picks).pipe(createSlice({ from: 0, to: this.picks.length - possibleWithoutDuplicates.length }), createConcat(possibleWithoutDuplicates));
+          return new Pipeable(this.picks).pipe(createSlice(0, this.picks.length - maybeWithoutDuplicates.length), createConcat(maybeWithoutDuplicates));
       }
     });
     this.computedFirst = Math.min(...this.picks);
@@ -3092,7 +2807,7 @@ class Pickable {
   picked() {
     this.computedStatus = "picked";
   }
-  omit(indexOrIndices) {
+  omit(indexOrIndices, options = { reference: "array" }) {
     if (isUndefined(indexOrIndices)) {
       this.computedPicks = [];
       this.computedFirst = void 0;
@@ -3101,7 +2816,7 @@ class Pickable {
       return this;
     }
     const omits = ensureIndices(indexOrIndices);
-    this.computedPicks = createFilter((pick) => isUndefined(lazyCollections.find((omit) => pick === 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.omitted();
@@ -3209,15 +2924,15 @@ class Searchable {
 }
 
 const defaultOptions = {
-  type: "local",
+  kind: "local",
   statusKeySuffix: " status"
 };
 class Storeable {
-  type;
+  kind;
   statusKeySuffix;
   constructor(key, options = {}) {
     this.constructing();
-    this.type = options.type ?? defaultOptions.type;
+    this.kind = options.kind ?? defaultOptions.kind;
     this.statusKeySuffix = options.statusKeySuffix ?? defaultOptions.statusKeySuffix;
     this.setKey(key);
     this.ready();
@@ -3250,7 +2965,7 @@ class Storeable {
     return this.computedStatus;
   }
   get storage() {
-    switch (this.type) {
+    switch (this.kind) {
       case "local":
         return localStorage;
       case "session":
@@ -3333,7 +3048,6 @@ exports.Animateable = Animateable;
 exports.Completeable = Completeable;
 exports.Copyable = Copyable;
 exports.Delayable = Delayable;
-exports.Dispatchable = Dispatchable;
 exports.Drawable = Drawable;
 exports.Fetchable = Fetchable;
 exports.Fullscreenable = Fullscreenable;