@oscarpalmer/atoms 0.76.0 → 0.77.0

package/types/index.d.cts

@@ -5,10 +5,7 @@
  * - Maximum size defaults to _2^20_; any provided size will be clamped at _2^24_
  * - Behaviour is similar to a _LRU_-cache, where the least recently used entries are removed
  */
-export declare class SizedMap<Key = unknown, Value = unknown> extends Map<
-	Key,
-	Value
-> {
+export declare class SizedMap<Key = unknown, Value = unknown> extends Map<Key, Value> {
 	private readonly maximumSize;
 	/**
 	 * Is the Map full?
@@ -21,7 +18,10 @@ export declare class SizedMap<Key = unknown, Value = unknown> extends Map<
 	/**
 	 * Create a new Map with entries and a maximum size _(2^20)_
 	 */
-	constructor(entries: Array<[Key, Value]>);
+	constructor(entries: Array<[
+		Key,
+		Value
+	]>);
 	/**
 	 * Create a new Map with a maximum size _(but clamped at 2^24)_
 	 */
@@ -29,7 +29,10 @@ export declare class SizedMap<Key = unknown, Value = unknown> extends Map<
 	/**
 	 * Create a new Map with _(optional)_ entries and a maximum size _(defaults to 2^20; clamped at 2^24)_
 	 */
-	constructor(entries?: Array<[Key, Value]>, maximum?: number);
+	constructor(entries?: Array<[
+		Key,
+		Value
+	]>, maximum?: number);
 	/**
 	 * @inheritdoc
 	 */
@@ -89,10 +92,7 @@ export declare function getRandomBoolean(): boolean;
  * Get a random string of characters with a specified length
  * - `selection` defaults to all lowercase letters in the English alphabet
  */
-export declare function getRandomCharacters(
-	length: number,
-	selection?: string,
-): string;
+export declare function getRandomCharacters(length: number, selection?: string): string;
 /**
  * Get a random hexadecimal colour
  */
@@ -117,10 +117,7 @@ export declare function getRandomItem<Value>(array: Value[]): Value;
  * - Get an amount of random items from an array
  * - If `amount` is not specified, a shuffled array will be returned instead
  */
-export declare function getRandomItems<Value>(
-	array: Value[],
-	amount?: number,
-): Value[];
+export declare function getRandomItems<Value>(array: Value[], amount?: number): Value[];
 /**
  * Queue a callback to be executed at the next best time
  */
@@ -130,14 +127,7 @@ Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/
 
 @category Type
 */
-export type Primitive =
-	| null
-	| undefined
-	| string
-	| number
-	| boolean
-	| symbol
-	| bigint;
+export type Primitive = null | undefined | string | number | boolean | symbol | bigint;
 /**
 Create a union of all keys from a given type, even those exclusive to specific union members.
 
@@ -175,9 +165,7 @@ type AllKeys = KeysOfUnion<Union>;
 
 @category Object
 */
-export type KeysOfUnion<ObjectType> = ObjectType extends unknown
-	? keyof ObjectType
-	: never;
+export type KeysOfUnion<ObjectType> = ObjectType extends unknown ? keyof ObjectType : never;
 declare const emptyObjectSymbol: unique symbol;
 /**
 Represents a strictly empty plain object, the `{}` value.
@@ -234,11 +222,7 @@ type Includes<Value extends readonly any[], Item> =
 @category Type Guard
 @category Utilities
 */
-export type IsEqual<A, B> = (<G>() => G extends A ? 1 : 2) extends <
-	G,
->() => G extends B ? 1 : 2
-	? true
-	: false;
+export type IsEqual<A, B> = (<G>() => G extends A ? 1 : 2) extends (<G>() => G extends B ? 1 : 2) ? true : false;
 /**
 Represents an object with `unknown` value. You probably want this instead of `{}`.
 
@@ -365,16 +349,14 @@ type B = StaticPartOfArray<A>;
 //=> [string, number, boolean]
 ```
 */
-export type StaticPartOfArray<
-	T extends UnknownArray,
-	Result extends UnknownArray = [],
-> = T extends unknown
-	? number extends T['length']
-		? T extends readonly [infer U, ...infer V]
-			? StaticPartOfArray<V, [...Result, U]>
-			: Result
-		: T
-	: never; // Should never happen
+export type StaticPartOfArray<T extends UnknownArray, Result extends UnknownArray = [
+]> = T extends unknown ? number extends T["length"] ? T extends readonly [
+	infer U,
+	...infer V
+] ? StaticPartOfArray<V, [
+	...Result,
+	U
+]> : Result : T : never; // Should never happen
 /**
 Returns the variable, non-fixed-length portion of the given array, excluding static-length parts.
 
@@ -385,22 +367,12 @@ type B = VariablePartOfArray<A>;
 //=> string[]
 ```
 */
-export type VariablePartOfArray<T extends UnknownArray> = T extends unknown
-	? T extends readonly [...StaticPartOfArray<T>, ...infer U]
-		? U
-		: []
-	: never; // Should never happen
-export type StringDigit =
-	| '0'
-	| '1'
-	| '2'
-	| '3'
-	| '4'
-	| '5'
-	| '6'
-	| '7'
-	| '8'
-	| '9';
+export type VariablePartOfArray<T extends UnknownArray> = T extends unknown ? T extends readonly [
+	...StaticPartOfArray<T>,
+	...infer U
+] ? U : [
+] : never; // Should never happen
+export type StringDigit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
 /**
 Returns a boolean for whether the given type is `any`.
 
@@ -443,7 +415,7 @@ Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/32277)
 */
 // See https://github.com/microsoft/TypeScript/issues/31752
 // eslint-disable-next-line @typescript-eslint/no-loss-of-precision
-export type PositiveInfinity = 1e999;
+export type PositiveInfinity = Infinity;
 /**
 Matches the hidden `-Infinity` type.
 
@@ -455,7 +427,7 @@ Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/32277)
 */
 // See https://github.com/microsoft/TypeScript/issues/31752
 // eslint-disable-next-line @typescript-eslint/no-loss-of-precision
-export type NegativeInfinity = -1e999;
+export type NegativeInfinity = -Infinity;
 /**
 A negative `number`/`bigint` (`-∞ < x < 0`)
 
@@ -466,11 +438,7 @@ Use-case: Validating and documenting parameters.
 
 @category Numeric
 */
-export type Negative<T extends Numeric> = T extends Zero
-	? never
-	: `${T}` extends `-${string}`
-		? T
-		: never;
+export type Negative<T extends Numeric> = T extends Zero ? never : `${T}` extends `-${string}` ? T : never;
 /**
 Returns a boolean for whether the given number is a negative number.
 
@@ -486,9 +454,7 @@ type ShouldBeTrue = IsNegative<-1>;
 
 @category Numeric
 */
-export type IsNegative<T extends Numeric> = T extends Negative<T>
-	? true
-	: false;
+export type IsNegative<T extends Numeric> = T extends Negative<T> ? true : false;
 /**
 Returns a boolean for whether two given types are both true.
 
@@ -509,12 +475,11 @@ And<true, false>;
 */
 export type And<A extends boolean, B extends boolean> = [
 	A,
-	B,
-][number] extends true
-	? true
-	: true extends [IsEqual<A, false>, IsEqual<B, false>][number]
-		? false
-		: never;
+	B
+][number] extends true ? true : true extends [
+	IsEqual<A, false>,
+	IsEqual<B, false>
+][number] ? false : never;
 /**
 Returns a boolean for whether either of two given types are true.
 
@@ -535,12 +500,11 @@ Or<false, false>;
 */
 export type Or<A extends boolean, B extends boolean> = [
 	A,
-	B,
-][number] extends false
-	? false
-	: true extends [IsEqual<A, true>, IsEqual<B, true>][number]
-		? true
-		: never;
+	B
+][number] extends false ? false : true extends [
+	IsEqual<A, true>,
+	IsEqual<B, true>
+][number] ? true : never;
 /**
 Returns a boolean for whether a given number is greater than another number.
 
@@ -558,44 +522,32 @@ GreaterThan<1, 5>;
 //=> false
 ```
 */
-export type GreaterThan<A extends number, B extends number> = number extends
-	| A
-	| B
-	? never
-	: [
-				IsEqual<A, PositiveInfinity>,
-				IsEqual<A, NegativeInfinity>,
-				IsEqual<B, PositiveInfinity>,
-				IsEqual<B, NegativeInfinity>,
-			] extends infer R extends [boolean, boolean, boolean, boolean]
-		? Or<
-				And<IsEqual<R[0], true>, IsEqual<R[2], false>>,
-				And<IsEqual<R[3], true>, IsEqual<R[1], false>>
-			> extends true
-			? true
-			: Or<
-						And<IsEqual<R[1], true>, IsEqual<R[3], false>>,
-						And<IsEqual<R[2], true>, IsEqual<R[0], false>>
-					> extends true
-				? false
-				: true extends R[number]
-					? false
-					: [IsNegative<A>, IsNegative<B>] extends infer R extends [
-								boolean,
-								boolean,
-							]
-						? [true, false] extends R
-							? false
-							: [false, true] extends R
-								? true
-								: [false, false] extends R
-									? PositiveNumericStringGt<`${A}`, `${B}`>
-									: PositiveNumericStringGt<
-											`${NumberAbsolute<B>}`,
-											`${NumberAbsolute<A>}`
-										>
-						: never
-		: never;
+export type GreaterThan<A extends number, B extends number> = number extends A | B ? never : [
+	IsEqual<A, PositiveInfinity>,
+	IsEqual<A, NegativeInfinity>,
+	IsEqual<B, PositiveInfinity>,
+	IsEqual<B, NegativeInfinity>
+] extends infer R extends [
+	boolean,
+	boolean,
+	boolean,
+	boolean
+] ? Or<And<IsEqual<R[0], true>, IsEqual<R[2], false>>, And<IsEqual<R[3], true>, IsEqual<R[1], false>>> extends true ? true : Or<And<IsEqual<R[1], true>, IsEqual<R[3], false>>, And<IsEqual<R[2], true>, IsEqual<R[0], false>>> extends true ? false : true extends R[number] ? false : [
+	IsNegative<A>,
+	IsNegative<B>
+] extends infer R extends [
+	boolean,
+	boolean
+] ? [
+	true,
+	false
+] extends R ? false : [
+	false,
+	true
+] extends R ? true : [
+	false,
+	false
+] extends R ? PositiveNumericStringGt<`${A}`, `${B}`> : PositiveNumericStringGt<`${NumberAbsolute<B>}`, `${NumberAbsolute<A>}`> : never : never;
 /**
 Returns a boolean for whether a given number is greater than or equal to another number.
 
@@ -613,10 +565,7 @@ GreaterThanOrEqual<1, 5>;
 //=> false
 ```
 */
