@oscarpalmer/atoms 0.179.1 → 0.181.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/find.d.mts

@@ -31,5 +31,46 @@ declare function find<Item>(array: Item[], filter: (item: Item, index: number, a
  * @returns First item that matches the value, or `undefined` if no match is found
  */
 declare function find<Item>(array: Item[], value: Item): Item | undefined;
+declare namespace find {
+  var last: typeof findLast;
+}
+/**
+ * Get the last item matching the given value
+ *
+ * Available as `findLast` and `find.last`
+ * @param array Array to search in
+ * @param callback Callback to get an item's value for matching
+ * @param value Value to match against
+ * @returns Last item that matches the value, or `undefined` if no match is found
+ */
+declare function findLast<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item | undefined;
+/**
+ * Get the last item matching the given value by key
+ *
+ * Available as `findLast` and `find.last`
+ * @param array Array to search in
+ * @param key Key to get an item's value for matching
+ * @param value Value to match against
+ * @returns Last item that matches the value, or `undefined` if no match is found
+ */
+declare function findLast<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): Item | undefined;
+/**
+ * Get the last item matching the filter
+ *
+ * Available as `findLast` and `find.last`
+ * @param array Array to search in
+ * @param filter Filter callback to match items
+ * @returns Last item that matches the filter, or `undefined` if no match is found
+ */
+declare function findLast<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): Item | undefined;
+/**
+ * Get the last item matching the given value
+ *
+ * Available as `findLast` and `find.last`
+ * @param array Array to search in
+ * @param value Value to match against
+ * @returns Last item that matches the value, or `undefined` if no match is found
+ */
+declare function findLast<Item>(array: Item[], value: Item): Item | undefined;
 //#endregion
-export { find };
+export { find, findLast };

package/dist/array/find.mjs

@@ -3,5 +3,9 @@ import { FIND_VALUE_ITEM, findValue } from "../internal/array/find.mjs";
 function find(array, ...parameters) {
 	return findValue(FIND_VALUE_ITEM, array, parameters, false);
 }
+find.last = findLast;
+function findLast(array, ...parameters) {
+	return findValue(FIND_VALUE_ITEM, array, parameters, true);
+}
 //#endregion
-export { find };
+export { find, findLast };

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/get.mjs

@@ -1,9 +1,9 @@
-import { isPlainObject } from "../internal/is.mjs";
+import { isNonPlainObject } from "../internal/is.mjs";
 //#region src/array/get.ts
 function getArray(value, indiced) {
 	if (Array.isArray(value)) return value;
 	if (value instanceof Map || value instanceof Set) return [...value.values()];
-	if (!isPlainObject(value)) return [value];
+	if (isNonPlainObject(value)) return [value];
 	if (indiced !== true) return Object.values(value);
 	const keys = Object.keys(value);
 	const { length } = keys;

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/index.d.mts

@@ -1,12 +1,12 @@
 import { difference } from "./difference.mjs";
 import { exists } from "./exists.mjs";
-import { find } from "./find.mjs";
+import { find, findLast } from "./find.mjs";
 import { flatten } from "./flatten.mjs";
 import { range, times } from "./from.mjs";
 import { getArray } from "./get.mjs";
 import { chunk } from "../internal/array/chunk.mjs";
 import { compact } from "../internal/array/compact.mjs";
-import { indexOf } from "../internal/array/index-of.mjs";
+import { indexOf, lastIndexOf } from "../internal/array/index-of.mjs";
 import { shuffle } from "../internal/array/shuffle.mjs";
 import { insert } from "./insert.mjs";
 import { intersection } from "./intersection.mjs";
@@ -23,4 +23,4 @@ import { toggle } from "./toggle.mjs";
 import { union } from "./union.mjs";
 import { unique } from "./unique.mjs";
 import { update } from "./update.mjs";
-export { ArrayPosition, chunk, compact, difference, drop, endsWithArray, exists, find, flatten, getArray, getArrayPosition, includesArray, indexOf, indexOfArray, insert, intersection, partition, push, range, reverse, select, shuffle, single, slice, splice, startsWithArray, take, times, toSet, toggle, union, unique, update };
+export { ArrayPosition, chunk, compact, difference, drop, endsWithArray, exists, find, findLast, flatten, getArray, getArrayPosition, includesArray, indexOf, indexOfArray, insert, intersection, lastIndexOf, partition, push, range, reverse, select, shuffle, single, slice, splice, startsWithArray, take, times, toSet, toggle, union, unique, update };

package/dist/array/index.mjs

@@ -1,10 +1,10 @@
 import { chunk } from "../internal/array/chunk.mjs";
 import { compact } from "../internal/array/compact.mjs";
-import { indexOf } from "../internal/array/index-of.mjs";
+import { indexOf, lastIndexOf } from "../internal/array/index-of.mjs";
 import { shuffle } from "../internal/array/shuffle.mjs";
 import { difference } from "./difference.mjs";
 import { exists } from "./exists.mjs";
-import { find } from "./find.mjs";
+import { find, findLast } from "./find.mjs";
 import { flatten } from "./flatten.mjs";
 import { range, times } from "./from.mjs";
 import { getArray } from "./get.mjs";
@@ -23,4 +23,4 @@ import { toggle } from "./toggle.mjs";
 import { union } from "./union.mjs";
 import { unique } from "./unique.mjs";
 import { update } from "./update.mjs";
-export { chunk, compact, difference, drop, endsWithArray, exists, find, flatten, getArray, getArrayPosition, includesArray, indexOf, indexOfArray, insert, intersection, partition, push, range, reverse, select, shuffle, single, slice, splice, startsWithArray, take, times, toSet, toggle, union, unique, update };
+export { chunk, compact, difference, drop, endsWithArray, exists, find, findLast, flatten, getArray, getArrayPosition, includesArray, indexOf, indexOfArray, insert, intersection, lastIndexOf, partition, push, range, reverse, select, shuffle, single, slice, splice, startsWithArray, take, times, toSet, toggle, union, unique, update };

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 };