@oscarpalmer/atoms 0.76.0 → 0.77.0

package/types/value/index.d.cts

@@ -5,14 +5,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.
 
@@ -50,9 +43,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.
@@ -109,11 +100,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 `{}`.
 
@@ -240,16 +227,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.
 
@@ -260,22 +245,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`.
 
@@ -318,7 +293,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.
 
@@ -330,7 +305,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`)
 
@@ -341,11 +316,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.
 
@@ -361,9 +332,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.
 
@@ -384,12 +353,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.
 
@@ -410,12 +378,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.
 
@@ -433,44 +400,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.
 
@@ -488,10 +443,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.
 
@@ -509,11 +461,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>`.
 
@@ -521,11 +469,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.
 
@@ -541,16 +489,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.
 
@@ -566,16 +508,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.
 
@@ -610,14 +546,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.
 
@@ -632,14 +561,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.
 
@@ -655,9 +581,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.
 
@@ -670,17 +594,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.
 
@@ -696,21 +611,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.
 
@@ -723,16 +633,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.
 
@@ -748,10 +649,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.
 
@@ -771,13 +669,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.
 */
@@ -785,12 +677,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.
 
@@ -822,45 +709,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.
 
@@ -891,40 +768,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.
 
@@ -1015,85 +881,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.
@@ -1124,9 +933,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.
 
@@ -1151,8 +958,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.
 
@@ -1174,14 +980,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.
@@ -1195,41 +1000,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.
 
@@ -1242,18 +1030,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.
 
@@ -1265,14 +1046,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.
 
@@ -1293,11 +1067,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.
 
@@ -1305,26 +1079,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.
@@ -1372,28 +1135,11 @@ 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 PlainObject = UnknownRecord;
 /**
@@ -1404,7 +1150,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;
@@ -1424,18 +1170,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)_
  */
@@ -1445,21 +1184,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?
@@ -1470,20 +1202,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`
@@ -1491,41 +1217,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 {};