@oscarpalmer/atoms 0.185.0 → 0.186.1

package/dist/index.d.mts

@@ -143,74 +143,157 @@ type ToString<Value> = Value extends string | number ? `${Value}` : never;
  * A union type of all typed arrays
  */
 type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+/**
+ * Converts a union type to an intersection type
+ *
+ * @example
+ * ```typescript
+ * type A = {a: string};
+ * type B = {b: number};
+ * type C = UnionToIntersection<A | B>; // {a: string} & {b: number}
+ * ```
+ *
+ * Thanks, type-fest!
+ */
+type UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends ((mergedIntersection: infer Intersection) => void) ? Intersection & Union : never;
 //#endregion
 //#region src/array/filter.d.ts
 /**
- * Get a filtered array of items that do not match the filter
+ * Get a filtered array of items that do not match the value
  *
  * 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 that do not match the filter
+ *
+ * @example
+ * ```typescript
+ * exclude(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id,
+ *   2,
+ * ); // => [{id: 1}, {id: 3}]
+ * ```
  */
 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 that do not match the filter
+ * Get a filtered array of items that do not match the value
  *
  * 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 that do not match the filter
+ *
+ * @example
+ * ```typescript
+ * exclude(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   'id',
+ *   2,
+ * ); // => [{id: 1}, {id: 3}]
+ * ```
  */
 declare function exclude<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): unknown[];
 /**
  * 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 that do not match the filter
+ *
+ * @example
+ * ```typescript
+ * exclude(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id === 2,
+ * ); // => [{id: 1}, {id: 3}]
+ * ```
  */
 declare function exclude<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): unknown[];
 /**
  * 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 that do not match the given item
+ *
+ * @example
+ * ```typescript
+ * exclude([1, 2, 3], 2); // => [1, 3]
+ * ```
  */
 declare function exclude<Item>(array: Item[], item: Item): unknown[];
 /**
  * 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
+ *
+ * @example
+ * ```typescript
+ * filter(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id,
+ *   2,
+ * ); // => [{id: 2}]
+ * ```
  */
 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
+ *
  * @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
+ *
+ * @example
+ * ```typescript
+ * filter(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   'id',
+ *   2,
+ * ); // => [{id: 2}]
+ * ```
  */
 declare function filter<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): Item[];
 /**
  * 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
+ *
+ * @example
+ * ```typescript
+ * filter(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id === 2,
+ * ); // => [{id: 2}]
+ * ```
  */
 declare function filter<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): 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
