@oscarpalmer/atoms 0.76.0 → 0.77.0

package/types/value/set.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;
 declare const emptyObjectSymbol: unique symbol;
 /**
 Represents a strictly empty plain object, the `{}` value.
@@ -69,11 +62,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 `{}`.
 
@@ -140,16 +129,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.
 
@@ -160,11 +147,11 @@ 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 VariablePartOfArray<T extends UnknownArray> = T extends unknown ? T extends readonly [
+	...StaticPartOfArray<T>,
+	...infer U
+] ? U : [
+] : never; // Should never happen
 /**
 Returns a boolean for whether the given type is `any`.
 
@@ -207,7 +194,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.
 
@@ -219,7 +206,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`)
 
@@ -230,11 +217,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.
 
@@ -250,9 +233,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.
 
@@ -273,12 +254,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.
 
@@ -299,12 +279,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.
 
@@ -322,44 +301,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.
 
@@ -377,10 +344,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.
 
@@ -398,11 +362,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>`.
 
@@ -410,11 +370,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.
 
@@ -430,16 +390,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.
 
@@ -455,16 +409,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.
 
@@ -499,14 +447,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.
 
@@ -521,14 +462,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.
 
@@ -544,9 +482,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.
 
@@ -559,17 +495,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.
 
@@ -585,21 +512,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.
 
@@ -612,16 +534,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.
 
@@ -637,10 +550,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.
 
@@ -660,13 +570,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.
 */
@@ -674,12 +578,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.
 
@@ -711,45 +610,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.
 
@@ -780,40 +669,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.
 
@@ -904,85 +782,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 PlainObject = UnknownRecord;
 /**
  * - Set the value in an object using a known path
@@ -990,10 +811,7 @@ export type PlainObject = UnknownRecord;
  * - 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`
@@ -1001,11 +819,6 @@ 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 {};