type-fest 5.5.0 → 5.6.0

package/source/numeric.d.ts

@@ -121,9 +121,9 @@ declare function setPercentage<T extends number>(length: Float<T>): void;
 @category Numeric
 */
 export type Float<T> =
-T extends unknown // To distributive type
-	? IsFloat<T> extends true ? T : never
-	: never; // Never happens
+	T extends unknown // To distributive type
+		? IsFloat<T> extends true ? T : never
+		: never; // Never happens
 
 /**
 A negative (`-∞ < x < 0`) `number` that is not an integer.

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

@@ -110,23 +110,23 @@ 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
-	>
->;
+		S,
+		IfNotAnyOrNever<
+			Prefix,
+			_RemovePrefix<S, Prefix, ApplyDefaultOptions<RemovePrefixOptions, DefaultRemovePrefixOptions, Options>>,
+			string,
+			S
+		>
+	>;
 
 type _RemovePrefix<S extends string, Prefix extends string, Options extends Required<RemovePrefixOptions>> =
-Prefix extends string // For distributing `Prefix`
-	? S extends `${Prefix}${infer Rest}`
-		? 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;
+	Prefix extends string // For distributing `Prefix`
+		? S extends `${Prefix}${infer Rest}`
+			? 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;
 
 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.

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
 ```
@@ -40,11 +40,9 @@ type _RequireAtLeastOne<
 	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.
@@ -41,8 +41,8 @@ export type RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType = ke
 
 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 {};

package/source/require-one-or-none.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 exactly one of the given keys and disallows more, or none of the given keys. The remaining keys are kept as is.
+Create a type that requires exactly one of the given keys or none of the given keys, while keeping the remaining keys as is.
 
 @example
 ```

package/source/required-deep.d.ts

@@ -3,12 +3,14 @@ import type {IsNever} from './is-never.d.ts';
 import type {Simplify} from './simplify.d.ts';
 
 /**
-Create a type from another type with all keys and nested keys set to required.
+Create a deeply required version of another type.
 
 Use-cases:
 - Creating optional configuration interfaces where the underlying implementation still requires all options to be fully specified.
 - Modeling the resulting type after a deep merge with a set of defaults.
 
+Use [`Required<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#requiredtype) if you only need one level deep.
+
 @example
 ```
 import type {RequiredDeep} from 'type-fest';

package/source/screaming-snake-case.d.ts

@@ -14,6 +14,7 @@ import type {ScreamingSnakeCase} from 'type-fest';
 
 const someVariable: ScreamingSnakeCase<'fooBar'> = 'FOO_BAR';
 const someVariableNoSplitOnNumbers: ScreamingSnakeCase<'p2pNetwork', {splitOnNumbers: false}> = 'P2P_NETWORK';
+const someVariableWithPunctuation: ScreamingSnakeCase<'div.card::after', {splitOnPunctuation: true}> = 'DIV_CARD_AFTER';
 
 ```
 

package/source/set-non-nullable-deep.d.ts

@@ -1,4 +1,6 @@
 import type {NonRecursiveType, StringToNumber} from './internal/index.d.ts';
+import type {IsAny} from './is-any.d.ts';
+import type {NonNullableDeep} from './non-nullable-deep.d.ts';
 import type {Paths} from './paths.d.ts';
 import type {SetNonNullable} from './set-non-nullable.d.ts';
 import type {Simplify} from './simplify.d.ts';
@@ -8,7 +10,7 @@ import type {UnknownArray} from './unknown-array.d.ts';
 /**
 Create a type that makes the specified keys non-nullable (removes `null` and `undefined`), supports deeply nested key paths, and leaves all other keys unchanged.
 
-NOTE: Optional modifiers (`?`) are not removed from properties. For example, `SetNonNullableDeep<{foo?: string | null | undefined}, 'foo'>` will result in `{foo?: string}`.
+NOTE: Optional modifiers (`?`) are not removed from properties. For example, `SetNonNullableDeep<{foo?: string | null | undefined}, 'foo'>` will result in `{foo?: string}`. To remove both optional modifiers and nullables, use {@link SetRequiredDeep} in conjunction with this type.
 
 @example
 ```
@@ -55,8 +57,9 @@ type ArrayExample2 = SetNonNullableDeep<{a: [(number | null)?, (number | null)?]
 
 @category Object
 */