+ *
+ * @example
+ * ```typescript
+ * filter([1, 2, 3], 2); // => [2]
+ * ```
  */
 declare function filter<Item>(array: Item[], item: Item): Item[];
 declare namespace filter {
@@ -220,31 +303,68 @@ declare namespace filter {
 //#region src/array/first.d.ts
 /**
  * Get the first item matching the given value
+ *
  * @param array Array to search in
  * @param callback Callback to get an item's value for matching
  * @param value Value to match against
  * @returns First item that matches the value, or `undefined` if no match is found
+ *
+ * @example
+ * ```typescript
+ * first(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value,
+ *   10,
+ * ); // => {id: 1, value: 10}
+ * ```
  */
 declare function first<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item | undefined;
 /**
  * Get the first item matching the given value by key
+ *
  * @param array Array to search in
  * @param key Key to get an item's value for matching
  * @param value Value to match against
  * @returns First item that matches the value, or `undefined` if no match is found
+ *
+ * @example
+ * ```typescript
+ * first(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   'value',
+ *   10,
+ * ); // => {id: 1, value: 10}
+ * ```
  */
 declare function first<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): Item | undefined;
 /**
  * Get the first item matching the filter
+ *
  * @param array Array to search in
  * @param filter Filter callback to match items
  * @returns First item that matches the filter, or `undefined` if no match is found
+ *
+ * @example
+ * ```typescript
+ * first(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value === 10,
+ * ); // => {id: 1, value: 10}
+ * ```
  */
 declare function first<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): Item | undefined;
 /**
  * Get the first item from an array
+ *
  * @param array Array to get from
- * @return First item from the array, or `undefined` if the array is empty
+ * @returns First item from the array, or `undefined` if the array is empty
+ *
+ * @example
+ * ```typescript
+ * first(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ * ); // => {id: 1, value: 10}
+ * ```
  */
 declare function first<Item>(array: Item[]): Item | undefined;
 declare namespace first {
@@ -255,41 +375,79 @@ declare namespace first {
  * 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
  * @param value Value to match against
  * @returns First item that matches the value, or the default value if no match is found
+ *
+ * @example
+ * ```typescript
+ * firstOrDefault(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   {id: -1, value: 30},
+ *   item => item.value,
+ *   30,
+ * ); // => {id: -1, value: 30}
+ * ```
  */
 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, 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
  * @param value Value to match against
  * @returns First item that matches the value, or the default value if no match is found
+ *
+ * @example
+ * ```typescript
+ * firstOrDefault(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   {id: -1, value: 30},
+ *   'value',
+ *   30,
+ * ); // => {id: -1, value: 30}
+ * ```
  */
 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, 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
  * @returns First item that matches the filter, or the default value if no match is found
+ *
+ * @example
+ * ```typescript
+ * firstOrDefault(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   {id: -1, value: 30},
+ *   item => item.value === 30,
+ * ); // => {id: -1, value: 30}
+ * ```
  */
 declare function firstOrDefault<Item>(array: Item[], defaultValue: Item, filter: (item: Item, index: number, array: Item[]) => boolean): Item;
 /**
  * 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
+ * @returns First item from the array, or the default value if the array is empty
+ *
+ * @example
+ * ```typescript
+ * firstOrDefault([], {id: -1, value: 30}); // => {id: -1, value: 30}
+ * ```
  */
 declare function firstOrDefault<Item>(array: Item[], defaultValue: Item): Item;
 //#endregion
@@ -298,64 +456,130 @@ declare function firstOrDefault<Item>(array: Item[], defaultValue: Item): Item;
  * Create a record from an array of items using a specific key and value
  *
  * If multiple items have the same key, the latest item's value will be used
+ *
  * @param array Array to group
  * @param key Callback to get an item's grouping key
  * @param value Callback to get an item's value
  * @returns Record of keyed values
+ *
+ * @example
+ * ```typescript
+ * groupBy(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value,
+ *   item => item,
+ * ); // => {10: {id: 3, value: 10}, 20: {id: 2, value: 20}}
+ * ```
  */
 declare function groupBy<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Simplify<Record<ReturnType<KeyCallback>, ReturnType<ValueCallback>>>;
 /**
  * Create a record from an array of items using a specific key and value
  *
  * If multiple items have the same key, the latest item's value will be used
+ *
  * @param array Array to group
  * @param key Callback to get an item's grouping key
  * @param value Key to use for value
  * @returns Record of keyed values
+ *
+ * @example
+ * ```typescript
+ * groupBy(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value,
+ *   'id'
+ * ); // => {10: 3, 20: 2}
+ * ```
  */
 declare function groupBy<Item extends PlainObject, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, 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
  *
  * If multiple items have the same key, the latest item's value will be used
+ *
  * @param array Array to group
  * @param key Key to use for grouping
  * @param value Callback to get an item's value
  * @returns Record of keyed values
+ *
+ * @example
+ * ```typescript
+ * groupBy(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   'value',
+ *   item => item,
+ * ); // => {10: {id: 3, value: 10}, 20: {id: 2, value: 20}}
+ * ```
  */
 declare function groupBy<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
  *
  * If multiple items have the same key, the latest item's value will be used
+ *
  * @param array Array to group
  * @param key Key to use for grouping
  * @param value Key to use for value
  * @returns Record of keyed values
+ *
+ * @example
+ * ```typescript
+ * groupBy(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   'value',
+ *   'id'
+ * ); // => {10: 3, 20: 2}
+ * ```
  */
 declare function groupBy<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
  *
  * If multiple items have the same key, the latest item will be used
+ *
  * @param array Array to group
  * @param callback Callback to get an item's grouping key
  * @returns Record of keyed items
+ *
+ * @example
+ * ```typescript
+ * groupBy(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value,
+ * ); // => {10: {id: 3, value: 10}, 20: {id: 2, value: 20}}
+ * ```
  */
 declare function groupBy<Item, Callback extends (item: Item, index: number, array: Item[]) => Key$1>(array: Item[], callback: Callback): Record<ReturnType<Callback>, Item>;
 /**
  * Create a record from an array of items using a specific key
  *
  * If multiple items have the same key, the latest item will be used
+ *
  * @param array Array to group
  * @param key Key to use for grouping
  * @returns Record of keyed items
+ *
+ * @example
+ * ```typescript
+ * groupBy(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   'value',
+ * ); // => {10: {id: 3, value: 10}, 20: {id: 2, value: 20}}
+ * ```
  */
 declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item>>;
 /**
  * Create a record from an array of items _(using indices as keys)_
+ *
  * @param array Array to group
  * @returns Record of indiced items
+ *
+ * @example
+ * ```typescript
+ * groupBy(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ * ); // => {0: {id: 1, value: 10}, 1: {id: 2, value: 20}, 2: {id: 3, value: 10}}
+ * ```
  */
 declare function groupBy<Item>(array: Item[]): Record<number, Item>;
 declare namespace groupBy {
@@ -365,114 +589,243 @@ 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
  * @returns Record of keyed values
+ *
+ * @example
+ * ```typescript
+ * groupArraysBy(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value,
+ *   item => item,
+ * ); // => {
+ *    //   10: [{id: 1, value: 10}, {id: 3, value: 10}],
+ *    //   20: [{id: 2, value: 20}],
+ *    // }
+ * ```
  */
 declare function groupArraysBy<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, 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
  * @returns Record of keyed values
+ *
+ * @example
+ * ```typescript
+ * groupArraysBy(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value,
+ *   'id',
+ * ); // => {
+ *    //   10: [1, 3],
+ *    //   20: [2],
+ *    // }
+ * ```
  */
 declare function groupArraysBy<Item extends PlainObject, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, 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
  * @returns Record of keyed values
+ *
+ * @example
+ * ```typescript
+ * groupArraysBy(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   'value',
+ *   item => item,
+ * ); // => {
+ *    //   10: [{id: 1, value: 10}, {id: 3, value: 10}],
+ *    //   20: [{id: 2, value: 20}],
+ *    // }
+ * ```
  */
 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
  * @returns Record of keyed values
+ *
+ * @example
+ * ```typescript
+ * groupArraysBy(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   'value',
+ *   'id',
+ * ); // => {
+ *    //   10: [1, 3],
+ *    //   20: [2],
+ *    // }
+ * ```
  */
 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
+ *
+ * @example
+ * ```typescript
+ * groupArraysBy(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value,
+ * ); // => {
+ *    //   10: [{id: 1, value: 10}, {id: 3, value: 10}],
+ *    //   20: [{id: 2, value: 20}],
+ *    // }
+ * ```
  */
 declare function groupArraysBy<Item, Callback extends (item: Item, index: number, array: Item[]) => Key$1>(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
+ *
+ * @example
+ * ```typescript
+ * groupArraysBy(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   'value',
+ * ); // => {
+ *    //   10: [{id: 1, value: 10}, {id: 3, value: 10}],
+ *    //   20: [{id: 2, value: 20}],
+ *    // }
+ * ```
  */
 declare function groupArraysBy<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
 //#endregion
 //#region src/internal/array/chunk.d.ts
 /**
  * Chunk an array into smaller arrays
+ *
  * @param array Array to chunk
  * @param size Size of each chunk _(minimum is `1`, maximum is `5000`; defaults to `5000`)_
  * @returns Array of arrays
+ *
+ * @example
+ * ```typescript
+ * chunk([1, 2, 3, 4, 5], 2); // => [[1, 2], [3, 4], [5]]
+ * ```
  */
 declare function chunk<Item>(array: Item[], size?: number): Item[][];
 //#endregion
 //#region src/internal/array/compact.d.ts
 /**
  * Compact an array _(removing all false-y values)_
+ *
  * @param array Array to compact
  * @param strict True to remove all false-y values
  * @returns Compacted array
+ *
+ * @example
+ * ```typescript
+ * compact([0, 1, '', 'hello', false, true, null, undefined]); // => [1, 'hello', true]
+ * ```
  */
 declare function compact<Item>(array: Item[], strict: true): Exclude<Item, 0 | '' | false | null | undefined>[];
 /**
  * Compact an array _(removing all `null` and `undefined` values)_
+ *
  * @param array Array to compact
  * @returns Compacted array
+ *
+ * @example
+ * ```typescript
+ * compact([0, 1, '', 'hello', false, true, null, undefined]); // => [0, 1, '', 'hello', false, true]
+ * ```
  */
 declare function compact<Item>(array: Item[]): Exclude<Item, null | undefined>[];
 //#endregion
 //#region src/internal/array/index-of.d.ts
 /**
  * Get the index of the first matching item by callback
+ *
  * @param array Array to search in
  * @param callback Callback to get an item's value
  * @param value Value to match against
  * @returns Index of the first matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * indexOf(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id,
+ *   2,
+ * ); // => 1
+ * ```
  */
 declare function indexOf<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): number;
 /**
  * Get the index of the first matching item by key
+ *
  * @param array Array to search in
  * @param key Key to match items by
  * @param value Value to match against
  * @returns Index of the first matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * indexOf(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   'id',
+ *   2,
+ * ); // => 1
+ * ```
  */
 declare function indexOf<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): number;
 /**
  * Get the index of the first item matching the filter
+ *
  * @param array Array to search in
  * @param filter Filter callback to match items
  * @returns Index of the first matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * indexOf(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id === 2,
+ * ); // => 1
+ * ```
  */
 declare function indexOf<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): number;
 /**
  * Get the index of the first item matching the given item
+ *
  * @param array Array to search in
  * @param item Item to match against
  * @returns Index of the first matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * indexOf([1, 2, 3, 4, 5], 3); // => 2
+ * ```
  */
 declare function indexOf<Item>(array: Item[], item: Item): number;
 declare namespace indexOf {
@@ -482,38 +835,73 @@ declare namespace indexOf {
  * Get the index of the last matching item by callback
  *
  * Available as `lastIndexOf` and `indexOf.last`
+ *
  * @param array Array to search in
  * @param callback Callback to get an item's value
  * @param value Value to match against
  * @returns Index of the last matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * lastIndexOf(
+ *   [{id: 1}, {id: 2}, {id: 3}, {id: 2}],
+ *   item => item.id,
+ *   2,
+ * ); // => 3
+ * ```
  */
 declare function lastIndexOf<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): number;
 /**
  * Get the index of the last matching item by key
  *
  * Available as `lastIndexOf` and `indexOf.last`
+ *
  * @param array Array to search in
  * @param key Key to match items by
  * @param value Value to match against
  * @returns Index of the last matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * lastIndexOf(
+ *   [{id: 1}, {id: 2}, {id: 3}, {id: 2}],
+ *   'id',
+ *   2,
+ * ); // => 3
+ * ```
  */
 declare function lastIndexOf<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): number;
 /**
  * Get the index of the last item matching the filter
  *
  * Available as `lastIndexOf` and `indexOf.last`
+ *
  * @param array Array to search in
  * @param filter Filter callback to match items
  * @returns Index of the last matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * lastIndexOf(
+ *   [{id: 1}, {id: 2}, {id: 3}, {id: 2}],
+ *   item => item.id === 2,
+ * ); // => 3
+ * ```
  */
 declare function lastIndexOf<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): number;
 /**
  * Get the index of the last item matching the given item
  *
  * Available as `lastIndexOf` and `indexOf.last`
+ *
  * @param array Array to search in
  * @param item Item to match against
  * @returns Index of the last matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * lastIndexOf([1, 2, 3, 2, 1], 2); // => 3
+ * ```
  */
 declare function lastIndexOf<Item>(array: Item[], item: Item): number;
 //#endregion
@@ -528,89 +916,188 @@ declare function shuffle<Item>(array: Item[]): Item[];
 //#region src/array/difference.d.ts
 /**
  * Get the items from the first array that are not in the second array
+ *
  * @param first First array
  * @param second Second array
  * @param callback Callback to get an item's value for comparison
  * @returns Unique values from the first array
+ *
+ * @example
+ * ```typescript
+ * difference(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   [{id: 2}, {id: 4}],
+ *   item => item.id,
+ * ); // => [{id: 1}, {id: 3}]
+ * ```
  */
 declare function difference<First, Second>(first: First[], second: Second[], callback: (item: First | Second) => unknown): First[];
 /**
  * Get the items from the first array that are not in the second array
+ *
  * @param first First array
  * @param second Second array
  * @param key Key to get an item's value for comparison
  * @returns Unique values from the first array
+ *
+ * @example
+ * ```typescript
+ * difference(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   [{id: 2}, {id: 4}],
+ *   'id',
+ * ); // => [{id: 1}, {id: 3}]
+ * ```
  */
 declare function difference<First extends PlainObject, Second extends PlainObject, SharedKey extends keyof First & keyof Second>(first: First[], second: Second[], key: SharedKey): First[];
 /**
  * Get the items from the first array that are not in the second array
+ *
  * @param first First array
  * @param second Second array
  * @returns Unique values from the first array
+ *
+ * @example
+ * ```typescript
+ * difference(
+ *   [1, 2, 3],
+ *   [2, 4],
+ * ); // => [1, 3]
+ * ```
  */
 declare function difference<First, Second>(first: First[], second: Second[]): First[];
 //#endregion
 //#region src/array/exists.d.ts
 /**
  * Does an item with a specific value exist in the array?
+ *
  * @param array Array to search in
  * @param callback Callback to get an item's value for matching
  * @param value Value to match against
  * @returns `true` if the item exists in the array, otherwise `false`
+ *
+ * @example
+ * ```typescript
+ * exists(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id,
+ *   2,
+ * ); // => true
+ * ```
  */
 declare function exists<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): boolean;
 /**
  * Does an item with a specific value exist in the array?
+ *
  * @param array Array to search in
  * @param key Key to get an item's value for matching
  * @param value Value to match against
  * @returns `true` if the item exists in the array, otherwise `false`
+ *
+ * @example
+ * ```typescript
+ * exists(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   'id',
+ *   2,
+ * ); // => true
+ * ```
  */
 declare function exists<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): boolean;
 /**
  * Does an item in the array match the filter?
+ *
  * @param array Array to search in
  * @param filter Filter callback to match items
  * @returns `true` if a matching item exists, otherwise `false`
+ *
+ * @example
+ * ```typescript
+ * exists(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id === 2,
+ * ); // => true
+ * ```
  */
 declare function exists<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): boolean;
 /**
  * Does the item exist in the array?
+ *
  * @param array Array to search in
  * @param item Item to search for
  * @returns `true` if the item exists in the array, otherwise `false`
+ *
+ * @example
+ * ```typescript
+ * exists([1, 2, 3], 2); // => true
+ * ```
  */
 declare function exists<Item>(array: Item[], item: Item): boolean;
 //#endregion
 //#region src/array/find.d.ts
 /**
  * Get the first item matching the given value
+ *
  * @param array Array to search in
  * @param callback Callback to get an item's value for matching
  * @param value Value to match against
  * @returns First item that matches the value, or `undefined` if no match is found
+ *
+ * @example
+ * ```typescript
+ * find(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value,
+ *   10,
+ * ); // => {id: 1, value: 10}
+ * ```
  */
 declare function find<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item | undefined;
 /**
  * Get the first item matching the given value by key
+ *
  * @param array Array to search in
  * @param key Key to get an item's value for matching
  * @param value Value to match against
  * @returns First item that matches the value, or `undefined` if no match is found
+ *
+ * @example
+ * ```typescript
+ * find(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   'value',
+ *   10,
+ * ); // => {id: 1, value: 10}
+ * ```
  */
 declare function find<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): Item | undefined;
 /**
  * Get the first item matching the filter
+ *
  * @param array Array to search in
  * @param filter Filter callback to match items
  * @returns First item that matches the filter, or `undefined` if no match is found
+ *
+ * @example
+ * ```typescript
+ * find(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value === 10,
+ * ); // => {id: 1, value: 10}
+ * ```
  */
 declare function find<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): Item | undefined;
 /**
  * Get the first item matching the given value
+ *
  * @param array Array to search in
  * @param value Value to match against
  * @returns First item that matches the value, or `undefined` if no match is found
+ *
+ * @example
+ * ```typescript
+ * find([1, 2, 3, 2, 1], 1); // => 1
+ * ```
  */
 declare function find<Item>(array: Item[], value: Item): Item | undefined;
 declare namespace find {
@@ -620,195 +1107,372 @@ declare namespace find {
  * 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
+ *
+ * @example
+ * ```typescript
+ * findLast(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value,
+ *   10,
+ * ); // => {id: 3, value: 10}
+ * ```
  */
 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
+ *
+ * @example
+ * ```typescript
+ * findLast(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   'value',
+ *   10,
+ * ); // => {id: 3, value: 10}
+ * ```
  */
 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
+ *
+ * @example
+ * ```typescript
+ * findLast(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value === 10,
+ * ); // => {id: 3, value: 10}
+ * ```
  */
 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
+ *
+ * @example
+ * ```typescript
+ * findLast([1, 2, 3, 2, 1], 1); // => 1
+ * ```
  */
 declare function findLast<Item>(array: Item[], value: Item): Item | undefined;
 //#endregion
 //#region src/array/flatten.d.ts
 /**
  * Flatten an array _(using native `flat` and maximum depth)_
+ *
  * @param array Array to flatten
  * @returns Flattened array
+ *
+ * @example
+ * ```typescript
+ * flatten([1, [2, [3, 4], 5], 6]); // => [1, 2, 3, 4, 5, 6]
+ * ```
  */
 declare function flatten<Item>(array: Item[]): NestedArray<Item>[];
 //#endregion
 //#region src/array/from.d.ts
 /**
  * Get an array with a specified length, filled with indices
+ *
  * @param length Length of the array
  * @returns Array of indices
+ *
+ * @example
+ * ```typescript
+ * range(5); // => [0, 1, 2, 3, 4]
+ * ```
  */
 declare function range(length: number): number[];
 /**
  * Get an array of numbers in a specified range
+ *
  * @param start Starting number _(inclusive)_
  * @param end Ending number _(exclusive)_
  * @returns Array of numbers in range
+ *
+ * @example
+ * ```typescript
+ * range(2, 5); // => [2, 3, 4]
+ * ```
  */
 declare function range(start: number, end: number): number[];
 /**
  * Get an array of numbers in a specified range with a specified step
+ *
  * @param start Starting number _(inclusive)_
  * @param end Ending number _(exclusive)_
  * @param step Step between numbers
  * @returns Array of numbers in range
+ *
+ * @example
+ * ```typescript
+ * range(0, 10, 2); // => [0, 2, 4, 6, 8]
+ * ```
  */
 declare function range(start: number, end: number, step: number): number[];
 /**
  * Get an array with a specified length, filled with indices
+ *
  * @param length Length of the array
  * @returns Array of indices
+ *
+ * @example
+ * ```typescript
+ * times(5); // => [0, 1, 2, 3, 4]
+ * ```
  */
 declare function times(length: number): number[];
 /**
  * Get an array with a specified length, filled by values from a callback
+ *
  * @param length Length of the array
  * @param callback Callback function to generate values
  * @returns Array of values generated by the callback
+ *
+ * @example
+ * ```typescript
+ * times(5, index => index * 2); // => [0, 2, 4, 6, 8]
+ * ```
  */
 declare function times<Callback extends (index: number) => unknown>(length: number, callback: Callback): ReturnType<Callback>[];
 /**
  * Get an array with a specified length, filled with a specified value
+ *
  * @param length Length of the array
  * @param value Value to fill the array with
  * @returns Array filled with the specified value
+ *
+ * @example
+ * ```typescript
+ * times(5, 'a'); // => ['a', 'a', 'a', 'a', 'a']
+ * ```
  */
 declare function times<Value>(length: number, value: Value): Value[];
 //#endregion
 //#region src/array/get.d.ts
 /**
  * Get an array from an object, where only values with numerical keys will be included
+ *
  * @param value Object to convert to an array
  * @returns Array holding the values of the object's numerical keys
+ *
+ * @example
+ * ```typescript
+ * getArray({0: 'a', 1: 'b', 2: 'c', d: 'd'}, true); // => ['a', 'b', 'c']
+ * getArray({a: 'a', b: 'b', c: 'c', d: 'd'}, true); // => []
+ * ```
  */
 declare function getArray<Value extends PlainObject>(value: Value, indiced: true): Value[NumericalKeys<Value>][];
 /**
  * Get an array from an object
+ *
  * @param value Object to convert to an array
  * @returns Array holding the values of the object
+ *
+ * @example
+ * ```typescript
+ * getArray({0: 'a', 1: 'b', 2: 'c', d: 'd'}); // => ['a', 'b', 'c', 'd']
+ * getArray({a: 'a', b: 'b', c: 'c', d: 'd'}); // => ['a', 'b', 'c', 'd']
+ * ```
  */
 declare function getArray<Value extends PlainObject>(value: Value): Value[keyof Value][];
 /**
- * Get an array
+ * Get an array from a value
+ *
  * @param value Original array
  * @returns Original array
+ *
+ * @example
+ * ```typescript
+ * getArray(123); // => [123]
+ * ```
  */
 declare function getArray<Item>(value: Item[]): Item[];
-/**
- * Get an array from a value
- * @param value Value to convert to an array
- * @returns Array holding the value
- */
-declare function getArray<Item>(value: Item): Item[];
 /**
  * Get an array from an unknown value
+ *
  * @param value Value to convert to an array
  * @returns Array of value
+ *
+ * @example
+ * ```typescript
+ * getArray(123); // => [123]
+ * ```
  */
 declare function getArray(value: unknown): unknown[];
 //#endregion
 //#region src/array/insert.d.ts
 /**
  * Insert items into an array at a specified index
+ *
+ * _(Uses chunking to avoid call stack size being exceeded)_
+ *
  * @param array Original array
  * @param index Index to insert at
  * @param items Inserted items
  * @returns Updated array
+ *
+ * @example
+ * ```typescript
+ * insert([1, 2, 3], 1, [4, 5]); // => [1, 4, 5, 2, 3]
+ * ```
  */
 declare function insert<Item>(array: Item[], index: number, items: Item[]): Item[];
 /**
  * Insert items into an array _(at the end)_
+ *
+ * _(Uses chunking to avoid call stack size being exceeded)_
+ *
  * @param array Original array
  * @param items Inserted items
  * @returns Updated array
+ *
+ * @example
+ * ```typescript
+ * insert([1, 2, 3], [4, 5]); // => [1, 2, 3, 4, 5]
+ * ```
  */
 declare function insert<Item>(array: Item[], items: Item[]): Item[];
 //#endregion
 //#region src/array/intersection.d.ts
 /**
  * Get the common values between two arrays
+ *
  * @param first First array
  * @param second Second array
  * @param callback Callback to get an item's value for comparison
  * @returns Common values from both arrays
+ *
+ * @example
+ * ```typescript
+ * intersection(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   [{id: 2}, {id: 3}, {id: 4}],
+ *   item => item.id,
+ * ); // => [{id: 2}, {id: 3}]
+ * ```
  */
 declare function intersection<First, Second>(first: First[], second: Second[], callback: (item: First | Second) => unknown): First[];
 /**
  * Get the common values between two arrays
+ *
  * @param first First array
  * @param second Second array
  * @param key Key to get an item's value for comparison
  * @returns Common values from both arrays
+ *
+ * @example
+ * ```typescript
+ * intersection(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   [{id: 2}, {id: 3}, {id: 4}],
+ *   'id',
+ * ); // => [{id: 2}, {id: 3}]
+ * ```
  */
 declare function intersection<First extends Record<string, unknown>, Second extends Record<string, unknown>, SharedKey extends keyof First & keyof Second>(first: First[], second: Second[], key: SharedKey): First[];
 /**
  * Get the common values between two arrays
+ *
  * @param first First array
  * @param second Second array
  * @returns Common values from both arrays
+ *
+ * @example
+ * ```typescript
+ * intersection(
+ *   [1, 2, 3],
+ *   [2, 3, 4],
+ * ); // => [2, 3]
+ * ```
  */
 declare function intersection<First, Second>(first: First[], second: Second[]): First[];
 //#endregion
 //#region src/array/partition.d.ts
 /**
  * Get a partitioned 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 Partitioned array of items
+ *
+ * @example
+ * ```typescript
+ * partition(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id,
+ *   2,
+ * ); // => [[{id: 2}], [{id: 1}, {id: 3}]]
+ * ```
  */
 declare function partition<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item[][];
 /**
  * Get a partitioned 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 Partitioned array of items
+ *
+ * @example
+ * ```typescript
+ * partition(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   'id',
+ *   2,
+ * ); // => [[{id: 2}], [{id: 1}, {id: 3}]]
+ * ```
  */
 declare function partition<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): Item[][];
 /**
  * Get a partitioned array of items
+ *
  * @param array Array to search in
  * @param filter Filter callback to match items
  * @returns Partitioned array of items
+ *
+ * @example
+ * ```typescript
+ * partition(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id === 2,
+ * ); // => [[{id: 2}], [{id: 1}, {id: 3}]]
+ * ```
  */
 declare function partition<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): Item[][];
 /**
  * Get a partitioned array of items matching the given item
+ *
  * @param array Array to search in
  * @param item Item to match against
  * @returns Partitioned array of items
+ *
+ * @example
+ * ```typescript
+ * partition([1, 2, 3, 4, 5], 3); // => [[3], [1, 2, 4, 5]]
+ * ```
  */
 declare function partition<Item>(array: Item[], item: Item): Item[][];
 //#endregion
