@baleada/logic 0.20.22 → 0.20.26

package/lib/index.cjs

@@ -18,16 +18,16 @@ var BezierEasing__default = /*#__PURE__*/_interopDefaultLegacy(BezierEasing);
 var polygonClipping__default = /*#__PURE__*/_interopDefaultLegacy(polygonClipping);
 var createDOMPurify__default = /*#__PURE__*/_interopDefaultLegacy(createDOMPurify);
 
-function createReduceAsync(reduce, initialValue) {
+function createReduceAsync(accumulate, initialValue) {
   return async (array) => {
     return await lazyCollections.reduce(async (accumulatorPromise, item, index) => {
       const accumulator = await accumulatorPromise;
-      return reduce(accumulator, item, index);
+      return accumulate(accumulator, item, index);
     }, Promise.resolve(initialValue))(array);
   };
 }
-function createReduce(reduce, initialValue) {
-  return (array) => lazyCollections.reduce(reduce, initialValue)(array);
+function createReduce(accumulate, initialValue) {
+  return (array) => lazyCollections.reduce(accumulate, initialValue)(array);
 }
 function createForEachAsync(forEach) {
   return async (array) => {
@@ -35,19 +35,19 @@ function createForEachAsync(forEach) {
     return array;
   };
 }
-function createMapAsync(map) {
+function createMapAsync(transform) {
   return async (array) => {
     return await createReduceAsync(async (resolvedMaps, item, index) => {
-      const mapped = await map(item, index);
-      resolvedMaps.push(mapped);
+      const transformed = await transform(item, index);
+      resolvedMaps.push(transformed);
       return resolvedMaps;
     }, [])(array);
   };
 }
-function createFilterAsync(filter) {
+function createFilterAsync(condition) {
   return async (array) => {
-    const mappedAsync = await createMapAsync(filter)(array);
-    return createFilter((_, index) => mappedAsync[index])(array);
+    const transformedAsync = await createMapAsync(condition)(array);
+    return createFilter((_, index) => transformedAsync[index])(array);
   };
 }
 function createDelete(required) {
@@ -122,11 +122,11 @@ function createSlice({ from, to }) {
     return from === to ? [] : lazyCollections.pipe(lazyCollections.slice(from, to - 1), lazyCollections.toArray())(array);
   };
 }
-function createFilter(filter) {
-  return (array) => lazyCollections.pipe(lazyCollections.filter(filter), lazyCollections.toArray())(array);
+function createFilter(condition) {
+  return (array) => lazyCollections.pipe(lazyCollections.filter(condition), lazyCollections.toArray())(array);
 }
-function createMap(map) {
-  return (array) => lazyCollections.pipe(lazyCollections.map(map), lazyCollections.toArray())(array);
+function createMap(transform) {
+  return (array) => lazyCollections.pipe(lazyCollections.map(transform), lazyCollections.toArray())(array);
 }
 function createConcat(...arrays) {
   return (array) => lazyCollections.pipe(lazyCollections.concat(array, ...arrays), lazyCollections.toArray())();
@@ -167,8 +167,8 @@ function createDetermine(potentialities) {
   return (determinant) => lazyCollections.find(({ predicate }) => predicate(determinant))(predicates).outcome;
 }
 function createRename({ from, to }) {
-  return (map) => {
-    const keys = [...map.keys()], keyToRenameIndex = lazyCollections.findIndex((k) => k === from)(keys), newKeys = createReplace({ index: keyToRenameIndex, item: to })(keys), values = [...map.values()];
+  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);
   };
 }
@@ -482,11 +482,11 @@ function ensureClickcombo(type) {
 function ensurePointercombo(type) {
   return toCombo(type);
 }
-const unique = lazyCollections.unique();
+const toUnique$1 = lazyCollections.unique();
 const toComboItems = lazyCollections.map((name) => name === "" ? delimiter : name);
 const delimiter = "+";
 function toCombo(type) {
-  return lazyCollections.pipe(unique, toComboItems, lazyCollections.toArray())(type.split(delimiter));
+  return lazyCollections.pipe(toUnique$1, toComboItems, lazyCollections.toArray())(type.split(delimiter));
 }
 function fromComboItemNameToType(name) {
   return lazyCollections.find((type) => predicatesByType[type](name))(listenableComboItemTypes) ?? "custom";
@@ -737,7 +737,7 @@ 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), lazyCollections.join("+"));
+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);
 
 class Listenable {
   constructor(type, options) {
@@ -2109,13 +2109,13 @@ class Completeable {
     this.computedStatus = "completed";
   }
 }
-const join = lazyCollections.join(""), reverse = createReverse();
+const toString = lazyCollections.join(""), reverse = createReverse();
 function toPreviousMatch({ string, re, from }) {
   let indexOf;
   if (!re.test(string.slice(0, from)) || from === 0) {
     indexOf = -1;
   } else {
-    const reversedStringBeforeFrom = new Pipeable(string).pipe((string2) => string2.slice(0, from), (sliced) => sliced.split(""), reverse, join), toNextMatchIndex = toNextMatch({ string: reversedStringBeforeFrom, re, from: 0 });
+    const reversedStringBeforeFrom = new Pipeable(string).pipe((string2) => string2.slice(0, from), (sliced) => sliced.split(""), reverse, toString), toNextMatchIndex = toNextMatch({ string: reversedStringBeforeFrom, re, from: 0 });
     indexOf = toNextMatchIndex === -1 ? -1 : reversedStringBeforeFrom.length - 1 - toNextMatchIndex;
   }
   return indexOf;
@@ -2877,10 +2877,16 @@ class Pickable {
     this.pick(indices);
   }
   get first() {
-    return Math.min(...this.picks);
+    return this.computedFirst;
   }
   get last() {
-    return Math.max(...this.picks);
+    return this.computedLast;
+  }
+  get oldest() {
+    return this.picks[0];
+  }
+  get newest() {
+    return this.picks[this.picks.length - 1];
   }
   get status() {
     return this.computedStatus;
@@ -2900,18 +2906,41 @@ class Pickable {
     return this.pick(indexOrIndices);
   }
   pick(indexOrIndices, options = {}) {
-    const { replaces } = options;
-    const newPicks = new Pipeable(indexOrIndices).pipe(ensureIndices, this.toPossiblePicks, (possiblePicks) => {
-      if (replaces)
-        return possiblePicks;
-      return createFilter((possiblePick) => !lazyCollections.find((pick) => pick === possiblePick)(this.picks || []))(possiblePicks);
+    const { replace = "none" } = options;
+    this.computedPicks = new Pipeable(indexOrIndices).pipe(ensureIndices, this.toPossiblePicks, (possiblePicks) => {
+      if (replace === "all") {
+        return toUnique(possiblePicks);
+      }
+      const possibleWithoutDuplicates = createFilter((possiblePick) => !lazyCollections.find((pick) => pick === possiblePick)(this.picks || []))(possiblePicks);
+      switch (replace) {
+        case "none":
+          return createConcat(this.picks || [], possibleWithoutDuplicates)([]);
+        case "fifo":
+          if (possibleWithoutDuplicates.length === 0) {
+            return this.picks;
+          }
+          if (possibleWithoutDuplicates.length === this.picks.length) {
+            return possibleWithoutDuplicates;
+          }
+          if (possibleWithoutDuplicates.length > this.picks.length) {
+            return createSlice({ from: possibleWithoutDuplicates.length - this.picks.length })(possibleWithoutDuplicates);
+          }
+          return new Pipeable(this.picks).pipe(createSlice({ from: possibleWithoutDuplicates.length }), createConcat(possibleWithoutDuplicates));
+        case "lifo":
+          if (possibleWithoutDuplicates.length === 0) {
+            return this.picks;
+          }
+          if (possibleWithoutDuplicates.length === this.picks.length) {
+            return possibleWithoutDuplicates;
+          }
+          if (possibleWithoutDuplicates.length > this.picks.length) {
+            return createSlice({ from: 0, to: possibleWithoutDuplicates.length - this.picks.length + 1 })(possibleWithoutDuplicates);
+          }
+          return new Pipeable(this.picks).pipe(createSlice({ from: 0, to: this.picks.length - possibleWithoutDuplicates.length }), createConcat(possibleWithoutDuplicates));
+      }
     });
-    if (replaces) {
-      this.computedPicks = newPicks;
-      this.picked();
-      return this;
-    }
-    this.computedPicks = createConcat(newPicks)(this.picks || []);
+    this.computedFirst = Math.min(...this.picks);
+    this.computedLast = Math.max(...this.picks);
     this.picked();
     return this;
   }
@@ -2921,11 +2950,15 @@ class Pickable {
   omit(indexOrIndices) {
     if (isUndefined(indexOrIndices)) {
       this.computedPicks = [];
+      this.computedFirst = void 0;
+      this.computedLast = void 0;
       this.omitted();
       return this;
     }
-    const omits = ensureIndices(indexOrIndices), filter = createFilter((pick) => isUndefined(lazyCollections.find((omit) => pick === omit)(omits)));
-    this.computedPicks = filter(this.computedPicks);
+    const omits = ensureIndices(indexOrIndices);
+    this.computedPicks = createFilter((pick) => isUndefined(lazyCollections.find((omit) => pick === omit)(omits)))(this.computedPicks);
+    this.computedFirst = Math.min(...this.picks);
+    this.computedLast = Math.max(...this.picks);
     this.omitted();
     return this;
   }
@@ -2936,6 +2969,7 @@ class Pickable {
 function ensureIndices(indexOrIndices) {
   return Array.isArray(indexOrIndices) ? indexOrIndices : [indexOrIndices];
 }
+const toUnique = createUnique();
 
 class Sanitizeable {
   constructor(html, options) {

package/lib/index.d.ts

@@ -753,8 +753,12 @@ declare class Pickable<Item> {
     private computedPicks;
     get picks(): number[];
     set picks(indices: number[]);
+    computedFirst: number;
     get first(): number;
+    computedLast: number;
     get last(): number;
+    get oldest(): number;
+    get newest(): number;
     get status(): PickableStatus;
     get items(): Item[];
     private toItems;
@@ -763,7 +767,7 @@ declare class Pickable<Item> {
     setArray(array: Item[]): this;
     setPicks(indexOrIndices: number | number[]): this;
     pick(indexOrIndices: number | number[], options?: {
-        replaces?: boolean;
+        replace?: 'none' | 'all' | 'fifo' | 'lifo';
     }): this;
     private picked;
     omit(indexOrIndices?: number | number[]): this;
@@ -840,12 +844,12 @@ declare class Storeable {
     removeStatus(): this;
 }
 
-declare function createReduceAsync<Item, Accumulator>(reduce: (accumulator?: Accumulator, item?: Item, index?: number) => Promise<Accumulator>, initialValue?: Accumulator): (array: Item[]) => Promise<Accumulator>;
-declare function createReduce<Item, Accumulator>(reduce: (accumulator?: Accumulator, item?: Item, index?: number) => Accumulator, initialValue?: Accumulator): (array: Item[]) => Accumulator;
+declare function createReduceAsync<Item, Accumulator>(accumulate: (accumulator?: Accumulator, item?: Item, index?: number) => Promise<Accumulator>, initialValue?: Accumulator): (array: Item[]) => Promise<Accumulator>;
+declare function createReduce<Item, Accumulator>(accumulate: (accumulator?: Accumulator, item?: Item, index?: number) => Accumulator, initialValue?: Accumulator): (array: Item[]) => Accumulator;
 declare type ArrayFunctionAsync<Item, Returned> = (array: Item[]) => Promise<Returned>;
 declare function createForEachAsync<Item>(forEach: (item?: Item, index?: number) => any): ArrayFunctionAsync<Item, any>;
-declare function createMapAsync<Item, Mapped>(map: (item?: Item, index?: number) => Promise<Mapped>): ArrayFunctionAsync<Item, Mapped[]>;
-declare function createFilterAsync<Item>(filter: (item?: Item, index?: number) => Promise<boolean>): ArrayFunctionAsync<Item, Item[]>;
+declare function createMapAsync<Item, Mapped>(transform: (item?: Item, index?: number) => Promise<Mapped>): ArrayFunctionAsync<Item, Mapped[]>;
+declare function createFilterAsync<Item>(condition: (item?: Item, index?: number) => Promise<boolean>): ArrayFunctionAsync<Item, Item[]>;
 declare type ArrayFunction<Item, Returned> = (array: Item[]) => Returned;
 declare function createDelete<Item>(required: {
     index: number;
@@ -878,8 +882,8 @@ declare function createSlice<Item>({ from, to }: {
     from: number;
     to?: number;
 }): ArrayFunction<Item, Item[]>;
-declare function createFilter<Item>(filter: (item?: Item, index?: number) => boolean): ArrayFunction<Item, Item[]>;
-declare function createMap<Item, Mapped = Item>(map: (item?: Item, index?: number) => Mapped): ArrayFunction<Item, Mapped[]>;
+declare function createFilter<Item>(condition: (item?: Item, index?: number) => boolean): ArrayFunction<Item, Item[]>;
+declare function createMap<Item, Transformed = Item>(transform: (item?: Item, index?: number) => Transformed): ArrayFunction<Item, Transformed[]>;
 declare function createConcat<Item>(...arrays: Item[][]): ArrayFunction<Item, Item[]>;
 declare function createReverse<Item>(): ArrayFunction<Item, Item[]>;
 declare type StringFunction<Returned> = (string: string) => Returned;
@@ -895,7 +899,7 @@ declare type Potentiality<Outcome> = {
     probability: number;
 };
 declare function createDetermine<Outcome>(potentialities: Potentiality<Outcome>[]): NumberFunction<Outcome>;
-declare type MapFunction<Key, Value, Returned> = (map: Map<Key, Value>) => Returned;
+declare type MapFunction<Key, Value, Returned> = (transform: Map<Key, Value>) => Returned;
 declare function createRename<Key, Value>({ from, to }: {
     from: Key;
     to: Key;

package/lib/index.js

@@ -1,4 +1,4 @@
-import { reduce, pipe, filter, toArray, findIndex, slice, concat, unique as unique$1, map, find, some, join as join$1, every } from 'lazy-collections';
+import { reduce, pipe, filter, toArray, findIndex, slice, concat, unique, map, find, some, join, every } from 'lazy-collections';
 import slugify from '@sindresorhus/slugify';
 import BezierEasing from 'bezier-easing';
 import { mix } from '@snigo.dev/color';
@@ -7,16 +7,16 @@ import polygonClipping from 'polygon-clipping';
 import createDOMPurify from 'dompurify';
 import { Searcher } from 'fast-fuzzy';
 
-function createReduceAsync(reduce$1, initialValue) {
+function createReduceAsync(accumulate, initialValue) {
   return async (array) => {
     return await reduce(async (accumulatorPromise, item, index) => {
       const accumulator = await accumulatorPromise;
-      return reduce$1(accumulator, item, index);
+      return accumulate(accumulator, item, index);
     }, Promise.resolve(initialValue))(array);
   };
 }
-function createReduce(reduce$1, initialValue) {
-  return (array) => reduce(reduce$1, initialValue)(array);
+function createReduce(accumulate, initialValue) {
+  return (array) => reduce(accumulate, initialValue)(array);
 }
 function createForEachAsync(forEach) {
   return async (array) => {
@@ -24,19 +24,19 @@ function createForEachAsync(forEach) {
     return array;
   };
 }
-function createMapAsync(map) {
+function createMapAsync(transform) {
   return async (array) => {
     return await createReduceAsync(async (resolvedMaps, item, index) => {
-      const mapped = await map(item, index);
-      resolvedMaps.push(mapped);
+      const transformed = await transform(item, index);
+      resolvedMaps.push(transformed);
       return resolvedMaps;
     }, [])(array);
   };
 }
-function createFilterAsync(filter) {
+function createFilterAsync(condition) {
   return async (array) => {
-    const mappedAsync = await createMapAsync(filter)(array);
-    return createFilter((_, index) => mappedAsync[index])(array);
+    const transformedAsync = await createMapAsync(condition)(array);
+    return createFilter((_, index) => transformedAsync[index])(array);
   };
 }
 function createDelete(required) {
@@ -104,18 +104,18 @@ function createReplace({ index, item }) {
   };
 }
 function createUnique() {
-  return (array) => pipe(unique$1(), toArray())(array);
+  return (array) => pipe(unique(), toArray())(array);
 }
 function createSlice({ from, to }) {
   return (array) => {
     return from === to ? [] : pipe(slice(from, to - 1), toArray())(array);
   };
 }
-function createFilter(filter$1) {
-  return (array) => pipe(filter(filter$1), toArray())(array);
+function createFilter(condition) {
+  return (array) => pipe(filter(condition), toArray())(array);
 }
-function createMap(map$1) {
-  return (array) => pipe(map(map$1), toArray())(array);
+function createMap(transform) {
+  return (array) => pipe(map(transform), toArray())(array);
 }
 function createConcat(...arrays) {
   return (array) => pipe(concat(array, ...arrays), toArray())();
@@ -156,8 +156,8 @@ function createDetermine(potentialities) {
   return (determinant) => find(({ predicate }) => predicate(determinant))(predicates).outcome;
 }
 function createRename({ from, to }) {
-  return (map) => {
-    const keys = [...map.keys()], keyToRenameIndex = findIndex((k) => k === from)(keys), newKeys = createReplace({ index: keyToRenameIndex, item: to })(keys), values = [...map.values()];
+  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);
   };
 }
@@ -471,11 +471,11 @@ function ensureClickcombo(type) {
 function ensurePointercombo(type) {
   return toCombo(type);
 }
-const unique = unique$1();
+const toUnique$1 = unique();
 const toComboItems = map((name) => name === "" ? delimiter : name);
 const delimiter = "+";
 function toCombo(type) {
-  return pipe(unique, toComboItems, toArray())(type.split(delimiter));
+  return pipe(toUnique$1, toComboItems, toArray())(type.split(delimiter));
 }
 function fromComboItemNameToType(name) {
   return find((type) => predicatesByType[type](name))(listenableComboItemTypes) ?? "custom";
@@ -726,7 +726,7 @@ function createToType({
     }
   };
 }
-const leftclickcomboEventTypes = new Set(["click", "mousedown", "mouseup", "dblclick"]), rightclickComboEventTypes = new Set(["contextmenu"]), keycomboEventTypes = new Set(["keydown", "keyup"]), toJoinedClickcombo = join$1("+"), toJoinedKeycombo = pipe(map(({ name }) => name), join$1("+"));
+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);
 
 class Listenable {
   constructor(type, options) {
@@ -2098,13 +2098,13 @@ class Completeable {
     this.computedStatus = "completed";
   }
 }
-const join = join$1(""), reverse = createReverse();
+const toString = join(""), reverse = createReverse();
 function toPreviousMatch({ string, re, from }) {
   let indexOf;
   if (!re.test(string.slice(0, from)) || from === 0) {
     indexOf = -1;
   } else {
-    const reversedStringBeforeFrom = new Pipeable(string).pipe((string2) => string2.slice(0, from), (sliced) => sliced.split(""), reverse, join), toNextMatchIndex = toNextMatch({ string: reversedStringBeforeFrom, re, from: 0 });
+    const reversedStringBeforeFrom = new Pipeable(string).pipe((string2) => string2.slice(0, from), (sliced) => sliced.split(""), reverse, toString), toNextMatchIndex = toNextMatch({ string: reversedStringBeforeFrom, re, from: 0 });
     indexOf = toNextMatchIndex === -1 ? -1 : reversedStringBeforeFrom.length - 1 - toNextMatchIndex;
   }
   return indexOf;
@@ -2866,10 +2866,16 @@ class Pickable {
     this.pick(indices);
   }
   get first() {
-    return Math.min(...this.picks);
+    return this.computedFirst;
   }
   get last() {
-    return Math.max(...this.picks);
+    return this.computedLast;
+  }
+  get oldest() {
+    return this.picks[0];
+  }
+  get newest() {
+    return this.picks[this.picks.length - 1];
   }
   get status() {
     return this.computedStatus;
@@ -2889,18 +2895,41 @@ class Pickable {
     return this.pick(indexOrIndices);
   }
   pick(indexOrIndices, options = {}) {
-    const { replaces } = options;
-    const newPicks = new Pipeable(indexOrIndices).pipe(ensureIndices, this.toPossiblePicks, (possiblePicks) => {
-      if (replaces)
-        return possiblePicks;
-      return createFilter((possiblePick) => !find((pick) => pick === possiblePick)(this.picks || []))(possiblePicks);
+    const { replace = "none" } = options;
+    this.computedPicks = new Pipeable(indexOrIndices).pipe(ensureIndices, this.toPossiblePicks, (possiblePicks) => {
+      if (replace === "all") {
+        return toUnique(possiblePicks);
+      }
+      const possibleWithoutDuplicates = createFilter((possiblePick) => !find((pick) => pick === possiblePick)(this.picks || []))(possiblePicks);
+      switch (replace) {
+        case "none":
+          return createConcat(this.picks || [], possibleWithoutDuplicates)([]);
+        case "fifo":
+          if (possibleWithoutDuplicates.length === 0) {
+            return this.picks;
+          }
+          if (possibleWithoutDuplicates.length === this.picks.length) {
+            return possibleWithoutDuplicates;
+          }
+          if (possibleWithoutDuplicates.length > this.picks.length) {
+            return createSlice({ from: possibleWithoutDuplicates.length - this.picks.length })(possibleWithoutDuplicates);
+          }
+          return new Pipeable(this.picks).pipe(createSlice({ from: possibleWithoutDuplicates.length }), createConcat(possibleWithoutDuplicates));
+        case "lifo":
+          if (possibleWithoutDuplicates.length === 0) {
+            return this.picks;
+          }
+          if (possibleWithoutDuplicates.length === this.picks.length) {
+            return possibleWithoutDuplicates;
+          }
+          if (possibleWithoutDuplicates.length > this.picks.length) {
+            return createSlice({ from: 0, to: possibleWithoutDuplicates.length - this.picks.length + 1 })(possibleWithoutDuplicates);
+          }
+          return new Pipeable(this.picks).pipe(createSlice({ from: 0, to: this.picks.length - possibleWithoutDuplicates.length }), createConcat(possibleWithoutDuplicates));
+      }
     });
-    if (replaces) {
-      this.computedPicks = newPicks;
-      this.picked();
-      return this;
-    }
-    this.computedPicks = createConcat(newPicks)(this.picks || []);
+    this.computedFirst = Math.min(...this.picks);
+    this.computedLast = Math.max(...this.picks);
     this.picked();
     return this;
   }
@@ -2910,11 +2939,15 @@ class Pickable {
   omit(indexOrIndices) {
     if (isUndefined(indexOrIndices)) {
       this.computedPicks = [];
+      this.computedFirst = void 0;
+      this.computedLast = void 0;
       this.omitted();
       return this;
     }
-    const omits = ensureIndices(indexOrIndices), filter = createFilter((pick) => isUndefined(find((omit) => pick === omit)(omits)));
-    this.computedPicks = filter(this.computedPicks);
+    const omits = ensureIndices(indexOrIndices);
+    this.computedPicks = createFilter((pick) => isUndefined(find((omit) => pick === omit)(omits)))(this.computedPicks);
+    this.computedFirst = Math.min(...this.picks);
+    this.computedLast = Math.max(...this.picks);
     this.omitted();
     return this;
   }
@@ -2925,6 +2958,7 @@ class Pickable {
 function ensureIndices(indexOrIndices) {
   return Array.isArray(indexOrIndices) ? indexOrIndices : [indexOrIndices];
 }
+const toUnique = createUnique();
 
 class Sanitizeable {
   constructor(html, options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@baleada/logic",
-  "version": "0.20.22",
+  "version": "0.20.26",
   "description": "UI logic for the Baleada toolkit",
   "main": "lib/index.cjs",
   "module": "lib/index.js",
@@ -66,7 +66,7 @@
     "@types/resize-observer-browser": "^0.1.5",
     "bezier-easing": "^2.1.0",
     "dompurify": "^2.2.6",
-    "fast-fuzzy": "^1.10.8",
+    "fast-fuzzy": "^1.11.0",
     "lazy-collections": "^0.8.0",
     "perfect-freehand": "^1.0.4",
     "polygon-clipping": "^0.15.3"