-export type SetNonNullableDeep<BaseType, KeyPaths extends Paths<BaseType>> =
-	SetNonNullableDeepHelper<BaseType, UnionToTuple<KeyPaths>>;
+export type SetNonNullableDeep<BaseType, KeyPaths extends Paths<BaseType>> = IsAny<KeyPaths> extends true
+	? NonNullableDeep<BaseType>
+	: SetNonNullableDeepHelper<BaseType, UnionToTuple<KeyPaths>>;
 
 /**
 Internal helper for {@link SetNonNullableDeep}.

package/source/set-non-nullable.d.ts

@@ -1,5 +1,5 @@
 /**
-Create a type that makes the given keys non-nullable, where the remaining keys are kept as is.
+Create a type that makes the given keys non-nullable, while keeping the remaining keys as is.
 
 If no keys are given, all keys will be made non-nullable.
 

package/source/set-optional.d.ts

@@ -3,7 +3,7 @@ import type {HomomorphicPick} from './internal/index.d.ts';
 import type {Simplify} from './simplify.d.ts';
 
 /**
-Create a type that makes the given keys optional. The remaining keys are kept as is. The sister of the `SetRequired` type.
+Create a type that makes the given keys optional, while keeping the remaining keys as is.
 
 Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are optional.
 
@@ -32,10 +32,10 @@ export type SetOptional<BaseType, Keys extends keyof BaseType> =
 type _SetOptional<BaseType, Keys extends keyof BaseType> =
 	BaseType extends unknown // To distribute `BaseType` when it's a union type.
 		? Simplify<
-		// Pick just the keys that are readonly from the base type.
-			Except<BaseType, Keys> &
-		// Pick the keys that should be mutable from the base type and make them mutable.
-			Partial<HomomorphicPick<BaseType, Keys>>
+			// Pick just the keys that are readonly from the base type.
+			Except<BaseType, Keys>
+			// Pick the keys that should be mutable from the base type and make them mutable.
+			& Partial<HomomorphicPick<BaseType, Keys>>
 		>
 		: never;
 

package/source/set-readonly.d.ts

@@ -3,7 +3,7 @@ import type {HomomorphicPick} from './internal/index.d.ts';
 import type {Simplify} from './simplify.d.ts';
 
 /**
-Create a type that makes the given keys readonly. The remaining keys are kept as is.
+Create a type that makes the given keys readonly, while keeping the remaining keys as is.
 
 Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are readonly.
 
@@ -32,8 +32,8 @@ export type SetReadonly<BaseType, Keys extends keyof BaseType> =
 export type _SetReadonly<BaseType, Keys extends keyof BaseType> =
 	BaseType extends unknown // To distribute `BaseType` when it's a union type.
 		? Simplify<
-			Except<BaseType, Keys> &
-			Readonly<HomomorphicPick<BaseType, Keys>>
+			Except<BaseType, Keys>
+			& Readonly<HomomorphicPick<BaseType, Keys>>
 		>
 		: never;
 

package/source/set-required-deep.d.ts

@@ -8,7 +8,7 @@ import type {RequiredDeep} from './required-deep.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
 
 /**
-Create a type that makes the given keys required. You can specify deeply nested key paths. The remaining keys are kept as is.
+Create a type that makes the given keys required, with support for deeply nested key paths, while keeping the remaining keys as is.
 
 Use-case: Selectively make nested properties required in complex types like models.
 

package/source/set-required.d.ts

@@ -6,7 +6,7 @@ import type {Simplify} from './simplify.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
 
 /**
-Create a type that makes the given keys required. The remaining keys are kept as is. The sister of the `SetOptional` type.
+Create a type that makes the given keys required, while keeping the remaining keys as is.
 
 Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are required.
 
@@ -43,9 +43,9 @@ type _SetRequired<BaseType, Keys extends keyof BaseType> =
 			: never
 		: Simplify<
 		// Pick just the keys that are optional from the base type.
-			Except<BaseType, Keys> &
+			Except<BaseType, Keys>
 		// Pick the keys that should be required from the base type and make them required.
-			Required<HomomorphicPick<BaseType, Keys>>
+			& Required<HomomorphicPick<BaseType, Keys>>
 		>;
 
 /**

package/source/shared-union-fields.d.ts

@@ -66,14 +66,14 @@ function displayPetInfoWithSharedUnionFields(petInfo: SharedUnionFields<Cat | Do
 @category Union
 */
 export type SharedUnionFields<Union> =
-Extract<Union, NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | UnknownArray> extends infer SkippedMembers
-	? Exclude<Union, SkippedMembers> extends infer RelevantMembers
-		?
-		| SkippedMembers
-		| (IsNever<RelevantMembers> extends true
-			? never
-			: Simplify<Pick<RelevantMembers, keyof RelevantMembers>>)
-		: never
-	: never;
+	Extract<Union, NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | UnknownArray> extends infer SkippedMembers
+		? Exclude<Union, SkippedMembers> extends infer RelevantMembers
+			? // eslint-disable-line @stylistic/operator-linebreak
+			| SkippedMembers
+			| (IsNever<RelevantMembers> extends true
+				? never
+				: Simplify<Pick<RelevantMembers, keyof RelevantMembers>>)
+			: never
+		: never;
 
 export {};

package/source/snake-case.d.ts

@@ -16,6 +16,7 @@ import type {SnakeCase} from 'type-fest';
 const someVariable: SnakeCase<'fooBar'> = 'foo_bar';
 const noSplitOnNumbers: SnakeCase<'p2pNetwork'> = 'p2p_network';
 const splitOnNumbers: SnakeCase<'p2pNetwork', {splitOnNumbers: true}> = 'p_2_p_network';
+const splitOnPunctuation: SnakeCase<'div.card::after', {splitOnPunctuation: true}> = 'div_card_after';
 
 // Advanced
 

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

@@ -51,6 +51,13 @@ const splitOnNumbers: SnakeCasedPropertiesDeep<{line1: {line2: [{line3: string}]
 		],
 	},
 };
+
+const splitOnPunctuation: SnakeCasedPropertiesDeep<{'user@info': {'user::id': number; 'user::name': string}}, {splitOnPunctuation: true}> = {
+	'user_info': {
+		'user_id': 1,
+		'user_name': 'Tom',
+	},
+};
 ```
 
 @category Change case

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

@@ -4,7 +4,7 @@ import type {ApplyDefaultOptions} from './internal/index.d.ts';
 import type {WordsOptions} from './words.d.ts';
 
 /**
-Convert object properties to snake case but not recursively.
+Convert top-level object properties to snake case.
 
 This can be useful when, for example, converting some API types from a different style.
 
@@ -28,6 +28,10 @@ const result: SnakeCasedProperties<User> = {
 const splitOnNumbers: SnakeCasedProperties<{line1: string}, {splitOnNumbers: true}> = {
 	'line_1': 'string',
 };
+
+const splitOnPunctuation: SnakeCasedProperties<{'foo::bar': string}, {splitOnPunctuation: true}> = {
+	'foo_bar': 'string',
+};
 ```
 
 @category Change case

package/source/subtract.d.ts

@@ -1,7 +1,8 @@
-import type {NumberAbsolute, ReverseSign} from './internal/index.d.ts';
+import type {ReverseSign} from './internal/index.d.ts';
 import type {PositiveInfinity, NegativeInfinity, IsNegative} from './numeric.d.ts';
 import type {LessThan} from './less-than.d.ts';
 import type {TupleOf} from './tuple-of.d.ts';