@@ -821,130 +1485,268 @@ type ArrayComparison = 'end' | 'inside' | 'invalid' | 'outside' | 'same' | 'star
  * Does the needle array end the haystack array?
  * @param haystack Haystack array
  * @param needle Needle array
- * @param key Key to get an item's value for matching
- * @return `true` if the haystack ends with the needle, otherwise `false`
+ * @param callback Callback to get an item's value for matching
+ * @returns `true` if the haystack ends with the needle, otherwise `false`
+ *
+ * @example
+ * ```typescript
+ * endsWithArray(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   [{id: 2}, {id: 3}],
+ *   item => item.id,
+ * ); // => true
+ * ```
  */
-declare function endsWithArray<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): boolean;
+declare function endsWithArray<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): boolean;
 /**
  * Does the needle array end the haystack array?
+ *
  * @param haystack Haystack array
  * @param needle Needle array
- * @param callback Callback to get an item's value for matching
- * @return `true` if the haystack ends with the needle, otherwise `false`
+ * @param key Key to get an item's value for matching
+ * @returns `true` if the haystack ends with the needle, otherwise `false`
+ *
+ * @example
+ * ```typescript
+ * endsWithArray(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   [{id: 2}, {id: 3}],
+ *   'id',
+ * ); // => true
+ * ```
  */
-declare function endsWithArray<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): boolean;
+declare function endsWithArray<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): boolean;
 /**
  * Does the needle array end the haystack array?
+ *
  * @param haystack Haystack array
  * @param needle Needle array
- * @return `true` if the haystack ends with the needle, otherwise `false`
+ * @returns `true` if the haystack ends with the needle, otherwise `false`
+ *
+ * @example
+ * ```typescript
+ * endsWithArray([1, 2, 3], [2, 3]); // => true
+ * ```
  */
 declare function endsWithArray<Item>(haystack: Item[], needle: Item[]): boolean;
 /**
  * Get the position of an array within another array
+ *
  * @param haystack Haystack array
  * @param needle Needle array
- * @param key Key to get an item's value for matching
+ * @param callback Callback to get an item's value for matching
  * @returns Position of the needle within the haystack
+ *
+ * @example
+ * ```typescript
+ * getArrayComparison(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   [{id: 2}, {id: 3}],
+ *   item => item.id,
+ * ); // => 'end'
+ * ```
  */
-declare function getArrayComparison<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): ArrayComparison;
+declare function getArrayComparison<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): ArrayComparison;
 /**
  * Get the position of an array within another array
+ *
  * @param haystack Haystack array
  * @param needle Needle array
- * @param callback Callback to get an item's value for matching
+ * @param key Key to get an item's value for matching
  * @returns Position of the needle within the haystack
+ *
+ * @example
+ * ```typescript
+ * getArrayComparison(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   [{id: 2}, {id: 3}],
+ *   'id',
+ * ); // => 'end'
+ * ```
  */
-declare function getArrayComparison<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): ArrayComparison;
+declare function getArrayComparison<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): ArrayComparison;
 /**
  * Get the position of an array within another array
+ *
  * @param haystack Haystack array
  * @param needle Needle array
  * @returns Position of the needle within the haystack
+ *
+ * @example
+ * ```typescript
+ * getArrayComparison([1, 2, 3], [2, 3]); // => 'end'
+ * ```
  */
 declare function getArrayComparison<Item>(haystack: Item[], needle: Item[]): ArrayComparison;
 /**
  * Does the needle array exist within the haystack array?
+ *
  * @param haystack Haystack array
  * @param needle Needle array
- * @param key Key to get an item's value for matching
- * @return `true` if the haystack includes the needle, otherwise `false`
+ * @param callback Callback to get an item's value for matching
+ * @returns `true` if the haystack includes the needle, otherwise `false`
+ *
+ * @example
+ * ```typescript
+ * includesArray(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   [{id: 2}, {id: 3}],
+ *   item => item.id,
+ * ); // => true
+ * ```
  */
-declare function includesArray<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): boolean;
+declare function includesArray<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): boolean;
 /**
  * Does the needle array exist within the haystack array?
+ *
  * @param haystack Haystack array
  * @param needle Needle array
- * @param callback Callback to get an item's value for matching
- * @return `true` if the haystack includes the needle, otherwise `false`
+ * @param key Key to get an item's value for matching
+ * @returns `true` if the haystack includes the needle, otherwise `false`
+ *
+ * @example
+ * ```typescript
+ * includesArray(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   [{id: 2}, {id: 3}],
+ *   'id',
+ * ); // => true
+ * ```
  */
-declare function includesArray<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): boolean;
+declare function includesArray<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): boolean;
 /**
  * Does the needle array exist within the haystack array?
+ *
  * @param haystack Haystack array
  * @param needle Needle array
- * @return `true` if the haystack includes the needle, otherwise `false`
+ * @returns `true` if the haystack includes the needle, otherwise `false`
+ *
+ * @example
+ * ```typescript
+ * includesArray([1, 2, 3], [2, 3]); // => true
+ * ```
  */
 declare function includesArray<Item>(haystack: Item[], needle: Item[]): boolean;
 /**
  * Get the index of an array within another array
+ *
  * @param haystack Haystack array
  * @param needle Needle array
- * @param key Key to get an item's value for matching
- * @return Index of the needle's start within the haystack, or `-1` if it is not found
+ * @param callback Callback to get an item's value for matching
+ * @returns Index of the needle's start within the haystack, or `-1` if it is not found
+ *
+ * @example
+ * ```typescript
+ * indexOfArray(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   [{id: 2}, {id: 3}],
+ *   item => item.id,
+ * ); // => 1
+ * ```
  */
-declare function indexOfArray<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): number;
+declare function indexOfArray<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): number;
 /**
  * Get the index of an array within another array
+ *
  * @param haystack Haystack array
  * @param needle Needle array
- * @param callback Callback to get an item's value for matching
- * @return Index of the needle's start within the haystack, or `-1` if it is not found
+ * @param key Key to get an item's value for matching
+ * @returns Index of the needle's start within the haystack, or `-1` if it is not found
+ *
+ * @example
+ * ```typescript
+ * indexOfArray(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   [{id: 2}, {id: 3}],
+ *   'id',
+ * ); // => 1
+ * ```
  */
-declare function indexOfArray<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): number;
+declare function indexOfArray<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): number;
 /**
  * Get the index of an array within another array
+ *
  * @param haystack Haystack array
  * @param needle Needle array
- * @return Index of the needle's start within the haystack, or `-1` if it is not found
+ * @returns Index of the needle's start within the haystack, or `-1` if it is not found
+ *
+ * @example
+ * ```typescript
+ * indexOfArray([1, 2, 3], [2, 3]); // => 1
+ * ```
  */
 declare function indexOfArray<Item>(haystack: Item[], needle: Item[]): number;
 /**
  * Does the needle array start the haystack array?
+ *
  * @param haystack Haystack array
  * @param needle Needle array
- * @param key Key to get an item's value for matching
- * @return `true` if the haystack starts with the needle, otherwise `false`
+ * @param callback Callback to get an item's value for matching
+ * @returns `true` if the haystack starts with the needle, otherwise `false`
+ *
+ * @example
+ * ```typescript
+ * startsWithArray(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   [{id: 1}, {id: 2}],
+ *   item => item.id,
+ * ); // => true
+ * ```
  */
-declare function startsWithArray<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): boolean;
+declare function startsWithArray<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): boolean;
 /**
  * Does the needle array start the haystack array?
+ *
  * @param haystack Haystack array
  * @param needle Needle array
- * @param callback Callback to get an item's value for matching
- * @return `true` if the haystack starts with the needle, otherwise `false`
+ * @param key Key to get an item's value for matching
+ * @returns `true` if the haystack starts with the needle, otherwise `false`
+ *
+ * @example
+ * ```typescript
+ * startsWithArray(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   [{id: 1}, {id: 2}],
+ *   'id',
+ * ); // => true
+ * ```
  */
-declare function startsWithArray<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): boolean;
+declare function startsWithArray<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): boolean;
 /**
  * Does the needle array start the haystack array?
+ *
  * @param haystack Haystack array
  * @param needle Needle array
- * @return `true` if the haystack starts with the needle, otherwise `false`
+ * @returns `true` if the haystack starts with the needle, otherwise `false`
+ *
+ * @example
+ * ```typescript
+ * startsWithArray([1, 2, 3], [1, 2]); // => true
+ * ```
  */
 declare function startsWithArray<Item>(haystack: Item[], needle: Item[]): boolean;
 //#endregion
 //#region src/array/push.d.ts
 /**
  * Push items into an array _(at the end)_
+ *
+ * _(Uses chunking to avoid call stack size being exceeded)_
+ *
  * @param array Original array
  * @param pushed Pushed items
  * @returns New length of the array
+ *
+ * @example
+ * ```typescript
+ * push([1, 2, 3], [4, 5]); // => 5 (new length); array becomes [1, 2, 3, 4, 5]
+ * ```
  */
 declare function push<Item>(array: Item[], pushed: Item[]): number;
 //#endregion
 //#region src/array/reverse.d.ts
 /**
  * Reverse the order of items in an array
+ *
  * @param array Array to reverse
  * @returns Reversed array
  */