-export type GreaterThanOrEqual<
-	A extends number,
-	B extends number,
-> = number extends A | B ? never : A extends B ? true : GreaterThan<A, B>;
+export type GreaterThanOrEqual<A extends number, B extends number> = number extends A | B ? never : A extends B ? true : GreaterThan<A, B>;
 /**
 Returns a boolean for whether a given number is less than another number.
 
@@ -634,11 +583,7 @@ LessThan<1, 5>;
 //=> true
 ```
 */
-export type LessThan<A extends number, B extends number> = number extends A | B
-	? never
-	: GreaterThanOrEqual<A, B> extends true
-		? false
-		: true;
+export type LessThan<A extends number, B extends number> = number extends A | B ? never : GreaterThanOrEqual<A, B> extends true ? false : true;
 /**
 Create a tuple type of the given length `<L>` and fill it with the given type `<Fill>`.
 
@@ -646,11 +591,11 @@ If `<Fill>` is not provided, it will default to `unknown`.
 
 @link https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f
 */
-export type BuildTuple<
-	L extends number,
-	Fill = unknown,
-	T extends readonly unknown[] = [],
-> = T['length'] extends L ? T : BuildTuple<L, Fill, [...T, Fill]>;
+export type BuildTuple<L extends number, Fill = unknown, T extends readonly unknown[] = [
+]> = T["length"] extends L ? T : BuildTuple<L, Fill, [
+	...T,
+	Fill
+]>;
 /**
 Returns the maximum value from a tuple of integers.
 
@@ -666,16 +611,10 @@ ArrayMax<[1, 2, 5, 3, 99, -1]>;
 //=> 99
 ```
 */
-export type TupleMax<
-	A extends number[],
-	Result extends number = NegativeInfinity,
-> = number extends A[number]
-	? never
-	: A extends [infer F extends number, ...infer R extends number[]]
-		? GreaterThan<F, Result> extends true
-			? TupleMax<R, F>
-			: TupleMax<R, Result>
-		: Result;
+export type TupleMax<A extends number[], Result extends number = NegativeInfinity> = number extends A[number] ? never : A extends [
+	infer F extends number,
+	...infer R extends number[]
+] ? GreaterThan<F, Result> extends true ? TupleMax<R, F> : TupleMax<R, Result> : Result;
 /**
 Returns the minimum value from a tuple of integers.
 
@@ -691,16 +630,10 @@ ArrayMin<[1, 2, 5, 3, -5]>;
 //=> -5
 ```
 */
-export type TupleMin<
-	A extends number[],
-	Result extends number = PositiveInfinity,
-> = number extends A[number]
-	? never
-	: A extends [infer F extends number, ...infer R extends number[]]
-		? LessThan<F, Result> extends true
-			? TupleMin<R, F>
-			: TupleMin<R, Result>
-		: Result;
+export type TupleMin<A extends number[], Result extends number = PositiveInfinity> = number extends A[number] ? never : A extends [
+	infer F extends number,
+	...infer R extends number[]
+] ? LessThan<F, Result> extends true ? TupleMin<R, F> : TupleMin<R, Result> : Result;
 /**
 Return a string representation of the given string or number.
 
@@ -735,14 +668,7 @@ type NegativeInfinity = StringToNumber<'-Infinity'>;
 @category Numeric
 @category Template literal
 */
-export type StringToNumber<S extends string> =
-	S extends `${infer N extends number}`
-		? N
-		: S extends 'Infinity'
-			? PositiveInfinity
-			: S extends '-Infinity'
-				? NegativeInfinity
-				: never;
+export type StringToNumber<S extends string> = S extends `${infer N extends number}` ? N : S extends "Infinity" ? PositiveInfinity : S extends "-Infinity" ? NegativeInfinity : never;
 /**
 Returns an array of the characters of the string.
 
@@ -757,14 +683,11 @@ StringToArray<string>;
 
 @category String
 */
-export type StringToArray<
-	S extends string,
-	Result extends string[] = [],
-> = string extends S
-	? never
-	: S extends `${infer F}${infer R}`
-		? StringToArray<R, [...Result, F]>
-		: Result;
+export type StringToArray<S extends string, Result extends string[] = [
+]> = string extends S ? never : S extends `${infer F}${infer R}` ? StringToArray<R, [
+	...Result,
+	F
+]> : Result;
 /**
 Returns the length of the given string.
 
@@ -780,9 +703,7 @@ StringLength<string>;
 @category String
 @category Template literal
 */
-export type StringLength<S extends string> = string extends S
-	? never
-	: StringToArray<S>['length'];
+export type StringLength<S extends string> = string extends S ? never : StringToArray<S>["length"];
 /**
 Returns a boolean for whether `A` represents a number greater than `B`, where `A` and `B` are both numeric strings and have the same length.
 
@@ -795,17 +716,8 @@ SameLengthPositiveNumericStringGt<'10', '10'>;
 //=> false
 ```
 */
-export type SameLengthPositiveNumericStringGt<
-	A extends string,
-	B extends string,
-> = A extends `${infer FirstA}${infer RestA}`
-	? B extends `${infer FirstB}${infer RestB}`
-		? FirstA extends FirstB
-			? SameLengthPositiveNumericStringGt<RestA, RestB>
-			: PositiveNumericCharacterGt<FirstA, FirstB>
-		: never
-	: false;
-export type NumericString = '0123456789';
+export type SameLengthPositiveNumericStringGt<A extends string, B extends string> = A extends `${infer FirstA}${infer RestA}` ? B extends `${infer FirstB}${infer RestB}` ? FirstA extends FirstB ? SameLengthPositiveNumericStringGt<RestA, RestB> : PositiveNumericCharacterGt<FirstA, FirstB> : never : false;
+export type NumericString = "0123456789";
 /**
 Returns a boolean for whether `A` is greater than `B`, where `A` and `B` are both positive numeric strings.
 
@@ -821,21 +733,16 @@ PositiveNumericStringGt<'1', '500'>;
 //=> false
 ```
 */
-export type PositiveNumericStringGt<
-	A extends string,
-	B extends string,
-> = A extends B
-	? false
-	: [
-				BuildTuple<StringLength<A>, 0>,
-				BuildTuple<StringLength<B>, 0>,
-			] extends infer R extends [readonly unknown[], readonly unknown[]]
-		? R[0] extends [...R[1], ...infer Remain extends readonly unknown[]]
-			? 0 extends Remain['length']
-				? SameLengthPositiveNumericStringGt<A, B>
-				: true
-			: false
-		: never;
+export type PositiveNumericStringGt<A extends string, B extends string> = A extends B ? false : [
+	BuildTuple<StringLength<A>, 0>,
+	BuildTuple<StringLength<B>, 0>
+] extends infer R extends [
+	readonly unknown[],
+	readonly unknown[]
+] ? R[0] extends [
+	...R[1],
+	...infer Remain extends readonly unknown[]
+] ? 0 extends Remain["length"] ? SameLengthPositiveNumericStringGt<A, B> : true : false : never;
 /**
 Returns a boolean for whether `A` represents a number greater than `B`, where `A` and `B` are both positive numeric characters.
 
@@ -848,16 +755,7 @@ PositiveNumericCharacterGt<'1', '1'>;
 //=> false
 ```
 */
-export type PositiveNumericCharacterGt<
-	A extends string,
-	B extends string,
-> = NumericString extends `${infer HeadA}${A}${infer TailA}`
-	? NumericString extends `${infer HeadB}${B}${infer TailB}`
-		? HeadA extends `${HeadB}${infer _}${infer __}`
-			? true
-			: false
-		: never
-	: never;
+export type PositiveNumericCharacterGt<A extends string, B extends string> = NumericString extends `${infer HeadA}${A}${infer TailA}` ? NumericString extends `${infer HeadB}${B}${infer TailB}` ? HeadA extends `${HeadB}${infer _}${infer __}` ? true : false : never : never;
 /**
 Returns the absolute value of a given value.
 
@@ -873,10 +771,7 @@ NumberAbsolute<NegativeInfinity>
 //=> PositiveInfinity
 ```
 */
-export type NumberAbsolute<N extends number> =
-	`${N}` extends `-${infer StringPositiveN}`
-		? StringToNumber<StringPositiveN>
-		: N;
+export type NumberAbsolute<N extends number> = `${N}` extends `-${infer StringPositiveN}` ? StringToNumber<StringPositiveN> : N;
 /**
 Check whether the given type is a number or a number string.
 
@@ -896,13 +791,7 @@ type C = IsNumberLike<1>;
 type D = IsNumberLike<'a'>;
 //=> false
 */
-export type IsNumberLike<N> = N extends number
-	? true
-	: N extends `${number}`
-		? true
-		: N extends `${number}.${number}`
-			? true
-			: false;
+export type IsNumberLike<N> = N extends number ? true : N extends `${number}` ? true : N extends `${number}.${number}` ? true : false;
 /**
 Matches any primitive, `void`, `Date`, or `RegExp` value.
 */
@@ -910,12 +799,7 @@ export type BuiltIns = Primitive | void | Date | RegExp;
 /**
 Matches non-recursive types.
 */
-export type NonRecursiveType =
-	| BuiltIns
-	| Function
-	| (new (
-			...arguments_: any[]
-	  ) => unknown);
+export type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown);
 /**
 Returns the sum of two numbers.
 
@@ -947,45 +831,35 @@ Sum<PositiveInfinity, NegativeInfinity>;
 @category Numeric
 */
 // TODO: Support big integer and negative number.
