type-fest 3.13.0 → 3.13.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "type-fest",
-	"version": "3.13.0",
+	"version": "3.13.1",
 	"description": "A collection of essential TypeScript types",
 	"license": "(MIT OR CC0-1.0)",
 	"repository": "sindresorhus/type-fest",

package/source/internal.d.ts

@@ -235,8 +235,8 @@ Needed to handle the case of a single call signature with properties.
 Multiple call signatures cannot currently be supported due to a TypeScript limitation.
 @see https://github.com/microsoft/TypeScript/issues/29732
 */
-export type HasMultipleCallSignatures<T extends (...arguments: any[]) => unknown> =
-	T extends {(...arguments: infer A): unknown; (...arguments: any[]): unknown}
+export type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> =
+	T extends {(...arguments_: infer A): unknown; (...arguments_: any[]): unknown}
 		? unknown[] extends A
 			? false
 			: true

package/source/jsonify.d.ts

@@ -1,26 +1,16 @@
 import type {JsonPrimitive, JsonValue} from './basic';
 import type {EmptyObject} from './empty-object';
 import type {UndefinedToOptional} from './internal';
-import type {IsAny} from './is-any';
-import type {IsNever} from './is-never';
 import type {NegativeInfinity, PositiveInfinity} from './numeric';
 import type {TypedArray} from './typed-array';
+import type {IsAny} from './is-any';
 
 // Note: The return value has to be `any` and not `unknown` so it can match `void`.
 type NotJsonable = ((...arguments_: any[]) => any) | undefined | symbol;
 
-type FilterNonNever<T extends unknown[]> = T extends [infer F, ...infer R]
-	? IsNever<F> extends true
-		? FilterNonNever<R>
-		: [F, ...FilterNonNever<R>]
-	: IsNever<T[number]> extends true
-		? []
-		: T;
-
-// Handles tuples and arrays
-type JsonifyList<T extends unknown[]> = T extends [infer F, ...infer R]
-	? FilterNonNever<[Jsonify<F>, ...JsonifyList<R>]>
-	: Array<Jsonify<T[number]>>;
+type JsonifyTuple<T extends [unknown, ...unknown[]]> = {
+	[Key in keyof T]: T[Key] extends NotJsonable ? null : Jsonify<T[Key]>;
+};
 
 type FilterJsonableKeys<T extends object> = {
 	[Key in keyof T]: T[Key] extends NotJsonable ? never : Key;
@@ -117,7 +107,7 @@ export type Jsonify<T> = IsAny<T> extends true
 										: T extends []
 											? []
 											: T extends [unknown, ...unknown[]]
-												? JsonifyList<T>
+												? JsonifyTuple<T>
 												: T extends ReadonlyArray<infer U>
 													? Array<U extends NotJsonable ? null : Jsonify<U>>
 													: T extends object

package/source/partial-deep.d.ts

@@ -69,7 +69,7 @@ export type PartialDeep<T, Options extends PartialDeepOptions = {}> = T extends
 				? PartialReadonlyMapDeep<KeyType, ValueType, Options>
 				: T extends ReadonlySet<infer ItemType>
 					? PartialReadonlySetDeep<ItemType, Options>
-					: T extends ((...arguments: any[]) => unknown)
+					: T extends ((...arguments_: any[]) => unknown)
 						? T | undefined
 						: T extends object
 							? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156

package/source/partial-on-undefined-deep.d.ts

@@ -55,7 +55,7 @@ export type PartialOnUndefinedDeep<T, Options extends PartialOnUndefinedDeepOpti
 /**
 Utility type to get the value type by key and recursively call `PartialOnUndefinedDeep` to transform sub-objects.
 */
-type PartialOnUndefinedDeepValue<T, Options extends PartialOnUndefinedDeepOptions> = T extends BuiltIns | ((...arguments: any[]) => unknown)
+type PartialOnUndefinedDeepValue<T, Options extends PartialOnUndefinedDeepOptions> = T extends BuiltIns | ((...arguments_: any[]) => unknown)
 	? T
 	: T extends ReadonlyArray<infer U> // Test if type is array or tuple
 		? Options['recurseIntoArrays'] extends true // Check if option is activated

package/source/readonly-deep.d.ts

@@ -38,12 +38,12 @@ Note that types containing overloaded functions are not made deeply readonly due
 */
 export type ReadonlyDeep<T> = T extends BuiltIns
 	? T
-	: T extends (...arguments: any[]) => unknown
+	: T extends (...arguments_: any[]) => unknown
 		? {} extends ReadonlyObjectDeep<T>
 			? T
 			: HasMultipleCallSignatures<T> extends true
 				? T
-				: ((...arguments: Parameters<T>) => ReturnType<T>) & ReadonlyObjectDeep<T>
+				: ((...arguments_: Parameters<T>) => ReturnType<T>) & ReadonlyObjectDeep<T>
 		: T extends Readonly<ReadonlyMap<infer KeyType, infer ValueType>>
 			? ReadonlyMapDeep<KeyType, ValueType>
 			: T extends Readonly<ReadonlySet<infer ItemType>>

package/source/required-deep.d.ts

@@ -59,12 +59,12 @@ export type RequiredDeep<T, E extends ExcludeUndefined<T> = ExcludeUndefined<T>>
 							? WeakSet<RequiredDeep<ItemType>>
 							: E extends Promise<infer ValueType>
 								? Promise<RequiredDeep<ValueType>>
-								: E extends (...args: any[]) => unknown
+								: E extends (...arguments_: any[]) => unknown
 									? {} extends RequiredObjectDeep<E>
 										? E
 										: HasMultipleCallSignatures<E> extends true
 											? E
-											: ((...arguments: Parameters<E>) => ReturnType<E>) & RequiredObjectDeep<E>
+											: ((...arguments_: Parameters<E>) => ReturnType<E>) & RequiredObjectDeep<E>
 									: E extends object
 										? E extends Array<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
 											? ItemType[] extends E // Test for arrays (non-tuples) specifically

package/source/schema.d.ts

@@ -51,7 +51,7 @@ export type Schema<ObjectType, ValueType> = ObjectType extends string
 						? ValueType
 						: ObjectType extends unknown[]
 							? ValueType
-							: ObjectType extends (...arguments: unknown[]) => unknown
+							: ObjectType extends (...arguments_: unknown[]) => unknown
 								? ValueType
 								: ObjectType extends Date
 									? ValueType

package/source/writable-deep.d.ts

@@ -32,12 +32,12 @@ Note that types containing overloaded functions are not made deeply writable due
 */
 export type WritableDeep<T> = T extends BuiltIns
 	? T
-	: T extends (...arguments: any[]) => unknown
+	: T extends (...arguments_: any[]) => unknown
 		? {} extends WritableObjectDeep<T>
 			? T
 			: HasMultipleCallSignatures<T> extends true
 				? T
-				: ((...arguments: Parameters<T>) => ReturnType<T>) & WritableObjectDeep<T>
+				: ((...arguments_: Parameters<T>) => ReturnType<T>) & WritableObjectDeep<T>
 		: T extends Readonly<ReadonlyMap<infer KeyType, infer ValueType>>
 			? WritableMapDeep<KeyType, ValueType>
 			: T extends Readonly<ReadonlySet<infer ItemType>>