@@ -953,46 +1755,100 @@ declare function reverse<Item>(array: Item[]): Item[];
 //#region src/array/select.d.ts
 /**
  * Get a filtered and mapped array of items
+ *
  * @param array Array to search in
  * @param filterCallback Callback to get an item's value for matching
  * @param filterValue Value to match against
  * @param mapCallback Callback to map the matched items
  * @returns Filtered and mapped array of items
+ *
+ * @example
+ * ```typescript
+ * select(
+ *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
+ *   item => item.id,
+ *   2,
+ *   item => item.name,
+ * ); // => ['Bob']
+ * ```
  */
 declare function select<Item, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, MapCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, mapCallback: MapCallback): Array<ReturnType<MapCallback>>;
 /**
  * Get a filtered and mapped array of items
+ *
  * @param array Array to search in
  * @param filterCallback Callback to get an item's value for matching
  * @param filterValue Value to match against
  * @param mapKey Key to get an item's value for mapping
  * @returns Filtered and mapped array of items
+ *
+ * @example
+ * ```typescript
+ * select(
+ *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
+ *   item => item.id,
+ *   2,
+ *   'name',
+ * ); // => ['Bob']
+ * ```
  */
 declare function select<Item extends PlainObject, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, MapKey extends keyof Item>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, mapKey: MapKey): Array<Item[MapKey]>;
 /**
  * Get a filtered and mapped array of items
+ *
  * @param array Array to search in
  * @param filterKey Key to get an item's value for matching
  * @param filterValue Value to match against
  * @param mapCallback Callback to map the matched items
  * @returns Filtered and mapped array of items
+ *
+ * @example
+ * ```typescript
+ * select(
+ *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
+ *   'id',
+ *   2,
+ *   item => item.name,
+ * ); // => ['Bob']
+ * ```
  */
 declare function select<Item extends PlainObject, ItemKey extends keyof Item, MapCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], filterKey: ItemKey, filterValue: Item[ItemKey], mapCallback: MapCallback): Array<ReturnType<MapCallback>>;
 /**
  * Get a filtered and mapped array of items
+ *
  * @param array Array to search in
  * @param filterKey Key to get an item's value for matching
  * @param filterValue Value to match against
  * @param mapKey Key to get an item's value for mapping
  * @returns Filtered and mapped array of items
+ *
+ * @example
+ * ```typescript
+ * select(
+ *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
+ *   'id',
+ *   2,
+ *   'name',
+ * ); // => ['Bob']
+ * ```
  */
 declare function select<Item extends PlainObject, ItemKey extends keyof Item, MapKey extends keyof Item>(array: Item[], filterKey: ItemKey, filterValue: Item[ItemKey], mapKey: MapKey): Array<Item[MapKey]>;
 /**
  * Get a filtered and mapped array of items
+ *
  * @param array Array to search in
  * @param filterCallback Filter callback to match items
  * @param mapCallback Callback to map the matched items
  * @returns Filtered and mapped array of items
+ *
+ * @example
+ * ```typescript
+ * select(
+ *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
+ *   item => item.id === 2,
+ *   item => item.name,
+ * ); // => ['Bob']
+ * ```
  */
 declare function select<Item, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, MapCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, mapCallback: MapCallback): Array<ReturnType<MapCallback>>;
 /**
@@ -1001,336 +1857,717 @@ declare function select<Item, FilterCallback extends (item: Item, index: number,
  * @param filterCallback Filter callback to match items
  * @param mapKey Key to get an item's value for mapping
  * @returns Filtered and mapped array of items
+ *
+ * @example
+ * ```typescript
+ * select(
+ *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
+ *   item => item.id,
+ *   2,
+ *   'name'
+ * ); // => ['Bob']
+ * ```
  */
 declare function select<Item extends PlainObject, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, MapKey extends keyof Item>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, mapKey: MapKey): Array<Item[MapKey]>;
 /**
  * Get a filtered and mapped array of items
+ *
  * @param array Array to search in
  * @param filter Filter callback to match items
  * @param map Callback to map the matched items
  * @returns Filtered and mapped array of items
+ *
+ * @example
+ * ```typescript
+ * select(
+ *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
+ *   item => item.id === 2,
+ *   item => item.name,
+ * ); // => ['Bob']
+ * ```
  */
 declare function select<Item, MapCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean, map: MapCallback): Array<ReturnType<MapCallback>>;
 /**
  * Get a filtered and mapped array of items
+ *
  * @param array Array to search in
  * @param filter Filter callback to match items
  * @param map Key to get an item's value for mapping
  * @returns Filtered and mapped array of items
+ *
+ * @example
+ * ```typescript
+ * select(
+ *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
+ *   item => item.id === 2,
+ *   'name'
+ * ); // => ['Bob']
+ * ```
  */
 declare function select<Item extends PlainObject, MapKey extends keyof Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean, map: MapKey): Array<Item[MapKey]>;
 /**
  * Get a filtered and mapped array of items
+ *
  * @param array Array to search in
  * @param item Item to match against
  * @param map Callback to map the matched items
  * @returns Filtered and mapped array of items
+ *
+ * @example
+ * ```typescript
+ * select(
+ *   [1, 2, 3, 2, 1],
+ *   3,
+ *   value => value ** 2,
+ * ); // => [9]
+ * ```
  */
 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
- * @param item Item to match against
- * @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[], item: Item, map: MapKey): Array<Item[MapKey]>;
 //#endregion
 //#region src/array/single.d.ts
 /**
  * Get the _only_ item matching the given value
  *
  * Throws an error if multiple items match the value
+ *
  * @param array Array to search in
  * @param callback Callback to get an item's value for matching
  * @param value Value to match against
  * @returns Only item that matches the value, or `undefined` if no match is found
+ *
+ * @example
+ * ```typescript
+ * single(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id,
+ *   2
+ * ); // => {id: 2}
+ * ```
  */
 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
  *
  * Throws an error if multiple items match the value
+ *
  * @param array Array to search in
  * @param key Key to get an item's value for matching
  * @param value Value to match against
  * @returns Only item that matches the value, or `undefined` if no match is found
+ *
+ * @example
+ * ```typescript
+ * single(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   'id',
+ *   2
+ * ); // => {id: 2}
+ * ```
  */
 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
  *
  * Throws an error if multiple items match the filter
+ *
  * @param array Array to search in
  * @param filter Filter callback to match items
  * @returns Only item that matches the filter, or `undefined` if no match is found
+ *
+ * @example
+ * ```typescript
+ * single(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id === 2
+ * ); // => {id: 2}
+ * ```
  */
 declare function single<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): Item | undefined;
 //#endregion
 //#region src/array/slice.d.ts
 /**
  * Drop items from the start of an array until they match a value
+ *
  * @param array Original array
- * @param key Key to get an item's value for matching
+ * @param callback Callback to get an item's value for matching
  * @param value Value to match against
  * @returns New array with items dropped
+ *
+ * @example
+ * ```typescript
+ * drop(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id,
+ *   2,
+ * ); // => [{id: 2}, {id: 3}]
+ * ```
  */
-declare function drop<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): Item[];
+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
+ *
  * @param array Original array
- * @param callback Callback to get an item's value for matching
+ * @param key Key to get an item's value for matching
  * @param value Value to match against
- * @return New array with items dropped
+ * @returns New array with items dropped
+ *
+ * @example
+ * ```typescript
+ * drop(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   'id',
+ *   2,
+ * ); // => [{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[];
+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
+ *
  * @param array Original array
  * @param callback Filter callback to match items
- * @return New array with items dropped
+ * @returns New array with items dropped
+ *
+ * @example
+ * ```typescript
+ * drop(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id === 2,
+ * ); // => [{id: 2}, {id: 3}]
+ * ```
  */
 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`
+ *
  * @param array Original array
  * @param count Number of items to drop
  * @returns New array with items dropped
+ *
+ * @example
+ * ```typescript
+ * drop([1, 2, 3, 4, 5], 2);  // => [3, 4, 5]
+ * drop([1, 2, 3, 4, 5], -2); // => [1, 2, 3]
+ * ```
  */
 declare function drop(array: unknown[], count: number): unknown[];
 /**
  * Slice an array, returning a new array with a specified range of items
+ *
  * @param array Original array
  * @param start Start index _(inclusive)_
  * @param end End index _(exclusive)_
- * @return New array with sliced items
+ * @returns New array with sliced items
+ *
+ * @example
+ * ```typescript
+ * slice([1, 2, 3, 4, 5], 1, 4); // => [2, 3, 4]
+ * ```
  */
 declare function slice<Item>(array: Item[], start: number, end: number): Item[];
 /**
- * Slice an array, returning a new array with a specified number of items
+ * Slice an array, returning a new array with a specified number of items _(from the start)_
+ *
  * @param array Original array
- * @param count Maximum sixe of the new array
- * @return New array with sliced items
+ * @param count Maximum size of the new array
+ * @returns New array with sliced items
+ *
+ * @example
+ * ```typescript
+ * slice([1, 2, 3, 4, 5], 3); // => [1, 2, 3]
+ * ```
  */
 declare function slice<Item>(array: Item[], count: number): Item[];
 /**
  * Slice an array
+ *
  * @param array Array to slice
  * @returns Sliced array
+ *
+ * @example
+ * ```typescript
+ * slice([1, 2, 3]); // => [1, 2, 3]
+ * ```
  */
 declare function slice<Item>(array: Item[]): Item[];
 /**
  * Take items from the start of an array until they match a value
+ *
  * @param array Original array
- * @param key Key to get an item's value for matching
+ * @param callback Callback to get an item's value for matching
  * @param value Value to match against
  * @returns New array with taken items
+ *
+ * @example
+ * ```typescript
+ * take(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id,
+ *   2,
+ * ); // => [{id: 1}]
+ * ```
  */
-declare function take<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): Item[];
+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
+ *
  * @param array Original array
- * @param callback Callback to get an item's value for matching
+ * @param key Key to get an item's value for matching
  * @param value Value to match against
- * @return New array with taken items
+ * @returns New array with taken items
+ *
+ * @example
+ * ```typescript
+ * take(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   'id',
+ *   2,
+ * ); // => [{id: 1}]
+ * ```
  */
-declare function take<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item[];
+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
+ *
  * @param array Original array
  * @param callback Filter callback to match items
