@oscarpalmer/atoms 0.202.0 → 0.203.0

package/dist/array/select.d.mts

@@ -22,7 +22,7 @@ type ObjectKeysOf<Item> = { [Key in keyof Item]: Item[Key] extends PlainObject ?
  * ); // => ['Bob']
  * ```
  */
-declare function reverseSelect<Item, Map extends MapKeyOrCallback<Item>, FilterCallback extends (item: Mapped<Item, Map>, index: number, array: Item[]) => unknown>(array: Item[], map: Map, filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>): Array<Mapped<Item, Map>>;
+export declare function reverseSelect<Item, Map extends MapKeyOrCallback<Item>, FilterCallback extends (item: Mapped<Item, Map>, index: number, array: Item[]) => unknown>(array: Item[], map: Map, filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>): Array<Mapped<Item, Map>>;
 /**
  * Get a mapped and filtered array of items
  *
@@ -42,7 +42,7 @@ declare function reverseSelect<Item, Map extends MapKeyOrCallback<Item>, FilterC
  * ); // => [{label: 'Bob'}]
  * ```
  */
-declare function reverseSelect<Item, MapCallback extends (item: Item, index: number, array: Item[]) => PlainObject, ItemKey extends keyof ReturnType<MapCallback>>(array: Item[], map: MapCallback, filterKey: ItemKey, filterValue: ReturnType<MapCallback>[ItemKey]): Array<ReturnType<MapCallback>>;
+export declare function reverseSelect<Item, MapCallback extends (item: Item, index: number, array: Item[]) => PlainObject, ItemKey extends keyof ReturnType<MapCallback>>(array: Item[], map: MapCallback, filterKey: ItemKey, filterValue: ReturnType<MapCallback>[ItemKey]): Array<ReturnType<MapCallback>>;
 /**
  * Get a mapped and filtered array of items
  *
@@ -62,7 +62,7 @@ declare function reverseSelect<Item, MapCallback extends (item: Item, index: num
  * ); // => [{tag: 'b'}]
  * ```
  */
-declare function reverseSelect<Item, MapKey extends ObjectKeysOf<Item>, ItemKey extends keyof Item[MapKey]>(array: Item[], map: MapKey, filterKey: ItemKey, filterValue: Item[MapKey][ItemKey]): Array<Item[MapKey]>;
+export declare function reverseSelect<Item, MapKey extends ObjectKeysOf<Item>, ItemKey extends keyof Item[MapKey]>(array: Item[], map: MapKey, filterKey: ItemKey, filterValue: Item[MapKey][ItemKey]): Array<Item[MapKey]>;
 /**
  * Get a mapped and filtered array of items
  *
@@ -80,7 +80,7 @@ declare function reverseSelect<Item, MapKey extends ObjectKeysOf<Item>, ItemKey
  * ); // => ['Bob']
  * ```
  */
-declare function reverseSelect<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], map: Map, filter: (item: Mapped<Item, Map>, index: number, array: Item[]) => boolean): Array<Mapped<Item, Map>>;
+export declare function reverseSelect<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], map: Map, filter: (item: Mapped<Item, Map>, index: number, array: Item[]) => boolean): Array<Mapped<Item, Map>>;
 /**
  * Get a mapped and filtered array of items
  *
@@ -98,7 +98,7 @@ declare function reverseSelect<Item, Map extends MapKeyOrCallback<Item>>(array:
  * ); // => [4, 4]
  * ```
  */
-declare function reverseSelect<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], map: Map, value: Mapped<Item, Map>): Array<Mapped<Item, Map>>;
+export declare function reverseSelect<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], map: Map, value: Mapped<Item, Map>): Array<Mapped<Item, Map>>;
 /**
  * Get a filtered and mapped array of items
  *
@@ -118,7 +118,7 @@ declare function reverseSelect<Item, Map extends MapKeyOrCallback<Item>>(array:
  * ); // => ['Bob']
  * ```
  */
