@oscarpalmer/atoms 0.179.0 → 0.180.0

package/dist/array/filter.d.mts

@@ -2,67 +2,75 @@ import { PlainObject } from "../models.mjs";
 
 //#region src/array/filter.d.ts
 /**
- * Get a filtered array of items
+ * Get a filtered array of items that do not match the filter
+ *
+ * Available as `exclude` and `filter.remove`
  * @param array Array to search in
  * @param callback Callback to get an item's value for matching
  * @param value Value to match against
- * @returns Filtered array of items
+ * @returns Filtered array of items that do not match the filter
  */
-declare function filter<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item[];
+declare function exclude<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): unknown[];
 /**
- * Get a filtered array of items
+ * Get a filtered array of items that do not match the filter
+ *
+ * Available as `exclude` and `filter.remove`
  * @param array Array to search in
  * @param key Key to get an item's value for matching
  * @param value Value to match against
- * @returns Filtered array of items
+ * @returns Filtered array of items that do not match the filter
  */
-declare function filter<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): Item[];
+declare function exclude<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): unknown[];
 /**
- * Get a filtered array of items matching the filter
+ * Get a filtered array of items that do not match the filter
+ *
+ * Available as `exclude` and `filter.remove`
  * @param array Array to search in
  * @param filter Filter callback to match items
- * @returns Filtered array of items
+ * @returns Filtered array of items that do not match the filter
  */
-declare function filter<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): Item[];
+declare function exclude<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): unknown[];
 /**
- * Get a filtered array of items matching the given item
+ * Get a filtered array of items that do not match the given item
+ *
+ * Available as `exclude` and `filter.remove`
  * @param array Array to search in
  * @param item Item to match against
- * @returns Filtered array of items
+ * @returns Filtered array of items that do not match the given item
  */
-declare function filter<Item>(array: Item[], item: Item): Item[];
-declare namespace filter {
-  var remove: typeof removeFiltered;
-}
+declare function exclude<Item>(array: Item[], item: Item): unknown[];
 /**
- * Get a filtered array of items that do not match the filter
+ * Get a filtered array of items
  * @param array Array to search in
  * @param callback Callback to get an item's value for matching
  * @param value Value to match against
- * @returns Filtered array of items that do not match the filter
+ * @returns Filtered array of items
  */
-declare function removeFiltered<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): unknown[];
+declare function filter<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item[];
 /**
- * Get a filtered array of items that do not match the filter
+ * Get a filtered array of items
  * @param array Array to search in
  * @param key Key to get an item's value for matching
  * @param value Value to match against
- * @returns Filtered array of items that do not match the filter
+ * @returns Filtered array of items
  */
-declare function removeFiltered<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): unknown[];
+declare function filter<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): Item[];
 /**
- * Get a filtered array of items that do not match the filter
+ * Get a filtered array of items matching the filter
  * @param array Array to search in
  * @param filter Filter callback to match items
- * @returns Filtered array of items that do not match the filter
+ * @returns Filtered array of items
  */
-declare function removeFiltered<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): unknown[];
+declare function filter<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): Item[];
 /**
- * Get a filtered array of items that do not match the given item
+ * Get a filtered array of items matching the given item
  * @param array Array to search in
  * @param item Item to match against
- * @returns Filtered array of items that do not match the given item
+ * @returns Filtered array of items
  */
-declare function removeFiltered<Item>(array: Item[], item: Item): unknown[];
+declare function filter<Item>(array: Item[], item: Item): Item[];
+declare namespace filter {
+  var remove: typeof exclude;
+}
 //#endregion
-export { filter };
+export { exclude, filter };

package/dist/array/filter.mjs

@@ -1,11 +1,11 @@
 import { findValues } from "../internal/array/find.mjs";
 //#region src/array/filter.ts
+function exclude(array, ...parameters) {
+	return findValues("all", array, parameters).notMatched;
+}
 function filter(array, ...parameters) {
 	return findValues("all", array, parameters).matched;
 }
-filter.remove = removeFiltered;
-function removeFiltered(array, ...parameters) {
-	return findValues("all", array, parameters).notMatched;
-}
+filter.remove = exclude;
 //#endregion