- * @return New array with taken items
+ * @returns New array with taken items
+ *
+ * @example
+ * ```typescript
+ * take(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id === 2,
+ * ); // => [{id: 1}]
+ * ```
  */
 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`
+ *
  * @param array Original array
  * @param count Number of items to take
  * @returns New array with taken items
+ *
+ * @example
+ * ```typescript
+ * take([1, 2, 3, 4, 5], 2);  // => [1, 2]
+ * take([1, 2, 3, 4, 5], -2); // => [4, 5]
+ * ```
  */
 declare function take(array: unknown[], count: number): unknown[];
 //#endregion
 //#region src/array/splice.d.ts
 /**
  * Adds items into an array at a specific index and removes a specific amount of items
+ *
+ * _(Uses chunking to avoid call stack size being exceeded)_
+ *
  * @param array Original array
  * @param start Index to start splicing from
  * @param amount Number of items to remove
  * @param added Added items
  * @returns Removed items
+ *
+ * @example
+ * ```typescript
+ * splice(
+ *   [1, 2, 3, 4, 5],
+ *   2,
+ *   2,
+ *   [6, 7]
+ * ); // => [3, 4], array becomes [1, 2, 6, 7, 5]
+ * ```
  */
 declare function splice<Item>(array: Item[], start: number, amount: number, added: Item[]): Item[];
 /**
  * Adds items into an array at a specific index
+ *
+ * _(Uses chunking to avoid call stack size being exceeded)_
+ *
  * @param array Original array
  * @param start Index to start splicing from
  * @param added Added items
  * @returns Removed items
+ *
+ * @example
+ * ```typescript
+ * splice(
+ *   [1, 2, 3, 4, 5],
+ *   2,
+ *   [6, 7]
+ * ); // => [], array becomes [1, 2, 6, 7, 3, 4, 5]
+ * ```
  */
 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
+ *
+ * _(Uses chunking to avoid call stack size being exceeded)_
+ *
  * @param array Original array
  * @param start Index to start splicing from
  * @param amount Number of items to remove
  * @returns Removed items
+ *
+ * @example
+ * ```typescript
+ * splice(
+ *   [1, 2, 3, 4, 5],
+ *   2,
+ *   2,
+ * ); // => [3, 4], array becomes [1, 2, 5]
+ * ```
  */
 declare function splice<Item>(array: Item[], start: number, amount: number): Item[];
 /**
  * Removes and returns all items from an array starting from a specific index
+ *
+ * _(Uses chunking to avoid call stack size being exceeded)_
+ *
  * @param array Original array
  * @param start Index to start splicing from
  * @returns Removed items
+ *
+ * @example
+ * ```typescript
+ * splice(
+ *   [1, 2, 3, 4, 5],
+ *   2,
+ * ); // => [3, 4, 5], array becomes [1, 2]
+ * ```
  */
 declare function splice<Item>(array: Item[], start: number): Item[];
 //#endregion
 //#region src/array/to-set.d.ts
 /**
  * Create a Set from an array of items using a callback
+ *
  * @param array Array to convert
  * @param callback Callback to get an item's value
  * @returns Set of values
+ *
+ * @example
+ * ```typescript
+ * toSet(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id,
+ * ); // => Set { 1, 2, 3 }
+ * ```
  */
 declare function toSet<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback): Set<ReturnType<Callback>>;
 /**
  * Create a Set from an array of items using a key
+ *
  * @param array Array to convert
  * @param key Key to use for value
  * @returns Set of values
+ *
+ * @example
+ * ```typescript
+ * toSet(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   'id',
+ * ); // => Set { 1, 2, 3 }
+ * ```
  */
 declare function toSet<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Set<Item[ItemKey]>;
 /**
  * Create a Set from an array of items
+ *
  * @param array Array to convert
  * @returns Set of items
+ *
+ * @example
+ * ```typescript
+ * toSet([1, 2, 3]); // => Set { 1, 2, 3 }
+ * ```
  */
 declare function toSet<Item>(array: Item[]): Set<Item>;
 //#endregion
 //#region src/array/toggle.d.ts
 /**
- * Toggle an item in an array: if the item exists, it will be removed; if it doesn't, it will be added
+ * Toggle an item in an array
+ *
+ * If the item exists, it will be removed; if it doesn't, it will be added
+ *
  * @param destination Array to toggle within
  * @param toggled Toggled items
  * @param callback Callback to find existing item
  * @returns Original array
+ *
+ * @example
+ * ```typescript
+ * toggle(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   [{id: 2}, {id: 4}],
+ *   item => item.id,
+ * ); // => [{id: 1}, {id: 3}, {id: 4}]
+ * ```
  */
 declare function toggle<Item>(destination: Item[], toggled: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
 /**
- * Toggle an item in an array: if the item exists, it will be removed; if it doesn't, it will be added
+ * Toggle an item in an array
+ *
+ * If the item exists, it will be removed; if it doesn't, it will be added
+ *
  * @param destination Array to toggle within
  * @param toggled Toggled items
  * @param key Key to find existing item
  * @returns Original array
+ *
+ * @example
+ * ```typescript
+ * toggle(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   [{id: 2}, {id: 4}],
+ *   'id',
+ * ); // => [{id: 1}, {id: 3}, {id: 4}]
+ * ```
  */
 declare function toggle<Item extends PlainObject, ItemKey extends keyof Item>(destination: Item[], toggled: Item[], key: ItemKey): Item[];
 /**
- * Toggle an item in an array: if the item exists, it will be removed; if it doesn't, it will be added
+ * Toggle an item in an array
+ *
+ * If the item exists, it will be removed; if it doesn't, it will be added
+ *
  * @param destination Array to toggle within
  * @param toggled Toggled items
  * @returns Original array
+ *
+ * @example
+ * ```typescript
+ * toggle(
+ *   [1, 2, 3],
+ *   [2, 4],
+ * ); // => [1, 3, 4]
+ * ```
  */
 declare function toggle<Item>(destination: Item[], toggled: Item[]): Item[];
 //#endregion
 //#region src/array/union.d.ts
 /**
  * Get the combined, unique values from two arrays
+ *
  * @param first First array
  * @param second Second array
  * @param callback Callback to get an item's value for comparison
  * @returns Combined, unique values from both arrays
+ *
+ * @example
+ * ```typescript
+ * union(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   [{id: 2}, {id: 4}],
+ *   item => item.id,
+ * ); // => [{id: 1}, {id: 2}, {id: 3}, {id: 4}]
+ * ```
  */
 declare function union<First, Second>(first: First[], second: Second[], callback: (item: First | Second) => unknown): (First | Second)[];
 /**
  * Get the combined, unique values from two arrays
+ *
  * @param first First array
  * @param second Second array
  * @param key Key to get an item's value for comparison
  * @returns Combined, unique values from both arrays
+ *
+ * @example
+ * ```typescript
+ * union(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   [{id: 2}, {id: 4}],
+ *   'id',
+ * ); // => [{id: 1}, {id: 2}, {id: 3}, {id: 4}]
+ * ```
  */
 declare function union<First extends Record<string, unknown>, Second extends Record<string, unknown>, SharedKey extends keyof First & keyof Second>(first: First[], second: Second[], key: SharedKey): (First | Second)[];
 /**
  * Get the combined, unique values from two arrays
+ *
  * @param first First array
  * @param second Second array
  * @returns Combined, unique values from both arrays
+ *
+ * @example
+ * ```typescript
+ * union(
+ *   [1, 2, 3],
+ *   [2, 4],
+ * ); // => [1, 2, 3, 4]
+ * ```
  */
 declare function union<First, Second>(first: First[], second: Second[]): (First | Second)[];
 //#endregion
 //#region src/array/unique.d.ts
 /**
  * Get an array of unique items
+ *
  * @param array Original array
  * @param callback Callback to get an item's value
  * @returns Array of unique items
+ *
+ * @example
+ * ```typescript
+ * unique(
+ *   [{id: 1}, {id: 2}, {id: 3}, {id: 2}],
+ *   item => item.id,
+ * ); // => [{id: 1}, {id: 2}, {id: 3}]
+ * ```
  */
 declare function unique<Item>(array: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
 /**
  * Get an array of unique items
+ *
  * @param array Original array
  * @param key Key to use for unique value
  * @returns Array of unique items
+ *
+ * @example
+ * ```typescript
+ * unique(
+ *   [{id: 1}, {id: 2}, {id: 3}, {id: 2}],
+ *   'id',
+ * ); // => [{id: 1}, {id: 2}, {id: 3}]
+ * ```
  */
 declare function unique<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Item[];
 /**
  * Get an array of unique items
+ *
  * @param array Original array
  * @returns Array of unique items
+ *
+ * @example
+ * ```typescript
+ * unique([1, 2, 3, 2]); // => [1, 2, 3]
+ * ```
  */
 declare function unique<Item>(array: Item[]): Item[];
 //#endregion
 //#region src/array/update.d.ts
 /**
- * Update an item in an array: if the item exists, it will be updated; if it doesn't, it will be added
+ * Update an item in an array
+ *
+ * If the item exists, it will be updated; if it doesn't, it will be added
+ *
  * @param destination Array to update within
  * @param updated Updated items
  * @param callback Callback to find existing item
  * @returns Original array
+ *
+ * @example
+ * ```typescript
+ * update(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   [{id: 2, name: 'Updated'}, {id: 4, name: 'New'}],
+ *   item => item.id,
+ * ); // => [{id: 1}, {id: 2, name: 'Updated'}, {id: 3}, {id: 4, name: 'New'}]
+ * ```
  */
 declare function update<Item>(destination: Item[], updated: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
 /**
- * Update an item in an array: if the item exists, it will be updated; if it doesn't, it will be added
+ * Update an item in an array
+ *
+ * If the item exists, it will be updated; if it doesn't, it will be added
+ *
  * @param destination Array to update within
  * @param updated Updated items
  * @param key Key to find existing item
  * @returns Original array
+ *
+ * @example
+ * ```typescript
+ * update(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   [{id: 2, name: 'Updated'}, {id: 4, name: 'New'}],
+ *   'id',
+ * ); // => [{id: 1}, {id: 2, name: 'Updated'}, {id: 3}, {id: 4, name: 'New'}]
+ * ```
  */
 declare function update<Item extends PlainObject, ItemKey extends keyof Item>(destination: Item[], updated: Item[], key: ItemKey): Item[];
 /**
- * Update an item in an array: if the item exists, it will be updated; if it doesn't, it will be added
+ * Update an item in an array
+ *
+ * If the item exists, it will be updated; if it doesn't, it will be added
+ *
  * @param destination Array to update within
  * @param updated Updated items
  * @returns Original array
+ *
+ * @example
+ * ```typescript
+ * update(
+ *   [1, 2, 3],
+ *   [2, 4],
+ * ); // => [1, 2, 3, 4]
+ * ```
  */
 declare function update<Item>(destination: Item[], updated: Item[]): Item[];
 //#endregion
 //#region src/array/last.d.ts
 /**
  * Get the last items matching the given value
+ *
  * @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
+ *
+ * @example
+ * ```typescript
+ * last(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value,
+ *   10,
+ * ); // => {id: 3, value: 10}
+ * ```
  */
 declare function last<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item | undefined;
 /**
  * Get the first item matching the given value by key
+ *
  * @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
+ *
+ * @example
+ * ```typescript
+ * last(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   'value',
+ *   10,
+ * ); // => {id: 3, value: 10}
+ * ```
  */
 declare function last<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): Item | undefined;
 /**
  * Get the last item matching the filter
+ *
  * @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
+ *
+ * @example
+ * ```typescript
+ * last(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value === 10,
+ * ); // => {id: 3, value: 10}
+ * ```
  */
 declare function last<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): Item | undefined;
 /**
  * Get the last item from an array
+ *
  * @param array Array to get from
- * @return Last item from the array, or `undefined` if the array is empty
+ * @returns Last item from the array, or `undefined` if the array is empty
+ *
+ * @example
+ * ```typescript
+ * last([1, 2, 3]); // => 3
+ * ```
  */
 declare function last<Item>(array: Item[]): Item | undefined;
 declare namespace last {
@@ -1341,41 +2578,79 @@ 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
  * @param value Value to match against
  * @returns Last item that matches the value, or the default value if no match is found
+ *
+ * @example
+ * ```typescript
+ * lastOrDefault(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   {id: -1, value: 30},
+ *   item => item.value,
+ *   30,
+ * ); // => {id: -1, value: 30}
+ * ```
  */
 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
  * @param value Value to match against
  * @returns Last item that matches the value, or the default value if no match is found
+ *
+ * @example
+ * ```typescript
+ * lastOrDefault(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   {id: -1, value: 30},
+ *   'value',
+ *   30,
+ * ); // => {id: -1, value: 30}
+ * ```
  */
 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
  * @returns Last item that matches the filter, or the default value if no match is found
+ *
+ * @example
+ * ```typescript
+ * lastOrDefault(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   {id: -1, value: 30},
+ *   item => item.value === 30,
+ * ); // => {id: -1, value: 30}
+ * ```
  */
 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
+ * @returns Last item from the array, or the default value if the array is empty
+ *
+ * @example
+ * ```typescript
+ * lastOrDefault([], {id: -1, value: 30}); // => {id: -1, value: 30}
+ * ```
  */
 declare function lastOrDefault<Item>(array: Item[], defaultValue: Item): Item;
 //#endregion
@@ -1386,36 +2661,66 @@ declare function lastOrDefault<Item>(array: Item[], defaultValue: Item): Item;
  * When moving to the front of the array, the moved items will be placed __before__ the target item. When moving to the back of the array, the moved items will be placed __after__ the target item.
  *
  * If either of values are not present in the array, or if they overlap, the array will be returned unchanged
+ *
  * @param array Array to move within
  * @param from Item or items to move
  * @param to Item or items to move to
- * @param key Key to get an item's value for matching
+ * @param callback Callback to get an item's value for matching
  * @returns Original array with items moved _(or unchanged if unable to move)_
+ *
+ * @example
+ * ```typescript
+ * const array = [{id: 1}, {id: 2}, {id: 3}, {id: 4}];
+ *
+ * move(array, {id: 1}, {id: 3}, item => item.id);            // => [{id: 2}, {id: 3}, {id: 1}, {id: 4}]
+ * move(array, [{id: 2}, {id: 3}], {id: 4}, item => item.id); // => [{id: 1}, {id: 4}, {id: 2}, {id: 3}]
+ * move(array, {id: 5}, {id: 1}, item => item.id);            // => [{id: 1}, {id: 2}, {id: 3}, {id: 4}] (unchanged)
+ * ```
  */
-declare function move<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], from: Item | Item[], to: Item | Item[], key: ItemKey): Item[];
+declare function move<Item>(array: Item[], from: Item | Item[], to: Item | Item[], callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
 /**
  * Move an item _(or array of items)_ to the position of another item _(or array of items)_ within an array
  *
  * When moving to the front of the array, the moved items will be placed __before__ the target item. When moving to the back of the array, the moved items will be placed __after__ the target item.
  *
  * If either of values are not present in the array, or if they overlap, the array will be returned unchanged
+ *
  * @param array Array to move within
  * @param from Item or items to move
  * @param to Item or items to move to
- * @param callback Callback to get an item's value for matching
+ * @param key Key to get an item's value for matching
  * @returns Original array with items moved _(or unchanged if unable to move)_
+ *
+ * @example
+ * ```typescript
+ * const array = [{id: 1}, {id: 2}, {id: 3}, {id: 4}];
+ *
+ * move(array, {id: 1}, {id: 3}, 'id');            // => [{id: 2}, {id: 3}, {id: 1}, {id: 4}]
+ * move(array, [{id: 2}, {id: 3}], {id: 4}, 'id'); // => [{id: 1}, {id: 4}, {id: 2}, {id: 3}]
+ * move(array, {id: 5}, {id: 1}, 'id');            // => [{id: 1}, {id: 2}, {id: 3}, {id: 4}] (unchanged)
+ * ```
  */
-declare function move<Item>(array: Item[], from: Item | Item[], to: Item | Item[], callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
+declare function move<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], from: Item | Item[], to: Item | Item[], key: ItemKey): Item[];
 /**
  * Move an item _(or array of items)_ to the position of another item _(or array of items)_ within an array
  *
  * When moving to the front of the array, the moved items will be placed __before__ the target item. When moving to the back of the array, the moved items will be placed __after__ the target item.
  *
  * If either of values are not present in the array, or if they overlap, the array will be returned unchanged
+ *
  * @param array Array to move within
  * @param from Item or items to move
  * @param to Item or items to move to
  * @returns Original array with items moved _(or unchanged if unable to move)_
+ *
+ * @example
+ * ```typescript
+ * const array = [1, 2, 3, 4];
+ *
+ * move(array, 1, 3);      // => [2, 3, 1, 4]
+ * move(array, [2, 3], 4); // => [1, 4, 2, 3]
+ * move(array, 5, 1);      // => [1, 2, 3, 4] (unchanged)
+ * ```
  */
 declare function move<Item>(array: Item[], from: Item | Item[], to: Item | Item[]): Item[];
 declare namespace move {
@@ -1428,10 +2733,20 @@ declare namespace move {
  * 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
  * @returns Original array with item moved _(or unchanged if unable to move)_
+ *
+ * @example
+ * ```typescript
+ * const array = [1, 2, 3, 4];
+ *
+ * moveIndices(array, 0, 2);  // => [2, 3, 1, 4]
+ * moveIndices(array, -1, 0); // => [4, 2, 3, 1]
+ * moveIndices(array, 5, 1);  // => [4, 2, 3, 1] (unchanged)
+ * ```
  */
 declare function moveIndices<Item>(array: Item[], from: number, to: number): Item[];
 /**
@@ -1440,36 +2755,66 @@ declare function moveIndices<Item>(array: Item[], from: number, to: number): Ite
  * 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`