-declare function select<Item, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, Map extends MapKeyOrCallback<Item>>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, map: Map): Array<Mapped<Item, Map>>;
+export declare function select<Item, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, Map extends MapKeyOrCallback<Item>>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, map: Map): Array<Mapped<Item, Map>>;
 /**
  * Get a filtered and mapped array of items
  *
@@ -138,7 +138,7 @@ declare function select<Item, FilterCallback extends (item: Item, index: number,
  * ); // => ['Bob']
  * ```
  */
-declare function select<Item extends PlainObject, ItemKey extends keyof Item, Map extends MapKeyOrCallback<Item>>(array: Item[], filterKey: ItemKey, filterValue: Item[ItemKey], map: Map): Array<Mapped<Item, Map>>;
+export declare function select<Item extends PlainObject, ItemKey extends keyof Item, Map extends MapKeyOrCallback<Item>>(array: Item[], filterKey: ItemKey, filterValue: Item[ItemKey], map: Map): Array<Mapped<Item, Map>>;
 /**
  * Get a filtered and mapped array of items
  *
@@ -156,7 +156,7 @@ declare function select<Item extends PlainObject, ItemKey extends keyof Item, Ma
  * ); // => ['Bob']
  * ```
  */
-declare function select<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean, map: Map): Array<Mapped<Item, Map>>;
+export declare function select<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean, map: Map): Array<Mapped<Item, Map>>;
 /**
  * Get a filtered and mapped array of items
  *
@@ -174,9 +174,8 @@ declare function select<Item, Map extends MapKeyOrCallback<Item>>(array: Item[],
  * ); // => [9]
  * ```
  */
-declare function select<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], item: Item, map: Map): Array<Mapped<Item, Map>>;
-declare namespace select {
+export declare function select<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], item: Item, map: Map): Array<Mapped<Item, Map>>;
+export declare namespace select {
   var reverse: typeof reverseSelect;
 }
-//#endregion
-export { reverseSelect, select };
+//#endregion

package/dist/array/single.d.mts

@@ -19,7 +19,7 @@ import { PlainObject } from "../models.mjs";
  * ); // => {id: 2}
  * ```
  */
-declare function single<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item | undefined;
+export declare function single<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item | undefined;
 /**
  * Get the _only_ item matching the given value by key
  *
@@ -39,7 +39,7 @@ declare function single<Item, Callback extends (item: Item, index: number, array
  * ); // => {id: 2}
  * ```
  */
-declare function single<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): Item | undefined;
+export declare function single<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): Item | undefined;
 /**
  * Get the _only_ item matching the filter
  *
@@ -57,6 +57,5 @@ declare function single<Item extends PlainObject, ItemKey extends keyof Item>(ar
  * ); // => {id: 2}
  * ```
  */
-declare function single<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): Item | undefined;
-//#endregion
-export { single };
+export declare function single<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): Item | undefined;
+//#endregion

package/dist/array/slice.d.mts

@@ -17,7 +17,7 @@ import { PlainObject } from "../models.mjs";
  * ); // => [{id: 2}, {id: 3}]
  * ```
  */
-declare function drop<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item[];
+export declare function drop<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item[];
 /**
  * Drop items from the start of an array until they match a value
  *
@@ -35,7 +35,7 @@ declare function drop<Item, Callback extends (item: Item, index: number, array:
  * ); // => [{id: 2}, {id: 3}]
  * ```
  */
-declare function drop<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): Item[];
+export declare function drop<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): Item[];
 /**
  * Drop items from the start of an array while they match a filter
  *
@@ -51,7 +51,7 @@ declare function drop<Item extends PlainObject, ItemKey extends keyof Item>(arra
  * ); // => [{id: 2}, {id: 3}]
  * ```
  */
