@visulima/object 1.0.0 → 1.0.2

package/dist/index.d.ts

@@ -166,6 +166,71 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 */
 type Simplify<T> = {[KeyType in keyof T]: T[KeyType]} & {};
 
+/**
+Returns the static, fixed-length portion of the given array, excluding variable-length parts.
+
+@example
+```
+type A = [string, number, boolean, ...string[]];
+type B = StaticPartOfArray<A>;
+//=> [string, number, boolean]
+```
+*/
+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.
+
+@example
+```
+type A = [string, number, boolean, ...string[]];
+type B = VariablePartOfArray<A>;
+//=> string[]
+```
+*/
+type VariablePartOfArray<T extends UnknownArray> =
+	T extends unknown
+		? T extends readonly [...StaticPartOfArray<T>, ...infer U]
+			? U
+			: []
+		: never; // Should never happen
+
+/**
+Set the given array to readonly if `IsReadonly` is `true`, otherwise set the given array to normal, then return the result.
+
+@example
+```
+type ReadonlyArray = readonly string[];
+type NormalArray = string[];
+
+type ReadonlyResult = SetArrayAccess<NormalArray, true>;
+//=> readonly string[]
+
+type NormalResult = SetArrayAccess<ReadonlyArray, false>;
+//=> string[]
+```
+*/
+type SetArrayAccess<T extends UnknownArray, IsReadonly extends boolean> =
+T extends readonly [...infer U] ?
+	IsReadonly extends true
+		? readonly [...U]
+		: [...U]
+	: T;
+
+/**
+Returns whether the given array `T` is readonly.
+*/
+type IsArrayReadonly<T extends UnknownArray> = T extends unknown[] ? false : true;
+
+type StringDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
+
 /**
 Returns a boolean for whether the given type is `any`.
 
@@ -255,6 +320,49 @@ type ShouldBeTrue = IsNegative<-1>;
 */
 type IsNegative<T extends Numeric> = T extends Negative<T> ? true : false;
 
+/**
+Returns a boolean for whether the given type is `never`.
+
+@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
+@link https://stackoverflow.com/a/53984913/10292952
+@link https://www.zhenghao.io/posts/ts-never
+
+Useful in type utilities, such as checking if something does not occur.
+
+@example
+```
+import type {IsNever, And} from 'type-fest';
+
+// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
+type AreStringsEqual<A extends string, B extends string> =
+	And<
+		IsNever<Exclude<A, B>> extends true ? true : false,
+		IsNever<Exclude<B, A>> extends true ? true : false
+	>;
+
+type EndIfEqual<I extends string, O extends string> =
+	AreStringsEqual<I, O> extends true
+		? never
+		: void;
+
+function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
+	if (input === output) {
+		process.exit(0);
+	}
+}
+
+endIfEqual('abc', 'abc');
+//=> never
+
+endIfEqual('abc', '123');
+//=> void
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsNever<T> = [T] extends [never] ? true : false;
+
 /**
 Returns a boolean for whether two given types are both true.
 
@@ -391,49 +499,6 @@ type LessThan<A extends number, B extends number> = number extends A | B
 	? never
 	: GreaterThanOrEqual<A, B> extends true ? false : true;
 
-/**
-Returns a boolean for whether the given type is `never`.
-
-@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
-@link https://stackoverflow.com/a/53984913/10292952
-@link https://www.zhenghao.io/posts/ts-never
-
-Useful in type utilities, such as checking if something does not occur.
-
-@example
-```
-import type {IsNever, And} from 'type-fest';
-
-// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
-type AreStringsEqual<A extends string, B extends string> =
-	And<
-		IsNever<Exclude<A, B>> extends true ? true : false,
-		IsNever<Exclude<B, A>> extends true ? true : false
-	>;
-
-type EndIfEqual<I extends string, O extends string> =
-	AreStringsEqual<I, O> extends true
-		? never
-		: void;
-
-function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
-	if (input === output) {
-		process.exit(0);
-	}
-}
-
-endIfEqual('abc', 'abc');
-//=> never
-
-endIfEqual('abc', '123');
-//=> void
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IsNever<T> = [T] extends [never] ? true : false;
-
 /**
 Infer the length of the given tuple `<T>`.
 
@@ -473,45 +538,57 @@ type BuildTuple<L extends number, Fill = unknown, T extends readonly unknown[] =
 	: BuildTuple<L, Fill, [...T, Fill]>;
 
 /**
-Create an object type with the given key `<Key>` and value `<Value>`.
+Returns the maximum value from a tuple of integers.
 
-It will copy the prefix and optional status of the same key from the given object `CopiedFrom` into the result.
+Note:
+- Float numbers are not supported.
 
 @example
 ```
-type A = BuildObject<'a', string>;
-//=> {a: string}
+ArrayMax<[1, 2, 5, 3]>;
+//=> 5
 
-// Copy `readonly` and `?` from the key `a` of `{readonly a?: any}`
-type B = BuildObject<'a', string, {readonly a?: any}>;
-//=> {readonly a?: string}
+ArrayMax<[1, 2, 5, 3, 99, -1]>;
+//=> 99
 ```
 */