+ *
+ * @example
+ * ```typescript
+ * const array = [{id: 1}, {id: 2}, {id: 3}, {id: 4}];
+ *
+ * moveToIndex(array, {id: 1}, 2, item => item.id);            // => [{id: 2}, {id: 3}, {id: 1}, {id: 4}]
+ * moveToIndex(array, [{id: 2}, {id: 3}], 3, item => item.id); // => [{id: 1}, {id: 4}, {id: 2}, {id: 3}]
+ * moveToIndex(array, {id: 5}, 1, item => item.id);            // => [{id: 1}, {id: 2}, {id: 3}, {id: 4}] (unchanged)
+ * ```
+ *
  * @param array Array to move within
  * @param value Item or items to move
  * @param index Index to move to
- * @param key Key to get an item's value for matching
+ * @param callback Callback to get an item's value for matching
  * @returns Original array with items moved _(or unchanged if unable to move)_
  */
-declare function moveToIndex<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], value: Item | Item[], index: number, key: ItemKey): Item[];
+declare function moveToIndex<Item>(array: Item[], value: Item | Item[], index: number, callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
 /**
  * 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
- * @param callback Callback to get an item's value for matching
+ * @param key Key to get an item's value for matching
  * @returns Original array with items moved _(or unchanged if unable to move)_
+ *
+ * @example
+ * ```typescript
+ * const array = [{id: 1}, {id: 2}, {id: 3}, {id: 4}];
+ *
+ * moveToIndex(array, {id: 1}, 2, 'id');            // => [{id: 2}, {id: 3}, {id: 1}, {id: 4}]
+ * moveToIndex(array, [{id: 2}, {id: 3}], 3, 'id'); // => [{id: 1}, {id: 4}, {id: 2}, {id: 3}]
+ * moveToIndex(array, {id: 5}, 1, 'id');            // => [{id: 1}, {id: 2}, {id: 3}, {id: 4}] (unchanged)
+ * ```
  */
-declare function moveToIndex<Item>(array: Item[], value: Item | Item[], index: number, callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
+declare function moveToIndex<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], value: Item | Item[], index: number, key: ItemKey): Item[];
 /**
  * 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
  * @returns Original array with items moved _(or unchanged if unable to move)_
+ *
+ * @example
+ * ```typescript
+ * const array = [1, 2, 3, 4];
+ *
+ * moveToIndex(array, 1, 2);      // => [2, 3, 1, 4]
+ * moveToIndex(array, [2, 3], 3); // => [1, 4, 2, 3]
+ * moveToIndex(array, 5, 1);      // => [1, 2, 3, 4] (unchanged)
+ * ```
  */
 declare function moveToIndex<Item>(array: Item[], value: Item | Item[], index: number): Item[];
 //#endregion
