@baleada/logic 0.20.30 → 0.21.0

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);
   };
@@ -140,9 +136,14 @@ 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__default['default'](string, options);
+    return slugify__default["default"](string, options);
   };
 }
 function createClip(required) {
@@ -150,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);
@@ -166,10 +167,10 @@ 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()];
-    return createReduce((renamed, key, index) => renamed.set(key, values[index]), new Map())(newKeys);
+    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);
   };
 }
 function createToEntries() {
@@ -197,7 +198,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),
@@ -209,7 +210,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) => {
@@ -219,7 +220,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) => {
@@ -246,8 +247,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")
@@ -276,8 +275,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")
@@ -500,7 +497,7 @@ function toCombo(type) {
 function fromComboItemNameToType(name) {
   return lazyCollections.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),
@@ -596,6 +593,10 @@ function isString(value) {
 }
 
 class Recognizeable {
+  maxSequenceLength;
+  effects;
+  effectApi;
+  toType;
   constructor(sequence, options = { effectsIncludeCombos: true }) {
     const defaultOptions = {
       maxSequenceLength: true,
@@ -619,6 +620,7 @@ class Recognizeable {
     };
     this.ready();
   }
+  computedMetadata;
   resetComputedMetadata() {
     this.computedMetadata = {};
   }
@@ -628,6 +630,7 @@ class Recognizeable {
   denied() {
     this.computedStatus = "denied";
   }
+  computedStatus;
   ready() {
     this.computedStatus = "ready";
   }
@@ -643,13 +646,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 || (() => {
@@ -746,9 +750,12 @@ function createToType({
     }
   };
 }
-const leftclickcomboEventTypes = new Set(["click", "mousedown", "mouseup", "dblclick"]), rightclickComboEventTypes = new Set(["contextmenu"]), keycomboEventTypes = new Set(["keydown", "keyup"]), toJoinedClickcombo = lazyCollections.join("+"), toJoinedKeycombo = lazyCollections.pipe(lazyCollections.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 = lazyCollections.join("+"), toJoinedKeycombo = lazyCollections.pipe(lazyCollections.map(({ name }) => name), toJoinedClickcombo);
 
 class Listenable {
+  computedRecognizeable;
+  recognizeableEffectsKeys;
+  computedActive;
   constructor(type, options) {
     if (type === "recognizeable") {
       const recognizeableOptions = {
@@ -761,10 +768,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";
   }
@@ -783,6 +791,8 @@ class Listenable {
   get recognizeable() {
     return this.computedRecognizeable;
   }
+  computedType;
+  implementation;
   setType(type) {
     this.stop();
     this.computedType = type;
@@ -975,7 +985,7 @@ function stop(stoppable) {
 function toImplementation(type) {
   return lazyCollections.find((implementation) => predicatesByImplementation.get(implementation)(type))(predicatesByImplementation.keys());
 }
-const predicatesByImplementation = new Map([
+const predicatesByImplementation = /* @__PURE__ */ new Map([
   [
     "recognizeable",
     (type) => type === "recognizeable"
@@ -1025,7 +1035,7 @@ const predicatesByImplementation = new Map([
     () => true
   ]
 ]);
-const documentEvents = new Set([
+const documentEvents = /* @__PURE__ */ new Set([
   "fullscreenchange",
   "fullscreenerror",
   "pointerlockchange",
@@ -1048,6 +1058,11 @@ function eventMatchesKeycombo({ event, keycombo }) {
   return lazyCollections.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 === "!";
@@ -1063,7 +1078,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())
@@ -1093,9 +1135,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 lazyCollections.every((name) => fromComboItemNameToType(name) === "click" || name.startsWith("!") && !isModified({ alias: name.slice(1), event }) || !name.startsWith("!") && isModified({ alias: name, event }))(clickcombo);
 }
@@ -1120,6 +1162,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);
@@ -1143,21 +1200,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;
   }
@@ -1188,6 +1249,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);
@@ -1197,6 +1263,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;
@@ -1342,6 +1411,7 @@ class Animateable {
   reversed() {
     this.computedStatus = "reversed";
   }
+  invisibleAt;
   listenForVisibilitychange() {
     if (this.visibilitychange.active.size === 0) {
       this.totalTimeInvisible = 0;
@@ -1357,6 +1427,7 @@ class Animateable {
       });
     }
   }
+  computedRequest;
   createAnimate(type) {
     return (effect, options = {}) => {
       const { interpolate: interpolateOptions } = options;
@@ -1377,6 +1448,7 @@ class Animateable {
       return this;
     };
   }
+  startTime;
   setStartTimeAndStatus(type, timestamp) {
     switch (type) {
       case "play":
@@ -1743,7 +1815,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)) {
@@ -1768,7 +1840,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__default["default"](point1x, point1y, point2x, point2y);
 }
 function toInterpolated({ previous, next, progress }, options = {}) {
   if (isUndefined(previous)) {
@@ -1786,7 +1858,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 = [
@@ -1981,6 +2053,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;
@@ -1994,6 +2070,7 @@ class Completeable {
   constructing() {
     this.computedStatus = "constructing";
   }
+  computedStatus;
   ready() {
     this.computedStatus = "ready";
   }
@@ -2038,6 +2115,7 @@ class Completeable {
         return this.dividerIndices.after;
     }
   }
+  computedString;
   setString(string) {
     this.computedString = string;
     switch (this.status) {
@@ -2049,6 +2127,7 @@ class Completeable {
     }
     return this;
   }
+  computedSelection;
   setSelection(selection) {
     this.computedSelection = selection;
     this.setDividerIndices();
@@ -2135,6 +2214,10 @@ function toNextMatch({ string, re, from }) {
 }
 
 class Copyable {
+  computedIsClipboardText;
+  copyListenable;
+  cutListenable;
+  copyAndCutEffect;
   constructor(string, options = {}) {
     this.computedIsClipboardText = false;
     this.copyListenable = new Listenable("copy");
@@ -2146,6 +2229,7 @@ class Copyable {
     this.setString(string);
     this.ready();
   }
+  computedStatus;
   ready() {
     this.computedStatus = "ready";
   }
@@ -2167,10 +2251,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;
@@ -2223,6 +2310,7 @@ const defaultOptions$4 = {
   executions: 1
 };
 class Delayable {
+  animateable;
   constructor(effect, options = {}) {
     this.animateable = new Animateable([
       { progress: 0, properties: { progress: 0 } },
@@ -2234,6 +2322,7 @@ class Delayable {
     this.setEffect(effect);
     this.ready();
   }
+  computedStatus;
   ready() {
     this.computedStatus = "ready";
   }
@@ -2255,12 +2344,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;
@@ -2363,6 +2454,7 @@ class Dispatchable {
     this.setType(type);
     this.ready();
   }
+  computedStatus;
   ready() {
     this.computedStatus = "ready";
   }
@@ -2378,10 +2470,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);
@@ -2397,11 +2491,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";
   }
@@ -2417,6 +2514,7 @@ class Drawable {
   get d() {
     return this.computedD;
   }
+  computedStroke;
   setStroke(stroke) {
     this.computedStroke = stroke;
     this.computedD = this.toD(stroke);
@@ -2445,7 +2543,7 @@ function toFlattenedD(stroke) {
   if (stroke.length === 0) {
     return "";
   }
-  const multiPolygon = polygonClipping__default['default'].union([stroke]);
+  const multiPolygon = polygonClipping__default["default"].union([stroke]);
   return createReduce((dFromMultiPolygon, polygon) => {
     return dFromMultiPolygon + createReduce((dFromRing, points) => {
       return dFromRing + toD(points);
@@ -2458,6 +2556,7 @@ class Resolveable {
     this.setGetPromise(getPromise);
     this.ready();
   }
+  computedStatus;
   ready() {
     this.computedStatus = "ready";
   }
@@ -2473,10 +2572,12 @@ class Resolveable {
   get value() {
     return this.computedValue;
   }
+  computedGetPromise;
   setGetPromise(getPromise) {
     this.computedGetPromise = getPromise;
     return this;
   }
+  computedValue;
   async resolve(...args) {
     this.resolving();
     try {
@@ -2501,6 +2602,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);
@@ -2510,6 +2616,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";
   }
@@ -2519,6 +2626,7 @@ class Fetchable {
   set resource(resource) {
     this.setResource(resource);
   }
+  computedAbortController;
   get abortController() {
     if (!this.computedAbortController) {
       this.computedAbortController = new AbortController();
@@ -2564,10 +2672,13 @@ class Fetchable {
         return resolveable;
     }
   }
+  computedResource;
   setResource(resource) {
     this.computedResource = resource;
     return this;
   }
+  computedResponse;
+  computedError;
   async fetch(options = {}) {
     this.computedStatus = "fetching";
     try {
@@ -2622,6 +2733,7 @@ class Fullscreenable {
     this.setGetElement(getElement);
     this.ready();
   }
+  computedStatus;
   ready() {
     this.computedStatus = "ready";
   }
@@ -2640,6 +2752,7 @@ class Fullscreenable {
   get error() {
     return this.computedError;
   }
+  computedGetElement;
   setGetElement(getElement) {
     this.computedGetElement = () => getElement();
     return this;
@@ -2648,6 +2761,7 @@ class Fullscreenable {
     await this.fullscreen(options);
     return this;
   }
+  computedError;
   async fullscreen(options = {}) {
     try {
       await this.element.requestFullscreen(options);
@@ -2684,6 +2798,7 @@ class Grantable {
     this.setDescriptor(descriptor);
     this.ready();
   }
+  computedStatus;
   ready() {
     this.computedStatus = "ready";
   }
@@ -2699,10 +2814,12 @@ class Grantable {
   get status() {
     return this.computedStatus;
   }
+  computedDescriptor;
   setDescriptor(descriptor) {
     this.computedDescriptor = descriptor;
     return this;
   }
+  computedPermission;
   async query() {
     this.querying();
     try {
@@ -2739,15 +2856,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;
   }
@@ -2871,29 +2991,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;
   }
@@ -2909,9 +3033,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);
@@ -2926,7 +3052,7 @@ class Pickable {
       if (replace === "all") {
         return toUnique(possiblePicks);
       }
-      const possibleWithoutDuplicates = createFilter((possiblePick) => !lazyCollections.find((pick) => pick === possiblePick)(this.picks || []))(possiblePicks);
+      const possibleWithoutDuplicates = createFilter((possiblePick) => typeof lazyCollections.find((pick) => pick === possiblePick)(this.picks || []) !== "number")(possiblePicks);
       switch (replace) {
         case "none":
           return createConcat(this.picks || [], possibleWithoutDuplicates)([]);
@@ -2938,9 +3064,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;
@@ -2949,9 +3075,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);
@@ -2987,14 +3113,17 @@ 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__default['default']();
+      this.computedDompurify = createDOMPurify__default["default"]();
       this.computedDompurify.setConfig(this.domPurifyConfig);
     }
     this.computedStatus = "ready";
@@ -3007,7 +3136,7 @@ class Sanitizeable {
   }
   get dompurify() {
     if (!this.computedDompurify && domIsAvailable()) {
-      this.computedDompurify = createDOMPurify__default['default']();
+      this.computedDompurify = createDOMPurify__default["default"]();
       this.computedDompurify.setConfig(this.domPurifyConfig);
     }
     return this.computedDompurify;
@@ -3015,6 +3144,7 @@ class Sanitizeable {
   get status() {
     return this.computedStatus;
   }
+  computedHtml;
   setHtml(html) {
     this.computedHtml = html;
     return this;
@@ -3030,15 +3160,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;
   }
@@ -3054,6 +3188,7 @@ class Searchable {
   get status() {
     return this.computedStatus;
   }
+  computedSearcher;
   setCandidates(candidates) {
     this.computedCandidates = Array.from(candidates);
     this.computedSearcher = new fastFuzzy.Searcher(candidates, this.searcherOptions);
@@ -3074,6 +3209,8 @@ const defaultOptions = {
   statusKeySuffix: " status"
 };
 class Storeable {
+  type;
+  statusKeySuffix;
   constructor(key, options = {}) {
     this.constructing();
     this.type = options.type ?? defaultOptions.type;
@@ -3084,6 +3221,7 @@ class Storeable {
   constructing() {
     this.computedStatus = "constructing";
   }
+  computedStatus;
   ready() {
     this.computedStatus = "ready";
     if (domIsAvailable()) {
@@ -3121,6 +3259,8 @@ class Storeable {
   get error() {
     return this.computedError;
   }
+  computedKey;
+  computedStatusKey;
   setKey(key) {
     let string;
     switch (this.status) {
@@ -3146,6 +3286,8 @@ class Storeable {
     }
     return this;
   }
+  computedString;
+  computedError;
   store(string) {
     try {
       this.storage.setItem(this.key, string);
@@ -3220,6 +3362,7 @@ exports.createReplace = createReplace;
 exports.createReverse = createReverse;
 exports.createSlice = createSlice;
 exports.createSlug = createSlug;
+exports.createSort = createSort;
 exports.createSwap = createSwap;
 exports.createToEntries = createToEntries;
 exports.createUnique = createUnique;