-export type Sum<A extends number, B extends number> = number extends A | B
-	? number
-	: [
-				IsEqual<A, PositiveInfinity>,
-				IsEqual<A, NegativeInfinity>,
-				IsEqual<B, PositiveInfinity>,
-				IsEqual<B, NegativeInfinity>,
-			] extends infer R extends [boolean, boolean, boolean, boolean]
-		? Or<
-				And<IsEqual<R[0], true>, IsEqual<R[3], false>>,
-				And<IsEqual<R[2], true>, IsEqual<R[1], false>>
-			> extends true
-			? PositiveInfinity
-			: Or<
-						And<IsEqual<R[1], true>, IsEqual<R[2], false>>,
-						And<IsEqual<R[3], true>, IsEqual<R[0], false>>
-					> extends true
-				? NegativeInfinity
-				: true extends R[number]
-					? number
-					: ([IsNegative<A>, IsNegative<B>] extends infer R
-							? [false, false] extends R
-								? [...BuildTuple<A>, ...BuildTuple<B>]['length']
-								: [true, true] extends R
-									? number
-									: TupleMax<
-												[NumberAbsolute<A>, NumberAbsolute<B>]
-											> extends infer Max_
-										? TupleMin<
-												[NumberAbsolute<A>, NumberAbsolute<B>]
-											> extends infer Min_ extends number
-											? Max_ extends A | B
-												? Subtract<Max_, Min_>
-												: number
-											: never
-										: never
-							: never) &
-							number
-		: never;
+export type Sum<A extends number, B extends number> = number extends A | B ? number : [
+	IsEqual<A, PositiveInfinity>,
+	IsEqual<A, NegativeInfinity>,
+	IsEqual<B, PositiveInfinity>,
+	IsEqual<B, NegativeInfinity>
+] extends infer R extends [
+	boolean,
+	boolean,
+	boolean,
+	boolean
+] ? Or<And<IsEqual<R[0], true>, IsEqual<R[3], false>>, And<IsEqual<R[2], true>, IsEqual<R[1], false>>> extends true ? PositiveInfinity : Or<And<IsEqual<R[1], true>, IsEqual<R[2], false>>, And<IsEqual<R[3], true>, IsEqual<R[0], false>>> extends true ? NegativeInfinity : true extends R[number] ? number : ([
+	IsNegative<A>,
+	IsNegative<B>
+] extends infer R ? [
+	false,
+	false
+] extends R ? [
+	...BuildTuple<A>,
+	...BuildTuple<B>
+]["length"] : [
+	true,
+	true
+] extends R ? number : TupleMax<[
+	NumberAbsolute<A>,
+	NumberAbsolute<B>
+]> extends infer Max_ ? TupleMin<[
+	NumberAbsolute<A>,
+	NumberAbsolute<B>
+]> extends infer Min_ extends number ? Max_ extends A | B ? Subtract<Max_, Min_> : number : never : never : never) & number : never;
 /**
 Returns the difference between two numbers.
 
@@ -1016,40 +890,29 @@ Subtract<PositiveInfinity, PositiveInfinity>;
 @category Numeric
 */
 // TODO: Support big integer and negative number.
-export type Subtract<A extends number, B extends number> = number extends A | B
-	? number
-	: [
-				IsEqual<A, PositiveInfinity>,
-				IsEqual<A, NegativeInfinity>,
-				IsEqual<B, PositiveInfinity>,
-				IsEqual<B, NegativeInfinity>,
-			] extends infer R extends [boolean, boolean, boolean, boolean]
-		? Or<
-				And<IsEqual<R[0], true>, IsEqual<R[2], false>>,
-				And<IsEqual<R[3], true>, IsEqual<R[1], false>>
-			> extends true
-			? PositiveInfinity
-			: Or<
-						And<IsEqual<R[1], true>, IsEqual<R[3], false>>,
-						And<IsEqual<R[2], true>, IsEqual<R[0], false>>
-					> extends true
-				? NegativeInfinity
-				: true extends R[number]
-					? number
-					: [IsNegative<A>, IsNegative<B>] extends infer R
-						? [false, false] extends R
-							? BuildTuple<A> extends infer R
-								? R extends [...BuildTuple<B>, ...infer R]
-									? R['length']
-									: number
-								: never
-							: LessThan<A, B> extends true
-								? number
-								: [false, true] extends R
-									? Sum<A, NumberAbsolute<B>>
-									: Subtract<NumberAbsolute<B>, NumberAbsolute<A>>
-						: never
-		: never;
+export type Subtract<A extends number, B extends number> = number extends A | B ? number : [
+	IsEqual<A, PositiveInfinity>,
+	IsEqual<A, NegativeInfinity>,
+	IsEqual<B, PositiveInfinity>,
+	IsEqual<B, NegativeInfinity>
+] extends infer R extends [
+	boolean,
+	boolean,
+	boolean,
+	boolean
+] ? Or<And<IsEqual<R[0], true>, IsEqual<R[2], false>>, And<IsEqual<R[3], true>, IsEqual<R[1], false>>> extends true ? PositiveInfinity : Or<And<IsEqual<R[1], true>, IsEqual<R[3], false>>, And<IsEqual<R[2], true>, IsEqual<R[0], false>>> extends true ? NegativeInfinity : true extends R[number] ? number : [
+	IsNegative<A>,
+	IsNegative<B>
+] extends infer R ? [
+	false,
+	false
+] extends R ? BuildTuple<A> extends infer R ? R extends [
+	...BuildTuple<B>,
+	...infer R
+] ? R["length"] : number : never : LessThan<A, B> extends true ? number : [
+	false,
+	true
+] extends R ? Sum<A, NumberAbsolute<B>> : Subtract<NumberAbsolute<B>, NumberAbsolute<A>> : never : never;
 /**
 Paths options.
 
@@ -1140,85 +1003,28 @@ open('listB.1'); // TypeError. Because listB only has one element.
 @category Object
 @category Array
 */
-export type Paths<T, Options extends PathsOptions = {}> = _Paths<
-	T,
-	{
-		// Set default maxRecursionDepth to 10
-		maxRecursionDepth: Options['maxRecursionDepth'] extends number
-			? Options['maxRecursionDepth']
-			: DefaultPathsOptions['maxRecursionDepth'];
-		// Set default bracketNotation to false
-		bracketNotation: Options['bracketNotation'] extends boolean
-			? Options['bracketNotation']
-			: DefaultPathsOptions['bracketNotation'];
-	}
->;
-export type _Paths<T, Options extends Required<PathsOptions>> = T extends
-	| NonRecursiveType
-	| ReadonlyMap<unknown, unknown>
-	| ReadonlySet<unknown>
-	? never
-	: IsAny<T> extends true
-		? never
-		: T extends UnknownArray
-			? number extends T['length']
-				?
-						| InternalPaths<StaticPartOfArray<T>, Options>
-						| InternalPaths<Array<VariablePartOfArray<T>[number]>, Options>
-				: InternalPaths<T, Options>
-			: T extends object
-				? InternalPaths<T, Options>
-				: never;
-export type InternalPaths<
-	T,
-	Options extends Required<PathsOptions>,
-> = Options['maxRecursionDepth'] extends infer MaxDepth extends number
-	? Required<T> extends infer T
-		? T extends EmptyObject | readonly []
-			? never
-			: {
-					[Key in keyof T]: Key extends string | number // Limit `Key` to string or number.
-						? (
-								Options['bracketNotation'] extends true
-									? IsNumberLike<Key> extends true
-										? `[${Key}]`
-										: Key | ToString<Key>
-									: never | Options['bracketNotation'] extends false
-										? Key | ToString<Key>
-										: never
-							) extends infer TranformedKey extends string | number
-							? // 1. If style is 'a[0].b' and 'Key' is a numberlike value like 3 or '3', transform 'Key' to `[${Key}]`, else to `${Key}` | Key
-								// 2. If style is 'a.0.b', transform 'Key' to `${Key}` | Key
-									| TranformedKey
-									// Recursively generate paths for the current key
-									| (GreaterThan<MaxDepth, 0> extends true // Limit the depth to prevent infinite recursion
-											? _Paths<
-													T[Key],
-													{
-														bracketNotation: Options['bracketNotation'];
-														maxRecursionDepth: Subtract<MaxDepth, 1>;
-													}
-												> extends infer SubPath
-												? SubPath extends string | number
-													?
-															| (Options['bracketNotation'] extends true
-																	? SubPath extends
-																			| `[${any}]`
-																			| `[${any}]${string}`
-																		? `${TranformedKey}${SubPath}` // If next node is number key like `[3]`, no need to add `.` before it.
-																		: `${TranformedKey}.${SubPath}`
-																	: never)
-															| (Options['bracketNotation'] extends false
-																	? `${TranformedKey}.${SubPath}`
-																	: never)
-													: never
-												: never
-											: never)
-							: never
-						: never;
-				}[keyof T & (T extends UnknownArray ? number : unknown)]
-		: never
-	: never;
+export type Paths<T, Options extends PathsOptions = {}> = _Paths<T, {
+	// Set default maxRecursionDepth to 10
+	maxRecursionDepth: Options["maxRecursionDepth"] extends number ? Options["maxRecursionDepth"] : DefaultPathsOptions["maxRecursionDepth"];
+	// Set default bracketNotation to false
+	bracketNotation: Options["bracketNotation"] extends boolean ? Options["bracketNotation"] : DefaultPathsOptions["bracketNotation"];
+}>;
+export type _Paths<T, Options extends Required<PathsOptions>> = T extends NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> ? never : IsAny<T> extends true ? never : T extends UnknownArray ? number extends T["length"] ? InternalPaths<StaticPartOfArray<T>, Options> | InternalPaths<Array<VariablePartOfArray<T>[number]>, Options> : InternalPaths<T, Options> : T extends object ? InternalPaths<T, Options> : never;
+export type InternalPaths<T, Options extends Required<PathsOptions>> = Options["maxRecursionDepth"] extends infer MaxDepth extends number ? Required<T> extends infer T ? T extends EmptyObject | readonly [
+] ? never : {
+	[Key in keyof T]: Key extends string | number // Limit `Key` to string or number.
+	 ? (Options["bracketNotation"] extends true ? IsNumberLike<Key> extends true ? `[${Key}]` : (Key | ToString<Key>) : never | Options["bracketNotation"] extends false ? (Key | ToString<Key>) : never) extends infer TranformedKey extends string | number ? 
+	// 1. If style is 'a[0].b' and 'Key' is a numberlike value like 3 or '3', transform 'Key' to `[${Key}]`, else to `${Key}` | Key
+	// 2. If style is 'a.0.b', transform 'Key' to `${Key}` | Key
+	TranformedKey | (
+	// Recursively generate paths for the current key
+	GreaterThan<MaxDepth, 0> extends true // Limit the depth to prevent infinite recursion
+	 ? _Paths<T[Key], {
+		bracketNotation: Options["bracketNotation"];
+		maxRecursionDepth: Subtract<MaxDepth, 1>;
+	}> extends infer SubPath ? SubPath extends string | number ? (Options["bracketNotation"] extends true ? SubPath extends `[${any}]` | `[${any}]${string}` ? `${TranformedKey}${SubPath}` // If next node is number key like `[3]`, no need to add `.` before it.
+	 : `${TranformedKey}.${SubPath}` : never) | (Options["bracketNotation"] extends false ? `${TranformedKey}.${SubPath}` : never) : never : never : never) : never : never;
+}[keyof T & (T extends UnknownArray ? number : unknown)] : never : never;
 export type LiteralStringUnion<T> = LiteralUnion<T, string>;
 /**
 Allows creating a union type by combining primitive types and literal types without sacrificing auto-completion in IDEs for the literal type part of the union.
@@ -1249,9 +1055,7 @@ const pet: Pet2 = '';
 
 @category Type
 */