@@ -1546,6 +2891,7 @@ type SortDirection = 'ascending' | 'descending';
 type Sorter<Item> = {
   /**
    * Sort an array of items
+   *
    * @param array Array to sort
    * @returns Sorted array
    */
@@ -1554,6 +2900,7 @@ type Sorter<Item> = {
    * Get the index for an item _(to be inserted into an array of items)_
    *
    * _(If the array is not sorted, it will be treated as sorted, and the result may be inaccurate)_
+   *
    * @param array Array to get the index from
    * @param item Item to get the index for
    * @returns Index for item
@@ -1561,6 +2908,7 @@ type Sorter<Item> = {
   index(array: Item[], item: Item): number;
   /**
    * Is the array sorted?
+   *
    * @param array Array to check
    * @returns `true` if sorted, otherwise `false`
    */
@@ -1572,6 +2920,7 @@ type Sorter<Item> = {
  * _(If the array is not sorted, it will be treated as sorted, and the result may be inaccurate)_
  *
  * Available as `getSortedIndex` and `sort.getIndex`
+ *
  * @param array Array to get the index from
  * @param item Item to get the index for
  * @param sorters Sorters to use to determine sorting
@@ -1585,6 +2934,7 @@ declare function getSortedIndex<Item>(array: Item[], item: Item, sorters: Array<
  * _(If the array is not sorted, it will be treated as sorted, and the result may be inaccurate)_
  *
  * Available as `getSortedIndex` and `sort.getIndex`
+ *
  * @param array Array to get the index from
  * @param item Item to get the index for
  * @param sorter Sorter to use to determine sorting
@@ -1598,6 +2948,7 @@ declare function getSortedIndex<Item>(array: Item[], item: Item, sorter: ArraySo
  * _(If the array is not sorted, it will be treated as sorted, and the result may be inaccurate)_
  *
  * Available as `getSortedIndex` and `sort.getIndex`
+ *
  * @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`)_
@@ -1608,6 +2959,7 @@ declare function getSortedIndex<Item>(array: Item[], item: Item, descending?: bo
  * 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
@@ -1617,6 +2969,7 @@ declare function initializeSorter<Item>(sorters: Array<ArraySorter<Item>>, desce
  * 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
@@ -1626,12 +2979,14 @@ declare function initializeSorter<Item>(sorter: ArraySorter<Item>, descending?:
  * 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 initializeSorter<Item>(descending?: boolean): Sorter<Item>;
 /**
  * Is the array sorted according to the sorters _(and the optional default direction)_?
+ *
  * @param array Array to check
  * @param sorters Sorters to determine sorting
  * @param descending Sorted in descending order? _(defaults to `false`; overridden by individual sorters)_
@@ -1640,6 +2995,7 @@ declare function initializeSorter<Item>(descending?: boolean): Sorter<Item>;
 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)_?
+ *
  * @param array Array to check
  * @param sorter Sorter to determine sorting
  * @param descending Sorted in descending order? _(defaults to `false`; overridden by individual sorters)_
@@ -1650,6 +3006,7 @@ declare function isSorted<Item>(array: Item[], sorter: ArraySorter<Item>, descen
  * 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`
@@ -1657,10 +3014,19 @@ declare function isSorted<Item>(array: Item[], sorter: ArraySorter<Item>, descen
 declare function isSorted<Item>(array: Item[], descending?: boolean): boolean;
 /**
  * Sort an array of items using a comparison callback
+ *
  * @param array Array to sort
  * @param comparator Comparator to use for sorting
  * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Sorted array
+ *
+ * @example
+ * ```typescript
+ * sort(
+ *   [{id: 3}, {id: 1}, {id: 2}],
+ *   (first, second) => first.id - second.id,
+ * ); // => [{id: 1}, {id: 2}, {id: 3}]
+ * ```
  */
 declare function sort<Item>(array: Item[], comparator: (first: Item, second: Item) => number, descending?: boolean): Item[];
 /**
@@ -1699,62 +3065,166 @@ declare const SORT_DIRECTION_DESCENDING: SortDirection;
  * Swap two smaller arrays within a larger array
  *
  * If either of the smaller arrays are not present in the larger array, or if they overlap, the larger array will be returned unchanged
+ *
  * @param array Array of items to swap
  * @param first First array
  * @param second Second array
- * @param key Key to get an item's value for matching
+ * @param callback Callback to get an item's value for matching
  * @returns Original array with items swapped _(or unchanged if unable to swap)_
+ *
+ * @example
+ * ```typescript
+ * swap(
+ *   [
+ *     {id: 1, name: 'Alice'},
+ *     {id: 2, name: 'Bob'},
+ *     {id: 3, name: 'Charlie'},
+ *   ],
+ *   [
+ *     {id: 2, name: 'Bob'},
+ *   ],
+ *   [
+ *     {id: 3, name: 'Charlie'},
+ *   ],
+ *   item => item.id,
+ * ); // => [
+ *    //   {id: 1, name: 'Alice'},
+ *    //   {id: 3, name: 'Charlie'},
+ *    //   {id: 2, name: 'Bob'},
+ *    // ]
+ * ```
  */
-declare function swap<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], first: Item[], second: Item[], key: ItemKey): Item[];
+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
  *
  * If either of the smaller arrays are not present in the larger array, or if they overlap, the larger array will be returned unchanged
+ *
  * @param array Array of items to swap
  * @param first First array
  * @param second Second array
- * @param callback Callback to get an item's value for matching
+ * @param key Key to get an item's value for matching
  * @returns Original array with items swapped _(or unchanged if unable to swap)_
+ *
+ * @example
+ * ```typescript
+ * swap(
+ *   [
+ *     {id: 1, name: 'Alice'},
+ *     {id: 2, name: 'Bob'},
+ *     {id: 3, name: 'Charlie'},
+ *   ],
+ *   [
+ *     {id: 2, name: 'Bob'},
+ *   ],
+ *   [
+ *     {id: 3, name: 'Charlie'},
+ *   ],
+ *   'id',
+ * ); // => [
+ *    //   {id: 1, name: 'Alice'},
+ *    //   {id: 3, name: 'Charlie'},
+ *    //   {id: 2, name: 'Bob'},
+ *    // ]
+ * ```
  */
-declare function swap<Item>(array: Item[], first: Item[], second: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
+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
  *
  * If either of the smaller arrays are not present in the larger array, or if they overlap, the larger array will be returned unchanged
+ *
  * @param array Array of items to swap
  * @param first First array
  * @param second Second array
  * @returns Original array with items swapped _(or unchanged if unable to swap)_
+ *
+ * @example
+ * ```typescript
+ * swap(
+ *   [1, 2, 3, 4, 5, 6],
+ *   [1, 2],
+ *   [5, 6],
+ * ); // => [5, 6, 3, 4, 1, 2]
+ * ```
  */
 declare function swap<Item>(array: Item[], first: Item[], second: Item[]): Item[];
 /**
  * Swap two indiced items in an array
  *
  * If either of the items are not present in the array, the array will be returned unchanged
+ *
  * @param array Array of items to swap
  * @param first First item
  * @param second Second item
- * @param key Key to get an item's value for matching
+ * @param callback Callback to get an item's value for matching
  * @returns Original array with items swapped _(or unchanged if unable to swap)_
+ *
+ * @example
+ * ```typescript
+ * swap(
+ *   [
+ *     {id: 1, name: 'Alice'},
+ *     {id: 2, name: 'Bob'},
+ *     {id: 3, name: 'Charlie'},
+ *   ],
+ *   {id: 2, name: 'Bob'},
+ *   {id: 3, name: 'Charlie'},
+ *   item => item.id,
+ * ); // => [
+ *    //   {id: 1, name: 'Alice'},
+ *    //   {id: 3, name: 'Charlie'},
+ *    //   {id: 2, name: 'Bob'},
+ *    // ]
+ * ```
  */
-declare function swap<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], first: Item, second: Item, key: ItemKey): Item[];
+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
  *
  * If either of the items are not present in the array, the array will be returned unchanged
+ *
  * @param array Array of items to swap
  * @param first First item
  * @param second Second item
- * @param callback Callback to get an item's value for matching
+ * @param key Key to get an item's value for matching
  * @returns Original array with items swapped _(or unchanged if unable to swap)_
+ *
+ * @example
+ * ```typescript
+ * swap(
+ *   [
+ *     {id: 1, name: 'Alice'},
+ *     {id: 2, name: 'Bob'},
+ *     {id: 3, name: 'Charlie'},
+ *   ],
+ *   {id: 2, name: 'Bob'},
+ *   {id: 3, name: 'Charlie'},
+ *   'id',
+ * ); // => [
+ *    //   {id: 1, name: 'Alice'},
+ *    //   {id: 3, name: 'Charlie'},
+ *    //   {id: 2, name: 'Bob'},
+ *    // ]
+ * ```
  */
-declare function swap<Item>(array: Item[], first: Item, second: Item, callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
+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
+ *
  * @param array Array of items to swap
  * @param first First item
  * @param second Second item
  * @returns Original array with items swapped _(or unchanged if unable to swap)_
+ *
+ * @example
+ * ```typescript
+ * swap(
+ *   [1, 2, 3, 4, 5, 6],
+ *   2,
+ *   5,
+ * ); // => [1, 5, 3, 4, 2, 6]
+ * ```
  */
 declare function swap<Item>(array: Item[], first: Item, second: Item): Item[];
 declare namespace swap {
@@ -1766,6 +3236,7 @@ declare namespace swap {
  * 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)_
@@ -1778,64 +3249,130 @@ declare function swapIndices<Item>(array: Item[], first: number, second: number)
  * Create a Map from an array of items using callbacks
  *
  * If multiple items have the same key, the latest item's value will be used
+ *
  * @param array Array to convert
  * @param key Callback to get an item's grouping key
  * @param value Callback to get an item's value
  * @returns Map of keyed values
+ *
+ * @example
+ * ```typescript
+ * toMap(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value,
+ *   item => item.id,
+ * ); // => Map { 10 => 3, 20 => 2 }
+ * ```
  */
 declare function toMap<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, 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
  *
  * If multiple items have the same key, the latest item's value will be used
+ *
  * @param array Array to convert
  * @param key Callback to get an item's grouping key
  * @param value Key to use for value
  * @returns Map of keyed values
+ *
+ * @example
+ * ```typescript
+ * toMap(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value,
+ *   'id',
+ * ); // => Map { 10 => 3, 20 => 2 }
+ * ```
  */
 declare function toMap<Item extends PlainObject, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, 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
  *
  * If multiple items have the same key, the latest item's value will be used
+ *
  * @param array Array to convert
  * @param key Key to use for grouping
  * @param value Callback to get an item's value
  * @returns Map of keyed values
+ *
+ * @example
+ * ```typescript
+ * toMap(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   'value',
+ *   item => item.id,
+ * ); // => Map { 10 => 3, 20 => 2 }
+ * ```
  */
 declare function toMap<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
  *
  * If multiple items have the same key, the latest item's value will be used
+ *
  * @param array Array to convert
  * @param key Key to use for grouping
  * @param value Key to use for value
  * @returns Map of keyed values
+ *
+ * @example
+ * ```typescript
+ * toMap(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   'value',
+ *   'id',
+ * ); // => Map { 10 => 3, 20 => 2 }
+ * ```
  */
 declare function toMap<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
  *
  * If multiple items have the same key, the latest item will be used
+ *
  * @param array Array to convert
  * @param callback Callback to get an item's grouping key
  * @returns Map of keyed items
+ *
+ * @example
+ * ```typescript
+ * toMap(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value,
+ * ); // => Map { 10 => {id: 3, value: 10}, 20 => {id: 2, value: 20} }
+ * ```
  */
 declare function toMap<Item, Callback extends (item: Item, index: number, array: Item[]) => Key$1>(array: Item[], callback: Callback): Map<ReturnType<Callback>, Item>;
 /**
  * Create a Map from an array of items using a key
  *
  * If multiple items have the same key, the latest item will be used
+ *
  * @param array Array to convert
  * @param key Key to use for grouping
  * @returns Map of keyed items
+ *
+ * @example
+ * ```typescript
+ * toMap(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   'value',
+ * ); // => Map { 10 => {id: 3, value: 10}, 20 => {id: 2, value: 20} }
+ * ```
  */
 declare function toMap<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Map<Item[ItemKey], Item>;
 /**
  * Create a Map from an array of items _(using indices as keys)_
+ *
  * @param array Array to convert
  * @returns Map of indiced items
+ *
+ * @example
+ * ```typescript
+ * toMap(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ * ); // => Map { 0 => {id: 1, value: 10}, 1 => {id: 2, value: 20}, 2 => {id: 3, value: 10} }
+ * ```
  */
 declare function toMap<Item>(array: Item[]): Map<number, Item>;
 declare namespace toMap {
@@ -1845,58 +3382,116 @@ 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
  * @returns Map of keyed arrays of values
+ *
+ * @example
+ * ```typescript
+ * toMapArrays(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value,
+ *   item => item.id,
+ * ); // => Map { 10 => [1, 3], 20 => [2] }
+ * ```
  */
 declare function toMapArrays<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, 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
  * @returns Map of keyed arrays of values
+ *
+ * @example
+ * ```typescript
+ * toMapArrays(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value,
+ *   'id',
+ * ); // => Map { 10 => [1, 3], 20 => [2] }
+ * ```
  */
 declare function toMapArrays<Item extends PlainObject, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, 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
  * @returns Map of keyed arrays of values
+ *
+ * @example
+ * ```typescript
+ * toMapArrays(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   'value',
+ *   item => item.id,
+ * ); // => Map { 10 => [1, 3], 20 => [2] }
+ * ```
  */
 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
  * @returns Map of keyed arrays of values
+ *
+ * @example
+ * ```typescript
+ * toMapArrays(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   'value',
+ *   'id',
+ * ); // => Map { 10 => [1, 3], 20 => [2] }
+ * ```
  */
 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
+ *
+ * @example
+ * ```typescript
+ * toMapArrays(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value,
+ * ); // => Map { 10 => [{id: 1, value: 10}, {id: 3, value: 10}], 20 => [{id: 2, value: 20}] }
+ * ```
  */
 declare function toMapArrays<Item, Callback extends (item: Item, index: number, array: Item[]) => Key$1>(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
+ *
+ * @example
+ * ```typescript
+ * toMapArrays(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   'value',
+ * ); // => Map { 10 => [{id: 1, value: 10}, {id: 3, value: 10}], 20 => [{id: 2, value: 20}] }
+ * ```
  */
 declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Map<Item[ItemKey], Item[]>;
 //#endregion
@@ -1905,64 +3500,130 @@ declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Ite
  * Create a record from an array of items using callbacks
  *
  * If multiple items have the same key, the latest item will be used
+ *
  * @param array Array to convert
  * @param key Callback to get an item's grouping key
  * @param value Callback to get an item's value
  * @returns Record of keyed values
+ *
+ * @example
+ * ```typescript
+ * toRecord(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value,
+ *   item => item.id,
+ * ); // => { 10: 3, 20: 2 }
+ * ```
  */
 declare function toRecord<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, 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 callback and value
  *
  * If multiple items have the same key, the latest item will be used
+ *
  * @param array Array to convert
  * @param callback Callback to get an item's grouping key
  * @param value Key to use for value
  * @returns Record with keys
+ *
+ * @example
+ * ```typescript
+ * toRecord(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value,
+ *   'id',
+ * ); // => { 10: 3, 20: 2 }
+ * ```
  */
 declare function toRecord<Item extends PlainObject, Callback extends (item: Item, index: number, array: Item[]) => Key$1, ItemValue extends keyof Item>(array: Item[], callback: Callback, value: ItemValue): Record<ReturnType<Callback>, Item[ItemValue]>;
 /**
  * Create a record from an array of items using a key and callback
  *
  * If multiple items have the same key, the latest item will be used
+ *
  * @param array Array to convert
  * @param key Key to use for grouping
  * @param callback Callback to get an item's value
  * @returns Record with keys
+ *
+ * @example
+ * ```typescript
+ * toRecord(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   'value',
+ *   item => item.id,
+ * ); // => { 10: 3, 20: 2 }
+ * ```
  */
 declare function toRecord<Item extends PlainObject, ItemKey extends keyof Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, callback: Callback): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<Callback>>>;
 /**
  * Create a record from an array of items using a key and value
  *
  * If multiple items have the same key, the latest item will be used
+ *
  * @param array Array to convert
  * @param key Key to use for grouping
  * @param value Key to use for value
  * @returns Record of keyed values
+ *
+ * @example
+ * ```typescript
+ * toRecord(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   'value',
+ *   'id',
+ * ); // => { 10: 3, 20: 2 }
+ * ```
  */
 declare function toRecord<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 callback
  *
  * If multiple items have the same key, the latest item will be used
+ *
  * @param array Array to convert
  * @param callback Callback to get an item's grouping key
  * @returns Record of keyed values
+ *
+ * @example
+ * ```typescript
+ * toRecord(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value,
+ * ); // => { 10: {id: 3, value: 10}, 20: {id: 2, value: 20} }
+ * ```
  */
 declare function toRecord<Item, Callback extends (item: Item, index: number, array: Item[]) => Key$1>(array: Item[], callback: Callback): Record<ReturnType<Callback>, Item>;
 /**
  * Create a record from an array of items using a key
  *
  * If multiple items have the same key, the latest item will be used
+ *
  * @param array Array to convert
  * @param key Key to use for grouping
  * @returns Record of keyed values
+ *
+ * @example
+ * ```typescript
+ * toRecord(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   'value',
+ * ); // => { 10: {id: 3, value: 10}, 20: {id: 2, value: 20} }
+ * ```
  */
 declare function toRecord<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item>>;
 /**
  * Create a record from an array of items _(using indices as keys)_
+ *
  * @param array Array to convert
  * @returns Record of indiced values
+ *
+ * @example
+ * ```typescript
+ * toRecord(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ * ); // => { 0: {id: 1, value: 10}, 1: {id: 2, value: 20}, 2: {id: 3, value: 10} }
+ * ```
  */
 declare function toRecord<Item>(array: Item[]): Record<number, Item>;
 declare namespace toRecord {
@@ -1972,58 +3633,116 @@ declare namespace toRecord {
  * Create a record from an array of items using callbacks, grouping values into arrays
  *
  * Available as `toRecordArrays` and `toRecord.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
  * @returns Record of keyed arrays of values
+ *
+ * @example
+ * ```typescript
+ * toRecordArrays(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value,
+ *   item => item.id,
+ * ); // => { 10: [1, 3], 20: [2] }
+ * ```
  */
 declare function toRecordArrays<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, 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 callback and value, grouping values into arrays
  *
  * Available as `toRecordArrays` and `toRecord.arrays`
+ *
  * @param array Array to convert
  * @param callback Callback to get an item's grouping key
  * @param value Key to use for value
  * @returns Record of keyed arrays of values
+ *
+ * @example
+ * ```typescript
+ * toRecordArrays(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value,
+ *   'id',
+ * ); // => { 10: [1, 3], 20: [2] }
+ * ```
  */
 declare function toRecordArrays<Item extends PlainObject, Callback extends (item: Item, index: number, array: Item[]) => Key$1, ItemValue extends keyof Item>(array: Item[], callback: Callback, value: ItemValue): Record<ReturnType<Callback>, Item[ItemValue][]>;
 /**
  * Create a record from an array of items using a key and callback, grouping values into arrays
  *
  * Available as `toRecordArrays` and `toRecord.arrays`
+ *
  * @param array Array to convert
  * @param key Key to use for grouping
  * @param callback Callback to get an item's value
  * @returns Record of keyed arrays of values
+ *
+ * @example
+ * ```typescript
+ * toRecordArrays(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   'value',
+ *   item => item.id,
+ * ); // => { 10: [1, 3], 20: [2] }
+ * ```
  */
 declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, callback: Callback): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<Callback>[]>>;
 /**
  * Create a record from an array of items using a key and value, grouping values into arrays
  *
  * Available as `toRecordArrays` and `toRecord.arrays`
+ *
  * @param array Array to convert
  * @param key Key to use for grouping
  * @param value Key to use for value
  * @returns Record of keyed arrays of values
+ *
+ * @example
+ * ```typescript
+ * toRecordArrays(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   'value',
+ *   'id',
+ * ); // => { 10: [1, 3], 20: [2] }
+ * ```
  */
 declare function toRecordArrays<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 callback, grouping items into arrays
  *
  * Available as `toRecordArrays` and `toRecord.arrays`
+ *
  * @param array Array to convert
  * @param callback Callback to get an item's grouping key
  * @returns Record of keyed arrays of items
+ *
+ * @example
+ * ```typescript
+ * toRecordArrays(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value,
+ * ); // => { 10: [{id: 1, value: 10}, {id: 3, value: 10}], 20: [{id: 2, value: 20}] }
+ * ```
  */
 declare function toRecordArrays<Item, Callback extends (item: Item, index: number, array: Item[]) => Key$1>(array: Item[], callback: Callback): Record<ReturnType<Callback>, Item[]>;
 /**
  * Create a record from an array of items using a key, grouping items into arrays
  *
  * Available as `toRecordArrays` and `toRecord.arrays`
+ *
  * @param array Array to convert
  * @param key Key to use for grouping
  * @returns Record of keyed arrays of items
+ *
+ * @example
+ * ```typescript
+ * toRecordArrays(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   'value',
+ * ); // => { 10: [{id: 1, value: 10}, {id: 3, value: 10}], 20: [{id: 2, value: 20}] }
+ * ```
  */
 declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
 //#endregion
@@ -2844,16 +4563,38 @@ declare function registerEqualizer<Instance>(constructor: Constructor<Instance>,
 //#region src/internal/value/get.d.ts
 /**
  * Get the value from an object using a known path
+ *
+ * @example
+ * ```typescript
+ * const data = {foo: {bar: {baz: 42}}};
+ *
+ * getValue(data, 'foo');         // {bar: {baz: 42}}
+ * getValue(data, 'foo.bar');     // {baz: 42}
+ * getValue(data, 'foo.bar.baz'); // 42
+ * getValue(data, 'foo.nope');    // undefined
+ * ```
+ *
  * @param data Object to get value from
- * @param path Path for value, e.g., `foo.bar.baz`
+ * @param path Path for value
  * @returns Found value, or `undefined`
  */
 declare function getValue<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path): NestedValue<Data, Path>;
 /**
  * Get the value from an object using an unknown path
+ *
+ * @example
+ * ```typescript
+ * const data = {foo: {bar: {baz: 42}}};
+ *
+ * getValue(data, 'foo');               // {bar: {baz: 42}}
+ * getValue(data, 'foo.bar');           // {baz: 42}
+ * getValue(data, 'Foo.Bar.Baz', true); // 42
+ * getValue(data, 'foo.nope');          // undefined
+ * ```
+ *
  * @param data Object to get value from
- * @param path Path for value, e.g., `foo.bar.baz`
- * @param ignoreCase If `true`, the path matching is case-insensitive
+ * @param path Path for value
+ * @param ignoreCase If `true`, path matching is case-insensitive
  * @returns Found value, or `undefined`
  */
 declare function getValue<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): unknown;
@@ -2863,7 +4604,7 @@ declare function getValue<Data extends PlainObject>(data: Data, path: string, ig
  * Check if a nested property is defined in an object
  * @param data Object to check in
  * @param path Path for property
- * @return `true` if the property exists, `false` otherwise
+ * @returns `true` if the property exists, `false` otherwise
  */
 declare function hasValue<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path): boolean;
 /**
@@ -2871,7 +4612,7 @@ declare function hasValue<Data extends PlainObject, Path extends NestedKeys<Data
  * @param data Object to check in
  * @param path Path for property
  * @param ignoreCase If `true`, the path matching is case-insensitive
- * @return `true` if the property exists, `false` otherwise
+ * @returns `true` if the property exists, `false` otherwise
  */
 declare function hasValue<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): boolean;
 declare namespace hasValue {
@@ -2884,7 +4625,7 @@ declare namespace hasValue {
  * @param data Object to check in
  * @param path Path for property
  * @param ignoreCase If `true`, the path matching is case-insensitive
- * @return Result object
+ * @returns Result object
  */
 declare function hasValueResult<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path, ignoreCase?: boolean): Result<NestedValue<Data, ToString<Path>>, string>;
 /**
@@ -2894,7 +4635,7 @@ declare function hasValueResult<Data extends PlainObject, Path extends NestedKey
  * @param data Object to check in
  * @param path Path for property
  * @param ignoreCase If `true`, the path matching is case-insensitive
- * @return Result object
+ * @returns Result object
  */
 declare function hasValueResult<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): Result<unknown, string>;
 //#endregion
@@ -3358,7 +5099,7 @@ declare function inMap<Value>(map: Map<unknown, Value>, value: Value): boolean;
  * @param map Map to check in
  * @param value Value to check for
  * @param key To return the key for the value
- * @return The key for the value if it exists, otherwise `undefined`
+ * @returns The key for the value if it exists, otherwise `undefined`
  */
 declare function inMap<Key, Value>(map: Map<Key, Value>, value: Value, key: true): Key;
 /**
@@ -3500,10 +5241,6 @@ declare function smush<Value extends PlainObject>(value: Value): Smushed<Value>;
  * Thanks, type-fest!
  */
 type KeysOfUnion<ObjectType> = keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;
-/**
- * Thanks, type-fest!
- */
-type UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends ((mergedIntersection: infer Intersection) => void) ? Intersection & Union : never;
 /**
  * An unsmushed object, with all dot notation keys turned into nested keys
  */
@@ -3520,13 +5257,16 @@ declare function unsmush<Value extends PlainObject>(value: Value): Unsmushed<Val
  * Options for assigning values
  */
 type AssignOptions = Omit<MergeOptions, 'assignValues'>;
-/**
- * Assign values from multiple arrays or objects to the first one
- * @param to Value to assign to
- * @param from Values to assign
- * @returns Assigned value
- */
-type Assigner<Model extends ArrayOrPlainObject = ArrayOrPlainObject> = (to: NestedPartial<Model>, from: NestedPartial<Model>[]) => Model;
+type Assigner = {
+  /**
+   * Assign values from one or more objects to the first one
+   *
+   * @param to Value to assign to
+   * @param from Values to assign
+   * @returns Assigned value
+   */
+  <To extends PlainObject, From extends PlainObject[]>(to: To, from: [...From]): To & UnionToIntersection<From[number]>;
+};
 /**
  * Options for merging values
  */
@@ -3560,20 +5300,24 @@ type MergeOptions = {
    */
   skipNullableInArrays?: boolean;
 };
+type Merger = {
+  /**
+   * Merge multiple arrays or objects into a single one
+   *
+   * @param values Values to merge
+   * @returns Merged value
+   */
+  <Values extends ArrayOrPlainObject[]>(values: NestedPartial<Values[number]>[]): UnionToIntersection<Values[number]>;
+};
 /**
- * Merge multiple arrays or objects into a single one
- * @param values Values to merge
- * @returns Merged value
- */
-type Merger<Model extends ArrayOrPlainObject = ArrayOrPlainObject> = (values: NestedPartial<Model>[]) => Model;
-/**
- * Assign values from multiple arrays or objects to the first one
+ * Assign values from one or more objects to the first one
+ *
  * @param to Value to assign to
  * @param from Values to assign
  * @param options Assigning options
  * @returns Assigned value
  */
-declare function assign<Model extends ArrayOrPlainObject>(to: NestedPartial<Model>, from: NestedPartial<Model>[], options?: AssignOptions): Model;
+declare function assign<To extends PlainObject, From extends PlainObject[]>(to: To, from: [...From], options?: AssignOptions): To & UnionToIntersection<From[number]>;
 declare namespace assign {
   var initialize: typeof initializeAssigner;
 }
@@ -3581,32 +5325,28 @@ declare namespace assign {
  * Create an assigner with predefined options
  *
  * Available as `initializeAssigner` and `assign.initialize`
+ *
  * @param options Assigning options
  * @returns Assigner function
  */
-declare function initializeAssigner<Model extends ArrayOrPlainObject>(options?: AssignOptions): Assigner<Model>;
+declare function initializeAssigner(options?: AssignOptions): Assigner;
 /**
  * Create a merger with predefined options
  *
  * Available as `initializeMerger` and `merge.initialize`
+ *
  * @param options Merging options
  * @returns Merger function
  */
 declare function initializeMerger(options?: MergeOptions): Merger;
 /**
  * Merge multiple arrays or objects into a single one
+ *
  * @param values Values to merge
  * @param options Merging options
  * @returns Merged value
  */
-declare function merge<Model extends ArrayOrPlainObject>(values: NestedPartial<Model>[], options?: MergeOptions): Model;
-/**
- * Merge multiple arrays or objects into a single one
- * @param values Values to merge
- * @param options Merging options
- * @returns Merged value
- */
-declare function merge(values: NestedPartial<ArrayOrPlainObject>[], options?: MergeOptions): ArrayOrPlainObject;
+declare function merge<Values extends ArrayOrPlainObject[]>(values: [...Values], options?: MergeOptions): UnionToIntersection<Values[number]>;
 declare namespace merge {
   var initialize: typeof initializeMerger;
 }
@@ -3639,7 +5379,7 @@ declare function initializeTransformer<Value extends PlainObject>(transform: Tra
  *
  * Available as `initializeTransformer` and `transform.initialize`
  * @param transformers Keyed transformer functions
- * @return Transformer
+ * @returns Transformer
  */
 declare function initializeTransformer<Value extends PlainObject>(transformers: TransformCallbacks<Value>): Transformer<Value>;
 /**
@@ -4323,6 +6063,17 @@ declare const logger: Logger;
 //#region src/internal/math/aggregate.d.ts
 /**
  * Get the maximum value from a list of items
+ *
+ * @example
+ * ```typescript
+ * max(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}],
+ *   item => item.value,
+ * ); // 20
+ *
+ * max([], item => item.value); // Number.NaN
+ * ```
+ *
  * @param items List of items
  * @param callback Callback to get an item's value
  * @returns Maximum value, or `NaN` if no maximum can be found
@@ -4330,6 +6081,17 @@ declare const logger: Logger;
 declare function max<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number): number;
 /**
  * Get the maximum value from a list of items
+ *
+ * @example
+ * ```typescript
+ * max(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}],
+ *   'value',
+ * ); // 20
+ *
+ * max([], 'value'); // Number.NaN
+ * ```
+ *
  * @param items List of items
  * @param key Key to use for value
  * @returns Maximum value, or `NaN` if no maximum can be found
@@ -4337,6 +6099,13 @@ declare function max<Item>(items: Item[], callback: (item: Item, index: number,
 declare function max<Item extends PlainObject, ItemKey extends keyof NumericalValues<Item>>(items: Item[], key: ItemKey): number;
 /**
  * Get the maximum value from a list of numbers
+ *
+ * @example
+ * ```typescript
+ * max([10, 20]); // 20
+ * max([]);       // Number.NaN
+ * ```
+ *
  * @param values List of numbers
  * @returns Maximum value, or `NaN` if no maximum can be found
  */
@@ -5654,4 +7423,4 @@ declare class SizedSet<Value = unknown> extends Set<Value> {
   get(value: Value, update?: boolean): Value | undefined;
 }
 //#endregion
-export { AnyResult, ArrayComparison, ArrayComparisonSorter, ArrayKeySorter, ArrayOrPlainObject, ArrayValueSorter, AssertProperty, Asserter, AssignOptions, Assigner, AsyncCancelableCallback, AttemptFlow, AttemptFlowPromise, type Beacon, type BeaconOptions, BuiltIns, CancelableCallback, CancelablePromise, type Color, Constructor, DiffOptions, DiffResult, DiffValue, EqualOptions, Err, EventPosition, type Events, ExtendedErr, ExtendedResult, Flow, FlowPromise, Frozen, FulfilledPromise, FuzzyConfiguration, FuzzyOptions, FuzzyResult, FuzzySearchOptions, GenericAsyncCallback, GenericCallback, type HSLAColor, type HSLColor, type Kalas, Key$1 as Key, type KeyedQueue, KeyedValue, type Logger, type Memoized, type MemoizedOptions, MergeOptions, Merger, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NormalizeOptions, Normalizer, NumericalKeys, NumericalValues, type Observable, type Observer, Ok, OnceAsyncCallback, OnceCallback, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PlainObject, Primitive, PromiseData, PromiseHandlers, PromiseOptions, PromiseParameters, PromiseStrategy, PromiseTimeoutError, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValue, PromisesValues, type Queue, type QueueError, type QueueOptions, type Queued, type QueuedResult, type RGBAColor, type RGBColor, RejectedPromise, RequiredKeys, Result, ResultMatch, RetryError, RetryOptions, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, Shaken, Simplify, SizedMap, SizedSet, Smushed, SortDirection, Sorter, type Subscription, TemplateOptions, type Time, ToString, Transformer, TypedArray, Unsmushed, Unsubscriber, UnwrapValue, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, find, findLast, first, firstOrDefault, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getError, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isSorted, isTypedArray, join, kalas, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, logger, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { AnyResult, ArrayComparison, ArrayComparisonSorter, ArrayKeySorter, ArrayOrPlainObject, ArrayValueSorter, AssertProperty, Asserter, AssignOptions, Assigner, AsyncCancelableCallback, AttemptFlow, AttemptFlowPromise, type Beacon, type BeaconOptions, BuiltIns, CancelableCallback, CancelablePromise, type Color, Constructor, DiffOptions, DiffResult, DiffValue, EqualOptions, Err, EventPosition, type Events, ExtendedErr, ExtendedResult, Flow, FlowPromise, Frozen, FulfilledPromise, FuzzyConfiguration, FuzzyOptions, FuzzyResult, FuzzySearchOptions, GenericAsyncCallback, GenericCallback, type HSLAColor, type HSLColor, type Kalas, Key$1 as Key, type KeyedQueue, KeyedValue, type Logger, type Memoized, type MemoizedOptions, MergeOptions, Merger, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NormalizeOptions, Normalizer, NumericalKeys, NumericalValues, type Observable, type Observer, Ok, OnceAsyncCallback, OnceCallback, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PlainObject, Primitive, PromiseData, PromiseHandlers, PromiseOptions, PromiseParameters, PromiseStrategy, PromiseTimeoutError, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValue, PromisesValues, type Queue, type QueueError, type QueueOptions, type Queued, type QueuedResult, type RGBAColor, type RGBColor, RejectedPromise, RequiredKeys, Result, ResultMatch, RetryError, RetryOptions, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, Shaken, Simplify, SizedMap, SizedSet, Smushed, SortDirection, Sorter, type Subscription, TemplateOptions, type Time, ToString, Transformer, TypedArray, UnionToIntersection, Unsmushed, Unsubscriber, UnwrapValue, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, find, findLast, first, firstOrDefault, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getError, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isSorted, isTypedArray, join, kalas, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, logger, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };