@baleada/logic 0.20.30 → 0.21.0

package/lib/index.js

@@ -1,4 +1,4 @@
-import { reduce, pipe, filter, toArray, findIndex, slice, concat, unique, map, find, some, join, every } from 'lazy-collections';
+import { reduce, pipe, filter, toArray, slice, concat, unique, map, find, findIndex, some, join, every } from 'lazy-collections';
 import slugify from '@sindresorhus/slugify';
 import BezierEasing from 'bezier-easing';
 import { mix } from '@snigo.dev/color';
@@ -39,34 +39,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 : 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;
@@ -75,19 +71,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 {
@@ -98,15 +94,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) => pipe(unique(), toArray())(array);
 }
-function createSlice({ from, to }) {
+function createSlice(from, to) {
   return (array) => {
     return from === to ? [] : pipe(slice(from, to - 1), toArray())(array);
   };
@@ -129,6 +125,11 @@ function createReverse() {
     return reversed;
   };
 }
+function createSort(compare) {
+  return (array) => {
+    return new Pipeable(array).pipe(createSlice(0), (sliced) => sliced.sort(compare));
+  };
+}
 function createSlug(options) {
   return (string) => {
     return slugify(string, options);
@@ -139,7 +140,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);
@@ -155,10 +156,10 @@ function createDetermine(potentialities) {
   })(potentialities);
   return (determinant) => find(({ predicate }) => predicate(determinant))(predicates).outcome;
 }
-function createRename({ from, to }) {
+function createRename(from, to) {
   return (map2) => {
-    const keys = [...map2.keys()], keyToRenameIndex = findIndex((k) => k === from)(keys), newKeys = createReplace({ index: keyToRenameIndex, item: to })(keys), values = [...map2.values()];
-    return createReduce((renamed, key, index) => renamed.set(key, values[index]), new Map())(newKeys);
+    const keys = [...map2.keys()], keyToRenameIndex = 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);
   };
 }
 function createToEntries() {
@@ -186,7 +187,7 @@ 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);
+      const combo = toCombo(eventType), modifiers = createSlice(0, combo.length - 1)(combo), { 0: name } = createSlice(combo.length - 1)(combo);
       return new KeyboardEvent("keyDirection" in options ? `key${options.keyDirection}` : "keydown", {
         ...options.init || {},
         key: toKey(name),
@@ -198,7 +199,7 @@ function toEvent(eventType, options) {
     }
     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);
+      const combo = toCombo(eventType), modifiers = createSlice(0, combo.length - 1)(combo), { 0: name } = createSlice(combo.length - 1)(combo);
       return new MouseEvent(name === "rightclick" ? "contextmenu" : name, {
         ...options.init || {},
         ...createReduce((flags, alias) => {
@@ -208,7 +209,7 @@ function toEvent(eventType, options) {
       });
     }
     case "pointercombo": {
-      const combo = toCombo(eventType), modifiers = createSlice({ from: 0, to: combo.length - 1 })(combo), { 0: name } = createSlice({ from: combo.length - 1 })(combo);
+      const combo = toCombo(eventType), modifiers = createSlice(0, combo.length - 1)(combo), { 0: name } = createSlice(combo.length - 1)(combo);
       return new PointerEvent(name === "rightclick" ? "contextmenu" : name, {
         ...options.init || {},
         ...createReduce((flags, alias) => {
@@ -235,8 +236,6 @@ function toEvent(eventType, options) {
         return new InputEvent(eventType, options.init);
       if (eventType === "blur")
         return new FocusEvent(eventType, options.init);
-      if (eventType === "cancel")
-        return new Event(eventType, options.init);
       if (eventType === "canplay")
         return new Event(eventType, options.init);
       if (eventType === "canplaythrough")
@@ -265,8 +264,6 @@ function toEvent(eventType, options) {
         return new DragEvent(eventType, options.init);
       if (eventType === "dragenter")
         return new DragEvent(eventType, options.init);
-      if (eventType === "dragexit")
-        return new Event(eventType, options.init);
       if (eventType === "dragleave")
         return new DragEvent(eventType, options.init);
       if (eventType === "dragover")
@@ -489,7 +486,7 @@ function toCombo(type) {
 function fromComboItemNameToType(name) {
   return find((type) => predicatesByType[type](name))(listenableComboItemTypes) ?? "custom";
 }
-const listenableComboItemTypes = new Set(["singleCharacter", "arrow", "other", "modifier", "click", "pointer"]);
+const listenableComboItemTypes = /* @__PURE__ */ new Set(["singleCharacter", "arrow", "other", "modifier", "click", "pointer"]);
 const predicatesByType = {
   singleCharacter: (name) => typeREs["singleCharacter"].test(name),
   arrow: (name) => typeREs["arrow"].test(name),
@@ -585,6 +582,10 @@ function isString(value) {
 }
 
 class Recognizeable {
+  maxSequenceLength;
+  effects;
+  effectApi;
+  toType;
   constructor(sequence, options = { effectsIncludeCombos: true }) {
     const defaultOptions = {
       maxSequenceLength: true,
@@ -608,6 +609,7 @@ class Recognizeable {
     };
     this.ready();
   }
+  computedMetadata;
   resetComputedMetadata() {
     this.computedMetadata = {};
   }
@@ -617,6 +619,7 @@ class Recognizeable {
   denied() {
     this.computedStatus = "denied";
   }
+  computedStatus;
   ready() {
     this.computedStatus = "ready";
   }
@@ -632,13 +635,14 @@ class Recognizeable {
   get metadata() {
     return this.computedMetadata;
   }
+  computedSequence;
   setSequence(sequence) {
     this.computedSequence = sequence;
     return this;
   }
   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 || (() => {
@@ -735,9 +739,12 @@ function createToType({
     }
   };
 }
-const leftclickcomboEventTypes = new Set(["click", "mousedown", "mouseup", "dblclick"]), rightclickComboEventTypes = new Set(["contextmenu"]), keycomboEventTypes = new Set(["keydown", "keyup"]), toJoinedClickcombo = join("+"), toJoinedKeycombo = pipe(map(({ name }) => name), toJoinedClickcombo);
+const leftclickcomboEventTypes = /* @__PURE__ */ new Set(["click", "mousedown", "mouseup", "dblclick"]), rightclickComboEventTypes = /* @__PURE__ */ new Set(["contextmenu"]), keycomboEventTypes = /* @__PURE__ */ new Set(["keydown", "keyup"]), toJoinedClickcombo = join("+"), toJoinedKeycombo = pipe(map(({ name }) => name), toJoinedClickcombo);
 
 class Listenable {
+  computedRecognizeable;
+  recognizeableEffectsKeys;
+  computedActive;
   constructor(type, options) {
     if (type === "recognizeable") {
       const recognizeableOptions = {
@@ -750,10 +757,11 @@ class Listenable {
       this.computedRecognizeable = new Recognizeable([], recognizeableOptions);
       this.recognizeableEffectsKeys = Object.keys(recognizeableOptions.effects);
     }
-    this.computedActive = new Set();
+    this.computedActive = /* @__PURE__ */ new Set();
     this.setType(type);
     this.ready();
   }
+  computedStatus;
   ready() {
     this.computedStatus = "ready";
   }
@@ -772,6 +780,8 @@ class Listenable {
   get recognizeable() {
     return this.computedRecognizeable;
   }
+  computedType;
+  implementation;
   setType(type) {
     this.stop();
     this.computedType = type;
@@ -964,7 +974,7 @@ function stop(stoppable) {
 function toImplementation(type) {
   return find((implementation) => predicatesByImplementation.get(implementation)(type))(predicatesByImplementation.keys());
 }
-const predicatesByImplementation = new Map([
+const predicatesByImplementation = /* @__PURE__ */ new Map([
   [
     "recognizeable",
     (type) => type === "recognizeable"
@@ -1014,7 +1024,7 @@ const predicatesByImplementation = new Map([
     () => true
   ]
 ]);
-const documentEvents = new Set([
+const documentEvents = /* @__PURE__ */ new Set([
   "fullscreenchange",
   "fullscreenerror",
   "pointerlockchange",
@@ -1037,6 +1047,11 @@ function eventMatchesKeycombo({ event, keycombo }) {
   return every(({ name, type }, index) => {
     switch (type) {
       case "singleCharacter":
+        if (name === "!") {
+          return event.key === "!";
+        }
+        const keyToTest = event.altKey && fromComboItemNameToType(event.key) === "custom" ? fromCodeToSingleCharacter(event.code) : event.key.toLowerCase();
+        return name.startsWith("!") ? keyToTest !== toKey(name.slice(1)).toLowerCase() : keyToTest === toKey(name).toLowerCase();
       case "other":
         if (name === "!") {
           return event.key === "!";
@@ -1052,7 +1067,34 @@ function eventMatchesKeycombo({ event, keycombo }) {
     }
   })(keycombo);
 }
-const predicatesByArrow = new Map([
+function fromCodeToSingleCharacter(code) {
+  for (const c in aliasesByCode) {
+    if (c === code) {
+      return aliasesByCode[c];
+    }
+  }
+  for (const prefix of ["Key", "Digit"]) {
+    const re = new RegExp(`^${prefix}`);
+    if (re.test(code)) {
+      return createClip(re)(code).toLowerCase();
+    }
+  }
+  return code;
+}
+const aliasesByCode = {
+  "Backquote": "`",
+  "Minus": "-",
+  "Equal": "=",
+  "BracketLeft": "[",
+  "BracketRight": "]",
+  "Backslash": "\\",
+  "Semicolon": ";",
+  "Quote": "'",
+  "Comma": ",",
+  "Period": ".",
+  "Slash": "/"
+};
+const predicatesByArrow = /* @__PURE__ */ new Map([
   [
     "arrow",
     ({ event }) => arrows.has(event.key.toLowerCase())
@@ -1082,9 +1124,9 @@ const predicatesByArrow = new Map([
     ({ event, name }) => name.startsWith("!") ? event.key.toLowerCase() !== `arrow${name.toLowerCase()}` : event.key.toLowerCase() === `arrow${name.toLowerCase()}`
   ]
 ]);
-const arrows = new Set(["arrowup", "arrowright", "arrowdown", "arrowleft"]);
-const verticalArrows = new Set(["arrowup", "arrowdown"]);
-const horizontalArrows = new Set(["arrowright", "arrowleft"]);
+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);
 }
@@ -1109,6 +1151,21 @@ const defaultOptions$6 = {
   alternates: false
 };
 class Animateable {
+  initialDuration;
+  iterationLimit;
+  alternates;
+  controlPoints;
+  reversedControlPoints;
+  toAnimationProgress;
+  reversedToAnimationProgress;
+  playCache;
+  reverseCache;
+  pauseCache;
+  seekCache;
+  alternateCache;
+  visibilitychange;
+  getEaseables;
+  getReversedEaseables;
   constructor(keyframes, options = {}) {
     this.initialDuration = options?.duration || defaultOptions$6.duration;
     this.controlPoints = fromTimingToControlPoints(options?.timing || defaultOptions$6.timing);
@@ -1132,21 +1189,25 @@ class Animateable {
     this.resetProgress();
     this.resetIterations();
   }
+  computedStatus;
   ready() {
     this.computedStatus = "ready";
   }
+  computedTime;
   resetTime() {
     this.computedTime = {
       elapsed: 0,
       remaining: this.duration
     };
   }
+  computedProgress;
   resetProgress() {
     this.computedProgress = {
       time: 0,
       animation: 0
     };
   }
+  computedIterations;
   resetIterations() {
     this.computedIterations = 0;
   }
@@ -1177,6 +1238,11 @@ class Animateable {
   get progress() {
     return this.computedProgress;
   }
+  computedKeyframes;
+  reversedKeyframes;
+  properties;
+  easeables;
+  reversedEaseables;
   setKeyframes(keyframes) {
     this.stop();
     this.computedKeyframes = Array.from(keyframes).sort(({ progress: progressA }, { progress: progressB }) => progressA - progressB);
@@ -1186,6 +1252,9 @@ class Animateable {
     this.reversedEaseables = this.getReversedEaseables({ keyframes: this.reversedKeyframes, properties: this.properties });
     return this;
   }
+  computedPlaybackRate;
+  duration;
+  totalTimeInvisible;
   setPlaybackRate(playbackRate) {
     const ensuredPlaybackRate = Math.max(0, playbackRate);
     this.computedPlaybackRate = ensuredPlaybackRate;
@@ -1331,6 +1400,7 @@ class Animateable {
   reversed() {
     this.computedStatus = "reversed";
   }
+  invisibleAt;
   listenForVisibilitychange() {
     if (this.visibilitychange.active.size === 0) {
       this.totalTimeInvisible = 0;
@@ -1346,6 +1416,7 @@ class Animateable {
       });
     }
   }
+  computedRequest;
   createAnimate(type) {
     return (effect, options = {}) => {
       const { interpolate: interpolateOptions } = options;
@@ -1366,6 +1437,7 @@ class Animateable {
       return this;
     };
   }
+  startTime;
   setStartTimeAndStatus(type, timestamp) {
     switch (type) {
       case "play":
@@ -1732,7 +1804,7 @@ function createGetEaseables(fromKeyframeToControlPoints) {
   };
 }
 function toProperties(keyframes) {
-  const properties = new Set();
+  const properties = /* @__PURE__ */ new Set();
   for (const keyframe of keyframes) {
     for (const property in keyframe.properties) {
       if (!properties.has(property)) {
@@ -1775,7 +1847,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 = [
@@ -1970,6 +2042,10 @@ const defaultCompleteOptions = {
   select: "completionEnd"
 };
 class Completeable {
+  segmentFrom;
+  segmentTo;
+  divider;
+  computedDividerIndices;
   constructor(string, options = {}) {
     this.constructing();
     this.segmentFrom = options?.segment?.from || defaultOptions$5.segment.from;
@@ -1983,6 +2059,7 @@ class Completeable {
   constructing() {
     this.computedStatus = "constructing";
   }
+  computedStatus;
   ready() {
     this.computedStatus = "ready";
   }
@@ -2027,6 +2104,7 @@ class Completeable {
         return this.dividerIndices.after;
     }
   }
+  computedString;
   setString(string) {
     this.computedString = string;
     switch (this.status) {
@@ -2038,6 +2116,7 @@ class Completeable {
     }
     return this;
   }
+  computedSelection;
   setSelection(selection) {
     this.computedSelection = selection;
     this.setDividerIndices();
@@ -2124,6 +2203,10 @@ function toNextMatch({ string, re, from }) {
 }
 
 class Copyable {
+  computedIsClipboardText;
+  copyListenable;
+  cutListenable;
+  copyAndCutEffect;
   constructor(string, options = {}) {
     this.computedIsClipboardText = false;
     this.copyListenable = new Listenable("copy");
@@ -2135,6 +2218,7 @@ class Copyable {
     this.setString(string);
     this.ready();
   }
+  computedStatus;
   ready() {
     this.computedStatus = "ready";
   }
@@ -2156,10 +2240,13 @@ class Copyable {
   get error() {
     return this.computedError;
   }
+  computedString;
   setString(string) {
     this.computedString = string;
     return this;
   }
+  computedResponse;
+  computedError;
   async copy(options = { type: "clipboard" }) {
     this.copying();
     const { type } = options;
@@ -2212,6 +2299,7 @@ const defaultOptions$4 = {
   executions: 1
 };
 class Delayable {
+  animateable;
   constructor(effect, options = {}) {
     this.animateable = new Animateable([
       { progress: 0, properties: { progress: 0 } },
@@ -2223,6 +2311,7 @@ class Delayable {
     this.setEffect(effect);
     this.ready();
   }
+  computedStatus;
   ready() {
     this.computedStatus = "ready";
   }
@@ -2244,12 +2333,14 @@ class Delayable {
   get progress() {
     return this.animateable.progress.time;
   }
+  computedEffect;
   setEffect(effect) {
     this.stop();
     this.computedEffect = effect;
     this.setFrameEffect(effect);
     return this;
   }
+  frameEffect;
   setFrameEffect(effect) {
     this.frameEffect = (frame) => {
       const { properties: { progress }, timestamp } = frame;
@@ -2352,6 +2443,7 @@ class Dispatchable {
     this.setType(type);
     this.ready();
   }
+  computedStatus;
   ready() {
     this.computedStatus = "ready";
   }
@@ -2367,10 +2459,12 @@ class Dispatchable {
   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);
@@ -2386,11 +2480,14 @@ const defaultOptions$3 = {
   toD: (stroke) => stroke.length === 0 ? "" : toD(stroke)
 };
 class Drawable {
+  computedD;
+  toD;
   constructor(stroke, options = {}) {
     this.toD = options?.toD || defaultOptions$3.toD;
     this.setStroke(stroke);
     this.ready();
   }
+  computedStatus;
   ready() {
     this.computedStatus = "ready";
   }
@@ -2406,6 +2503,7 @@ class Drawable {
   get d() {
     return this.computedD;
   }
+  computedStroke;
   setStroke(stroke) {
     this.computedStroke = stroke;
     this.computedD = this.toD(stroke);
@@ -2447,6 +2545,7 @@ class Resolveable {
     this.setGetPromise(getPromise);
     this.ready();
   }
+  computedStatus;
   ready() {
     this.computedStatus = "ready";
   }
@@ -2462,10 +2561,12 @@ class Resolveable {
   get value() {
     return this.computedValue;
   }
+  computedGetPromise;
   setGetPromise(getPromise) {
     this.computedGetPromise = getPromise;
     return this;
   }
+  computedValue;
   async resolve(...args) {
     this.resolving();
     try {
@@ -2490,6 +2591,11 @@ class Resolveable {
 }
 
 class Fetchable {
+  computedArrayBuffer;
+  computedBlob;
+  computedFormData;
+  computedJson;
+  computedText;
   constructor(resource, options = {}) {
     this.setResource(resource);
     this.computedArrayBuffer = new Resolveable(async () => "arrayBuffer" in this.response ? await this.response.arrayBuffer() : await void 0);
@@ -2499,6 +2605,7 @@ class Fetchable {
     this.computedText = new Resolveable(async () => "text" in this.response ? await this.response.text() : await void 0);
     this.ready();
   }
+  computedStatus;
   ready() {
     this.computedStatus = "ready";
   }
@@ -2508,6 +2615,7 @@ class Fetchable {
   set resource(resource) {
     this.setResource(resource);
   }
+  computedAbortController;
   get abortController() {
     if (!this.computedAbortController) {
       this.computedAbortController = new AbortController();
@@ -2553,10 +2661,13 @@ class Fetchable {
         return resolveable;
     }
   }
+  computedResource;
   setResource(resource) {
     this.computedResource = resource;
     return this;
   }
+  computedResponse;
+  computedError;
   async fetch(options = {}) {
     this.computedStatus = "fetching";
     try {
@@ -2611,6 +2722,7 @@ class Fullscreenable {
     this.setGetElement(getElement);
     this.ready();
   }
+  computedStatus;
   ready() {
     this.computedStatus = "ready";
   }
@@ -2629,6 +2741,7 @@ class Fullscreenable {
   get error() {
     return this.computedError;
   }
+  computedGetElement;
   setGetElement(getElement) {
     this.computedGetElement = () => getElement();
     return this;
@@ -2637,6 +2750,7 @@ class Fullscreenable {
     await this.fullscreen(options);
     return this;
   }
+  computedError;
   async fullscreen(options = {}) {
     try {
       await this.element.requestFullscreen(options);
@@ -2673,6 +2787,7 @@ class Grantable {
     this.setDescriptor(descriptor);
     this.ready();
   }
+  computedStatus;
   ready() {
     this.computedStatus = "ready";
   }
@@ -2688,10 +2803,12 @@ class Grantable {
   get status() {
     return this.computedStatus;
   }
+  computedDescriptor;
   setDescriptor(descriptor) {
     this.computedDescriptor = descriptor;
     return this;
   }
+  computedPermission;
   async query() {
     this.querying();
     try {
@@ -2728,15 +2845,18 @@ class Navigateable {
     this.navigate(options?.initialLocation ?? defaultOptions$2.initialLocation);
     this.ready();
   }
+  computedStatus;
   ready() {
     this.computedStatus = "ready";
   }
+  computedArray;
   get array() {
     return this.computedArray;
   }
   set array(value) {
     this.setArray(value);
   }
+  computedLocation;
   get location() {
     return this.computedLocation;
   }
@@ -2860,29 +2980,33 @@ const defaultOptions$1 = {
 };
 class Pickable {
   constructor(array, options = {}) {
-    this.toItems = createMap((index) => this.array[index]);
     this.setArray(array);
     this.pick(options.initialPicks ?? defaultOptions$1.initialPicks);
     this.ready();
   }
+  computedStatus;
   ready() {
     this.computedStatus = "ready";
   }
+  computedArray;
   get array() {
     return this.computedArray;
   }
   set array(array) {
     this.setArray(array);
   }
+  computedPicks;
   get picks() {
     return this.computedPicks;
   }
   set picks(indices) {
     this.pick(indices);
   }
+  computedFirst;
   get first() {
     return this.computedFirst;
   }
+  computedLast;
   get last() {
     return this.computedLast;
   }
@@ -2898,9 +3022,11 @@ class Pickable {
   get items() {
     return this.toItems(this.picks);
   }
+  toItems = createMap((index) => this.array[index]);
   get multiple() {
     return this.picks.length > 1;
   }
+  toPossiblePicks;
   setArray(array) {
     this.computedArray = array;
     this.toPossiblePicks = createFilter((index) => index >= 0 && index < array.length);
@@ -2915,7 +3041,7 @@ class Pickable {
       if (replace === "all") {
         return toUnique(possiblePicks);
       }
-      const possibleWithoutDuplicates = createFilter((possiblePick) => !find((pick) => pick === possiblePick)(this.picks || []))(possiblePicks);
+      const possibleWithoutDuplicates = createFilter((possiblePick) => typeof find((pick) => pick === possiblePick)(this.picks || []) !== "number")(possiblePicks);
       switch (replace) {
         case "none":
           return createConcat(this.picks || [], possibleWithoutDuplicates)([]);
@@ -2927,9 +3053,9 @@ class Pickable {
             return possibleWithoutDuplicates;
           }
           if (possibleWithoutDuplicates.length > this.picks.length) {
-            return createSlice({ from: possibleWithoutDuplicates.length - this.picks.length })(possibleWithoutDuplicates);
+            return createSlice(possibleWithoutDuplicates.length - this.picks.length)(possibleWithoutDuplicates);
           }
-          return new Pipeable(this.picks).pipe(createSlice({ from: possibleWithoutDuplicates.length }), createConcat(possibleWithoutDuplicates));
+          return new Pipeable(this.picks).pipe(createSlice(possibleWithoutDuplicates.length), createConcat(possibleWithoutDuplicates));
         case "lifo":
           if (possibleWithoutDuplicates.length === 0) {
             return this.picks;
@@ -2938,9 +3064,9 @@ class Pickable {
             return possibleWithoutDuplicates;
           }
           if (possibleWithoutDuplicates.length > this.picks.length) {
-            return createSlice({ from: 0, to: possibleWithoutDuplicates.length - this.picks.length + 1 })(possibleWithoutDuplicates);
+            return createSlice(0, possibleWithoutDuplicates.length - this.picks.length + 1)(possibleWithoutDuplicates);
           }
-          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 - possibleWithoutDuplicates.length), createConcat(possibleWithoutDuplicates));
       }
     });
     this.computedFirst = Math.min(...this.picks);
@@ -2976,11 +3102,14 @@ function ensureIndices(indexOrIndices) {
 const toUnique = createUnique();
 
 class Sanitizeable {
+  domPurifyConfig;
   constructor(html, options) {
     this.computedHtml = html;
     this.domPurifyConfig = options;
     this.ready();
   }
+  computedDompurify;
+  computedStatus;
   ready() {
     if (domIsAvailable()) {
       this.computedDompurify = createDOMPurify();
@@ -3004,6 +3133,7 @@ class Sanitizeable {
   get status() {
     return this.computedStatus;
   }
+  computedHtml;
   setHtml(html) {
     this.computedHtml = html;
     return this;
@@ -3019,15 +3149,19 @@ class Sanitizeable {
 }
 
 class Searchable {
+  searcherOptions;
+  computedResults;
   constructor(candidates, options = {}) {
     this.searcherOptions = options;
     this.setCandidates(candidates);
     this.computedResults = [];
     this.ready();
   }
+  computedStatus;
   ready() {
     this.computedStatus = "ready";
   }
+  computedCandidates;
   get candidates() {
     return this.computedCandidates;
   }
@@ -3043,6 +3177,7 @@ class Searchable {
   get status() {
     return this.computedStatus;
   }
+  computedSearcher;
   setCandidates(candidates) {
     this.computedCandidates = Array.from(candidates);
     this.computedSearcher = new Searcher(candidates, this.searcherOptions);
@@ -3063,6 +3198,8 @@ const defaultOptions = {
   statusKeySuffix: " status"
 };
 class Storeable {
+  type;
+  statusKeySuffix;
   constructor(key, options = {}) {
     this.constructing();
     this.type = options.type ?? defaultOptions.type;
@@ -3073,6 +3210,7 @@ class Storeable {
   constructing() {
     this.computedStatus = "constructing";
   }
+  computedStatus;
   ready() {
     this.computedStatus = "ready";
     if (domIsAvailable()) {
@@ -3110,6 +3248,8 @@ class Storeable {
   get error() {
     return this.computedError;
   }
+  computedKey;
+  computedStatusKey;
   setKey(key) {
     let string;
     switch (this.status) {
@@ -3135,6 +3275,8 @@ class Storeable {
     }
     return this;
   }
+  computedString;
+  computedError;
   store(string) {
     try {
       this.storage.setItem(this.key, string);
@@ -3172,4 +3314,4 @@ class Storeable {
   }
 }
 
-export { Animateable, Completeable, Copyable, Delayable, Dispatchable, 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, 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, ensureKeycombo, eventMatchesKeycombo, linear, materialAccelerated, materialDecelerated, materialStandard, toD, toFlattenedD, verouEase, verouEaseIn, verouEaseInOut, verouEaseOut };
+export { Animateable, Completeable, Copyable, Delayable, Dispatchable, 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, ensureKeycombo, eventMatchesKeycombo, linear, materialAccelerated, materialDecelerated, materialStandard, toD, toFlattenedD, verouEase, verouEaseIn, verouEaseInOut, verouEaseOut };