@oscarpalmer/atoms 0.77.0 → 0.77.2

package/dist/js/array/chunk.cjs

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const number = require("../number.cjs");
 function chunk(array, size) {
-  const chunkSize = number.clamp(size ?? 64e3, 1, 64e3);
+  const chunkSize = number.clamp(size ?? 5e3, 1, 5e3);
   const { length } = array;
   if (length <= chunkSize) {
     return [array];

package/dist/js/array/chunk.js

@@ -1,6 +1,6 @@
 import { clamp } from "../number.js";
 function chunk(array, size) {
-  const chunkSize = clamp(size ?? 64e3, 1, 64e3);
+  const chunkSize = clamp(size ?? 5e3, 1, 5e3);
   const { length } = array;
   if (length <= chunkSize) {
     return [array];

package/dist/js/value/equal.cjs

@@ -40,7 +40,10 @@ function equalArrayBuffer(first, second) {
   ) : false;
 }
 function equalDataView(first, second) {
-  return first.byteOffset === second.byteOffset ? equalArrayBuffer(first.buffer, second.buffer) : false;
+  return first.byteOffset === second.byteOffset ? equalArrayBuffer(
+    first.buffer,
+    second.buffer
+  ) : false;
 }
 function equalMap(first, second) {
   const { size } = first;

package/dist/js/value/equal.js

@@ -38,7 +38,10 @@ function equalArrayBuffer(first, second) {
   ) : false;
 }
 function equalDataView(first, second) {
-  return first.byteOffset === second.byteOffset ? equalArrayBuffer(first.buffer, second.buffer) : false;
+  return first.byteOffset === second.byteOffset ? equalArrayBuffer(
+    first.buffer,
+    second.buffer
+  ) : false;
 }
 function equalMap(first, second) {
   const { size } = first;

package/package.json

@@ -237,5 +237,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.cts",
-	"version": "0.77.0"
+	"version": "0.77.2"
 }

package/src/js/array/chunk.ts

@@ -4,7 +4,7 @@ import {clamp} from '~/number';
  * Chunk an array _(into smaller arrays of a specified size)_
  */
 export function chunk<Item>(array: Item[], size?: number): Item[][] {
-	const chunkSize = clamp(size ?? 64_000, 1, 64_000);
+	const chunkSize = clamp(size ?? 5_000, 1, 5_000);
 	const {length} = array;
 
 	if (length <= chunkSize) {

package/src/js/array/count.ts

@@ -1,5 +1,5 @@
 import {findValues} from '~/internal/array/find';
-import type {Key as SimpleKey} from '~/models';
+import type {Key, PlainObject} from '~/models';
 
 /**
  * Get the number of items _(count)_ that match the given value
@@ -17,10 +17,10 @@ export function count<Item>(
 /**
  * Get the number of items _(count)_ that match the given value
  */
-export function count<Item, Key extends keyof Item>(
+export function count<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
-	key: Key,
-	value: Item[Key],
+	key: ItemKey,
+	value: Item[ItemKey],
 ): number;
 
 /**
@@ -28,8 +28,8 @@ export function count<Item, Key extends keyof Item>(
  */
 export function count<
 	Item,
-	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
->(array: Item[], key: Key, value: ReturnType<Key>): number;
+	ItemKey extends (item: Item, index: number, array: Item[]) => Key,
+>(array: Item[], key: ItemKey, value: ReturnType<ItemKey>): number;
 
 export function count(array: unknown[], ...parameters: unknown[]): number {
 	return findValues('all', array, parameters).length;

package/src/js/array/exists.ts

@@ -1,5 +1,5 @@
 import {findValue} from '~/internal/array/find';
-import type {Key as SimpleKey} from '~/models';
+import type {Key, PlainObject} from '~/models';
 
 /**
  * Does the value exist in array?
@@ -18,10 +18,10 @@ export function exists<Item>(
  * - Does the value exist in array?
  * - Use `key` to find a comparison value to match with `value`
  */
-export function exists<Item, Key extends keyof Item>(
+export function exists<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
-	key: Key,
-	value: Item[Key],
+	key: ItemKey,
+	value: Item[ItemKey],
 ): boolean;
 
 /**
@@ -30,8 +30,8 @@ export function exists<Item, Key extends keyof Item>(
  */
 export function exists<
 	Item,
-	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
->(array: Item[], key: Key, value: ReturnType<Key>): boolean;
+	ItemKey extends (item: Item, index: number, array: Item[]) => Key,
+>(array: Item[], key: ItemKey, value: ReturnType<ItemKey>): boolean;
 
 export function exists(array: unknown[], ...parameters: unknown[]): boolean {
 	return (findValue('index', array, parameters) as number) > -1;

package/src/js/array/filter.ts

@@ -1,5 +1,5 @@
 import {findValues} from '~/internal/array/find';
-import type {Key as SimpleKey} from '~/models';
+import type {Key, PlainObject} from '~/models';
 
 /**
  * Get a filtered array of items matching `value`
@@ -18,10 +18,10 @@ export function filter<Item>(
  * - Get a filtered array of items
  * - Use `key` to find a comparison value to match with `value`
  */
-export function filter<Item, Key extends keyof Item>(
+export function filter<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
-	key: Key,
-	value: Item[Key],
+	key: ItemKey,
+	value: Item[ItemKey],
 ): Item[];
 
 /**
@@ -30,8 +30,8 @@ export function filter<Item, Key extends keyof Item>(
  */
 export function filter<
 	Item,
-	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
->(array: Item[], key: Key, value: ReturnType<Key>): Item[];
+	ItemKey extends (item: Item, index: number, array: Item[]) => Key,
+>(array: Item[], key: ItemKey, value: ReturnType<ItemKey>): Item[];
 
 export function filter(array: unknown[], ...parameters: unknown[]): unknown[] {
 	return findValues('all', array, parameters);

package/src/js/array/find.ts

@@ -1,5 +1,5 @@
 import {findValue} from '~/internal/array/find';
-import type {Key as SimpleKey} from '~/models';
+import type {Key, PlainObject} from '~/models';
 
 /**
  * Get the first item matching `value` _(or `undefined` if no match is found)_
@@ -18,10 +18,10 @@ export function find<Item>(
  * - Get the first matching item _(or `undefined` if no match is found)_
  * - Use `key` to find a comparison value to match with `value`
  */
-export function find<Item, Key extends keyof Item>(
+export function find<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
-	key: Key,
-	value: Item[Key],
+	key: ItemKey,
+	value: Item[ItemKey],
 ): Item | undefined;
 
 /**
@@ -30,8 +30,8 @@ export function find<Item, Key extends keyof Item>(
  */
 export function find<
 	Item,
-	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
->(array: Item[], key: Key, value: ReturnType<Key>): Item | undefined;
+	ItemKey extends (item: Item, index: number, array: Item[]) => Key,
+>(array: Item[], key: ItemKey, value: ReturnType<ItemKey>): Item | undefined;
 
 export function find<Item>(
 	array: unknown[],

package/src/js/array/group-by.ts

@@ -1,138 +1,150 @@
 import {getCallbacks} from '~/internal/array/callbacks';
-import type {Key as SimpleKey, KeyedValue, PlainObject} from '~/models';
+import type {Key, KeyedValue, PlainObject} from '~/models';
 
 /**
  * Create a record from an array of items using a specific key
  */
-export function groupBy<Item, Key extends keyof Item>(
+export function groupBy<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
-	key: Key,
-): Record<KeyedValue<Item, Key>, Item>;
+	key: ItemKey,
+): Record<KeyedValue<Item, ItemKey>, Item>;
 
 /**
  * Create a record from an array of items using a specific key, and grouping them into arrays
  */
-export function groupBy<Item, Key extends keyof Item>(
+export function groupBy<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
-	key: Key,
+	key: ItemKey,
 	arrays: true,
-): Record<KeyedValue<Item, Key>, Item[]>;
+): Record<KeyedValue<Item, ItemKey>, Item[]>;
 
 /**
  * Create a record from an array of items using a specific key
  */
 export function groupBy<
 	Item,
-	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
->(array: Item[], key: Key): Record<ReturnType<Key>, Item>;
+	ItemKey extends (item: Item, index: number, array: Item[]) => Key,
+>(array: Item[], key: ItemKey): Record<ReturnType<ItemKey>, Item>;
 
 /**
  * Create a record from an array of items using a specific key, and grouping them into arrays
  */
 export function groupBy<
 	Item,
-	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
->(array: Item[], key: Key, arrays: true): Record<ReturnType<Key>, Item[]>;
+	ItemKey extends (item: Item, index: number, array: Item[]) => Key,
+>(
+	array: Item[],
+	key: ItemKey,
+	arrays: true,
+): Record<ReturnType<ItemKey>, Item[]>;
 
 /**
  * Create a record from an array of items using a specific key and value
  */
-export function groupBy<Item, Key extends keyof Item, Value extends keyof Item>(
+export function groupBy<
+	Item extends PlainObject,
+	ItemKey extends keyof Item,
+	ItemValue extends keyof Item,
+>(
 	array: Item[],
-	key: Key,
-	value: Value,
-): Record<KeyedValue<Item, Key>, KeyedValue<Item, Value>>;
+	key: ItemKey,
+	value: ItemValue,
+): Record<KeyedValue<Item, ItemKey>, KeyedValue<Item, ItemValue>>;
 
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export function groupBy<Item, Key extends keyof Item, Value extends keyof Item>(
+export function groupBy<
+	Item extends PlainObject,
+	ItemKey extends keyof Item,
+	ItemValue extends keyof Item,
+>(
 	array: Item[],
-	key: Key,
-	value: Value,
+	key: ItemKey,
+	value: ItemValue,
 	arrays: true,
-): Record<KeyedValue<Item, Key>, Array<KeyedValue<Item, Value>>>;
+): Record<KeyedValue<Item, ItemKey>, Array<KeyedValue<Item, ItemValue>>>;
 
 /**
  * Create a record from an array of items using a specific key and value
  */
 export function groupBy<
-	Item,
-	Key extends keyof Item,
-	Value extends (item: Item, index: number, array: Item[]) => unknown,
+	Item extends PlainObject,
+	ItemKey extends keyof Item,
+	ItemValue extends (item: Item, index: number, array: Item[]) => unknown,
 >(
 	array: Item[],
-	key: Key,
-	value: Value,
-): Record<KeyedValue<Item, Key>, ReturnType<Value>>;
+	key: ItemKey,
+	value: ItemValue,
+): Record<KeyedValue<Item, ItemKey>, ReturnType<ItemValue>>;
 
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
 export function groupBy<
-	Item,
-	Key extends keyof Item,
-	Value extends (item: Item, index: number, array: Item[]) => unknown,
+	Item extends PlainObject,
+	ItemKey extends keyof Item,
+	ItemValue extends (item: Item, index: number, array: Item[]) => unknown,
 >(
 	array: Item[],
-	key: Key,
-	value: Value,
+	key: ItemKey,
+	value: ItemValue,
 	arrays: true,
-): Record<KeyedValue<Item, Key>, Array<ReturnType<Value>>>;
+): Record<KeyedValue<Item, ItemKey>, Array<ReturnType<ItemValue>>>;
 
 /**
  * Create a record from an array of items using a specific key and value
  */
 export function groupBy<
-	Item,
-	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
-	Value extends keyof Item,
+	Item extends PlainObject,
+	ItemKey extends (item: Item, index: number, array: Item[]) => Key,
+	ItemValue extends keyof Item,
 >(
 	array: Item[],
-	key: Key,
-	value: Value,
-): Record<ReturnType<Key>, KeyedValue<Item, Value>>;
+	key: ItemKey,
+	value: ItemValue,
+): Record<ReturnType<ItemKey>, KeyedValue<Item, ItemValue>>;
 
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
 export function groupBy<
-	Item,
-	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
-	Value extends keyof Item,
+	Item extends PlainObject,
+	ItemKey extends (item: Item, index: number, array: Item[]) => Key,
+	ItemValue extends keyof Item,
 >(
 	array: Item[],
-	key: Key,
-	value: Value,
+	key: ItemKey,
+	value: ItemValue,
 	arrays: true,
-): Record<ReturnType<Key>, Array<KeyedValue<Item, Value>>>;
+): Record<ReturnType<ItemKey>, Array<KeyedValue<Item, ItemValue>>>;
 
 /**
  * Create a record from an array of items using a specific key and value
  */
 export function groupBy<
 	Item,
-	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
-	Value extends (item: Item, index: number, array: Item[]) => unknown,
+	ItemKey extends (item: Item, index: number, array: Item[]) => Key,
+	ItemValue extends (item: Item, index: number, array: Item[]) => unknown,
 >(
 	array: Item[],
-	key: Key,
-	value: Value,
-): Record<ReturnType<Key>, ReturnType<Value>>;
+	key: ItemKey,
+	value: ItemValue,
+): Record<ReturnType<ItemKey>, ReturnType<ItemValue>>;
 
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
 export function groupBy<
 	Item,
-	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
-	Value extends (item: Item, index: number, array: Item[]) => unknown,
+	ItemKey extends (item: Item, index: number, array: Item[]) => Key,
+	ItemValue extends (item: Item, index: number, array: Item[]) => unknown,
 >(
 	array: Item[],
-	key: Key,
-	value: Value,
+	key: ItemKey,
+	value: ItemValue,
 	arrays: true,
-): Record<ReturnType<Key>, Array<ReturnType<Value>>>;
+): Record<ReturnType<ItemKey>, Array<ReturnType<ItemValue>>>;
 
 export function groupBy(
 	array: unknown[],
@@ -153,9 +165,9 @@ export function groupValues(
 	key: unknown,
 	value: unknown,
 	arrays: boolean,
-): Record<SimpleKey, unknown> {
+): Record<Key, unknown> {
 	const callbacks = getCallbacks(undefined, key, value);
-	const record: Record<SimpleKey, unknown> = {};
+	const record: Record<Key, unknown> = {};
 	const {length} = array;
 
 	for (let index = 0; index < length; index += 1) {

package/src/js/array/index-of.ts

@@ -1,5 +1,5 @@
 import {findValue} from '~/internal/array/find';
-import type {Key as SimpleKey} from '~/models';
+import type {Key, PlainObject} from '~/models';
 
 /**
  * Get the index for the first item matching `value` _(or `-1` if no match is found)_
@@ -18,10 +18,10 @@ export function indexOf<Item>(
  * - Get the index for the first matching item _(or `-1` if no match is found)_
  * - Use `key` to find a comparison value to match with `value`
  */
-export function indexOf<Item, Key extends keyof Item>(
+export function indexOf<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
-	key: Key,
-	value: Item[Key],
+	key: ItemKey,
+	value: Item[ItemKey],
 ): number;
 
 /**
@@ -30,8 +30,8 @@ export function indexOf<Item, Key extends keyof Item>(
  */
 export function indexOf<
 	Item,
-	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
->(array: Item[], key: Key, value: ReturnType<Key>): number;
+	ItemKey extends (item: Item, index: number, array: Item[]) => Key,
+>(array: Item[], key: ItemKey, value: ReturnType<ItemKey>): number;
 
 export function indexOf(array: unknown[], ...parameters: unknown[]): number {
 	return findValue('index', array, parameters) as number;

package/src/js/array/sort.ts

@@ -18,6 +18,16 @@ export function sort<Item>(
 	descending?: boolean,
 ): Item[];
 
+/**
+ * - Sort an array of items, using a `key` to sort by a specific value
+ * - Defaults to ascending, but can be changed by setting `descending` to `true`, or using a `SortKey`
+ */
+export function sort<Item extends PlainObject, ItemKey extends keyof Item>(
+	array: Item[],
+	key: ItemKey | Key | SortKey<Item> | ((item: Item) => Key),
+	descending?: boolean,
+): Item[];
+
 /**
  * - Sort an array of items, using multiple `keys` to sort by specific values
  * - Defaults to ascending, but can be changed by setting `descending` to `true`, or using `SortKey`
@@ -28,6 +38,16 @@ export function sort<Item>(
 	descending?: boolean,
 ): Item[];
 
+/**
+ * - Sort an array of items, using multiple `keys` to sort by specific values
+ * - Defaults to ascending, but can be changed by setting `descending` to `true`, or using `SortKey`
+ */
+export function sort<Item extends PlainObject, ItemKey extends keyof Item>(
+	array: Item[],
+	keys: Array<ItemKey | Key | SortKey<Item> | ((item: Item) => Key)>,
+	descending?: boolean,
+): Item[];
+
 export function sort(
 	array: unknown[],
 	first?: unknown,

package/src/js/array/to-map.ts

@@ -1,5 +1,5 @@
 import {getCallbacks} from '~/internal/array/callbacks';
-import type {KeyedValue, Key as SimpleKey} from '~/models';
+import type {Key, KeyedValue, PlainObject} from '~/models';
 
 /**
  * Create a map from an array of items _(using their indices as keys)_
@@ -9,115 +9,123 @@ export function toMap<Item>(array: Item[]): Map<number, Item>;
 /**
  * Create a map from an array of items using a specific key
  */
-export function toMap<Item, Key extends keyof Item>(
+export function toMap<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
-	key: Key,
-): Map<KeyedValue<Item, Key>, Item>;
+	key: ItemKey,
+): Map<KeyedValue<Item, ItemKey>, Item>;
 
 /**
  * Create a map from an array of items using a specific key, and grouping them into arrays
  */
-export function toMap<Item, Key extends keyof Item>(
+export function toMap<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
-	key: Key,
+	key: ItemKey,
 	arrays: true,
-): Map<KeyedValue<Item, Key>, Item[]>;
+): Map<KeyedValue<Item, ItemKey>, Item[]>;
 
 /**
  * Create a map from an array of items using a specific key
  */
 export function toMap<
 	Item,
-	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
->(array: Item[], key: Key): Map<ReturnType<Key>, Item>;
+	ItemKey extends (item: Item, index: number, array: Item[]) => Key,
+>(array: Item[], key: ItemKey): Map<ReturnType<ItemKey>, Item>;
 
 /**
  * Create a map from an array of items using a specific key, and grouping them into arrays
  */
 export function toMap<
 	Item,
-	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
->(array: Item[], key: Key, arrays: true): Map<ReturnType<Key>, Item[]>;
+	ItemKey extends (item: Item, index: number, array: Item[]) => Key,
+>(array: Item[], key: ItemKey, arrays: true): Map<ReturnType<ItemKey>, Item[]>;
 
 /**
  * Create a map from an array of items using a specific key and value
  */
-export function toMap<Item, Key extends keyof Item, Value extends keyof Item>(
+export function toMap<
+	Item extends PlainObject,
+	ItemKey extends keyof Item,
+	ItemValue extends keyof Item,
+>(
 	array: Item[],
-	key: Key,
-	value: Value,
-): Map<KeyedValue<Item, Key>, KeyedValue<Item, Value>>;
+	key: ItemKey,
+	value: ItemValue,
+): Map<KeyedValue<Item, ItemKey>, KeyedValue<Item, ItemValue>>;
 
 /**
  * Create a map from an array of items using a specific key and value, and grouping them into arrays
  */
-export function toMap<Item, Key extends keyof Item, Value extends keyof Item>(
+export function toMap<
+	Item extends PlainObject,
+	ItemKey extends keyof Item,
+	ItemValue extends keyof Item,
+>(
 	array: Item[],
-	key: Key,
-	value: Value,
+	key: ItemKey,
+	value: ItemValue,
 	arrays: true,
-): Map<KeyedValue<Item, Key>, Array<KeyedValue<Item, Value>>>;
+): Map<KeyedValue<Item, ItemKey>, Array<KeyedValue<Item, ItemValue>>>;
 
 /**
  * Create a map from an array of items using a specific key and value
  */
 export function toMap<
-	Item,
-	Key extends keyof Item,
-	Value extends (item: Item, index: number, array: Item[]) => unknown,
+	Item extends PlainObject,
+	ItemKey extends keyof Item,
+	ItemValue extends (item: Item, index: number, array: Item[]) => unknown,
 >(
 	array: Item[],
-	key: Key,
-	value: Value,
-): Map<KeyedValue<Item, Key>, ReturnType<Value>>;
+	key: ItemKey,
+	value: ItemValue,
+): Map<KeyedValue<Item, ItemKey>, ReturnType<ItemValue>>;
 
 /**
  * Create a map from an array of items using a specific key and value, and grouping them into arrays
  */
 export function toMap<
-	Item,
-	Key extends keyof Item,
-	Value extends (item: Item, index: number, array: Item[]) => unknown,
+	Item extends PlainObject,
+	ItemKey extends keyof Item,
+	ItemValue extends (item: Item, index: number, array: Item[]) => unknown,
 >(
 	array: Item[],
-	key: Key,
-	value: Value,
+	key: ItemKey,
+	value: ItemValue,
 	arrays: true,
-): Map<KeyedValue<Item, Key>, Array<ReturnType<Value>>>;
+): Map<KeyedValue<Item, ItemKey>, Array<ReturnType<ItemValue>>>;
 
 /**
  * Create a map from an array of items using a specific key and value
  */
 export function toMap<
-	Item,
-	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
-	Value extends keyof Item,
+	Item extends PlainObject,
+	ItemKey extends (item: Item, index: number, array: Item[]) => Key,
+	ItemValue extends keyof Item,
 >(
 	array: Item[],
-	key: Key,
-	value: Value,
-): Map<ReturnType<Key>, KeyedValue<Item, Value>>;
+	key: ItemKey,
+	value: ItemValue,
+): Map<ReturnType<ItemKey>, KeyedValue<Item, ItemValue>>;
 
 /**
  * Create a map from an array of items using a specific key and value, and grouping them into arrays
  */
 export function toMap<
-	Item,
-	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
-	Value extends keyof Item,
+	Item extends PlainObject,
+	ItemKey extends (item: Item, index: number, array: Item[]) => Key,
+	ItemValue extends keyof Item,
 >(
 	array: Item[],
-	key: Key,
-	value: Value,
+	key: ItemKey,
+	value: ItemValue,
 	arrays: true,
-): Map<ReturnType<Key>, Array<KeyedValue<Item, Value>>>;
+): Map<ReturnType<ItemKey>, Array<KeyedValue<Item, ItemValue>>>;
 
 /**
  * Create a map from an array of items using a specific key and value
  */
 export function toMap<
 	Item,
-	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
+	Key extends (item: Item, index: number, array: Item[]) => Key,
 	Value extends (item: Item, index: number, array: Item[]) => unknown,
 >(
 	array: Item[],
@@ -130,7 +138,7 @@ export function toMap<
  */
 export function toMap<
 	Item,
-	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
+	Key extends (item: Item, index: number, array: Item[]) => Key,
 	Value extends (item: Item, index: number, array: Item[]) => unknown,
 >(
 	array: Item[],
@@ -144,10 +152,10 @@ export function toMap(
 	first?: unknown,
 	second?: unknown,
 	third?: unknown,
-): Map<SimpleKey, unknown> {
+): Map<Key, unknown> {
 	const asArrays = first === true || second === true || third === true;
 	const callbacks = getCallbacks(undefined, first, second);
-	const map = new Map<SimpleKey, unknown>();
+	const map = new Map<Key, unknown>();
 	const {length} = array;
 
 	for (let index = 0; index < length; index += 1) {