-export type LiteralUnion<LiteralType, BaseType extends Primitive> =
-	| LiteralType
-	| (BaseType & Record<never, never>);
+export type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
 /**
 Get keys of the given type as strings.
 
@@ -1276,8 +1080,7 @@ type StringKeysOfFoo = StringKeyOf<Foo>;
 
 @category Object
 */
-export type StringKeyOf<BaseType> =
-	`${Extract<keyof BaseType, string | number>}`;
+export type StringKeyOf<BaseType> = `${Extract<keyof BaseType, string | number>}`;
 /**
 Represents an array of strings split using a given character or character set.
 
@@ -1299,14 +1102,13 @@ array = split(items, ',');
 @category String
 @category Template literal
 */
-export type Split<
-	S extends string,
-	Delimiter extends string,
-> = S extends `${infer Head}${Delimiter}${infer Tail}`
-	? [Head, ...Split<Tail, Delimiter>]
-	: S extends Delimiter
-		? []
-		: [S];
+export type Split<S extends string, Delimiter extends string> = S extends `${infer Head}${Delimiter}${infer Tail}` ? [
+	Head,
+	...Split<Tail, Delimiter>
+] : S extends Delimiter ? [
+] : [
+	S
+];
 export type GetOptions = {
 	/**
 	Include `undefined` in the return type when accessing properties.
@@ -1320,41 +1122,24 @@ export type GetOptions = {
 /**
 Like the `Get` type but receives an array of strings as a path parameter.
 */
-export type GetWithPath<
-	BaseType,
-	Keys,
-	Options extends GetOptions = {},
-> = Keys extends readonly []
-	? BaseType
-	: Keys extends readonly [infer Head, ...infer Tail]
-		? GetWithPath<
-				PropertyOf<BaseType, Extract<Head, string>, Options>,
-				Extract<Tail, string[]>,
-				Options
-			>
-		: never;
+export type GetWithPath<BaseType, Keys, Options extends GetOptions = {}> = Keys extends readonly [
+] ? BaseType : Keys extends readonly [
+	infer Head,
+	...infer Tail
+] ? GetWithPath<PropertyOf<BaseType, Extract<Head, string>, Options>, Extract<Tail, string[]>, Options> : never;
 /**
 Adds `undefined` to `Type` if `strict` is enabled.
 */
-export type Strictify<
-	Type,
-	Options extends GetOptions,
-> = Options['strict'] extends false ? Type : Type | undefined;
+export type Strictify<Type, Options extends GetOptions> = Options["strict"] extends false ? Type : (Type | undefined);
 /**
 If `Options['strict']` is `true`, includes `undefined` in the returned type when accessing properties on `Record<string, any>`.
 
 Known limitations:
 - Does not include `undefined` in the type on object types with an index signature (for example, `{a: string; [key: string]: string}`).
 */
-export type StrictPropertyOf<
-	BaseType,
-	Key extends keyof BaseType,
-	Options extends GetOptions,
-> = Record<string, any> extends BaseType
-	? string extends keyof BaseType
-		? Strictify<BaseType[Key], Options> // Record<string, any>
-		: BaseType[Key] // Record<'a' | 'b', any> (Records with a string union as keys have required properties)
-	: BaseType[Key];
+export type StrictPropertyOf<BaseType, Key extends keyof BaseType, Options extends GetOptions> = Record<string, any> extends BaseType ? string extends keyof BaseType ? Strictify<BaseType[Key], Options> // Record<string, any>
+ : BaseType[Key] // Record<'a' | 'b', any> (Records with a string union as keys have required properties)
+ : BaseType[Key];
 /**
 Splits a dot-prop style path into a tuple comprised of the properties in the path. Handles square-bracket notation.
 
@@ -1367,18 +1152,11 @@ ToPath<'foo[0].bar.baz'>
 //=> ['foo', '0', 'bar', 'baz']
 ```
 */
-export type ToPath<S extends string> = Split<FixPathSquareBrackets<S>, '.'>;
+export type ToPath<S extends string> = Split<FixPathSquareBrackets<S>, ".">;
 /**
 Replaces square-bracketed dot notation with dots, for example, `foo[0].bar` -> `foo.0.bar`.
 */
-export type FixPathSquareBrackets<Path extends string> =
-	Path extends `[${infer Head}]${infer Tail}`
-		? Tail extends `[${string}`
-			? `${Head}.${FixPathSquareBrackets<Tail>}`
-			: `${Head}${FixPathSquareBrackets<Tail>}`
-		: Path extends `${infer Head}[${infer Middle}]${infer Tail}`
-			? `${Head}.${FixPathSquareBrackets<`[${Middle}]${Tail}`>}`
-			: Path;
+export type FixPathSquareBrackets<Path extends string> = Path extends `[${infer Head}]${infer Tail}` ? Tail extends `[${string}` ? `${Head}.${FixPathSquareBrackets<Tail>}` : `${Head}${FixPathSquareBrackets<Tail>}` : Path extends `${infer Head}[${infer Middle}]${infer Tail}` ? `${Head}.${FixPathSquareBrackets<`[${Middle}]${Tail}`>}` : Path;
 /**
 Returns true if `LongString` is made up out of `Substring` repeated 0 or more times.
 
@@ -1390,14 +1168,7 @@ ConsistsOnlyOf<'aBa', 'a'> //=> false
 ConsistsOnlyOf<'', 'a'> //=> true
 ```
 */
-export type ConsistsOnlyOf<
-	LongString extends string,
-	Substring extends string,
-> = LongString extends ''
-	? true
-	: LongString extends `${Substring}${infer Tail}`
-		? ConsistsOnlyOf<Tail, Substring>
-		: false;
+export type ConsistsOnlyOf<LongString extends string, Substring extends string> = LongString extends "" ? true : LongString extends `${Substring}${infer Tail}` ? ConsistsOnlyOf<Tail, Substring> : false;
 /**
 Convert a type which may have number keys to one with string keys, making it possible to index using strings retrieved from template types.
 
@@ -1418,11 +1189,11 @@ export type WithStringKeys<BaseType> = {
 /**
 Perform a `T[U]` operation if `T` supports indexing.
 */
-export type UncheckedIndex<T, U extends string | number> = [T] extends [
-	Record<string | number, any>,
-]
-	? T[U]
-	: never;
+export type UncheckedIndex<T, U extends string | number> = [
+	T
+] extends [
+	Record<string | number, any>
+] ? T[U] : never;
 /**
 Get a property of an object or array. Works when indexing arrays using number-literal-strings, for example, `PropertyOf<number[], '0'> = number`, and when indexing objects with number keys.
 
@@ -1430,26 +1201,15 @@ Note:
 - Returns `unknown` if `Key` is not a property of `BaseType`, since TypeScript uses structural typing, and it cannot be guaranteed that extra properties unknown to the type system will exist at runtime.
 - Returns `undefined` from nullish values, to match the behaviour of most deep-key libraries like `lodash`, `dot-prop`, etc.
 */
-export type PropertyOf<
-	BaseType,
-	Key extends string,
-	Options extends GetOptions = {},
-> = BaseType extends null | undefined
-	? undefined
-	: Key extends keyof BaseType
-		? StrictPropertyOf<BaseType, Key, Options>
-		: BaseType extends readonly [] | readonly [unknown, ...unknown[]]
-			? unknown // It's a tuple, but `Key` did not extend `keyof BaseType`. So the index is out of bounds.
-			: BaseType extends {
-						[n: number]: infer Item;
-						length: number; // Note: This is needed to avoid being too lax with records types using number keys like `{0: string; 1: boolean}`.
-					}
-				? ConsistsOnlyOf<Key, StringDigit> extends true
-					? Strictify<Item, Options>
-					: unknown
-				: Key extends keyof WithStringKeys<BaseType>
-					? StrictPropertyOf<WithStringKeys<BaseType>, Key, Options>
-					: unknown;
+export type PropertyOf<BaseType, Key extends string, Options extends GetOptions = {}> = BaseType extends null | undefined ? undefined : Key extends keyof BaseType ? StrictPropertyOf<BaseType, Key, Options> : BaseType extends readonly [
+] | readonly [
+	unknown,
+	...unknown[]
+] ? unknown // It's a tuple, but `Key` did not extend `keyof BaseType`. So the index is out of bounds.
+ : BaseType extends {
+	[n: number]: infer Item;
+	length: number; // Note: This is needed to avoid being too lax with records types using number keys like `{0: string; 1: boolean}`.
+} ? (ConsistsOnlyOf<Key, StringDigit> extends true ? Strictify<Item, Options> : unknown) : Key extends keyof WithStringKeys<BaseType> ? StrictPropertyOf<WithStringKeys<BaseType>, Key, Options> : unknown;
 // This works by first splitting the path based on `.` and `[...]` characters into a tuple of string keys. Then it recursively uses the head key to get the next property of the current object, until there are no keys left. Number keys extract the item type from arrays, or are converted to strings to extract types from tuples and dictionaries with number keys.
 /**
 Get a deeply-nested property from an object using a key path, like Lodash's `.get()` function.
@@ -1497,40 +1257,18 @@ Get<Record<string, string>, 'foo', {strict: true}> // => string
 @category Array
 @category Template literal
 */
-export type Get<
-	BaseType,
-	Path extends
-		| readonly string[]
-		| LiteralStringUnion<
-				ToString<
-					| Paths<
-							BaseType,
-							{
-								bracketNotation: false;
-							}
-					  >
-					| Paths<
-							BaseType,
-							{
-								bracketNotation: true;
-							}
-					  >
-				>
-		  >,
-	Options extends GetOptions = {},
-> = GetWithPath<BaseType, Path extends string ? ToPath<Path> : Path, Options>;
+export type Get<BaseType, Path extends readonly string[] | LiteralStringUnion<ToString<Paths<BaseType, {
+	bracketNotation: false;
+}> | Paths<BaseType, {
+	bracketNotation: true;
+}>>>, Options extends GetOptions = {}> = GetWithPath<BaseType, Path extends string ? ToPath<Path> : Path, Options>;
 export type ArrayOrPlainObject = UnknownArray | UnknownRecord;
 export type EventPosition = {
 	x: number;
 	y: number;
 };
-export type KeyedValue<
-	Item,
-	Key extends keyof Item,
-> = Item[Key] extends PropertyKey ? Item[Key] : never;
-export type NestedArrayType<Value> = Value extends Array<infer NestedValue>
-	? NestedArrayType<NestedValue>
-	: Value;
+export type KeyedValue<Item, Key extends keyof Item> = Item[Key] extends PropertyKey ? Item[Key] : never;
+export type NestedArrayType<Value> = Value extends Array<infer NestedValue> ? NestedArrayType<NestedValue> : Value;
 export type GenericCallback = (...args: any[]) => any;
 export type Key = number | string;
 export type PlainObject = UnknownRecord;
@@ -1546,21 +1284,12 @@ export declare function toQuery(parameters: PlainObject): string;
 /**
  * Is the number between a minimum and maximum value?
  */
-export declare function between(
-	value: number,
-	min: number,
-	max: number,
-): boolean;
+export declare function between(value: number, min: number, max: number): boolean;
 /**
  * - Clamp a number between a minimum and maximum value
  * - If `loop` is `true`, when the value is less than the minimum, it will be clamped as the maximum, and vice versa
  */
-export declare function clamp(
-	value: number,
-	min: number,
-	max: number,
-	loop?: boolean,
-): number;
+export declare function clamp(value: number, min: number, max: number, loop?: boolean): number;
 /**
  * - Get the number value from an unknown value
  * - Returns `NaN` if the value is `undefined`, `null`, or cannot be parsed
@@ -1600,7 +1329,7 @@ declare class Logger {
 	 */
 	get dir(): {
 		(item?: any, options?: any): void;
-		(obj: any, options?: import('util').InspectOptions): void;
+		(obj: any, options?: import("util").InspectOptions): void;
 	};
 	/**
 	 * Is logging to the console enabled? _(defaults to `true`)_
@@ -1676,9 +1405,7 @@ export declare const logger: Logger;
 /**
  * Is the value an array or a record?
  */
-export declare function isArrayOrPlainObject(
-	value: unknown,
-): value is ArrayOrPlainObject;
+export declare function isArrayOrPlainObject(value: unknown): value is ArrayOrPlainObject;
 /**
  * Is the array or object completely empty or only containing `null` or `undefined` values?
  */
@@ -1694,15 +1421,11 @@ export declare function isNullable(value: unknown): value is undefined | null;
 /**
  * Is the value undefined, null, or an empty string?
  */
-export declare function isNullableOrEmpty(
-	value: unknown,
-): value is undefined | null | '';
+export declare function isNullableOrEmpty(value: unknown): value is undefined | null | "";
 /**
  * Is the value undefined, null, or a whitespace-only string?
  */
-export declare function isNullableOrWhitespace(
-	value: unknown,
-): value is undefined | null | '';
+export declare function isNullableOrWhitespace(value: unknown): value is undefined | null | "";
 /**
  * Is the value a number?
  */
@@ -1710,9 +1433,7 @@ export declare function isNumber(value: unknown): value is number;
 /**
  * Is the value a number, or a number-like string?
  */
-export declare function isNumerical(
-	value: unknown,
-): value is number | `${number}`;
+export declare function isNumerical(value: unknown): value is number | `${number}`;
 /**
  * Is the value an object?
  */
@@ -1732,29 +1453,11 @@ export declare function chunk<Item>(array: Item[], size?: number): Item[][];
 /**
  * Compact an array _(removing all `null` and `undefined` values)_
  */
-export declare function compact<Item>(
-	array: Item[],
-): Exclude<Item, null | undefined>[];
+export declare function compact<Item>(array: Item[]): Exclude<Item, null | undefined>[];
 /**
  * Compact an array _(removing all falsey values)_
  */
-export declare function compact<Item>(
-	array: Item[],
-	strict: true,
-): Exclude<Item, 0 | '' | false | null | undefined>[];
-export type ArrayCallback<Item, Value> = (
-	item: Item,
-	index: number,
-	array: Item[],
-) => Value;
-export type BooleanCallback<Item> = ArrayCallback<Item, boolean>;
-export type KeyCallback<Item> = ArrayCallback<Item, Key>;
-export type SortKey<Item> = {
-	direction: 'asc' | 'desc';
-	value: Key | SortKeyCallback<Item>;
-};
-export type SortKeyCallback<Item> = (item: Item) => unknown;
-export type ValueCallback<Item> = ArrayCallback<Item, unknown>;
+export declare function compact<Item>(array: Item[], strict: true): Exclude<Item, 0 | "" | false | null | undefined>[];
 /**
  * Get the number of items _(count)_ that match the given value
  */
@@ -1762,26 +1465,15 @@ export declare function count<Item>(array: Item[], value: Item): number;
 /**
  * Get the number of items _(count)_ that match the given value
  */
-export declare function count<Item>(
-	array: Item[],
-	matches: BooleanCallback<Item>,
-): number;
+export declare function count<Item>(array: Item[], matches: (item: Item, index: number, array: Item[]) => boolean): number;
 /**
  * Get the number of items _(count)_ that match the given value
  */
-export declare function count<Item, Key extends keyof Item>(
-	array: Item[],
-	key: Key,
-	value: Item[Key],
-): number;
+export declare function count<Item, Key extends keyof Item>(array: Item[], key: Key, value: Item[Key]): number;
 /**
  * Get the number of items _(count)_ that match the given value
  */
-export declare function count<Item, Key extends KeyCallback<Item>>(
-	array: Item[],
-	key: Key,
-	value: ReturnType<Key>,
-): number;
+export declare function count<Item, Key extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], key: Key, value: ReturnType<Key>): number;
 /**
  * Does the value exist in array?
  */