+import type {Absolute} from './absolute.d.ts';
 
 /**
 Returns the difference between two numbers.
@@ -59,9 +60,9 @@ type SubtractPostChecks<A extends number, B extends number, AreNegative = [IsNeg
 		? SubtractPositives<A, B>
 		: AreNegative extends [true, true]
 			// When both numbers are negative we subtract the absolute values and then reverse the sign
-			? ReverseSign<SubtractPositives<NumberAbsolute<A>, NumberAbsolute<B>>>
+			? ReverseSign<SubtractPositives<Absolute<A>, Absolute<B>>>
 			// When the signs are different we can add the absolute values and then reverse the sign if A < B
-			: [...TupleOf<NumberAbsolute<A>>, ...TupleOf<NumberAbsolute<B>>] extends infer R extends unknown[]
+			: [...TupleOf<Absolute<A>>, ...TupleOf<Absolute<B>>] extends infer R extends unknown[]
 				? LessThan<A, B> extends true ? ReverseSign<R['length']> : R['length']
 				: never;
 

package/source/sum.d.ts

@@ -1,7 +1,8 @@
 import type {TupleOf} from './tuple-of.d.ts';
-import type {NumberAbsolute, TupleMax, ReverseSign} from './internal/index.d.ts';
+import type {TupleMax, ReverseSign} from './internal/index.d.ts';
 import type {PositiveInfinity, NegativeInfinity, IsNegative} from './numeric.d.ts';
 import type {Subtract} from './subtract.d.ts';
+import type {Absolute} from './absolute.d.ts';
 
 /**
 Returns the sum of two numbers.
@@ -57,11 +58,11 @@ type SumPostChecks<A extends number, B extends number, AreNegative = [IsNegative
 		? SumPositives<A, B>
 		: AreNegative extends [true, true]
 			// When both numbers are negative we add the absolute values and then reverse the sign
-			? ReverseSign<SumPositives<NumberAbsolute<A>, NumberAbsolute<B>>>
+			? ReverseSign<SumPositives<Absolute<A>, Absolute<B>>>
 			// When the signs are different we can subtract the absolute values, remove the sign
 			// and then reverse the sign if the larger absolute value is negative
-			: NumberAbsolute<Subtract<NumberAbsolute<A>, NumberAbsolute<B>>> extends infer Result extends number
-				? TupleMax<[NumberAbsolute<A>, NumberAbsolute<B>]> extends infer Max_ extends number
+			: Absolute<Subtract<Absolute<A>, Absolute<B>>> extends infer Result extends number
+				? TupleMax<[Absolute<A>, Absolute<B>]> extends infer Max_ extends number
 					? Max_ extends A | B
 						// The larger absolute value is positive, so the result is positive
 						? Result

package/source/tagged.d.ts

@@ -8,12 +8,10 @@ export type TagContainer<Token> = {
 type Tag<Token extends PropertyKey, TagMetadata> = TagContainer<{[K in Token]: TagMetadata}>;
 
 /**
-Attach a "tag" to an arbitrary type. This allows you to create distinct types, that aren't assignable to one another, for distinct concepts in your program that should not be interchangeable, even if their runtime values have the same type. (See examples.)
+Create a [tagged type](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d) that can support [multiple tags](https://github.com/sindresorhus/type-fest/issues/665) and [per-tag metadata](https://medium.com/@ethanresnick/advanced-typescript-tagged-types-improved-with-type-level-metadata-5072fc125fcf).
 
 A type returned by `Tagged` can be passed to `Tagged` again, to create a type with multiple tags.
 
-[Read more about tagged types.](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d)
-
 A tag's name is usually a string (and must be a string, number, or symbol), but each application of a tag can also contain an arbitrary type as its "metadata". See {@link GetTagMetadata} for examples and explanation.
 
 A type `A` returned by `Tagged` is assignable to another type `B` returned by `Tagged` if and only if:
@@ -100,7 +98,7 @@ const parsed = parse(x); // The type of `parsed` is { hello: string }
 export type GetTagMetadata<Type extends Tag<TagName, unknown>, TagName extends PropertyKey> = Type[typeof tag][TagName];
 
 /**
-Revert a tagged type back to its original type by removing all tags.
+Get the untagged portion of a tagged type created with `Tagged`.
 
 Why is this necessary?
 
@@ -129,7 +127,7 @@ type WontWork = UnwrapTagged<string>;
 @category Type
 */
 export type UnwrapTagged<TaggedType extends Tag<PropertyKey, any>> =
-RemoveAllTags<TaggedType>;
+	RemoveAllTags<TaggedType>;
 
 type RemoveAllTags<T> = T extends Tag<PropertyKey, any>
 	? {