@baleada/logic 0.20.23 → 0.20.27

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;
@@ -2719,6 +2719,7 @@ class Grantable {
 const defaultOptions$2 = {
   initialLocation: 0
 };
+const defaultNavigateOptions = { allows: "possible" };
 const defaultNextAndPreviousOptions = {
   distance: 1,
   loops: true
@@ -2758,28 +2759,36 @@ class Navigateable {
     this.navigate(location);
     return this;
   }
-  navigate(location) {
-    this._navigate(location);
+  navigate(location, options = {}) {
+    const { allows } = { ...defaultNavigateOptions, ...options };
+    this._navigate(location, { allows });
     this.navigated();
     return this;
   }
   navigated() {
     this.computedStatus = "navigated";
   }
-  _navigate(location) {
+  _navigate(location, options = {}) {
+    const { allows } = { ...defaultNavigateOptions, ...options };
     const ensuredLocation = (() => {
-      if (location < 0) {
-        return 0;
-      }
-      if (location > this.array.length - 1) {
-        return Math.max(this.array.length - 1, 0);
+      if (allows === "possible") {
+        if (location < 0 && allows === "possible") {
+          return 0;
+        }
+        if (location > this.array.length - 1) {
+          return Math.max(this.array.length - 1, 0);
+        }
       }
       return location;
     })();
     this.computedLocation = ensuredLocation;
   }
   next(options = {}) {
-    const { distance, loops } = { ...defaultNextAndPreviousOptions, ...options }, lastLocation = this.array.length - 1, newLocation = (() => {
+    const { distance, loops, allows } = { ...defaultNextAndPreviousOptions, ...defaultNavigateOptions, ...options }, newLocation = (() => {
+      if (allows === "any") {
+        return this.location + distance;
+      }
+      const lastLocation = this.array.length - 1;
       if (this.location + distance <= lastLocation) {
         return this.location + distance;
       }
@@ -2794,7 +2803,7 @@ class Navigateable {
         return newLocation2;
       })();
     })();
-    this._navigate(newLocation);
+    this._navigate(newLocation, { allows });
     this.nexted();
     return this;
   }
@@ -2802,7 +2811,10 @@ class Navigateable {
     this.computedStatus = "navigated to next";
   }
   previous(options = {}) {
-    const { distance, loops } = { ...defaultNextAndPreviousOptions, ...options }, newLocation = (() => {
+    const { distance, loops, allows } = { ...defaultNextAndPreviousOptions, ...defaultNavigateOptions, ...options }, newLocation = (() => {
+      if (allows === "any") {
+        return this.location - distance;
+      }
       if (this.location - distance >= 0) {
         return this.location - distance;
       }
@@ -2817,7 +2829,7 @@ class Navigateable {
         return newLocation2;
       })();
     })();
-    this._navigate(newLocation);
+    this._navigate(newLocation, { allows });
     this.previoused();
     return this;
   }
@@ -2877,10 +2889,10 @@ 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];
@@ -2906,18 +2918,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;
   }
@@ -2927,11 +2962,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;
   }
@@ -2942,6 +2981,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

@@ -704,6 +704,13 @@ declare type NavigateableOptions = {
     initialLocation?: number;
 };
 declare type NavigateableStatus = 'ready' | 'navigated' | 'navigated to next' | 'navigated to previous' | 'navigated to random' | 'navigated to first' | 'navigated to last';
+declare type NavigateOptions = {
+    allows?: 'possible' | 'any';
+};
+declare type NextAndPreviousOptions = {
+    distance?: number;
+    loops?: boolean;
+};
 declare class Navigateable<Item> {
     constructor(array: Item[], options?: NavigateableOptions);
     private computedStatus;
@@ -718,18 +725,12 @@ declare class Navigateable<Item> {
     get item(): Item;
     setArray(array: Item[]): this;
     setLocation(location: number): this;
-    navigate(location: number): this;
+    navigate(location: number, options?: NavigateOptions): this;
     private navigated;
     private _navigate;
-    next(options?: {
-        distance?: number;
-        loops?: boolean;
-    }): this;
+    next(options?: NextAndPreviousOptions & NavigateOptions): this;
     private nexted;
-    previous(options?: {
-        distance?: number;
-        loops?: boolean;
-    }): this;
+    previous(options?: NextAndPreviousOptions & NavigateOptions): this;
     private previoused;
     random(): this;
     private randomed;
@@ -753,7 +754,9 @@ 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;
@@ -765,7 +768,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;
@@ -842,12 +845,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;
@@ -880,8 +883,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;
@@ -897,7 +900,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;
@@ -2708,6 +2708,7 @@ class Grantable {
 const defaultOptions$2 = {
   initialLocation: 0
 };
+const defaultNavigateOptions = { allows: "possible" };
 const defaultNextAndPreviousOptions = {
   distance: 1,
   loops: true
@@ -2747,28 +2748,36 @@ class Navigateable {
     this.navigate(location);
     return this;
   }
-  navigate(location) {
-    this._navigate(location);
+  navigate(location, options = {}) {
+    const { allows } = { ...defaultNavigateOptions, ...options };
+    this._navigate(location, { allows });
     this.navigated();
     return this;
   }
   navigated() {
     this.computedStatus = "navigated";
   }
-  _navigate(location) {
+  _navigate(location, options = {}) {
+    const { allows } = { ...defaultNavigateOptions, ...options };
     const ensuredLocation = (() => {
-      if (location < 0) {
-        return 0;
-      }
-      if (location > this.array.length - 1) {
-        return Math.max(this.array.length - 1, 0);
+      if (allows === "possible") {
+        if (location < 0 && allows === "possible") {
+          return 0;
+        }
+        if (location > this.array.length - 1) {
+          return Math.max(this.array.length - 1, 0);
+        }
       }
       return location;
     })();
     this.computedLocation = ensuredLocation;
   }
   next(options = {}) {
-    const { distance, loops } = { ...defaultNextAndPreviousOptions, ...options }, lastLocation = this.array.length - 1, newLocation = (() => {
+    const { distance, loops, allows } = { ...defaultNextAndPreviousOptions, ...defaultNavigateOptions, ...options }, newLocation = (() => {
+      if (allows === "any") {
+        return this.location + distance;
+      }
+      const lastLocation = this.array.length - 1;
       if (this.location + distance <= lastLocation) {
         return this.location + distance;
       }
@@ -2783,7 +2792,7 @@ class Navigateable {
         return newLocation2;
       })();
     })();
-    this._navigate(newLocation);
+    this._navigate(newLocation, { allows });
     this.nexted();
     return this;
   }
@@ -2791,7 +2800,10 @@ class Navigateable {
     this.computedStatus = "navigated to next";
   }
   previous(options = {}) {
-    const { distance, loops } = { ...defaultNextAndPreviousOptions, ...options }, newLocation = (() => {
+    const { distance, loops, allows } = { ...defaultNextAndPreviousOptions, ...defaultNavigateOptions, ...options }, newLocation = (() => {
+      if (allows === "any") {
+        return this.location - distance;
+      }
       if (this.location - distance >= 0) {
         return this.location - distance;
       }
@@ -2806,7 +2818,7 @@ class Navigateable {
         return newLocation2;
       })();
     })();
-    this._navigate(newLocation);
+    this._navigate(newLocation, { allows });
     this.previoused();
     return this;
   }
@@ -2866,10 +2878,10 @@ 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];
@@ -2895,18 +2907,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;
   }
@@ -2916,11 +2951,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;
   }
@@ -2931,6 +2970,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.23",
+  "version": "0.20.27",
   "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.1",
     "lazy-collections": "^0.8.0",
     "perfect-freehand": "^1.0.4",
     "polygon-clipping": "^0.15.3"