-type BuildObject<Key extends PropertyKey, Value, CopiedFrom extends object = {}> =
-	Key extends keyof CopiedFrom
-		? Pick<{[_ in keyof CopiedFrom]: Value}, Key>
-		: Key extends `${infer NumberKey extends number}`
-			? NumberKey extends keyof CopiedFrom
-				? Pick<{[_ in keyof CopiedFrom]: Value}, NumberKey>
-				: {[_ in Key]: Value}
-			: {[_ in Key]: Value};
+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;
 
 /**
-Return a string representation of the given string or number.
+Returns the minimum value from a tuple of integers.
 
-Note: This type is not the return type of the `.toString()` function.
-*/
-type ToString<T> = T extends string | number ? `${T}` : never;
+Note:
+- Float numbers are not supported.
 
-/**
-Matches any primitive, `void`, `Date`, or `RegExp` value.
+@example
+```
+ArrayMin<[1, 2, 5, 3]>;
+//=> 1
+
+ArrayMin<[1, 2, 5, 3, -5]>;
+//=> -5
+```
 */
-type BuiltIns = Primitive | void | Date | RegExp;
+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;
 
 /**
-Matches non-recursive types.
+Return a string representation of the given string or number.
+
+Note: This type is not the return type of the `.toString()` function.
 */
-type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown);
+type ToString<T> = T extends string | number ? `${T}` : never;
 
 /**
 Converts a numeric string to a number.
@@ -549,25 +626,6 @@ type StringToNumber<S extends string> = S extends `${infer N extends number}`
 			? NegativeInfinity
 			: never;
 
-/**
-Returns the length of the given string.
-
-@example
-```
-StringLength<'abcde'>;
-//=> 5
-
-StringLength<string>;
-//=> never
-```
-
-@category String
-@category Template literal
-*/
-type StringLength<S extends string> = string extends S
-	? never
-	: StringToArray<S>['length'];
-
 /**
 Returns an array of the characters of the string.
 
@@ -588,86 +646,24 @@ type StringToArray<S extends string, Result extends string[] = []> = string exte
 		? StringToArray<R, [...Result, F]>
 		: Result;
 
-type StringDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
-
-/**
-Extract the object field type if T is an object and K is a key of T, return `never` otherwise.
-
-It creates a type-safe way to access the member type of `unknown` type.
-*/
-type ObjectValue<T, K> =
-	K extends keyof T
-		? T[K]
-		: ToString<K> extends keyof T
-			? T[ToString<K>]
-			: K extends `${infer NumberK extends number}`
-				? NumberK extends keyof T
-					? T[NumberK]
-					: never
-				: never;
-
 /**
-Returns the maximum value from a tuple of integers.
-
-Note:
-- Float numbers are not supported.
+Returns the length of the given string.
 
 @example
 ```
-ArrayMax<[1, 2, 5, 3]>;
+StringLength<'abcde'>;
 //=> 5
 
-ArrayMax<[1, 2, 5, 3, 99, -1]>;
-//=> 99
-```
-*/
-type ArrayMax<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
-			? ArrayMax<R, F>
-			: ArrayMax<R, Result>
-		: Result;
-
-/**
-Returns the minimum value from a tuple of integers.
-
-Note:
-- Float numbers are not supported.
-
-@example
+StringLength<string>;
+//=> never
 ```
-ArrayMin<[1, 2, 5, 3]>;
-//=> 1
 
-ArrayMin<[1, 2, 5, 3, -5]>;
-//=> -5
-```
+@category String
+@category Template literal
 */
-type ArrayMin<A extends number[], Result extends number = PositiveInfinity> = number extends A[number]
+type StringLength<S extends string> = string extends S
 	? never
-	: A extends [infer F extends number, ...infer R extends number[]]
-		? LessThan<F, Result> extends true
-			? ArrayMin<R, F>
-			: ArrayMin<R, Result>
-		: Result;
-
-/**
-Returns the absolute value of a given value.
-
-@example
-```
-NumberAbsolute<-1>;
-//=> 1
-
-NumberAbsolute<1>;
-//=> 1
-
-NumberAbsolute<NegativeInfinity>
-//=> PositiveInfinity
-```
-*/
-type NumberAbsolute<N extends number> = `${N}` extends `-${infer StringPositiveN}` ? StringToNumber<StringPositiveN> : N;
+	: 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.
@@ -737,40 +733,84 @@ type PositiveNumericCharacterGt<A extends string, B extends string> = NumericStr
 	: never;
 
 /**
-Returns the static, fixed-length portion of the given array, excluding variable-length parts.
+Get the exact version of the given `Key` in the given object `T`.
+
+Use-case: You known that a number key (e.g. 10) is in an object, but you don't know how it is defined in the object, as a string or as a number (e.g. 10 or '10'). You can use this type to get the exact version of the key. See the example.
 
 @example
 ```
-type A = [string, number, boolean, ...string[]];
-type B = StaticPartOfArray<A>;
-//=> [string, number, boolean]
+type Object = {
+	0: number;
+	'1': string;
+};
+
+type Key1 = ExactKey<Object, '0'>;
+//=> 0
+type Key2 = ExactKey<Object, 0>;
+//=> 0
+
+type Key3 = ExactKey<Object, '1'>;
+//=> '1'
+type Key4 = ExactKey<Object, 1>;
+//=> '1'
 ```
+
+@category Object
 */
-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
+type ExactKey<T extends object, Key extends PropertyKey> =
+Key extends keyof T
+	? Key
+	: ToString<Key> extends keyof T
+		? ToString<Key>
+		: Key extends `${infer NumberKey extends number}`
+			? NumberKey extends keyof T
+				? NumberKey
+				: never
+			: never;
+
+/**
+Returns the absolute value of a given value.
+
+@example
+```
+NumberAbsolute<-1>;
+//=> 1
+
+NumberAbsolute<1>;
+//=> 1
+
+NumberAbsolute<NegativeInfinity>
+//=> PositiveInfinity
+```
+*/
+type NumberAbsolute<N extends number> = `${N}` extends `-${infer StringPositiveN}` ? StringToNumber<StringPositiveN> : N;
 
 /**
-Returns the variable, non-fixed-length portion of the given array, excluding static-length parts.
+Check whether the given type is a number or a number string.
+
+Supports floating-point as a string.
 
 @example
 ```
-type A = [string, number, boolean, ...string[]];
-type B = VariablePartOfArray<A>;
-//=> string[]
-```
+type A = IsNumberLike<'1'>;
+//=> true
+
+type B = IsNumberLike<'-1.1'>;
+//=> true
+
+type C = IsNumberLike<1>;
+//=> true
+
+type D = IsNumberLike<'a'>;
+//=> false
 */