@@ -1789,28 +1481,17 @@ export declare function exists<Item>(array: Item[], value: Item): boolean;
 /**
  * Does the value exist in array?
  */
-export declare function exists<Item>(
-	array: Item[],
-	matches: BooleanCallback<Item>,
-): boolean;
+export declare function exists<Item>(array: Item[], matches: (item: Item, index: number, array: Item[]) => boolean): boolean;
 /**
  * - Does the value exist in array?
  * - Use `key` to find a comparison value to match with `value`
  */
-export declare function exists<Item, Key extends keyof Item>(
-	array: Item[],
-	key: Key,
-	value: Item[Key],
-): boolean;
+export declare function exists<Item, Key extends keyof Item>(array: Item[], key: Key, value: Item[Key]): boolean;
 /**
  * - Does the value exist in array?
  * - Use `key` to find a comparison value to match with `value`
  */
-export declare function exists<Item, Key extends KeyCallback<Item>>(
-	array: Item[],
-	key: Key,
-	value: ReturnType<Key>,
-): boolean;
+export declare function exists<Item, Key extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], key: Key, value: ReturnType<Key>): boolean;
 /**
  * Get a filtered array of items matching `value`
  */
@@ -1818,190 +1499,83 @@ export declare function filter<Item>(array: Item[], value: Item): Item[];
 /**
  * Get a filtered array of items matching `value`
  */
-export declare function filter<Item>(
-	array: Item[],
-	matches: BooleanCallback<Item>,
-): Item[];
+export declare function filter<Item>(array: Item[], matches: (item: Item, index: number, array: Item[]) => boolean): Item[];
 /**
  * - Get a filtered array of items
  * - Use `key` to find a comparison value to match with `value`
  */
-export declare function filter<Item, Key extends keyof Item>(
-	array: Item[],
-	key: Key,
-	value: Item[Key],
-): Item[];
+export declare function filter<Item, Key extends keyof Item>(array: Item[], key: Key, value: Item[Key]): Item[];
 /**
  * - Get a filtered array of items
  * - Use `key` to find a comparison value to match with `value`
  */
-export declare function filter<Item, Key extends KeyCallback<Item>>(
-	array: Item[],
-	key: Key,
-	value: ReturnType<Key>,
-): Item[];
+export declare function filter<Item, Key extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], key: Key, value: ReturnType<Key>): Item[];
 /**
  * Get the first item matching `value` _(or `undefined` if no match is found)_
  */
-export declare function find<Item>(
-	array: Item[],
-	value: Item,
-): Item | undefined;
+export declare function find<Item>(array: Item[], value: Item): Item | undefined;
 /**
  * Get the first item matching `value` _(or `undefined` if no match is found)_
  */
-export declare function find<Item>(
-	array: Item[],
-	matches: BooleanCallback<Item>,
-): Item | undefined;
+export declare function find<Item>(array: Item[], matches: (item: Item, index: number, array: Item[]) => boolean): Item | undefined;
 /**
  * - Get the first matching item _(or `undefined` if no match is found)_
  * - Use `key` to find a comparison value to match with `value`
  */
-export declare function find<Item, Key extends keyof Item>(
-	array: Item[],
-	key: Key,
-	value: Item[Key],
-): Item | undefined;
+export declare function find<Item, Key extends keyof Item>(array: Item[], key: Key, value: Item[Key]): Item | undefined;
 /**
  * - Get the first matching item _(or `undefined` if no match is found)_
  * - Use `key` to find a comparison value to match with `value`
  */
-export declare function find<Item, Key extends KeyCallback<Item>>(
-	array: Item[],
-	key: Key,
-	value: ReturnType<Key>,
-): Item | undefined;
+export declare function find<Item, Key extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], key: Key, value: ReturnType<Key>): Item | undefined;
 /**
  * Create a record from an array of items using a specific key
  */