-declare function drop<Item extends PlainObject>(array: Item[], callback: (item: Item, index: number, array: Item[]) => boolean): Item[];
+export declare function drop<Item extends PlainObject>(array: Item[], callback: (item: Item, index: number, array: Item[]) => boolean): Item[];
 /**
  * Drop a specified number of items, from the start if `>= 0`, or from the end if `< 0`
  *
@@ -65,7 +65,7 @@ declare function drop<Item extends PlainObject>(array: Item[], callback: (item:
  * drop([1, 2, 3, 4, 5], -2); // => [1, 2, 3]
  * ```
  */
-declare function drop(array: unknown[], count: number): unknown[];
+export declare function drop(array: unknown[], count: number): unknown[];
 /**
  * Slice an array _(returning a new array with a specified range of items)_
  *
@@ -79,7 +79,7 @@ declare function drop(array: unknown[], count: number): unknown[];
  * slice([1, 2, 3, 4, 5], 1, 4); // => [2, 3, 4]
  * ```
  */
-declare function slice<Item>(array: Item[], start: number, end: number): Item[];
+export declare function slice<Item>(array: Item[], start: number, end: number): Item[];
 /**
  * Slice an array _(returning a new array with a specified number of items, from the start)_
  *
@@ -92,7 +92,7 @@ declare function slice<Item>(array: Item[], start: number, end: number): Item[];
  * slice([1, 2, 3, 4, 5], 3); // => [1, 2, 3]
  * ```
  */
-declare function slice<Item>(array: Item[], count: number): Item[];
+export declare function slice<Item>(array: Item[], count: number): Item[];
 /**
  * Slice an array _(returning a new array with all items)_
  *
@@ -104,7 +104,7 @@ declare function slice<Item>(array: Item[], count: number): Item[];
  * slice([1, 2, 3]); // => [1, 2, 3]
  * ```
  */
-declare function slice<Item>(array: Item[]): Item[];
+export declare function slice<Item>(array: Item[]): Item[];
 /**
  * Take items from the start of an array until they match a value
  *
@@ -122,7 +122,7 @@ declare function slice<Item>(array: Item[]): Item[];
  * ); // => [{id: 1}]
  * ```
  */
-declare function take<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item[];
+export declare function take<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item[];
 /**
  * Take items from the start of an array until they match a value
  *
@@ -140,7 +140,7 @@ declare function take<Item, Callback extends (item: Item, index: number, array:
  * ); // => [{id: 1}]
  * ```
  */
-declare function take<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): Item[];
+export declare function take<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): Item[];
 /**
  * Take items from the start of an array while they match a filter
  *
@@ -156,7 +156,7 @@ declare function take<Item extends PlainObject, ItemKey extends keyof Item>(arra
  * ); // => [{id: 1}]
  * ```
  */
-declare function take<Item extends PlainObject>(array: Item[], callback: (item: Item, index: number, array: Item[]) => boolean): Item[];
+export declare function take<Item extends PlainObject>(array: Item[], callback: (item: Item, index: number, array: Item[]) => boolean): Item[];
 /**
  * Take a specified number of items, from the start if `>= 0`, or from the end if `< 0`
  *
@@ -170,6 +170,5 @@ declare function take<Item extends PlainObject>(array: Item[], callback: (item:
  * take([1, 2, 3, 4, 5], -2); // => [4, 5]
  * ```
  */
-declare function take(array: unknown[], count: number): unknown[];
-//#endregion
-export { drop, slice, take };
+export declare function take(array: unknown[], count: number): unknown[];
+//#endregion

package/dist/array/sort.d.mts

@@ -3,7 +3,7 @@ import { PlainObject, Primitive } from "../models.mjs";
 /**
  * Sorting information for arrays _(using a comparison callback)_
  */
-type ArrayComparisonSorter<Item> = {
+export type ArrayComparisonSorter<Item> = {
   /**
    * Callback to use when comparing items and values
    */
@@ -16,7 +16,7 @@ type ArrayComparisonSorter<Item> = {
 /**
  * Sorting information for arrays _(using a key)_
  */
-type ArrayKeySorter<Item extends PlainObject, ItemKey extends keyof Item> = {
+export type ArrayKeySorter<Item extends PlainObject, ItemKey extends keyof Item> = {
   /**
    * Comparator to use when comparing items and values
    */
@@ -37,15 +37,15 @@ type ArrayKeySorters<Item extends PlainObject> = { [ItemKey in keyof Item]: Arra
 /**
  * Sorter to use for sorting
  */
-type ArraySorter<Item> = Item extends PlainObject ? keyof Item | ArrayComparisonSorter<Item> | ArrayKeySorters<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item> : ArrayComparisonSorter<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item>;
+export type ArraySorter<Item> = Item extends PlainObject ? keyof Item | ArrayComparisonSorter<Item> | ArrayKeySorters<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item> : ArrayComparisonSorter<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item>;
 /**
  * Sorters to use for sorting
  */
-type ArraySorters<Item> = Array<ArraySorter<Item>>;
+export type ArraySorters<Item> = Array<ArraySorter<Item>>;
 /**
  * Sorting information for arrays _(using a value callback and built-in comparison)_
  */
-type ArrayValueSorter<Item> = {
+export type ArrayValueSorter<Item> = {
   /**
    * Direction to sort by
    */
@@ -67,20 +67,13 @@ type ComparisonSorter<Item> = (first: Item, second: Item) => number;
 /**
  * Direction to sort by
  */
-type SortDirection = 'ascending' | 'descending';
+export type SortDirection = 'ascending' | 'descending';
 /**
  * Sorter for an array with predefined sorters
  *
  * Can be used to sort an array, get the predicted index for an item, and check if an array is sorted
  */
-type Sorter<Item> = {
-  /**
-   * Sort an array of items
-   *
-   * @param array Array to sort
-   * @returns Sorted array
-   */
-  (array: Item[]): Item[];
+export type Sorter<Item> = {
   /**
    * Get the index for an item _(to be inserted into an array of items)_
    *
@@ -98,6 +91,13 @@ type Sorter<Item> = {
    * @returns `true` if sorted, otherwise `false`
    */
   is(array: Item[]): boolean;
+  /**
+   * Sort an array of items
+   *
+   * @param array Array to sort
+   * @returns Sorted array
+   */
+  sort(array: Item[]): Item[];
 };
 /**
  * Get the index for an item _(to be inserted into an array of items)_ based on sorters _(and an optional default direction)_
@@ -112,7 +112,7 @@ type Sorter<Item> = {
  * @param descending Sorted in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Index for item
  */
-declare function getSortedIndex<Item>(array: Item[], item: Item, sorters: Array<ArraySorter<Item>>, descending?: boolean): number;
+export 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)_
  *
@@ -126,7 +126,7 @@ declare function getSortedIndex<Item>(array: Item[], item: Item, sorters: Array<
  * @param descending Sorted in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Index for item
  */
-declare function getSortedIndex<Item>(array: Item[], item: Item, sorter: ArraySorter<Item>, descending?: boolean): number;
+export 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_
  *
@@ -139,7 +139,7 @@ declare function getSortedIndex<Item>(array: Item[], item: Item, sorter: ArraySo
  * @param descending Sorted in descending order? _(defaults to `false`)_
  * @returns Index for item
  */
-declare function getSortedIndex<Item>(array: Item[], item: Item, descending?: boolean): number;
+export declare function getSortedIndex<Item>(array: Item[], item: Item, descending?: boolean): number;
 /**
  * Initialize a sort handler with sorters _(and an optional default direction)_
  *
@@ -149,7 +149,7 @@ declare function getSortedIndex<Item>(array: Item[], item: Item, descending?: bo
  * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Sort handler
  */
-declare function initializeSorter<Item>(sorters: Array<ArraySorter<Item>>, descending?: boolean): Sorter<Item>;
+export declare function initializeSorter<Item>(sorters: Array<ArraySorter<Item>>, descending?: boolean): Sorter<Item>;
 /**
  * Initialize a sort handler with a sorter _(and an optional default direction)_
  *
@@ -159,7 +159,7 @@ declare function initializeSorter<Item>(sorters: Array<ArraySorter<Item>>, desce
  * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Sort handler
  */
-declare function initializeSorter<Item>(sorter: ArraySorter<Item>, descending?: boolean): Sorter<Item>;
+export declare function initializeSorter<Item>(sorter: ArraySorter<Item>, descending?: boolean): Sorter<Item>;
 /**
  * Initialize a sort handler _(with an optional default direction)_
  *
@@ -168,7 +168,7 @@ declare function initializeSorter<Item>(sorter: ArraySorter<Item>, descending?:
  * @param descending Sort in descending order? _(defaults to `false`)_
  * @returns Sort handler
  */
-declare function initializeSorter<Item>(descending?: boolean): Sorter<Item>;
+export declare function initializeSorter<Item>(descending?: boolean): Sorter<Item>;
 /**
  * Is the array sorted according to the sorters _(and the optional default direction)_?
  *
@@ -179,7 +179,7 @@ declare function initializeSorter<Item>(descending?: boolean): Sorter<Item>;
  * @param descending Sorted in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns `true` if sorted, otherwise `false`
  */
-declare function isSorted<Item>(array: Item[], sorters: Array<ArraySorter<Item>>, descending?: boolean): boolean;
+export declare function isSorted<Item>(array: Item[], sorters: Array<ArraySorter<Item>>, descending?: boolean): boolean;
 /**
  * Is the array sorted according to the sorter _(and the optional default direction)_?
  *
@@ -190,7 +190,7 @@ declare function isSorted<Item>(array: Item[], sorters: Array<ArraySorter<Item>>
  * @param descending Sorted in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns `true` if sorted, otherwise `false`
  */
-declare function isSorted<Item>(array: Item[], sorter: ArraySorter<Item>, descending?: boolean): boolean;
+export declare function isSorted<Item>(array: Item[], sorter: ArraySorter<Item>, descending?: boolean): boolean;
 /**
  * Is the array sorted?
  *
@@ -200,7 +200,7 @@ declare function isSorted<Item>(array: Item[], sorter: ArraySorter<Item>, descen
  * @param descending Sorted in descending order? _(defaults to `false`)_
  * @returns `true` if sorted, otherwise `false`
  */
-declare function isSorted<Item>(array: Item[], descending?: boolean): boolean;
+export declare function isSorted<Item>(array: Item[], descending?: boolean): boolean;
 /**
  * Sort an array of items using a comparison callback
  *
@@ -217,7 +217,7 @@ declare function isSorted<Item>(array: Item[], descending?: boolean): boolean;
  * ); // => [{id: 1}, {id: 2}, {id: 3}]
  * ```
  */
-declare function sort<Item>(array: Item[], comparator: (first: Item, second: Item) => number, descending?: boolean): Item[];
+export declare function sort<Item>(array: Item[], comparator: (first: Item, second: Item) => number, descending?: boolean): Item[];
 /**
  * Sort an array of items, using multiple sorters to sort by specific values
  *
@@ -226,7 +226,7 @@ declare function sort<Item>(array: Item[], comparator: (first: Item, second: Ite
  * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Sorted array
  */
-declare function sort<Item>(array: Item[], sorters: Array<ArraySorter<Item>>, descending?: boolean): Item[];
+export declare function sort<Item>(array: Item[], sorters: Array<ArraySorter<Item>>, descending?: boolean): Item[];
 /**
  * Sort an array of items, using a single sorter to sort by a specific value
  *
@@ -235,7 +235,7 @@ declare function sort<Item>(array: Item[], sorters: Array<ArraySorter<Item>>, de
  * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Sorted array
  */
-declare function sort<Item>(array: Item[], sorter: ArraySorter<Item>, descending?: boolean): Item[];
+export declare function sort<Item>(array: Item[], sorter: ArraySorter<Item>, descending?: boolean): Item[];
 /**
  * Sort an array of items
  *
@@ -243,13 +243,12 @@ declare function sort<Item>(array: Item[], sorter: ArraySorter<Item>, descending
  * @param descending Sort in descending order? _(defaults to `false`)_
  * @returns Sorted array
  */
-declare function sort<Item>(array: Item[], descending?: boolean): Item[];
-declare namespace sort {
+export declare function sort<Item>(array: Item[], descending?: boolean): Item[];
+export declare namespace sort {
   var getIndex: 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, ArraySorter, ArraySorters, ArrayValueSorter, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SortDirection, Sorter, getSortedIndex, initializeSorter, isSorted, sort };
+export declare const SORT_DIRECTION_ASCENDING: SortDirection;
+export declare const SORT_DIRECTION_DESCENDING: SortDirection;
+//#endregion

package/dist/array/sort.mjs

@@ -1,10 +1,20 @@
 import { isPlainObject } from "../internal/is.mjs";
 import { compare } from "../internal/value/compare.mjs";
 //#region src/array/sort.ts
+const SORTER_PROPERTY = "$sorter";
+function Sorter(sorters) {
+	Object.defineProperty(this, SORTER_SYMBOL, { value: sorters });
+}
+Object.defineProperties(Sorter.prototype, {
+	[SORTER_PROPERTY]: { value: true },
+	index: { value: getSortedArrayIndex },
+	is: { value: isSortedArray },
+	sort: { value: sortArray }
+});
 function getComparisonSorter(callback, modifier) {
 	return {
 		modifier,
-		compare: { simple: callback },
+		comparison: { simple: callback },
 		get: false,
 		identifier: callback.toString()
 	};
@@ -13,15 +23,29 @@ function getComparisonValue(first, second, sorters, length) {
 	for (let index = 0; index < length; index += 1) {
 		const sorter = sorters[index];
 		const values = [sorter.get ? sorter.value(first) : first, sorter.get ? sorter.value(second) : second];
-		const comparison = (sorter.compare?.complex?.(first, values[0], second, values[1]) ?? sorter.compare?.simple?.(values[0], values[1]) ?? compare(values[0], values[1])) * sorter.modifier;
+		const comparison = (sorter.comparison?.complex?.(first, values[0], second, values[1]) ?? sorter.comparison?.simple?.(values[0], values[1]) ?? compare(values[0], values[1])) * sorter.modifier;
 		if (comparison !== 0) return comparison;
 	}
 	return 0;
 }
-function getIndex(array, item, sorters) {
+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 = getValueSortHandlers(obj.key, modifier);
+		if (typeof obj.compare === "function") sorter.comparison = { complex: obj.compare };
+	} else if (typeof obj.value === "function") sorter = getValueSortHandlers(obj.value, modifier);
+	if (sorter != null && typeof obj.direction === "string") sorter.modifier = modifiers[obj.direction] ?? modifier;
+	return sorter;
+}
+function getSortedArrayIndex(array, item) {
 	if (!Array.isArray(array)) return -1;
 	const { length } = array;
 	if (length === 0) return 0;
+	const sorters = Array.isArray(this) ? this : this[SORTER_SYMBOL];
 	const sortersLength = sorters.length;
 	if (getComparisonValue(item, array[0], sorters, sortersLength) < 0) return 0;
 	if (getComparisonValue(item, array[length - 1], sorters, sortersLength) >= 0) return length;
@@ -34,36 +58,23 @@ function getIndex(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)));
+	return getSortedArrayIndex.call(getSortHandlers(first, getModifier(first, second)), array, item);
 }
-function getSorter(value, modifier) {
+function getSortHandler(value, modifier) {
 	switch (true) {
 		case typeof value === "function": return getComparisonSorter(value, modifier);
-		case typeof value === "string": return getValueSorter(value, modifier);
+		case typeof value === "string": return getValueSortHandlers(value, modifier);
 		case isPlainObject(value): return getObjectSorter(value, modifier);
 	}
 }
-function getSorters(value, modifier) {
+function getSortHandlers(value, modifier) {
 	const array = Array.isArray(value) ? value : [value];
 	const { length } = array;
 	const sorters = [];
 	for (let index = 0; index < length; index += 1) {
 		const item = array[index];
-		const sorter = getSorter(item, modifier);
+		const sorter = getSortHandler(item, modifier);
 		if (sorter != null) sorters.push(sorter);
 	}
 	if (sorters.length === 0) return [{
@@ -73,7 +84,7 @@ function getSorters(value, modifier) {
 	}];
 	return sorters.filter((value, index, array) => array.findIndex((next) => next.identifier === value.identifier) === index);
 }
-function getValueSorter(value, modifier) {
+function getValueSortHandlers(value, modifier) {
 	const isFunction = typeof value === "function";
 	return {
 		modifier,
@@ -83,21 +94,16 @@ function getValueSorter(value, modifier) {
 	};
 }
 function initializeSorter(first, second) {
-	const sorters = getSorters(first, getModifier(first, second));
-	const sorter = (array) => sortArray(array, sorters);
-	Object.defineProperties(sorter, {
-		index: { value: (array, item) => getIndex(array, item, sorters) },
-		is: { value: (array) => isSortedArray(array, sorters) }
-	});
-	return sorter;
+	return new Sorter(getSortHandlers(first, getModifier(first, second)));
 }
 function isSorted(array, first, second) {
-	return isSortedArray(array, getSorters(first, getModifier(first, second)));
+	return isSortedArray.call(getSortHandlers(first, getModifier(first, second)), array);
 }
-function isSortedArray(array, sorters) {
+function isSortedArray(array) {
 	if (!Array.isArray(array)) return false;
 	const { length } = array;
 	if (length < 2) return true;
+	const sorters = Array.isArray(this) ? this : this[SORTER_SYMBOL];
 	const sortersLength = sorters.length;
 	let offset = 0;
 	if (length >= SORT_THRESHOLD) {
@@ -119,10 +125,11 @@ function isSortedArray(array, sorters) {
 	return true;
 }
 function sort(array, first, second) {
-	return sortArray(array, getSorters(first, getModifier(first, second)));
+	return sortArray.call(getSortHandlers(first, getModifier(first, second)), array);
 }
-function sortArray(array, sorters) {
+function sortArray(array) {
 	if (!Array.isArray(array)) return [];
+	const sorters = Array.isArray(this) ? this : this[SORTER_SYMBOL];
 	const { length } = sorters;
 	return array.length > 1 ? array.sort((first, second) => getComparisonValue(first, second, sorters, length)) : array;
 }
@@ -130,6 +137,7 @@ const SORT_PEEK_PERCENTAGE = 10;
 const SORT_THRESHOLD = 100;
 const SORT_DIRECTION_ASCENDING = "ascending";
 const SORT_DIRECTION_DESCENDING = "descending";
+const SORTER_SYMBOL = Symbol(SORTER_PROPERTY);
 const modifiers = {
 	[SORT_DIRECTION_ASCENDING]: 1,
 	[SORT_DIRECTION_DESCENDING]: -1

package/dist/array/splice.d.mts

@@ -20,7 +20,7 @@
  * ); // => [3, 4], array becomes [1, 2, 6, 7, 5]
  * ```
  */
-declare function splice<Item>(array: Item[], start: number, amount: number, added: Item[]): Item[];
+export declare function splice<Item>(array: Item[], start: number, amount: number, added: Item[]): Item[];
 /**
  * Adds items into an array at a specific index
  *
@@ -40,7 +40,7 @@ declare function splice<Item>(array: Item[], start: number, amount: number, adde
  * ); // => [], array becomes [1, 2, 6, 7, 3, 4, 5]
  * ```
  */
-declare function splice<Item>(array: Item[], start: number, added: Item[]): Item[];
+export declare function splice<Item>(array: Item[], start: number, added: Item[]): Item[];
 /**
  * Removes and returns _(up to)_ a specific amount of items from an array, starting from a specific index
  *
@@ -60,7 +60,7 @@ declare function splice<Item>(array: Item[], start: number, added: Item[]): Item
  * ); // => [3, 4], array becomes [1, 2, 5]
  * ```
  */
-declare function splice<Item>(array: Item[], start: number, amount: number): Item[];
+export declare function splice<Item>(array: Item[], start: number, amount: number): Item[];
 /**
  * Removes and returns all items from an array starting from a specific index
  *
@@ -78,6 +78,5 @@ declare function splice<Item>(array: Item[], start: number, amount: number): Ite
  * ); // => [3, 4, 5], array becomes [1, 2]
  * ```
  */
-declare function splice<Item>(array: Item[], start: number): Item[];
-//#endregion
-export { splice };
+export declare function splice<Item>(array: Item[], start: number): Item[];
+//#endregion

package/dist/array/swap.d.mts

@@ -33,7 +33,7 @@ import { PlainObject } from "../models.mjs";
  *    // ]
  * ```
  */
-declare function swap<Item>(array: Item[], first: Item[], second: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
+export declare function swap<Item>(array: Item[], first: Item[], second: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
 /**
  * Swap two smaller arrays within a larger array
  *
@@ -67,7 +67,7 @@ declare function swap<Item>(array: Item[], first: Item[], second: Item[], callba
  *    // ]
  * ```
  */
-declare function swap<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], first: Item[], second: Item[], key: ItemKey): Item[];
+export declare function swap<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], first: Item[], second: Item[], key: ItemKey): Item[];
 /**
  * Swap two smaller arrays within a larger array
  *
@@ -87,7 +87,7 @@ declare function swap<Item extends PlainObject, ItemKey extends keyof Item>(arra
  * ); // => [5, 6, 3, 4, 1, 2]
  * ```
  */
-declare function swap<Item>(array: Item[], first: Item[], second: Item[]): Item[];
+export declare function swap<Item>(array: Item[], first: Item[], second: Item[]): Item[];
 /**
  * Swap two indiced items in an array
  *
@@ -117,7 +117,7 @@ declare function swap<Item>(array: Item[], first: Item[], second: Item[]): Item[
  *    // ]
  * ```
  */
-declare function swap<Item>(array: Item[], first: Item, second: Item, callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
+export declare function swap<Item>(array: Item[], first: Item, second: Item, callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
 /**
  * Swap two indiced items in an array
  *
@@ -147,7 +147,7 @@ declare function swap<Item>(array: Item[], first: Item, second: Item, callback:
  *    // ]
  * ```
  */
-declare function swap<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], first: Item, second: Item, key: ItemKey): Item[];
+export declare function swap<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], first: Item, second: Item, key: ItemKey): Item[];
 /**
  * Swap two indiced items in an array
  *
@@ -165,8 +165,8 @@ declare function swap<Item extends PlainObject, ItemKey extends keyof Item>(arra
  * ); // => [1, 5, 3, 4, 2, 6]
  * ```
  */
-declare function swap<Item>(array: Item[], first: Item, second: Item): Item[];
-declare namespace swap {
+export declare function swap<Item>(array: Item[], first: Item, second: Item): Item[];
+export declare namespace swap {
   var indices: typeof swapIndices;
 }
 /**
@@ -182,5 +182,4 @@ declare namespace swap {
  * @returns Original array with items swapped _(or unchanged if unable to swap)_
  */
 declare function swapIndices<Item>(array: Item[], first: number, second: number): Item[];
-//#endregion
-export { swap };
+//#endregion