-type VariablePartOfArray<T extends UnknownArray> =
-	T extends unknown
-		? T extends readonly [...StaticPartOfArray<T>, ...infer U]
-			? U
-			: []
-		: never; // Should never happen
+type IsNumberLike<N> =
+	N extends number ? true
+		:	N extends `${number}`
+			? true
+			: N extends `${number}.${number}`
+				? true
+				: false;
 
 /**
 Returns the minimum number in the given union of numbers.
@@ -816,6 +856,16 @@ type InternalUnionMax<N extends number, T extends UnknownArray = []> =
 			? InternalUnionMax<Exclude<N, T['length']>, T>
 			: InternalUnionMax<N, [...T, unknown]>;
 
+/**
+Matches any primitive, `void`, `Date`, or `RegExp` value.
+*/
+type BuiltIns = Primitive | void | Date | RegExp;
+
+/**
+Matches non-recursive types.
+*/
+type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown);
+
 /**
 Returns a boolean for whether the given type is a union type.
 
@@ -852,67 +902,44 @@ type InternalIsUnion<T, U = T> =
 	: never; // Should never happen
 
 /**
-Set the given array to readonly if `IsReadonly` is `true`, otherwise set the given array to normal, then return the result.
+Create an object type with the given key `<Key>` and value `<Value>`.
+
+It will copy the prefix and optional status of the same key from the given object `CopiedFrom` into the result.
 
 @example
 ```
-type ReadonlyArray = readonly string[];
-type NormalArray = string[];
-
-type ReadonlyResult = SetArrayAccess<NormalArray, true>;
-//=> readonly string[]
+type A = BuildObject<'a', string>;
+//=> {a: string}
 
-type NormalResult = SetArrayAccess<ReadonlyArray, false>;
-//=> string[]
+// Copy `readonly` and `?` from the key `a` of `{readonly a?: any}`
+type B = BuildObject<'a', string, {readonly a?: any}>;
+//=> {readonly a?: string}
 ```
 */
-type SetArrayAccess<T extends UnknownArray, IsReadonly extends boolean> =
-T extends readonly [...infer U] ?
-	IsReadonly extends true
-		? readonly [...U]
-		: [...U]
-	: T;
-
-/**
-Returns whether the given array `T` is readonly.
-*/
-type IsArrayReadonly<T extends UnknownArray> = T extends unknown[] ? false : true;
+type BuildObject<Key extends PropertyKey, Value, CopiedFrom extends object = {}> =
+	Key extends keyof CopiedFrom
+		? Pick<{[_ in keyof CopiedFrom]: Value}, Key>
+		: Key extends `${infer NumberKey extends number}`
+			? NumberKey extends keyof CopiedFrom
+				? Pick<{[_ in keyof CopiedFrom]: Value}, NumberKey>
+				: {[_ in Key]: Value}
+			: {[_ in Key]: Value};
 
 /**
-Get the exact version of the given `Key` in the given object `T`.
-
-Use-case: You known that a number key (e.g. 10) is in an object, but you don't know how it is defined in the object, as a string or as a number (e.g. 10 or '10'). You can use this type to get the exact version of the key. See the example.
-
-@example
-```
-type Object = {
-	0: number;
-	'1': string;
-};
-
-type Key1 = ExactKey<Object, '0'>;
-//=> 0
-type Key2 = ExactKey<Object, 0>;
-//=> 0
-
-type Key3 = ExactKey<Object, '1'>;
-//=> '1'
-type Key4 = ExactKey<Object, 1>;
-//=> '1'
-```
+Extract the object field type if T is an object and K is a key of T, return `never` otherwise.
 
-@category Object
+It creates a type-safe way to access the member type of `unknown` type.
 */
-type ExactKey<T extends object, Key extends PropertyKey> =
-Key extends keyof T
-	? Key
-	: ToString<Key> extends keyof T
-		? ToString<Key>
-		: Key extends `${infer NumberKey extends number}`
-			? NumberKey extends keyof T
-				? NumberKey
-				: never
-			: never;
+type ObjectValue<T, K> =
+	K extends keyof T
+		? T[K]
+		: ToString<K> extends keyof T
+			? T[ToString<K>]
+			: K extends `${infer NumberK extends number}`
+				? NumberK extends keyof T
+					? T[NumberK]
+					: never
+				: never;
 
 /**
 Deeply simplifies an object type.
@@ -1028,132 +1055,184 @@ type SimplifyDeep<Type, ExcludeType = never> =
 	>;
 
 /**
-Returns the difference between two numbers.
+Returns the sum of two numbers.
 
 Note:
 - A or B can only support `-999` ~ `999`.
+- A and B can only be small integers, less than 1000.
 - If the result is negative, you can only get `number`.
 
 @example
 ```
-import type {Subtract} from 'type-fest';
-
-Subtract<333, 222>;
-//=> 111
+import type {Sum} from 'type-fest';
 
-Subtract<111, -222>;
+Sum<111, 222>;
 //=> 333
 
-Subtract<-111, 222>;
+Sum<-111, 222>;
+//=> 111
+
+Sum<111, -222>;
 //=> number
 
-Subtract<PositiveInfinity, 9999>;
+Sum<PositiveInfinity, -9999>;
 //=> PositiveInfinity
 
-Subtract<PositiveInfinity, PositiveInfinity>;
+Sum<PositiveInfinity, NegativeInfinity>;
 //=> number
 ```
 
 @category Numeric
 */
 // TODO: Support big integer and negative number.