-export declare function groupBy<Item, Key extends keyof Item>(
-	array: Item[],
-	key: Key,
-): Record<KeyedValue<Item, Key>, Item>;
+export declare function groupBy<Item, Key extends keyof Item>(array: Item[], key: Key): Record<KeyedValue<Item, Key>, Item>;
 /**
  * Create a record from an array of items using a specific key, and grouping them into arrays
  */
-export declare function groupBy<Item, Key extends keyof Item>(
-	array: Item[],
-	key: Key,
-	arrays: true,
-): Record<KeyedValue<Item, Key>, Item[]>;
+export declare function groupBy<Item, Key extends keyof Item>(array: Item[], key: Key, arrays: true): Record<KeyedValue<Item, Key>, Item[]>;
 /**
  * Create a record from an array of items using a specific key
  */
-export declare function groupBy<Item, Key extends KeyCallback<Item>>(
-	array: Item[],
-	key: Key,
-): Record<ReturnType<Key>, Item>;
+export declare function groupBy<Item, Key extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], key: Key): Record<ReturnType<Key>, Item>;
 /**
  * Create a record from an array of items using a specific key, and grouping them into arrays
  */
-export declare function groupBy<Item, Key extends KeyCallback<Item>>(
-	array: Item[],
-	key: Key,
-	arrays: true,
-): Record<ReturnType<Key>, Item[]>;
+export declare function groupBy<Item, Key extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], key: Key, arrays: true): Record<ReturnType<Key>, Item[]>;
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function groupBy<
-	Item,
-	Key extends keyof Item,
-	Value extends keyof Item,
->(
-	array: Item[],
-	key: Key,
-	value: Value,
-): Record<KeyedValue<Item, Key>, KeyedValue<Item, Value>>;
+export declare function groupBy<Item, Key extends keyof Item, Value extends keyof Item>(array: Item[], key: Key, value: Value): Record<KeyedValue<Item, Key>, KeyedValue<Item, Value>>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function groupBy<
-	Item,
-	Key extends keyof Item,
-	Value extends keyof Item,
->(
-	array: Item[],
-	key: Key,
-	value: Value,
-	arrays: true,
-): Record<KeyedValue<Item, Key>, Array<KeyedValue<Item, Value>>>;
+export declare function groupBy<Item, Key extends keyof Item, Value extends keyof Item>(array: Item[], key: Key, value: Value, arrays: true): Record<KeyedValue<Item, Key>, Array<KeyedValue<Item, Value>>>;
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function groupBy<
-	Item,
-	Key extends keyof Item,
-	Value extends ValueCallback<Item>,
->(
-	array: Item[],
-	key: Key,
-	value: Value,
-): Record<KeyedValue<Item, Key>, ReturnType<Value>>;
+export declare function groupBy<Item, Key extends keyof Item, Value extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: Key, value: Value): Record<KeyedValue<Item, Key>, ReturnType<Value>>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function groupBy<
-	Item,
-	Key extends keyof Item,
-	Value extends ValueCallback<Item>,
->(
-	array: Item[],
-	key: Key,
-	value: Value,
-	arrays: true,
-): Record<KeyedValue<Item, Key>, Array<ReturnType<Value>>>;
+export declare function groupBy<Item, Key extends keyof Item, Value extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: Key, value: Value, arrays: true): Record<KeyedValue<Item, Key>, Array<ReturnType<Value>>>;
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function groupBy<
-	Item,
-	Key extends KeyCallback<Item>,
-	Value extends keyof Item,
->(
-	array: Item[],
-	key: Key,
-	value: Value,
-): Record<ReturnType<Key>, KeyedValue<Item, Value>>;
+export declare function groupBy<Item, Key extends (item: Item, index: number, array: Item[]) => Key, Value extends keyof Item>(array: Item[], key: Key, value: Value): Record<ReturnType<Key>, KeyedValue<Item, Value>>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function groupBy<
-	Item,
-	Key extends KeyCallback<Item>,
-	Value extends keyof Item,
->(
-	array: Item[],
-	key: Key,
-	value: Value,
-	arrays: true,
-): Record<ReturnType<Key>, Array<KeyedValue<Item, Value>>>;
+export declare function groupBy<Item, Key extends (item: Item, index: number, array: Item[]) => Key, Value extends keyof Item>(array: Item[], key: Key, value: Value, arrays: true): Record<ReturnType<Key>, Array<KeyedValue<Item, Value>>>;
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function groupBy<
-	Item,
-	Key extends KeyCallback<Item>,
-	Value extends ValueCallback<Item>,
->(
-	array: Item[],
-	key: Key,
-	value: Value,
-): Record<ReturnType<Key>, ReturnType<Value>>;
+export declare function groupBy<Item, Key extends (item: Item, index: number, array: Item[]) => Key, Value extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: Key, value: Value): Record<ReturnType<Key>, ReturnType<Value>>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function groupBy<
-	Item,
-	Key extends KeyCallback<Item>,
-	Value extends ValueCallback<Item>,
->(
-	array: Item[],
-	key: Key,
-	value: Value,
-	arrays: true,
-): Record<ReturnType<Key>, Array<ReturnType<Value>>>;
+export declare function groupBy<Item, Key extends (item: Item, index: number, array: Item[]) => Key, Value extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: Key, value: Value, arrays: true): Record<ReturnType<Key>, Array<ReturnType<Value>>>;
 /**
  * Get the index for the first item matching `value` _(or `-1` if no match is found)_
  */
@@ -2009,28 +1583,21 @@ export declare function indexOf<Item>(array: Item[], value: Item): number;
 /**
  * Get the index for the first item matching `value` _(or `-1` if no match is found)_
  */
-export declare function indexOf<Item>(
-	array: Item[],
-	matches: BooleanCallback<Item>,
-): number;
+export declare function indexOf<Item>(array: Item[], matches: (item: Item, index: number, array: Item[]) => boolean): number;
 /**
  * - 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 declare function indexOf<Item, Key extends keyof Item>(
-	array: Item[],
-	key: Key,
-	value: Item[Key],
-): number;
+export declare function indexOf<Item, Key extends keyof Item>(array: Item[], key: Key, value: Item[Key]): number;
 /**
  * - 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 declare function indexOf<Item, Key extends KeyCallback<Item>>(
-	array: Item[],
-	key: Key,
-	value: ReturnType<Key>,
-): number;
+export declare function indexOf<Item, Key extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], key: Key, value: ReturnType<Key>): number;
+export type SortKey<Item> = {
+	direction: "asc" | "desc";
+	value: Key | ((item: Item) => Key);
+};
 /**
  * - Insert values into an array _(at the end)_
  * - _(Uses chunking to avoid stack overflow_)
@@ -2040,11 +1607,7 @@ export declare function insert<Item>(array: Item[], items: Item[]): void;
  * - Insert values into an array at a specified index
  * - _(Uses chunking to avoid stack overflow_)
  */
-export declare function insert<Item>(
-	array: Item[],
-	index: number,
-	items: Item[],
-): void;
+export declare function insert<Item>(array: Item[], index: number, items: Item[]): void;
 /**
  * Shuffle an array
  */