-export { filter };
+export { exclude, filter };

package/dist/array/first.d.mts

@@ -35,7 +35,9 @@ declare namespace first {
   export { _a as default };
 }
 /**
- * Get the first item matching the given value
+ * Get the first item matching the given value, or a default value if no match is found
+ *
+ * Available as `firstOrDefault` and `first.default`
  * @param array Array to search in
  * @param defaultValue Default value to return if no match is found
  * @param callback Callback to get an item's value for matching
@@ -44,7 +46,9 @@ declare namespace first {
  */
 declare function firstOrDefault<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], defaultValue: Item, callback: Callback, value: ReturnType<Callback>): Item;
 /**
- * Get the first item matching the given value by key
+ * Get the first item matching the given value by key, or a default value if no match is found
+ *
+ * Available as `firstOrDefault` and `first.default`
  * @param array Array to search in
  * @param defaultValue Default value to return if no match is found
  * @param key Key to get an item's value for matching
@@ -53,7 +57,9 @@ declare function firstOrDefault<Item, Callback extends (item: Item, index: numbe
  */
 declare function firstOrDefault<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], defaultValue: Item, key: ItemKey, value: Item[ItemKey]): Item;
 /**
- * Get the first item matching the filter
+ * Get the first item matching the filter, or a default value if no match is found
+ *
+ * Available as `firstOrDefault` and `first.default`
  * @param array Array to search in
  * @param defaultValue Default value to return if no match is found
  * @param filter Filter callback to match items
@@ -61,11 +67,13 @@ declare function firstOrDefault<Item extends PlainObject, ItemKey extends keyof
  */
 declare function firstOrDefault<Item>(array: Item[], defaultValue: Item, filter: (item: Item, index: number, array: Item[]) => boolean): Item;
 /**
- * Get the first item from an array
+ * Get the first item from an array, or a default value if the array is empty
+ *
+ * Available as `firstOrDefault` and `first.default`
  * @param array Array to get from
  * @param defaultValue Default value to return if the array is empty
  * @return First item from the array, or the default value if the array is empty
  */
 declare function firstOrDefault<Item>(array: Item[], defaultValue: Item): Item;
 //#endregion
-export { first };
+export { first, firstOrDefault };

package/dist/array/first.mjs

@@ -8,4 +8,4 @@ function firstOrDefault(array, defaultValue, ...parameters) {
 	return findAbsoluteValueOrDefault(array, parameters, defaultValue, true, false);
 }
 //#endregion
-export { first };
+export { first, firstOrDefault };

package/dist/array/group-by.d.mts

@@ -70,6 +70,8 @@ declare namespace groupBy {
 }
 /**
  * Create a record from an array of items using a specific key and value, grouping values into arrays
+ *
+ * Available as `groupArraysBy` and `groupBy.arrays`
  * @param array Array to group
  * @param key Callback to get an item's grouping key
  * @param value Callback to get an item's value
@@ -78,6 +80,8 @@ declare namespace groupBy {
 declare function groupArraysBy<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Record<ReturnType<KeyCallback>, ReturnType<ValueCallback>[]>;
 /**
  * Create a record from an array of items using a specific key and value, grouping values into arrays
+ *
+ * Available as `groupArraysBy` and `groupBy.arrays`
  * @param array Array to group
  * @param key Callback to get an item's grouping key
  * @param value Key to use for value
@@ -86,6 +90,8 @@ declare function groupArraysBy<Item, KeyCallback extends (item: Item, index: num
 declare function groupArraysBy<Item extends PlainObject, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: KeyCallback, value: ItemValue): Record<ReturnType<KeyCallback>, Item[ItemValue][]>;
 /**
  * Create a record from an array of items using a specific key and value, grouping values into arrays
+ *
+ * Available as `groupArraysBy` and `groupBy.arrays`
  * @param array Array to group
  * @param key Key to use for grouping
  * @param value Callback to get an item's value
@@ -94,6 +100,8 @@ declare function groupArraysBy<Item extends PlainObject, KeyCallback extends (it
 declare function groupArraysBy<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<ValueCallback>[]>>;
 /**
  * Create a record from an array of items using a specific key and value, grouping values into arrays
+ *
+ * Available as `groupArraysBy` and `groupBy.arrays`
  * @param array Array to group
  * @param key Key to use for grouping
  * @param value Key to use for value
@@ -102,6 +110,8 @@ declare function groupArraysBy<Item extends PlainObject, ItemKey extends keyof I
 declare function groupArraysBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Simplify<Record<KeyedValue<Item, ItemKey>, Item[ItemValue][]>>;
 /**
  * Create a record from an array of items using a specific key, grouping items into arrays
+ *
+ * Available as `groupArraysBy` and `groupBy.arrays`
  * @param array Array to group
  * @param callback Callback to get an item's grouping key
  * @returns Record of keyed items
@@ -109,10 +119,12 @@ declare function groupArraysBy<Item extends PlainObject, ItemKey extends keyof I
 declare function groupArraysBy<Item, Callback extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], callback: Callback): Record<ReturnType<Callback>, Item[]>;
 /**
  * Create a record from an array of items using a specific key, grouping items into arrays
+ *
+ * Available as `groupArraysBy` and `groupBy.arrays`
  * @param array Array to group
  * @param key Key to use for grouping
  * @returns Record of keyed items
  */
 declare function groupArraysBy<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
 //#endregion