-type Subtract<A extends number, B extends number> = number extends A | B
+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[2], false>>,
-		And<IsEqual<R[3], true>, IsEqual<R[1], false>>
+		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[3], false>>,
-			And<IsEqual<R[2], true>, IsEqual<R[0], false>>
+			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
+					: ([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
+							? [...BuildTuple<A>, ...BuildTuple<B>]['length']
+							: [true, true] extends R
 								? number
-								: [false, true] extends R
-									? Sum<A, NumberAbsolute<B>>
-									: Subtract<NumberAbsolute<B>, NumberAbsolute<A>>
-						: never
+								: 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 sum of two numbers.
+Returns the difference between two numbers.
 
 Note:
 - A or B can only support `-999` ~ `999`.
-- A and B can only be small integers, less than 1000.
 - If the result is negative, you can only get `number`.
 
 @example
 ```
-import type {Sum} from 'type-fest';
-
-Sum<111, 222>;
-//=> 333
+import type {Subtract} from 'type-fest';
 
-Sum<-111, 222>;
+Subtract<333, 222>;
 //=> 111
 
-Sum<111, -222>;
+Subtract<111, -222>;
+//=> 333
+
+Subtract<-111, 222>;
 //=> number
 
-Sum<PositiveInfinity, -9999>;
+Subtract<PositiveInfinity, 9999>;
 //=> PositiveInfinity
 
-Sum<PositiveInfinity, NegativeInfinity>;
+Subtract<PositiveInfinity, PositiveInfinity>;
 //=> number
 ```
 
 @category Numeric
 */
 // TODO: Support big integer and negative number.
-type Sum<A extends number, B extends number> = number extends A | B
+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[3], false>>,
-		And<IsEqual<R[2], true>, IsEqual<R[1], false>>
+		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[2], false>>,
-			And<IsEqual<R[3], true>, IsEqual<R[0], false>>
+			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
+					: [IsNegative<A>, IsNegative<B>] extends infer R
 						? [false, false] extends R
-							? [...BuildTuple<A>, ...BuildTuple<B>]['length']
-							: [true, true] extends R
+							? BuildTuple<A> extends infer R
+								? R extends [...BuildTuple<B>, ...infer R]
+									? R['length']
+									: number
+								: never
+							: LessThan<A, B> extends true
 								? number
-								: ArrayMax<[NumberAbsolute<A>, NumberAbsolute<B>]> extends infer Max_
-									? ArrayMin<[NumberAbsolute<A>, NumberAbsolute<B>]> extends infer Min_ extends number
-										? Max_ extends A | B
-											? Subtract<Max_, Min_>
-											: number
-										: never
-									: never
-						: never) & number
+								: [false, true] extends R
+									? Sum<A, NumberAbsolute<B>>
+									: Subtract<NumberAbsolute<B>, NumberAbsolute<A>>
+						: never
 		: never;
 
+/**
+Paths options.
+
+@see {@link Paths}
+*/
+type PathsOptions = {
+	/**
+	The maximum depth to recurse when searching for paths.
+
+	@default 10
+	*/
+	maxRecursionDepth?: number;
+
+	/**
+	Use bracket notation for array indices and numeric object keys.
+
+	@default false
+
+	@example
+	```
+	type ArrayExample = {
+		array: ['foo'];
+	};
+
+	type A = Paths<ArrayExample, {bracketNotation: false}>;
+	//=> 'array' | 'array.0'
+
+	type B = Paths<ArrayExample, {bracketNotation: true}>;
+	//=> 'array' | 'array[0]'
+	```
+
+	@example
+	```
+	type NumberKeyExample = {
+		1: ['foo'];
+	};
+
+	type A = Paths<NumberKeyExample, {bracketNotation: false}>;
+	//=> 1 | '1' | '1.0'
+
+	type B = Paths<NumberKeyExample, {bracketNotation: true}>;
+	//=> '[1]' | '[1][0]'
+	```
+	*/
+	bracketNotation?: boolean;
+};
+
+type DefaultPathsOptions = {
+	maxRecursionDepth: 10;
+	bracketNotation: false;
+};
+
 /**
 Generate a union of all possible paths to properties in the given object.
 
@@ -1195,9 +1274,14 @@ open('listB.1'); // TypeError. Because listB only has one element.
 @category Object
 @category Array
 */
-type Paths<T> = Paths_<T>;
+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'];
+}>;
 
