@depup/type-fest 5.5.0-depup.0 → 5.10.0-depup.0

package/source/omit-deep.d.ts

@@ -17,7 +17,7 @@ It supports removing specific items from an array, replacing each removed item w
 
 Use-case: Remove unneeded parts of complex objects.
 
-Use [`Omit`](https://www.typescriptlang.org/docs/handbook/utility-types.html#omittype-keys) if you only need one level deep.
+Use [`Omit<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#omittype-keys) if you only need one level deep.
 
 @example
 ```
@@ -93,34 +93,34 @@ type OmitDeepHelper<T, PathTuple extends UnknownArray> =
 Omit one path from the given object/array.
 */
 type OmitDeepWithOnePath<T, Path extends string | number> =
-T extends NonRecursiveType
-	? T
-	: T extends UnknownArray ? SetArrayAccess<OmitDeepArrayWithOnePath<T, Path>, IsArrayReadonly<T>>
-		: T extends object ? OmitDeepObjectWithOnePath<T, Path>
-			: T;
+	T extends NonRecursiveType
+		? T
+		: T extends UnknownArray ? SetArrayAccess<OmitDeepArrayWithOnePath<T, Path>, IsArrayReadonly<T>>
+			: T extends object ? OmitDeepObjectWithOnePath<T, Path>
+				: T;
 
 /**
 Omit one path from the given object.
 */
 type OmitDeepObjectWithOnePath<ObjectT extends object, P extends string | number> =
-P extends `${infer RecordKeyInPath}.${infer SubPath}`
-	? {
-		[Key in keyof ObjectT]:
-		IsEqual<RecordKeyInPath, ToString<Key>> extends true
-			? ExactKey<ObjectT, Key> extends infer RealKey
-				? RealKey extends keyof ObjectT
-					? OmitDeepWithOnePath<ObjectT[RealKey], SubPath>
+	P extends `${infer RecordKeyInPath}.${infer SubPath}`
+		? {
+			[Key in keyof ObjectT]:
+			IsEqual<RecordKeyInPath, ToString<Key>> extends true
+				? ExactKey<ObjectT, Key> extends infer RealKey
+					? RealKey extends keyof ObjectT
+						? OmitDeepWithOnePath<ObjectT[RealKey], SubPath>
+						: ObjectT[Key]
 					: ObjectT[Key]
 				: ObjectT[Key]
-			: ObjectT[Key]
-	}
-	: ExactKey<ObjectT, P> extends infer Key
-		? IsNever<Key> extends true
-			? ObjectT
-			: Key extends PropertyKey
-				? Omit<ObjectT, Key>
-				: ObjectT
-		: ObjectT;
+		}
+		: ExactKey<ObjectT, P> extends infer Key
+			? IsNever<Key> extends true
+				? ObjectT
+				: Key extends PropertyKey
+					? Omit<ObjectT, Key>
+					: ObjectT
+			: ObjectT;
 
 /**
 Omit one path from from the given array.

package/source/or.d.ts

@@ -1,7 +1,7 @@
 import type {OrAll} from './or-all.d.ts';
 
 /**
-Returns a boolean for whether either of two given types is true.
+Returns a boolean for whether either of two given types is `true`.
 
 Use-case: Constructing complex conditional types where at least one condition must be satisfied.
 

package/source/package-json.d.ts

@@ -699,12 +699,12 @@ Type for [npm's `package.json` file](https://docs.npmjs.com/creating-a-package-j
 @category File
 */
 export type PackageJson =
-	JsonObject &
-	PackageJson.NodeJsStandard &
-	PackageJson.PackageJsonStandard &
-	PackageJson.NonStandardEntryPoints &
-	PackageJson.TypeScriptConfiguration &
-	PackageJson.YarnConfiguration &
-	PackageJson.JSPMConfiguration;
+	JsonObject
+	& PackageJson.NodeJsStandard
+	& PackageJson.PackageJsonStandard
+	& PackageJson.NonStandardEntryPoints
+	& PackageJson.TypeScriptConfiguration
+	& PackageJson.YarnConfiguration
+	& PackageJson.JSPMConfiguration;
 
 export {};

package/source/partial-deep.d.ts

@@ -44,12 +44,14 @@ type DefaultPartialDeepOptions = {
 };
 
 /**
-Create a type from another type with all keys and nested keys set to optional.
+Create a deeply optional version of another type.
 
 Use-cases:
 - Merging a default settings/config object with another object, the second object would be a deep partial of the default object.
 - Mocking and testing complex entities, where populating an entire object with its keys would be redundant in terms of the mock or test.
 
+Use [`Partial<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#partialtype) if you only need one level deep.
+
 @example
 ```
 import type {PartialDeep} from 'type-fest';

package/source/pascal-case.d.ts

@@ -12,6 +12,7 @@ import type {PascalCase} from 'type-fest';
 
 const someVariable: PascalCase<'foo-bar'> = 'FooBar';
 const preserveConsecutiveUppercase: PascalCase<'foo-BAR-baz', {preserveConsecutiveUppercase: true}> = 'FooBARBaz';
+const splitOnPunctuation: PascalCase<'foo-bar>>baz', {splitOnPunctuation: true}> = 'FooBarBaz';
 
 // Advanced
 

package/source/pascal-cased-properties-deep.d.ts

@@ -48,6 +48,13 @@ const preserveConsecutiveUppercase: PascalCasedPropertiesDeep<{fooBAR: {fooBARBi
 		}],
 	},
 };
+
+const splitOnPunctuation: PascalCasedPropertiesDeep<{'user@info': {'user::id': number; 'user::name': string}}, {splitOnPunctuation: true}> = {
+	UserInfo: {
+		UserId: 1,
+		UserName: 'Tom',
+	},
+};
 ```
 
 @category Change case

package/source/pascal-cased-properties.d.ts

@@ -3,7 +3,7 @@ import type {ApplyDefaultOptions} from './internal/index.d.ts';
 import type {PascalCase} from './pascal-case.d.ts';
 
 /**
-Convert object properties to pascal case but not recursively.
+Convert top-level object properties to pascal case.
 
 This can be useful when, for example, converting some API types from a different style.
 
@@ -27,6 +27,10 @@ const result: PascalCasedProperties<User> = {
 const preserveConsecutiveUppercase: PascalCasedProperties<{fooBAR: string}, {preserveConsecutiveUppercase: true}> = {
 	FooBAR: 'string',
 };
+
+const splitOnPunctuation: PascalCasedProperties<{'foo::bar': string}, {splitOnPunctuation: true}> = {
+	FooBar: 'string',
+};
 ```
 
 @category Change case

package/source/pick-deep.d.ts

@@ -14,6 +14,8 @@ It supports recursing into arrays.
 
 Use-case: Distill complex objects down to the components you need to target.
 
+Use [`Pick<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#picktype-keys) if you only need one level deep.
+
 @example
 ```
 import type {PickDeep, PartialDeep} from 'type-fest';

package/source/readonly-deep.d.ts

@@ -1,12 +1,14 @@
 import type {BuiltIns, HasMultipleCallSignatures} from './internal/index.d.ts';
 
 /**
-Convert `object`s, `Map`s, `Set`s, and `Array`s and all of their keys/elements into immutable structures recursively.
+Create a deeply immutable version of another type.
 
 This is useful when a deeply nested structure needs to be exposed as completely immutable, for example, an imported JSON module or when receiving an API response that is passed around.
 
 Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/13923) if you want to have this type as a built-in in TypeScript.
 
+Use [`Readonly<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#readonlytype) if you only need one level deep.
+
 @example
 ```
 import type {ReadonlyDeep} from 'type-fest';
@@ -83,8 +85,8 @@ export type ReadonlyDeep<T> = T extends BuiltIns
 				? ReadonlyMapDeep<KeyType, ValueType>
 				: T extends Readonly<ReadonlySet<infer ItemType>>
 					? ReadonlySetDeep<ItemType>
-					: // Identify tuples to avoid converting them to arrays inadvertently; special case `readonly [...never[]]`, as it emerges undesirably from recursive invocations of ReadonlyDeep below.
-					T extends readonly [] | readonly [...never[]]
+					// Identify tuples to avoid converting them to arrays inadvertently; special case `readonly [...never[]]`, as it emerges undesirably from recursive invocations of ReadonlyDeep below.
+					: T extends readonly [] | readonly [...never[]]
 						? readonly []
 						: T extends readonly [infer U, ...infer V]
 							? readonly [ReadonlyDeep<U>, ...ReadonlyDeep<V>]

package/source/remove-prefix.d.ts

@@ -1,7 +1,9 @@
 import type {ApplyDefaultOptions} from './internal/object.d.ts';
 import type {IfNotAnyOrNever, Not} from './internal/type.d.ts';
-import type {IsStringLiteral} from './is-literal.d.ts';
+import type {IsStringLiteral} from './is-string-literal.d.ts';
+import type {IsNever} from './is-never.d.ts';
 import type {Or} from './or.d.ts';
+import type {If} from './if.d.ts';
 
 /**
 @see {@link RemovePrefix}
@@ -58,24 +60,6 @@ export type RemovePrefixOptions = {
 	type D = RemovePrefix<`id-${number}`, 'id-', {strict: false}>;
 	//=> `${number}`
 	```
-
-	Note: If it can be statically determined that the input string can never start with the specified non-literal prefix, then the input string is returned as-is, regardless of the value of this option.
-	For example, ``RemovePrefix<`${string}/${number}`, `${string}:`>`` returns `` `${string}/${number}` ``, since a string of type `` `${string}/${number}` `` can never start with a prefix of type `` `${string}:` ``.
-	```
-	import type {RemovePrefix} from 'type-fest';
-
-	type A = RemovePrefix<`${string}/${number}`, `${string}:`, {strict: true}>;
-	//=> `${string}/${number}`
-
-	type B = RemovePrefix<`${string}/${number}`, `${string}:`, {strict: false}>;
-	//=> `${string}/${number}`
-
-	type C = RemovePrefix<'on-change', `${number}-`, {strict: true}>;
-	//=> 'on-change'
-
-	type D = RemovePrefix<'on-change', `${number}-`, {strict: false}>;
-	//=> 'on-change'
-	```
 	*/
 	strict?: boolean;
 };
@@ -110,23 +94,21 @@ type D = RemovePrefix<`handle${Capitalize<string>}`, 'handle'>;
 @category Template literal
 */
 export type RemovePrefix<S extends string, Prefix extends string, Options extends RemovePrefixOptions = {}> =
-IfNotAnyOrNever<
-	S,
-	IfNotAnyOrNever<
-		Prefix,
-		_RemovePrefix<S, Prefix, ApplyDefaultOptions<RemovePrefixOptions, DefaultRemovePrefixOptions, Options>>,
-		string,
-		S
-	>
->;
+	IfNotAnyOrNever<S, {
+		ifNot: If<
+			IsNever<Prefix>,
+			S,
+			_RemovePrefix<S, Prefix, ApplyDefaultOptions<RemovePrefixOptions, DefaultRemovePrefixOptions, Options>>
+		>;
+	}>;
 
 type _RemovePrefix<S extends string, Prefix extends string, Options extends Required<RemovePrefixOptions>> =
-Prefix extends string // For distributing `Prefix`
-	? S extends `${Prefix}${infer Rest}`
+	Prefix extends string // For distributing `Prefix`
 		? Or<IsStringLiteral<Prefix>, Not<Options['strict']>> extends true
-			? Rest
-			: string // Fallback to `string` when `Prefix` is non-literal and `strict` is disabled
-		: S // Return back `S` when `Prefix` is not present at the start of `S`
-	: never;
+			? S extends `${Prefix}${infer Rest}`
+				? Rest
+				: S // Return back `S` when `Prefix` is not present at the start of `S`
+			: string // Fallback to `string` when `Prefix` is non-literal and `strict` is enabled
+		: never;
 
 export {};

package/source/remove-suffix.d.ts

@@ -0,0 +1,114 @@
+import type {ApplyDefaultOptions} from './internal/object.d.ts';
+import type {IfNotAnyOrNever, Not} from './internal/type.d.ts';
+import type {IsStringLiteral} from './is-string-literal.d.ts';
+import type {IsNever} from './is-never.d.ts';
+import type {Or} from './or.d.ts';
+import type {If} from './if.d.ts';
+
+/**
+@see {@link RemoveSuffix}
+*/
+export type RemoveSuffixOptions = {
+	/**
+	When enabled, instantiations with non-literal suffixes (e.g., `string`, `Uppercase<string>`, `` `.${string}` ``) simply return `string`, since their precise structure cannot be statically determined.
+
+	Note: Disabling this option can produce misleading results that might not reflect the actual runtime behavior.
+	For example, ``RemoveSuffix<'report.pdf', `.${string}`, {strict: false}>`` returns `'report'`, but at runtime, suffix could be `'.txt'` (which satisfies `` `.${string}` ``) and removing `'.txt'` from `'report.pdf'` would not result in `'report'`.
+
+	So, it is recommended to not disable this option unless you are aware of the implications.
+
+	@default true
+
+	@example
+	```
+	import type {RemoveSuffix} from 'type-fest';
+
+	type A = RemoveSuffix<'report.pdf', `.${string}`, {strict: true}>;
+	//=> string
+
+	type B = RemoveSuffix<'report.pdf', `.${string}`, {strict: false}>;
+	//=> 'report'
+
+	type C = RemoveSuffix<'on-change', string, {strict: true}>;
+	//=> string
+
+	type D = RemoveSuffix<'on-change', string, {strict: false}>;
+	//=> 'o'
+
+	type E = RemoveSuffix<`${number}/${string}`, `/${string}`, {strict: true}>;
+	//=> string
+
+	type F = RemoveSuffix<`${number}/${string}`, `/${string}`, {strict: false}>;
+	//=> `${number}`
+	```
+
+	Note: This option has no effect when only the input string type is non-literal. For example, ``RemoveSuffix<`${string}.pdf`, '.pdf'>`` will always return `string`.
+
+	@example
+	```
+	import type {RemoveSuffix} from 'type-fest';
+
+	type A = RemoveSuffix<`${string}.pdf`, '.pdf', {strict: true}>;
+	//=> string
+
+	type B = RemoveSuffix<`${string}.pdf`, '.pdf', {strict: false}>;
+	//=> string
+
+	type C = RemoveSuffix<`${number}px`, 'px', {strict: true}>;
+	//=> `${number}`
+
+	type D = RemoveSuffix<`${number}px`, 'px', {strict: false}>;
+	//=> `${number}`
+	```
+	*/
+	strict?: boolean;
+};
+
+type DefaultRemoveSuffixOptions = {
+	strict: true;
+};
+
+/**
+Remove the specified suffix from the end of a string.
+
+@example
+```
+import type {RemoveSuffix} from 'type-fest';
+
+type A = RemoveSuffix<'report.pdf', '.pdf'>;
+//=> 'report'
+
+type B = RemoveSuffix<'bg-blue-500' | 'text-green-500' | 'border-slate-500', '-500'>;
+//=> 'bg-blue' | 'border-slate' | 'text-green'
+
+type C = RemoveSuffix<'report.pdf', '.txt'>;
+//=> 'report.pdf'
+
+type D = RemoveSuffix<`api/${string}/analytics`, '/analytics'>;
+//=> `api/${string}`
+```
+
+@see {@link RemoveSuffixOptions}
+
+@category String
+@category Template literal
+*/
+export type RemoveSuffix<S extends string, Suffix extends string, Options extends RemoveSuffixOptions = {}> =
+	IfNotAnyOrNever<S, {
+		ifNot: If<
+			IsNever<Suffix>,
+			S,
+			_RemoveSuffix<S, Suffix, ApplyDefaultOptions<RemoveSuffixOptions, DefaultRemoveSuffixOptions, Options>>
+		>;
+	}>;
+
+type _RemoveSuffix<S extends string, Suffix extends string, Options extends Required<RemoveSuffixOptions>> =
+	Suffix extends string // For distributing `Suffix`
+		? Or<IsStringLiteral<Suffix>, Not<Options['strict']>> extends true
+			? S extends `${infer Rest}${Suffix}`
+				? Rest
+				: S // Return back `S` when `Suffix` is not present at the end of `S`
+			: string // Fallback to `string` when `Suffix` is non-literal and `strict` is enabled
+		: never;
+
+export {};

package/source/rename-keys.d.ts

@@ -0,0 +1,163 @@
+import type {IsLiteral} from './is-literal.d.ts';
+import type {ReadonlyKeysOf} from './readonly-keys-of.d.ts';
+import type {RequiredKeysOf} from './required-keys-of.d.ts';
+import type {OptionalKeysOf} from './optional-keys-of.d.ts';
+import type {OmitIndexSignature} from './omit-index-signature.d.ts';
+import type {SetRequired} from './set-required.d.ts';
+import type {SetReadonly} from './set-readonly.d.ts';
+import type {IfNotAnyOrNever, IsExactOptionalPropertyTypesEnabled} from './internal/type.d.ts';
+
+/**
+Rename keys in an object type according to a map of old-to-new names.
+
+@example
+```
+import type {RenameKeys} from 'type-fest';
+
+type User = {
+	id: string;
+	firstName: string;
+	createdAt: Date;
+};
+
+type Renamed = RenameKeys<User, {firstName: 'first_name'; createdAt: 'created_at'}>;
+//=> {id: string; first_name: string; created_at: Date}
+```
+
+@example
+```
+import type {RenameKeys} from 'type-fest';
+
+type SearchInput = {
+	textQuery: string;
+	voiceQuery: Blob;
+	imageQuery: File;
+};
+
+type Normalized = RenameKeys<SearchInput, {textQuery: 'query'; voiceQuery: 'query'; imageQuery: 'query'}>;
+//=> {query: string | Blob | File}
+```
+
+Note: When multiple source keys map to the same target, the target's value type is the union of the contributors' value types. The target is optional only when every contributor is optional, and is `readonly` when any contributor is `readonly`. With `exactOptionalPropertyTypes` disabled, the value type of a mixed-optionality merge also includes `undefined`.
+
+@example
+```
+import type {RenameKeys} from 'type-fest';
+
+// All colliding keys are required, so the target is required.
+type A = RenameKeys<{a: 1; b: 2}, {a: 'x'; b: 'x'}>;
+//=> {x: 1 | 2}
+
+// All colliding keys are optional, so the target is optional.
+type B = RenameKeys<{a?: 1; b?: 2}, {a: 'x'; b: 'x'}>;
+//=> {x?: 1 | 2}
+
+// One of the colliding keys is required, so the target is required.
+type C = RenameKeys<{a: 1; b?: 2}, {a: 'x'; b: 'x'}>;
+//=> {x: 1 | 2}
+
+// One of the colliding keys is `readonly`, so the target is `readonly`.
+type D = RenameKeys<{readonly a: 1; b: 2}, {a: 'x'; b: 'x'}>;
+//=> {readonly x: 1 | 2}
+```
+
+@example
+```
+// @exactOptionalPropertyTypes: false
+import type {RenameKeys} from 'type-fest';
+
+// With `exactOptionalPropertyTypes` disabled, a mixed-optionality merge includes `undefined`.
+type E = RenameKeys<{a?: 1; b: 2}, {a: 'x'; b: 'x'}>;
+//=> {x: 1 | 2 | undefined}
+```
+
+Note: A union target distributes, producing one output key per member.
+
+@example
+```
+import type {RenameKeys} from 'type-fest';
+
+type A = RenameKeys<{a: string}, {a: 'b' | 'c'}>;
+//=> {b: string; c: string}
+```
+
+Note: An entry whose value is not a literal `PropertyKey` (such as `string`) is also ignored, leaving that key's name unchanged.
+
+@example
+```
+import type {RenameKeys} from 'type-fest';
+
+type A = RenameKeys<{a: 1}, {a: string}>;
+//=> {a: 1}
+
+type B = RenameKeys<{a: 1; b: 2}, {a: 'x'; b: symbol}>;
+//=> {x: 1; b: 2}
+```
+
+Note: A rename map entry whose key is not a property of the source type is ignored.
+
+@example
+```
+import type {RenameKeys} from 'type-fest';
+
+type A = RenameKeys<{a: 1; b: 2}, {a: 'x'; c: 'y'}>;
+//=> {x: 1; b: 2}
+```
+
+@category Object
+*/
+export type RenameKeys<
+	BaseType extends object,
+	RenameMap extends Record<PropertyKey, PropertyKey>,
+> = IfNotAnyOrNever<BaseType, {
+	ifNot: BaseType extends unknown // For distributing `BaseType`
+		? RenameMap extends unknown // For distributing `RenameMap`
+			? RenameOnce<BaseType, NormalizeMap<RenameMap>>
+			: never
+		: never;
+}>;
+
+type RenameOnce<BaseType extends object, RenameMap extends Record<PropertyKey, PropertyKey>> =
+	RestoreMergedUndefined<BaseType, RenameMap,
+		ApplyReadonly<BaseType, RenameMap,
+			ApplyRequired<BaseType, RenameMap,
+				RenameNaive<BaseType, RenameMap>>>>;
+
+type RenameNaive<BaseType extends object, RenameMap extends Record<PropertyKey, PropertyKey>> = {
+	// Two keys mapping to one target produce a union value and keep only the first key's modifiers.
+	// Like for example, `{a?: 1; b: 2}` with `{a: 'x'; b: 'x'}` produces `{x?: 1 | 2}`, taking `a`'s optional.
+	[Key in keyof BaseType as TargetOf<Key, RenameMap>]: Required<BaseType>[Key];
+};
+
+// A merged target kept only one modifier in `RenameNaive`, so re-force these from every contributor.
+type ApplyRequired<BaseType extends object, RenameMap extends Record<PropertyKey, PropertyKey>, Renamed> =
+	SetRequired<Renamed, TargetOf<RequiredKeysOf<OmitIndexSignature<BaseType>>, RenameMap> & keyof Renamed>;
+
+type ApplyReadonly<BaseType extends object, RenameMap extends Record<PropertyKey, PropertyKey>, Renamed> =
+	SetReadonly<Renamed, TargetOf<ReadonlyKeysOf<OmitIndexSignature<BaseType>>, RenameMap> & keyof Renamed>;
+
+// `exactOptionalPropertyTypes` off keeps `undefined` on a target that merged a required and an optional source.
+// Source `{a?: 1; x: 2}` with `{a: 'x'}` gives `{x: 1 | 2 | undefined}`.
+type RestoreMergedUndefined<BaseType extends object, RenameMap extends Record<PropertyKey, PropertyKey>, Result> =
+	IsExactOptionalPropertyTypesEnabled extends true
+		? Result
+		: {
+			[Key in keyof Result]: Key extends MergedTargets<BaseType, RenameMap>
+				? Result[Key] | undefined
+				: Result[Key];
+		};
+
+type MergedTargets<BaseType extends object, RenameMap extends Record<PropertyKey, PropertyKey>> =
+	// Targets renamed from both a required and an optional key prefer the required modifier.
+	// Required `b` and optional `a` both rename to `x` in `{a?: 1; b: 2}` with `{a: 'x'; b: 'x'}`.
+	TargetOf<RequiredKeysOf<OmitIndexSignature<BaseType>>, RenameMap>
+	& TargetOf<OptionalKeysOf<OmitIndexSignature<BaseType>>, RenameMap>;
+
+type NormalizeMap<RenameMap extends Record<PropertyKey, PropertyKey>> = {
+	-readonly [Key in keyof RenameMap as true extends IsLiteral<RenameMap[Key]> ? Key : never]-?: RenameMap[Key];
+};
+
+type TargetOf<SourceKey extends PropertyKey, RenameMap extends Record<PropertyKey, PropertyKey>> =
+	SourceKey extends keyof RenameMap ? RenameMap[SourceKey] : SourceKey;
+
+export {};

package/source/replace.d.ts

@@ -27,7 +27,7 @@ declare function replace<
 >(
 	input: Input,
 	search: Search,
-	replacement: Replacement
+	replacement: Replacement,
 ): Replace<Input, Search, Replacement>;
 
 declare function replaceAll<
@@ -37,7 +37,7 @@ declare function replaceAll<
 >(
 	input: Input,
 	search: Search,
-	replacement: Replacement
+	replacement: Replacement,
 ): Replace<Input, Search, Replacement, {all: true}>;
 
 // The return type is the exact string literal, not just `string`.

package/source/require-all-or-none.d.ts

@@ -9,7 +9,7 @@ Requires all of the keys in the given object.
 type RequireAll<ObjectType, KeysType extends keyof ObjectType> = Required<Pick<ObjectType, KeysType>>;
 
 /**
-Create a type that requires all of the given keys or none of the given keys. The remaining keys are kept as is.
+Create a type that requires all of the given keys or none of the given keys, while keeping the remaining keys as is.
 
 Use-cases:
 - Creating interfaces for components with mutually-inclusive keys.
@@ -40,11 +40,11 @@ const responder2: RequireAllOrNone<Responder, 'text' | 'json'> = {
 @category Object
 */
 export type RequireAllOrNone<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> =
-	IfNotAnyOrNever<ObjectType,
-		If<IsNever<KeysType>,
+	IfNotAnyOrNever<ObjectType, {
+		ifNot: If<IsNever<KeysType>,
 			ObjectType,
-			_RequireAllOrNone<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>
-		>>;
+			_RequireAllOrNone<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>>;
+	}>;
 
 type _RequireAllOrNone<ObjectType, KeysType extends keyof ObjectType> = (
 	| RequireAll<ObjectType, KeysType>

package/source/require-at-least-one.d.ts

@@ -5,7 +5,7 @@ import type {IsAny} from './is-any.d.ts';
 import type {IsNever} from './is-never.d.ts';
 
 /**
-Create a type that requires at least one of the given keys. The remaining keys are kept as is.
+Create a type that requires at least one of the given keys, while keeping the remaining keys as is.
 
 @example
 ```
@@ -29,22 +29,20 @@ export type RequireAtLeastOne<
 	ObjectType,
 	KeysType extends keyof ObjectType = keyof ObjectType,
 > =
-	IfNotAnyOrNever<ObjectType,
-		If<IsNever<KeysType>,
+	IfNotAnyOrNever<ObjectType, {
+		ifNot: If<IsNever<KeysType>,
 			never,
-			_RequireAtLeastOne<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>
-		>>;
+			_RequireAtLeastOne<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>>;
+	}>;
 
 type _RequireAtLeastOne<
 	ObjectType,
 	KeysType extends keyof ObjectType,
 > = {
 	// For each `Key` in `KeysType` make a mapped type:
-	[Key in KeysType]-?: Required<Pick<ObjectType, Key>> & // 1. Make `Key`'s type required
-	// 2. Make all other keys in `KeysType` optional
-		Partial<Pick<ObjectType, Exclude<KeysType, Key>>>;
-}[KeysType] &
-// 3. Add the remaining keys not in `KeysType`
-Except<ObjectType, KeysType>;
+	[Key in KeysType]-?: Required<Pick<ObjectType, Key>> // 1. Make `Key`'s type required
+		& Partial<Pick<ObjectType, Exclude<KeysType, Key>>>; // 2. Make all other keys in `KeysType` optional
+}[KeysType]
+& Except<ObjectType, KeysType>; // 3. Add the remaining keys not in `KeysType`
 
 export {};

package/source/require-exactly-one.d.ts

@@ -4,7 +4,7 @@ import type {IsAny} from './is-any.d.ts';
 import type {IsNever} from './is-never.d.ts';
 
 /**
-Create a type that requires exactly one of the given keys and disallows more. The remaining keys are kept as is.
+Create a type that requires exactly one of the given keys and disallows more, while keeping the remaining keys as is.
 
 Use-cases:
 - Creating interfaces for components that only need one of the keys to display properly.
@@ -33,16 +33,16 @@ const responder: RequireExactlyOne<Responder, 'text' | 'json'> = {
 @category Object
 */
 export type RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> =
-	IfNotAnyOrNever<ObjectType,
-		If<IsNever<KeysType>,
+	IfNotAnyOrNever<ObjectType, {
+		ifNot: If<IsNever<KeysType>,
 			never,
-			_RequireExactlyOne<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>
-		>>;
+			_RequireExactlyOne<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>>;
+	}>;
 
 type _RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType> =
 	{[Key in KeysType]: (
-		Required<Pick<ObjectType, Key>> &
-		Partial<Record<Exclude<KeysType, Key>, never>>
+		Required<Pick<ObjectType, Key>>
+		& Partial<Record<Exclude<KeysType, Key>, never>>
 	)}[KeysType] & Omit<ObjectType, KeysType>;
 
 export {};