-export { groupBy };
+export { groupArraysBy, groupBy };

package/dist/array/group-by.mjs

@@ -8,4 +8,4 @@ function groupArraysBy(array, first, second) {
 	return groupValues(array, first, second, true);
 }
 //#endregion
-export { groupBy };
+export { groupArraysBy, groupBy };

package/dist/array/last.d.mts

@@ -36,6 +36,8 @@ declare namespace last {
 }
 /**
  * Get the last item matching the given value
+ *
+ * Available as `lastOrDefault` and `last.default`
  * @param array Array to search in
  * @param defaultValue Default value to return if no match is found
  * @param callback Callback to get an item's value for matching
@@ -45,6 +47,8 @@ declare namespace last {
 declare function lastOrDefault<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], defaultValue: Item, callback: Callback, value: ReturnType<Callback>): Item;
 /**
  * Get the last item matching the given value by key
+ *
+ * Available as `lastOrDefault` and `last.default`
  * @param array Array to search in
  * @param defaultValue Default value to return if no match is found
  * @param key Key to get an item's value for matching
@@ -54,6 +58,8 @@ declare function lastOrDefault<Item, Callback extends (item: Item, index: number
 declare function lastOrDefault<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], defaultValue: Item, key: ItemKey, value: Item[ItemKey]): Item;
 /**
  * Get the last item matching the filter
+ *
+ * Available as `lastOrDefault` and `last.default`
  * @param array Array to search in
  * @param defaultValue Default value to return if no match is found
  * @param filter Filter callback to match items
@@ -62,10 +68,12 @@ declare function lastOrDefault<Item extends PlainObject, ItemKey extends keyof I
 declare function lastOrDefault<Item>(array: Item[], defaultValue: Item, filter: (item: Item, index: number, array: Item[]) => boolean): Item;
 /**
  * Get the last item from an array
+ *
+ * Available as `lastOrDefault` and `last.default`
  * @param array Array to get from
  * @param defaultValue Default value to return if the array is empty
  * @return Last item from the array, or the default value if the array is empty
  */
 declare function lastOrDefault<Item>(array: Item[], defaultValue: Item): Item;
 //#endregion
-export { last };
+export { last, lastOrDefault };

package/dist/array/last.mjs

@@ -8,4 +8,4 @@ function lastOrDefault(array, defaultValue, ...parameters) {
 	return findAbsoluteValueOrDefault(array, parameters, defaultValue, true, true);
 }
 //#endregion
-export { last };
+export { last, lastOrDefault };

package/dist/array/move.d.mts