@@ -2057,20 +1620,12 @@ export declare function sort<Item>(array: 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 declare function sort<Item>(
-	array: Item[],
-	key: Key | SortKey<Item> | SortKeyCallback<Item>,
-	descending?: boolean,
-): Item[];
+export declare function sort<Item>(array: Item[], key: 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`
  */
-export declare function sort<Item>(
-	array: Item[],
-	keys: Array<Key | SortKey<Item> | SortKeyCallback<Item>>,
-	descending?: boolean,
-): Item[];
+export declare function sort<Item>(array: Item[], keys: Array<Key | SortKey<Item> | ((item: Item) => Key)>, descending?: boolean): Item[];
 /**
  * Removes and returns all items from an array starting from a specific index
  */
@@ -2078,30 +1633,17 @@ export declare function splice<Item>(array: Item[], start: number): Item[];
 /**
  * Removes and returns _(up to)_ a specific amount of items from an array, starting from a specific index
  */
-export declare function splice<Item>(
-	array: Item[],
-	start: number,
-	amount: number,
-): Item[];
+export declare function splice<Item>(array: Item[], start: number, amount: number): Item[];
 /**
  * - Splices values into an array and returns any removed values
  * - Uses chunking to avoid stack overflow
  */
-export declare function splice<Item>(
-	array: Item[],
-	start: number,
-	added: Item[],
-): Item[];
+export declare function splice<Item>(array: Item[], start: number, added: Item[]): Item[];
 /**
  * - Splices values into an array and returns any removed values
  * - Uses chunking to avoid stack overflow
  */
-export declare function splice<Item>(
-	array: Item[],
-	start: number,
-	amount: number,
-	added: Item[],
-): Item[];
+export declare function splice<Item>(array: Item[], start: number, amount: number, added: Item[]): Item[];
 /**
  * Create a map from an array of items _(using their indices as keys)_
  */
@@ -2109,133 +1651,51 @@ export declare function toMap<Item>(array: Item[]): Map<number, Item>;
 /**
  * Create a map from an array of items using a specific key
  */
-export declare function toMap<Item, Key extends keyof Item>(
-	array: Item[],
-	key: Key,
-): Map<KeyedValue<Item, Key>, Item>;
+export declare function toMap<Item, Key extends keyof Item>(array: Item[], key: Key): Map<KeyedValue<Item, Key>, Item>;
 /**
  * Create a map from an array of items using a specific key, and grouping them into arrays
  */
-export declare function toMap<Item, Key extends keyof Item>(
-	array: Item[],
-	key: Key,
-	arrays: true,
-): Map<KeyedValue<Item, Key>, Item[]>;
+export declare function toMap<Item, Key extends keyof Item>(array: Item[], key: Key, arrays: true): Map<KeyedValue<Item, Key>, Item[]>;
 /**
  * Create a map from an array of items using a specific key
  */
-export declare function toMap<Item, Key extends KeyCallback<Item>>(
-	array: Item[],
-	key: Key,
-): Map<ReturnType<Key>, Item>;
+export declare function toMap<Item, Key extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], key: Key): Map<ReturnType<Key>, Item>;
 /**
  * Create a map from an array of items using a specific key, and grouping them into arrays
  */
-export declare function toMap<Item, Key extends KeyCallback<Item>>(
-	array: Item[],
-	key: Key,
-	arrays: true,
-): Map<ReturnType<Key>, Item[]>;
+export declare function toMap<Item, Key extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], key: Key, arrays: true): Map<ReturnType<Key>, Item[]>;
 /**
  * Create a map from an array of items using a specific key and value
  */
-export declare function toMap<
-	Item,
-	Key extends keyof Item,
-	Value extends keyof Item,
->(
-	array: Item[],
-	key: Key,
-	value: Value,
-): Map<KeyedValue<Item, Key>, KeyedValue<Item, Value>>;
+export declare function toMap<Item, Key extends keyof Item, Value extends keyof Item>(array: Item[], key: Key, value: Value): Map<KeyedValue<Item, Key>, KeyedValue<Item, Value>>;
 /**
  * Create a map from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function toMap<
-	Item,
-	Key extends keyof Item,
-	Value extends keyof Item,
->(
-	array: Item[],
-	key: Key,
-	value: Value,
-	arrays: true,
-): Map<KeyedValue<Item, Key>, Array<KeyedValue<Item, Value>>>;
+export declare function toMap<Item, Key extends keyof Item, Value extends keyof Item>(array: Item[], key: Key, value: Value, arrays: true): Map<KeyedValue<Item, Key>, Array<KeyedValue<Item, Value>>>;
 /**
  * Create a map from an array of items using a specific key and value
  */
-export declare function toMap<
-	Item,
-	Key extends keyof Item,
-	Value extends ValueCallback<Item>,
->(
-	array: Item[],
-	key: Key,
-	value: Value,
-): Map<KeyedValue<Item, Key>, ReturnType<Value>>;
+export declare function toMap<Item, Key extends keyof Item, Value extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: Key, value: Value): Map<KeyedValue<Item, Key>, ReturnType<Value>>;
 /**
  * Create a map from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function toMap<
-	Item,
-	Key extends keyof Item,
-	Value extends ValueCallback<Item>,
->(
-	array: Item[],
-	key: Key,
-	value: Value,
-	arrays: true,
-): Map<KeyedValue<Item, Key>, Array<ReturnType<Value>>>;
+export declare function toMap<Item, Key extends keyof Item, Value extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: Key, value: Value, arrays: true): Map<KeyedValue<Item, Key>, Array<ReturnType<Value>>>;
 /**
  * Create a map from an array of items using a specific key and value
  */
-export declare function toMap<
-	Item,
-	Key extends KeyCallback<Item>,
-	Value extends keyof Item,
->(
-	array: Item[],
-	key: Key,
-	value: Value,
-): Map<ReturnType<Key>, KeyedValue<Item, Value>>;
+export declare function toMap<Item, Key extends (item: Item, index: number, array: Item[]) => Key, Value extends keyof Item>(array: Item[], key: Key, value: Value): Map<ReturnType<Key>, KeyedValue<Item, Value>>;
 /**
  * Create a map from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function toMap<
-	Item,
-	Key extends KeyCallback<Item>,
-	Value extends keyof Item,
->(
-	array: Item[],
-	key: Key,
-	value: Value,
-	arrays: true,
-): Map<ReturnType<Key>, Array<KeyedValue<Item, Value>>>;
+export declare function toMap<Item, Key extends (item: Item, index: number, array: Item[]) => Key, Value extends keyof Item>(array: Item[], key: Key, value: Value, arrays: true): Map<ReturnType<Key>, Array<KeyedValue<Item, Value>>>;
 /**
  * Create a map from an array of items using a specific key and value
  */
-export declare function toMap<
-	Item,
-	Key extends KeyCallback<Item>,
-	Value extends ValueCallback<Item>,
->(
-	array: Item[],
-	key: Key,
-	value: Value,
-): Map<ReturnType<Key>, ReturnType<Value>>;
+export declare function toMap<Item, Key extends (item: Item, index: number, array: Item[]) => Key, Value extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: Key, value: Value): Map<ReturnType<Key>, ReturnType<Value>>;
 /**
  * Create a map from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function toMap<
-	Item,
-	Key extends KeyCallback<Item>,
-	Value extends ValueCallback<Item>,
->(
-	array: Item[],
-	key: Key,
-	value: Value,
-	arrays: true,
-): Map<ReturnType<Key>, Array<ReturnType<Value>>>;
+export declare function toMap<Item, Key extends (item: Item, index: number, array: Item[]) => Key, Value extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: Key, value: Value, arrays: true): Map<ReturnType<Key>, Array<ReturnType<Value>>>;
 /**
  * Create a record from an array of items _(using their indices as keys)_
  */
@@ -2243,153 +1703,65 @@ export declare function toRecord<Item>(array: Item[]): Record<number, Item>;
 /**
  * Create a record from an array of items using a specific key
  */
-export declare function toRecord<Item, Key extends keyof Item>(
-	array: Item[],
-	key: Key,
-): Record<KeyedValue<Item, Key>, Item>;
+export declare function toRecord<Item, Key extends keyof Item>(array: Item[], key: Key): Record<KeyedValue<Item, Key>, Item>;
 /**
  * Create a record from an array of items using a specific key, and grouping them into arrays
  */
-export declare function toRecord<Item, Key extends keyof Item>(
-	array: Item[],
-	key: Key,
-	arrays: true,
-): Record<KeyedValue<Item, Key>, Item[]>;
+export declare function toRecord<Item, Key extends keyof Item>(array: Item[], key: Key, arrays: true): Record<KeyedValue<Item, Key>, Item[]>;
 /**
  * Create a record from an array of items using a specific key
  */
-export declare function toRecord<Item, Key extends KeyCallback<Item>>(
-	array: Item[],
-	key: Key,
-): Record<ReturnType<Key>, Item>;
+export declare function toRecord<Item, Key extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], key: Key): Record<ReturnType<Key>, Item>;
 /**
  * Create a record from an array of items using a specific key, and grouping them into arrays
  */
-export declare function toRecord<Item, Key extends KeyCallback<Item>>(
-	array: Item[],
-	key: Key,
-	arrays: true,
-): Record<ReturnType<Key>, Item[]>;
+export declare function toRecord<Item, Key extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], key: Key, arrays: true): Record<ReturnType<Key>, Item[]>;
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function toRecord<
-	Item,
-	Key extends keyof Item,
-	Value extends keyof Item,
->(
-	array: Item[],
-	key: Key,
-	value: Value,
-): Record<KeyedValue<Item, Key>, KeyedValue<Item, Value>>;
+export declare function toRecord<Item, Key extends keyof Item, Value extends keyof Item>(array: Item[], key: Key, value: Value): Record<KeyedValue<Item, Key>, KeyedValue<Item, Value>>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function toRecord<
-	Item,
-	Key extends keyof Item,
-	Value extends keyof Item,
->(
-	array: Item[],
-	key: Key,
-	value: Value,
-	arrays: true,
-): Record<KeyedValue<Item, Key>, Array<KeyedValue<Item, Value>>>;
+export declare function toRecord<Item, Key extends keyof Item, Value extends keyof Item>(array: Item[], key: Key, value: Value, arrays: true): Record<KeyedValue<Item, Key>, Array<KeyedValue<Item, Value>>>;
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function toRecord<
-	Item,
-	Key extends keyof Item,
-	Value extends ValueCallback<Item>,
->(
-	array: Item[],
-	key: Key,
-	value: Value,
-): Record<KeyedValue<Item, Key>, ReturnType<Value>>;
+export declare function toRecord<Item, Key extends keyof Item, Value extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: Key, value: Value): Record<KeyedValue<Item, Key>, ReturnType<Value>>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function toRecord<
-	Item,
-	Key extends keyof Item,
-	Value extends ValueCallback<Item>,
->(
-	array: Item[],
-	key: Key,
-	value: Value,
-	arrays: true,
-): Record<KeyedValue<Item, Key>, Array<ReturnType<Value>>>;
+export declare function toRecord<Item, Key extends keyof Item, Value extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: Key, value: Value, arrays: true): Record<KeyedValue<Item, Key>, Array<ReturnType<Value>>>;
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function toRecord<
-	Item,
-	Key extends KeyCallback<Item>,
-	Value extends keyof Item,
->(
-	array: Item[],
-	key: Key,
-	value: Value,
-): Record<ReturnType<Key>, KeyedValue<Item, Value>>;
+export declare function toRecord<Item, Key extends (item: Item, index: number, array: Item[]) => Key, Value extends keyof Item>(array: Item[], key: Key, value: Value): Record<ReturnType<Key>, KeyedValue<Item, Value>>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function toRecord<
-	Item,
-	Key extends KeyCallback<Item>,
-	Value extends keyof Item,
->(
-	array: Item[],
-	key: Key,
-	value: Value,
-	arrays: true,
-): Record<ReturnType<Key>, Array<KeyedValue<Item, Value>>>;
+export declare function toRecord<Item, Key extends (item: Item, index: number, array: Item[]) => Key, Value extends keyof Item>(array: Item[], key: Key, value: Value, arrays: true): Record<ReturnType<Key>, Array<KeyedValue<Item, Value>>>;
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function toRecord<
-	Item,
-	Key extends KeyCallback<Item>,
-	Value extends ValueCallback<Item>,
->(
-	array: Item[],
-	key: Key,
-	value: Value,
-): Record<ReturnType<Key>, ReturnType<Value>>;
+export declare function toRecord<Item, Key extends (item: Item, index: number, array: Item[]) => Key, Value extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: Key, value: Value): Record<ReturnType<Key>, ReturnType<Value>>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function toRecord<
-	Item,
-	Key extends KeyCallback<Item>,
-	Value extends ValueCallback<Item>,
->(
-	array: Item[],
-	key: Key,
-	value: Value,
-	arrays: true,
-): Record<ReturnType<Key>, Array<ReturnType<Value>>>;
+export declare function toRecord<Item, Key extends (item: Item, index: number, array: Item[]) => Key, Value extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: Key, value: Value, arrays: true): Record<ReturnType<Key>, Array<ReturnType<Value>>>;
 /**
  * Get an array of unique items
  */
 export declare function unique<Item>(array: Item[]): Item[];
 /**
  * - Get an array of unique items
- * - Use `key` to find a comparison value to match with `value`
+ * - Use `key` to find a comparison value for an item
  */
-export declare function unique<Item, Key extends keyof Item>(
-	array: Item[],
-	key: Key,
-): Item[];
+export declare function unique<Item, Key extends keyof Item>(array: Item[], key: Key): Item[];
 /**
  * - Get an array of unique items
- * - Use `key` to find a comparison value to match with `value`
+ * - Use `key` to find a comparison value for an item
  */
-export declare function unique<Item, Key extends KeyCallback<Item>>(
-	array: Item[],
-	key: Key,
-): Item[];
+export declare function unique<Item, Key extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], key: Key): Item[];
 /**
  * Flatten an array _(using native `flat` and maximum depth)_
  */
@@ -2492,12 +1864,7 @@ declare abstract class Colour<Model> {
 	 * Get the current value of the colour
 	 */
 	get value(): Model;
-	constructor(
-		type: string,
-		value: Model,
-		defaults: Model,
-		properties: Array<keyof Model>,
-	);
+	constructor(type: string, value: Model, defaults: Model, properties: Array<keyof Model>);
 	/**
 	 * Convert the colour to a hex-colour
 	 */
@@ -2569,9 +1936,7 @@ export declare function getRGBColour(value: RGBColourValue): RGBColour;
 /**
  * Is the value a colour?
  */
-export declare function isColour(
-	value: unknown,
-): value is HexColour | HSLColour | RGBColour;
+export declare function isColour(value: unknown): value is HexColour | HSLColour | RGBColour;
 /**
  * Is the value a hex-colour?
  */
@@ -2622,10 +1987,7 @@ export declare class Emitter<Value> {
 }
 export declare class Observable<Value> {
 	private readonly state;
-	constructor(
-		emitter: Emitter<Value>,
-		observers: Map<Subscription<Value>, Observer<Value>>,
-	);
+	constructor(emitter: Emitter<Value>, observers: Map<Subscription<Value>, Observer<Value>>);
 	/**
 	 * Subscribe to value changes
 	 */
@@ -2633,11 +1995,7 @@ export declare class Observable<Value> {
 	/**
 	 * Subscribe to value changes
 	 */
-	subscribe(
-		onNext: (value: Value) => void,
-		onError?: (error: Error) => void,
-		onComplete?: () => void,
-	): Subscription<Value>;
+	subscribe(onNext: (value: Value) => void, onError?: (error: Error) => void, onComplete?: () => void): Subscription<Value>;
 }
 export type ObservableState<Value> = {
 	emitter: Emitter<Value>;
@@ -2721,16 +2079,11 @@ export type MemoisedState<Callback extends GenericCallback> = {
  * - Time is clamped between _0_ and _1000_ milliseconds
  * - Returns the callback with an added `cancel`-method for manually cancelling the debounce
  */
-export declare function debounce<Callback extends GenericCallback>(
-	callback: Callback,
-	time?: number,
-): Debounced<Callback>;
+export declare function debounce<Callback extends GenericCallback>(callback: Callback, time?: number): Debounced<Callback>;
 /**
  * Memoise a function, caching and retrieving results based on the first parameter
  */
-export declare function memoise<Callback extends GenericCallback>(
-	callback: Callback,
-): Memoised<Callback>;
+export declare function memoise<Callback extends GenericCallback>(callback: Callback): Memoised<Callback>;
 /**
  * A function that does nothing, which can be useful, I guess…
  */
@@ -2739,10 +2092,7 @@ export declare function noop(): void;
  * - Throttle a function, ensuring it is only called once every `time` milliseconds
  * - Time is clamped between _0_ and _1000_ milliseconds
  */
-export declare function throttle<Callback extends GenericCallback>(
-	callback: Callback,
-	time?: number,
-): Callback;
+export declare function throttle<Callback extends GenericCallback>(callback: Callback, time?: number): Callback;
 /**
  * Convert a string to camel case _(thisIsCamelCase)_
  */
@@ -2780,11 +2130,7 @@ export type Options = {
 /**
  * Render a string from a template with variables
  */
-export declare function template(
-	value: string,
-	variables: PlainObject,
-	options?: Partial<Options>,
-): string;
+export declare function template(value: string, variables: PlainObject, options?: Partial<Options>): string;
 /**
  * Create a new UUID
  */
@@ -2800,20 +2146,13 @@ export declare function join(value: unknown[], delimiter?: string): string;
 /**
  * Parse a JSON string into its proper value _(or `undefined` if it fails)_
  */
-export declare function parse(
-	value: string,
-	reviver?: (this: unknown, key: string, value: unknown) => unknown,
-): unknown;
+export declare function parse(value: string, reviver?: (this: unknown, key: string, value: unknown) => unknown): unknown;
 /**
  * Truncate a string to a specified length, when possible
  * - Returned as-is if the string is already short enough
  * - A suffix may be appended to the truncated string, e.g., an ellipsis
  */
-export declare function truncate(
-	value: string,
-	length: number,
-	suffix?: string,
-): string;
+export declare function truncate(value: string, length: number, suffix?: string): string;
 /**
  * Split a string into words _(and other readable parts)_
  */
@@ -2826,7 +2165,7 @@ export declare function clone(value: unknown): {} | null | undefined;
  * Compare two values _(for sorting purposes)_
  */
 export declare function compare(first: unknown, second: unknown): number;
-export type DiffType = 'full' | 'none' | 'partial';
+export type DiffType = "full" | "none" | "partial";
 export type DiffResult<First, Second = First> = {
 	original: DiffValue<First, Second>;
 	type: DiffType;
@@ -2846,18 +2185,11 @@ export type DiffValue<First = unknown, Second = First> = {
  * 		- `partial` if the values are partially different
  * 	- `values` holds the differences with dot notation keys
  */
-export declare function diff<First, Second = First>(
-	first: First,
-	second: Second,
-): DiffResult<First, Second>;
+export declare function diff<First, Second = First>(first: First, second: Second): DiffResult<First, Second>;
 /**
  * Are two strings equal? _(Case-sensitive by default)_
  */
-export declare function equal(
-	first: string,
-	second: string,
-	ignoreCase?: boolean,
-): boolean;
+export declare function equal(first: string, second: string, ignoreCase?: boolean): boolean;
 /**
  * Are two values equal? _(Does a deep comparison, if needed)_
  */
@@ -2867,21 +2199,14 @@ export declare function equal(first: unknown, second: unknown): boolean;
  * - You can retrieve a nested value by using dot notation, e.g., `foo.bar.baz`
  * - Returns `undefined` if the value is not found
  */
-export declare function getValue<
-	Data extends PlainObject,
-	Path extends Paths<Data>,
->(data: Data, path: Path): Get<Data, ToString<Path>>;
+export declare function getValue<Data extends PlainObject, Path extends Paths<Data>>(data: Data, path: Path): Get<Data, ToString<Path>>;
 /**
  * - Get the value from an object using an unknown path
  * - You can retrieve a nested value by using dot notation, e.g., `foo.bar.baz`
  * - If `ignoreCase` is `true`, path matching will be case-insensitive
  * - Returns `undefined` if the value is not found
  */
-export declare function getValue<Data extends PlainObject>(
-	data: Data,
-	path: string,
-	ignoreCase?: boolean,
-): unknown;
+export declare function getValue<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): unknown;
 export type MergeOptions = {
 	/**
 	 * - Skip nullable values when merging arrays?
@@ -2892,20 +2217,14 @@ export type MergeOptions = {
 /**
  * Merge multiple arrays or objects into a single one
  */
-export declare function merge<Model extends ArrayOrPlainObject>(
-	values: Model[],
-	options?: Partial<MergeOptions>,
-): Model;
+export declare function merge<Model extends ArrayOrPlainObject>(values: Model[], options?: Partial<MergeOptions>): Model;
 /**
  * - Set the value in an object using a known path
  * - You can set a nested value by using dot notation, e.g., `foo.bar.baz`
  * - If a part of the path does not exist, it will be created, either as an array or a generic object, depending on the path
  * - Returns the original object
  */
-export declare function setValue<
-	Data extends PlainObject,
-	Path extends Paths<Data>,
->(data: Data, path: Path, value: unknown): Data;
+export declare function setValue<Data extends PlainObject, Path extends Paths<Data>>(data: Data, path: Path, value: unknown): Data;
 /**
  * - Set the value in an object using an unknown path
  * - You can set a nested value by using dot notation, e.g., `foo.bar.baz`
@@ -2913,41 +2232,24 @@ export declare function setValue<
  * - If `ignoreCase` is `true`, path matching will be case-insensitive
  * - Returns the original object
  */
-export declare function setValue<Data extends PlainObject>(
-	data: Data,
-	path: string,
-	value: unknown,
-	ignoreCase?: boolean,
-): Data;
+export declare function setValue<Data extends PlainObject>(data: Data, path: string, value: unknown, ignoreCase?: boolean): Data;
 export type Smushed<Value> = Simplify<{
 	[Key in Paths<Value>]: Get<Value, ToString<Key>>;
 }>;
 /**
  * Smush an object into a flat object that uses dot notation keys
  */
-export declare function smush<Value extends PlainObject>(
-	value: Value,
-): Smushed<Value>;
-export type Unsmushed<Value extends PlainObject> = Simplify<
-	Omit<
-		{
-			[Key in KeysOfUnion<Value>]: Value[Key];
-		},
-		`${string}.${string}`
-	>
->;
+export declare function smush<Value extends PlainObject>(value: Value): Smushed<Value>;
+export type Unsmushed<Value extends PlainObject> = Simplify<Omit<{
+	[Key in KeysOfUnion<Value>]: Value[Key];
+}, `${string}.${string}`>>;
 /**
  * Unsmush a smushed object _(turning dot notation keys into nested keys)_
  */
-export declare function unsmush<Value extends PlainObject>(
-	value: Value,
-): Unsmushed<Value>;
+export declare function unsmush<Value extends PlainObject>(value: Value): Unsmushed<Value>;
 /**
  * Create a new object with only the specified keys
  */
-export declare function partial<
-	Value extends PlainObject,
-	Key extends keyof Value,
->(value: Value, keys: Key[]): Pick<Value, Key>;
+export declare function partial<Value extends PlainObject, Key extends keyof Value>(value: Value, keys: Key[]): Pick<Value, Key>;
 
 export {};