-type Paths_<T, Depth extends number = 0> =
+type _Paths<T, Options extends Required<PathsOptions>> =
 	T extends NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown>
 		? never
 		: IsAny<T> extends true
@@ -1205,32 +1289,61 @@ type Paths_<T, Depth extends number = 0> =
 			: T extends UnknownArray
 				? number extends T['length']
 					// We need to handle the fixed and non-fixed index part of the array separately.
-					? InternalPaths<StaticPartOfArray<T>, Depth>
-					| InternalPaths<Array<VariablePartOfArray<T>[number]>, Depth>
-					: InternalPaths<T, Depth>
+					? InternalPaths<StaticPartOfArray<T>, Options>
+					| InternalPaths<Array<VariablePartOfArray<T>[number]>, Options>
+					: InternalPaths<T, Options>
 				: T extends object
-					? InternalPaths<T, Depth>
+					? InternalPaths<T, Options>
 					: never;
 
-type InternalPaths<_T, Depth extends number = 0, T = Required<_T>> =
-	T extends EmptyObject | readonly []
-		? never
-		: {
-			[Key in keyof T]:
-			Key extends string | number // Limit `Key` to string or number.
-				// If `Key` is a number, return `Key | `${Key}``, because both `array[0]` and `array['0']` work.
-				?
-				| Key
-				| ToString<Key>
-				| (
-					LessThan<Depth, 15> extends true // Limit the depth to prevent infinite recursion
-						? IsNever<Paths_<T[Key], Sum<Depth, 1>>> extends false
-							? `${Key}.${Paths_<T[Key], Sum<Depth, 1>>}`
+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
+								// If `Key` is a number, return `Key | `${Key}``, because both `array[0]` and `array['0']` work.
+									? (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
-				)
-				: never
-		}[keyof T & (T extends UnknownArray ? number : unknown)];
+				}[keyof T & (T extends UnknownArray ? number : unknown)]
+			: never
+		: never;
 
 /**
 Convert a union type to an intersection type using [distributive conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
@@ -1530,6 +1643,8 @@ type ArraySplice<
 			: never // Should never happen
 		: never; // Should never happen
 
+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.
 
@@ -1758,6 +1873,25 @@ type UsefulInfo = OmitDeep<Info, 'userInfo.uselessInfo'>;
 // 	userInfo: {
 // 		name: string;
 // 	};
+// };
+
+// Supports removing multiple paths
+type Info1 = {
+	userInfo: {
+		name: string;
+		uselessField: string;
+		uselessInfo: {
+			foo: string;
+		};
+	};
+};
+
+type UsefulInfo1 = OmitDeep<Info1, 'userInfo.uselessInfo' | 'userInfo.uselessField'>;
+// type UsefulInfo1 = {
+// 	userInfo: {
+// 		name: string;
+// 	};
+// };
 
 // Supports array
 type A = OmitDeep<[1, 'foo', 2], 1>;
@@ -1930,7 +2064,7 @@ type GetOptions = {
 /**
 Like the `Get` type but receives an array of strings as a path parameter.
 */
-type GetWithPath<BaseType, Keys extends readonly string[], Options extends GetOptions = {}> =
+type GetWithPath<BaseType, Keys, Options extends GetOptions = {}> =
 	Keys extends readonly []
 		? BaseType
 		: Keys extends readonly [infer Head, ...infer Tail]
@@ -2101,8 +2235,13 @@ Get<Record<string, string>, 'foo', {strict: true}> // => string
 @category Array
 @category Template literal
 */
-type Get<BaseType, Path extends string | readonly string[], Options extends GetOptions = {}> =
-	GetWithPath<BaseType, Path extends string ? ToPath<Path> : Path, Options>;
+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>;
 
 declare const omit: <T extends { [key in string]: unknown; }, K extends string>(object: T, keys: Paths<T>[]) => OmitDeep<T, K>;