@@ -47,6 +47,8 @@ declare namespace move {
  * Move an item from one index to another within an array
  *
  * If the from index is out of bounds, the array will be returned unchanged
+ *
+ * Available as `moveIndices` and `move.indices`
  * @param array Array to move within
  * @param from Index to move from
  * @param to Index to move to
@@ -57,6 +59,8 @@ declare function moveIndices<Item>(array: Item[], from: number, to: number): Ite
  * Move an item _(or array of items)_ to an index within an array
  *
  * If the value is not present in the array, or if the index is out of bounds, the array will be returned unchanged
+ *
+ * Available as `moveToIndex` and `move.toIndex`
  * @param array Array to move within
  * @param value Item or items to move
  * @param index Index to move to
@@ -68,6 +72,8 @@ declare function moveToIndex<Item extends PlainObject, ItemKey extends keyof Ite
  * Move an item _(or array of items)_ to an index within an array
  *
  * If the value is not present in the array, or if the index is out of bounds, the array will be returned unchanged
+ *
+ * Available as `moveToIndex` and `move.toIndex`
  * @param array Array to move within
  * @param value Item or items to move
  * @param index Index to move to
@@ -79,6 +85,8 @@ declare function moveToIndex<Item>(array: Item[], value: Item | Item[], index: n
  * Move an item _(or array of items)_ to an index within an array
  *
  * If the value is not present in the array, or if the index is out of bounds, the array will be returned unchanged
+ *
+ * Available as `moveToIndex` and `move.toIndex`
  * @param array Array to move within
  * @param value Item or items to move
  * @param index Index to move to
@@ -86,4 +94,4 @@ declare function moveToIndex<Item>(array: Item[], value: Item | Item[], index: n
  */
 declare function moveToIndex<Item>(array: Item[], value: Item | Item[], index: number): Item[];
 //#endregion
-export { move };
+export { move, moveIndices, moveToIndex };

package/dist/array/move.mjs

@@ -29,6 +29,8 @@ move.toIndex = moveToIndex;
 * Move an item from one index to another within an array
 *
 * If the from index is out of bounds, the array will be returned unchanged
+*
+* Available as `moveIndices` and `move.indices`
 * @param array Array to move within
 * @param from Index to move from
 * @param to Index to move to
@@ -61,4 +63,4 @@ function moveToIndex(array, value, index, key) {
 	return array;
 }
 //#endregion
-export { move };
+export { move, moveIndices, moveToIndex };

package/dist/array/reverse.d.mts

@@ -1,4 +1,9 @@
 //#region src/array/reverse.d.ts
+/**
+ * Reverse the order of items in an array
+ * @param array Array to reverse
+ * @returns Reversed array
+ */
 declare function reverse<Item>(array: Item[]): Item[];
 //#endregion
 export { reverse };

package/dist/array/reverse.mjs

@@ -1,4 +1,9 @@
 //#region src/array/reverse.ts
+/**
+* Reverse the order of items in an array
+* @param array Array to reverse
+* @returns Reversed array
+*/
 function reverse(array) {
 	if (!Array.isArray(array)) return [];
 	const { length } = array;

package/dist/array/select.d.mts

@@ -76,7 +76,7 @@ declare function select<Item extends PlainObject, MapKey extends keyof Item>(arr
  * @param map Callback to map the matched items
  * @returns Filtered and mapped array of items
  */
-declare function select<Item, MapCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], filter: Item, map: MapCallback): Array<ReturnType<MapCallback>>;
+declare function select<Item, MapCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], item: Item, map: MapCallback): Array<ReturnType<MapCallback>>;
 /**
  * Get a filtered and mapped array of items
  * @param array Array to search in
@@ -84,6 +84,6 @@ declare function select<Item, MapCallback extends (item: Item, index: number, ar
  * @param map Key to get an item's value for mapping
  * @returns Filtered and mapped array of items
  */
-declare function select<Item extends PlainObject, MapKey extends keyof Item>(array: Item[], filter: Item, map: MapKey): Array<Item[MapKey]>;
+declare function select<Item extends PlainObject, MapKey extends keyof Item>(array: Item[], item: Item, map: MapKey): Array<Item[MapKey]>;
 //#endregion
 export { select };

package/dist/array/sort.d.mts

@@ -92,54 +92,66 @@ type Sorter<Item> = {
  * Get the index for an item _(to be inserted into an array of items)_ based on sorters _(and an optional default direction)_
  *
  * _(If the array is not sorted, it will be treated as sorted, and the result may be inaccurate)_
+ *
+ * Available as `getSortedIndex` and `sort.index`
  * @param array Array to get the index from
  * @param item Item to get the index for
  * @param sorters Sorters to use to determine sorting
  * @param descending Sorted in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Index for item
  */
-declare function getIndex<Item>(array: Item[], item: Item, sorters: Array<ArraySorter<Item>>, descending?: boolean): number;
+declare function getSortedIndex<Item>(array: Item[], item: Item, sorters: Array<ArraySorter<Item>>, descending?: boolean): number;
 /**
  * Get the index for an item _(to be inserted into an array of items)_ based on a sorter _(and an optional default direction)_
  *
  * _(If the array is not sorted, it will be treated as sorted, and the result may be inaccurate)_
+ *
+ * Available as `getSortedIndex` and `sort.index`
  * @param array Array to get the index from
  * @param item Item to get the index for
  * @param sorter Sorter to use to determine sorting
  * @param descending Sorted in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Index for item
  */
-declare function getIndex<Item>(array: Item[], item: Item, sorter: ArraySorter<Item>, descending?: boolean): number;
+declare function getSortedIndex<Item>(array: Item[], item: Item, sorter: ArraySorter<Item>, descending?: boolean): number;
 /**
  * Get the index for an item _(to be inserted into an array of items)_ based on an optional default direction_
  *
  * _(If the array is not sorted, it will be treated as sorted, and the result may be inaccurate)_
+ *
+ * Available as `getSortedIndex` and `sort.index`
  * @param array Array to get the index from
  * @param item Item to get the index for
  * @param descending Sorted in descending order? _(defaults to `false`)_
  * @returns Index for item
  */
-declare function getIndex<Item>(array: Item[], item: Item, descending?: boolean): number;
+declare function getSortedIndex<Item>(array: Item[], item: Item, descending?: boolean): number;
 /**
  * Initialize a sort handler with sorters _(and an optional default direction)_
+ *
+ * Available as `initializeSorter` and `sort.initialize`
  * @param sorters Sorters to use for sorting
  * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Sort handler
  */
-declare function initializeSort<Item>(sorters: Array<ArraySorter<Item>>, descending?: boolean): Sorter<Item>;
+declare function initializeSorter<Item>(sorters: Array<ArraySorter<Item>>, descending?: boolean): Sorter<Item>;
 /**
  * Initialize a sort handler with a sorter _(and an optional default direction)_
+ *
+ * Available as `initializeSorter` and `sort.initialize`
  * @param sorter Sorter to use for sorting
  * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Sort handler
  */
-declare function initializeSort<Item>(sorter: ArraySorter<Item>, descending?: boolean): Sorter<Item>;
+declare function initializeSorter<Item>(sorter: ArraySorter<Item>, descending?: boolean): Sorter<Item>;
 /**
  * Initialize a sort handler _(with an optional default direction)_
+ *
+ * Available as `initializeSorter` and `sort.initialize`
  * @param descending Sort in descending order? _(defaults to `false`)_
  * @returns Sort handler
  */
-declare function initializeSort<Item>(descending?: boolean): Sorter<Item>;
+declare function initializeSorter<Item>(descending?: boolean): Sorter<Item>;
 /**
  * Is the array sorted according to the sorters _(and the optional default direction)_?
  * @param array Array to check
@@ -158,6 +170,8 @@ declare function isSorted<Item>(array: Item[], sorters: Array<ArraySorter<Item>>
 declare function isSorted<Item>(array: Item[], sorter: ArraySorter<Item>, descending?: boolean): boolean;
 /**
  * Is the array sorted?
+ *
+ * Available as `isSorted` and `sort.is`
  * @param array Array to check
  * @param descending Sorted in descending order? _(defaults to `false`)_
  * @returns `true` if sorted, otherwise `false`
@@ -187,11 +201,11 @@ declare function sort<Item>(array: Item[], sorter: ArraySorter<Item>, descending
  */
 declare function sort<Item>(array: Item[], descending?: boolean): Item[];
 declare namespace sort {
-  var index: typeof getIndex;
-  var initialize: typeof initializeSort;
+  var index: typeof getSortedIndex;
+  var initialize: typeof initializeSorter;
   var is: typeof isSorted;
 }
 declare const SORT_DIRECTION_ASCENDING: SortDirection;
 declare const SORT_DIRECTION_DESCENDING: SortDirection;
 //#endregion
-export { ArrayComparisonSorter, ArrayKeySorter, ArrayValueSorter, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SortDirection, Sorter, sort };
+export { ArrayComparisonSorter, ArrayKeySorter, ArrayValueSorter, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SortDirection, Sorter, getSortedIndex, initializeSorter, isSorted, sort };

package/dist/array/sort.mjs

@@ -18,23 +18,7 @@ function getComparisonValue(first, second, sorters, length) {
 	}
 	return 0;
 }
-function getIndex(array, item, first, second) {
-	return getSortedIndex(array, item, getSorters(first, getModifier(first, second)));
-}
-function getModifier(first, second) {
-	return modifiers[first === true || second === true ? SORT_DIRECTION_DESCENDING : SORT_DIRECTION_ASCENDING];
-}
-function getObjectSorter(obj, modifier) {
-	let sorter;
-	if (typeof obj.comparison === "function") sorter = getComparisonSorter(obj.comparison, modifier);
-	else if (typeof obj.key === "string") {
-		sorter = getValueSorter(obj.key, modifier);
-		if (typeof obj.compare === "function") sorter.compare = { complex: obj.compare };
-	} else if (typeof obj.value === "function") sorter = getValueSorter(obj.value, modifier);
-	if (sorter != null && typeof obj.direction === "string") sorter.modifier = modifiers[obj.direction] ?? modifier;
-	return sorter;
-}
-function getSortedIndex(array, item, sorters) {
+function getIndex(array, item, sorters) {
 	if (!Array.isArray(array)) return -1;
 	const { length } = array;
 	if (length === 0) return 0;
@@ -50,6 +34,22 @@ function getSortedIndex(array, item, sorters) {
 	}
 	return low;
 }
+function getModifier(first, second) {
+	return modifiers[first === true || second === true ? SORT_DIRECTION_DESCENDING : SORT_DIRECTION_ASCENDING];
+}
+function getObjectSorter(obj, modifier) {
+	let sorter;
+	if (typeof obj.comparison === "function") sorter = getComparisonSorter(obj.comparison, modifier);
+	else if (typeof obj.key === "string") {
+		sorter = getValueSorter(obj.key, modifier);
+		if (typeof obj.compare === "function") sorter.compare = { complex: obj.compare };
+	} else if (typeof obj.value === "function") sorter = getValueSorter(obj.value, modifier);
+	if (sorter != null && typeof obj.direction === "string") sorter.modifier = modifiers[obj.direction] ?? modifier;
+	return sorter;
+}
+function getSortedIndex(array, item, first, second) {
+	return getIndex(array, item, getSorters(first, getModifier(first, second)));
+}
 function getSorter(value, modifier) {
 	switch (true) {
 		case typeof value === "function": return getComparisonSorter(value, modifier);
@@ -82,10 +82,10 @@ function getValueSorter(value, modifier) {
 		value: typeof value === "function" ? value : (item) => item[value]
 	};
 }
-function initializeSort(first, second) {
+function initializeSorter(first, second) {
 	const sorters = getSorters(first, getModifier(first, second));
 	const sorter = (array) => sortArray(array, sorters);
-	sorter.index = (array, item) => getSortedIndex(array, item, sorters);
+	sorter.index = (array, item) => getIndex(array, item, sorters);
 	sorter.is = (array) => isSortedArray(array, sorters);
 	return sorter;
 }
@@ -124,8 +124,8 @@ function sortArray(array, sorters) {
 	const { length } = sorters;
 	return array.length > 1 ? array.sort((first, second) => getComparisonValue(first, second, sorters, length)) : array;
 }
-sort.index = getIndex;
-sort.initialize = initializeSort;
+sort.index = getSortedIndex;
+sort.initialize = initializeSorter;
 sort.is = isSorted;
 const ARRAY_PEEK_PERCENTAGE = 10;
 const ARRAY_THRESHOLD = 100;
@@ -136,4 +136,4 @@ const modifiers = {
 	[SORT_DIRECTION_DESCENDING]: -1
 };
 //#endregion
-export { SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, sort };
+export { SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, getSortedIndex, initializeSorter, isSorted, sort };

package/dist/array/swap.d.mts

@@ -70,6 +70,8 @@ declare namespace swap {
  * Swap two indiced items in an array
  *
  * If either index is out of bounds, the array will be returned unchanged
+ *
+ * Available as `swapIndices` and `swap.indices`
  * @param array Array of items to swap
  * @param first First index _(can be negative to count from the end)_
  * @param second Second index _(can be negative to count from the end)_

package/dist/array/swap.mjs

@@ -32,6 +32,8 @@ function swapArrays(array, from, to, key) {
 * Swap two indiced items in an array
 *
 * If either index is out of bounds, the array will be returned unchanged
+*
+* Available as `swapIndices` and `swap.indices`
 * @param array Array of items to swap
 * @param first First index _(can be negative to count from the end)_
 * @param second Second index _(can be negative to count from the end)_

package/dist/array/to-map.d.mts

@@ -70,6 +70,8 @@ declare namespace toMap {
 }
 /**
  * Create a Map from an array of items using callbacks, grouping values into arrays
+ *
+ * Available as `toMapArrays` and `toMap.arrays`
  * @param array Array to convert
  * @param key Callback to get an item's grouping key
  * @param value Callback to get an item's value
@@ -78,6 +80,8 @@ declare namespace toMap {
 declare function toMapArrays<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Map<ReturnType<KeyCallback>, ReturnType<ValueCallback>[]>;
 /**
  * Create a Map from an array of items using a callback and value, grouping values into arrays
+ *
+ * Available as `toMapArrays` and `toMap.arrays`
  * @param array Array to convert
  * @param key Callback to get an item's grouping key
  * @param value Key to use for value
@@ -86,6 +90,8 @@ declare function toMapArrays<Item, KeyCallback extends (item: Item, index: numbe
 declare function toMapArrays<Item extends PlainObject, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: KeyCallback, value: ItemValue): Map<ReturnType<KeyCallback>, Item[ItemValue][]>;
 /**
  * Create a Map from an array of items using a key and callback, grouping values into arrays
+ *
+ * Available as `toMapArrays` and `toMap.arrays`
  * @param array Array to convert
  * @param key Key to use for grouping
  * @param value Callback to get an item's value
@@ -94,6 +100,8 @@ declare function toMapArrays<Item extends PlainObject, KeyCallback extends (item
 declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Map<Item[ItemKey], ReturnType<ValueCallback>[]>;
 /**
  * Create a Map from an array of items using a key and value, grouping values into arrays
+ *
+ * Available as `toMapArrays` and `toMap.arrays`
  * @param array Array to convert
  * @param key Key to use for grouping
  * @param value Key to use for value
@@ -102,6 +110,8 @@ declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Ite
 declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Map<Item[ItemKey], Item[ItemValue][]>;
 /**
  * Create a Map from an array of items using a callback, grouping items into arrays
+ *
+ * Available as `toMapArrays` and `toMap.arrays`
  * @param array Array to convert
  * @param callback Callback to get an item's grouping key
  * @returns Map of keyed arrays of items
@@ -109,10 +119,12 @@ declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Ite
 declare function toMapArrays<Item, Callback extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], callback: Callback): Map<ReturnType<Callback>, Item[]>;
 /**
  * Create a Map from an array of items using a key, grouping items into arrays
+ *
+ * Available as `toMapArrays` and `toMap.arrays`
  * @param array Array to convert
  * @param key Key to use for grouping
  * @returns Map of keyed arrays of items
  */
 declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Map<Item[ItemKey], Item[]>;
 //#endregion
-export { toMap };
+export { toMap, toMapArrays };

package/dist/array/to-map.mjs

@@ -25,4 +25,4 @@ function toMapArrays(array, first, second) {
 	return getMapValues(array, first, second, true);
 }
 //#endregion
-export { toMap };
+export { toMap, toMapArrays };