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

package/source/string-to-array.d.ts

@@ -0,0 +1,97 @@
+import type {ApplyDefaultOptions} from './internal/object.d.ts';
+import type {IfNotAnyOrNever} from './internal/type.d.ts';
+import type {IsStringLiteral} from './is-string-literal.d.ts';
+import type {Or} from './or.d.ts';
+
+/**
+@see {@link StringToArray}
+*/
+export type StringToArrayOptions = {
+	/**
+	When enabled, non-literal parts of the string (e.g., `string`, `Uppercase<string>`) are mapped as single elements instead of being mapped as a rest element.
+
+	Note: Enabling this option can produce misleading results that might not reflect the actual runtime behavior.
+	For example, `StringToArray<string, {mapNonLiteralsDirectly: true}>` returns `[string]`, but at runtime, the string could be `'abc'` (which satisfies `string`), and converting it to an array would result in `['a', 'b', 'c']`, which doesn't satisfy `[string]`.
+
+	So, it is recommended to not enable this option unless you are aware of the implications.
+
+	@default false
+
+	@example
+	```
+	import type {StringToArray} from 'type-fest';
+
+	type A = StringToArray<string, {mapNonLiteralsDirectly: false}>;
+	//=> string[]
+
+	type B = StringToArray<string, {mapNonLiteralsDirectly: true}>;
+	//=> [string]
+
+	type C = StringToArray<`on${string}`, {mapNonLiteralsDirectly: false}>;
+	//=> ['o', 'n', ...string[]]
+
+	type D = StringToArray<`on${string}`, {mapNonLiteralsDirectly: true}>;
+	//=> ['o', 'n', string]
+
+	type E = StringToArray<`${string}xyz`, {mapNonLiteralsDirectly: false}>;
+	//=> [...string[], 'x', 'y', 'z']
+
+	type F = StringToArray<`${string}xyz`, {mapNonLiteralsDirectly: true}>;
+	//=> [string, 'x', 'y', 'z']
+	```
+	*/
+	mapNonLiteralsDirectly?: boolean;
+};
+
+type DefaultStringToArrayOptions = {
+	mapNonLiteralsDirectly: false;
+};
+
+/**
+Returns an array of the characters of the specified string.
+
+@example
+```
+import type {StringToArray} from 'type-fest';
+
+type A = StringToArray<'abcde'>;
+//=> ['a', 'b', 'c', 'd', 'e']
+
+type B = StringToArray<''>;
+//=> []
+
+type C = StringToArray<string>;
+//=> string[]
+
+type D = StringToArray<`foo${string}bar`>;
+//=> ['f', 'o', 'o', ...string[], 'b', 'a', 'r']
+
+type E = StringToArray<`foo${string}bar`, {mapNonLiteralsDirectly: true}>;
+//=> ['f', 'o', 'o', string, 'b', 'a', 'r']
+```
+
+@see {@link StringToArrayOptions}
+
+@category String
+*/
+export type StringToArray<S extends string, Options extends StringToArrayOptions = {}> =
+	IfNotAnyOrNever<
+		S,
+		{
+			ifNot: _StringToArray<S, ApplyDefaultOptions<StringToArrayOptions, DefaultStringToArrayOptions, Options>>;
+			ifAny: unknown[];
+		}
+	>;
+
+type _StringToArray<S extends string, Options extends Required<StringToArrayOptions>, Accumulator extends string[] = []> =
+	S extends `${infer First}${infer Rest}`
+		? Or<IsStringLiteral<First>, Options['mapNonLiteralsDirectly']> extends true
+			? _StringToArray<Rest, Options, [...Accumulator, First]>
+			: _StringToArray<Rest, Options, [...Accumulator, ...First[]]>
+		: S extends ''
+			? Accumulator
+			: Options['mapNonLiteralsDirectly'] extends true
+				? [...Accumulator, S]
+				: [...Accumulator, ...S[]];
+
+export {};

package/source/string-to-number.d.ts

@@ -0,0 +1,67 @@
+import type {IfNotAnyOrNever} from './internal/type.d.ts';
+import type {NegativeInfinity, PositiveInfinity} from './numeric.d.ts';
+
+/**
+Converts a numeric string to a number.
+
+@example
+```
+import type {StringToNumber} from 'type-fest';
+
+type PositiveInteger = StringToNumber<'1234'>;
+//=> 1234
+
+type NegativeInteger = StringToNumber<'-1234'>;
+//=> -1234
+
+type PositiveFloat = StringToNumber<'1234.56'>;
+//=> 1234.56
+
+type NegativeFloat = StringToNumber<'-1234.56'>;
+//=> -1234.56
+
+type PositiveInfinity = StringToNumber<'Infinity'>;
+//=> Infinity
+
+type NegativeInfinity = StringToNumber<'-Infinity'>;
+//=> -Infinity
+```
+
+Note: Some strings, such as `'1.50'`, `'0b10'`, or `'12_345'`, may look like they can be converted to numbers, but they don't actually have corresponding numeric literals. So, in such cases, this type produces `never`. See [type-fest#1446](https://github.com/sindresorhus/type-fest/pull/1446) for more details.
+
+@example
+```
+import type {StringToNumber} from 'type-fest';
+
+type FractionalsEndingInZero = StringToNumber<'1.50'>;
+//=> never
+
+type NonDecimalBases = StringToNumber<'0b10' | '0o10' | '0x10'>;
+//=> never
+
+type NumericSeparators = StringToNumber<'12_345'>;
+//=> never
+```
+
+@category String
+@category Numeric
+@category Template literal
+*/
+export type StringToNumber<S extends string> = IfNotAnyOrNever<S, {ifNot: _StringToNumber<S>; ifAny: number}>;
+
+type _StringToNumber<S extends string> =
+	S extends `${infer N extends number}`
+		? number extends N
+			? `${number}` extends S
+				? N
+				: never
+			: N
+		: string extends S
+			? number
+			: S extends 'Infinity'
+				? PositiveInfinity
+				: S extends '-Infinity'
+					? NegativeInfinity
+					: never;
+
+export {};

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>
 	? {

package/source/tsconfig-json.d.ts

@@ -61,6 +61,7 @@ export namespace TsConfigJson {
 			| 'ES2022'
 			| 'ES2023'
 			| 'ES2024'
+			| 'ES2025'
 			| 'ESNext'
 			// Lowercase alternatives
 			| 'es3'
@@ -76,6 +77,7 @@ export namespace TsConfigJson {
 			| 'es2022'
 			| 'es2023'
 			| 'es2024'
+			| 'es2025'
 			| 'esnext';
 
 		type Lib =
@@ -148,6 +150,13 @@ export namespace TsConfigJson {
 			| 'ES2024.Regexp'
 			| 'ES2024.SharedMemory'
 			| 'ES2024.String'
+			| 'ES2025'
+			| 'ES2025.Collection'
+			| 'ES2025.Float16'
+			| 'ES2025.Intl'
+			| 'ES2025.Iterator'
+			| 'ES2025.Promise'
+			| 'ES2025.RegExp'
 			| 'ESNext'
 			| 'ESNext.Array'
 			| 'ESNext.AsyncIterable'
@@ -156,6 +165,7 @@ export namespace TsConfigJson {
 			| 'ESNext.Decorators'
 			| 'ESNext.Disposable'
 			| 'ESNext.Error'
+			| 'ESNext.Float16'
 			| 'ESNext.Intl'
 			| 'ESNext.Iterator'
 			| 'ESNext.Object'
@@ -163,6 +173,7 @@ export namespace TsConfigJson {
 			| 'ESNext.Regexp'
 			| 'ESNext.String'
 			| 'ESNext.Symbol'
+			| 'ESNext.Temporal'
 			| 'ESNext.WeakRef'
 			| 'DOM'
 			| 'DOM.AsyncIterable'
@@ -244,6 +255,13 @@ export namespace TsConfigJson {
 			| 'es2024.regexp'
 			| 'es2024.sharedmemory'
 			| 'es2024.string'
+			| 'es2025'
+			| 'es2025.collection'
+			| 'es2025.float16'
+			| 'es2025.intl'
+			| 'es2025.iterator'
+			| 'es2025.promise'
+			| 'es2025.regexp'
 			| 'esnext'
 			| 'esnext.array'
 			| 'esnext.asynciterable'
@@ -252,6 +270,7 @@ export namespace TsConfigJson {
 			| 'esnext.decorators'
 			| 'esnext.disposable'
 			| 'esnext.error'
+			| 'esnext.float16'
 			| 'esnext.intl'
 			| 'esnext.iterator'
 			| 'esnext.object'
@@ -259,6 +278,7 @@ export namespace TsConfigJson {
 			| 'esnext.regexp'
 			| 'esnext.string'
 			| 'esnext.symbol'
+			| 'esnext.temporal'
 			| 'esnext.weakref'
 			| 'dom'
 			| 'dom.asynciterable'
@@ -326,7 +346,7 @@ export namespace TsConfigJson {
 			| 'legacy'
 			| 'force';
 
-		type IgnoreDeprecations = '5.0';
+		type IgnoreDeprecations = '5.0' | '6.0';
 	}
 
 	type CompilerOptions = {
@@ -479,7 +499,7 @@ export namespace TsConfigJson {
 		/**
 		Specify module code generation: 'None', 'CommonJS', 'AMD', 'System', 'UMD', 'ES6', 'ES2015' or 'ESNext'. Only 'AMD' and 'System' can be used in conjunction with `--outFile`. 'ES6' and 'ES2015' values may be used when targeting 'ES5' or lower.
 
-		@default ['ES3', 'ES5'].includes(target) ? 'CommonJS' : 'ES6'
+		Default: `'ESNext'` since TypeScript 6.0, `['ES3', 'ES5'].includes(target) ? 'CommonJS' : 'ES6'` before.
 		*/
 		module?: CompilerOptions.Module;
 
@@ -587,8 +607,17 @@ export namespace TsConfigJson {
 		*/
 		skipLibCheck?: boolean;
 
+		/**
+		Enforce stable type ordering.
+
+		@default false
+		*/
+		stableTypeOrdering?: boolean;
+
 		/**
 		Concatenate and emit output to single file.
+
+		@deprecated since TypeScript 6.0.
 		*/
 		outFile?: string;
 
@@ -696,7 +725,7 @@ export namespace TsConfigJson {
 		/**
 		Specify ECMAScript target version.
 
-		@default 'es3'
+		Default: Current-year ES version since TypeScript 6.0, `'es3'` before.
 		*/
 		target?: CompilerOptions.Target;
 
@@ -776,7 +805,7 @@ export namespace TsConfigJson {
 		/**
 		Report error if failed to find a source file for a side effect import.
 
-		@default false
+		Default: `true` since TypeScript 6.0, `false` before.
 		*/
 		noUncheckedSideEffectImports?: boolean;
 
@@ -822,6 +851,8 @@ export namespace TsConfigJson {
 
 		/**
 		Base directory to resolve non-relative module names.
+
+		@deprecated since TypeScript 6.0.
 		*/
 		baseUrl?: string;
 
@@ -944,7 +975,7 @@ export namespace TsConfigJson {
 		/**
 		Enable all strict type checking options.
 
-		@default false
+		Default: `true` since TypeScript 6.0, `false` before.
 		*/
 		strict?: boolean;
 
@@ -959,6 +990,7 @@ export namespace TsConfigJson {
 		Provide full support for iterables in `for-of`, spread, and destructuring when targeting `ES5` or `ES3`.
 
 		@default false
+		@deprecated since TypeScript 6.0.
 		*/
 		downlevelIteration?: boolean;
 
@@ -1150,7 +1182,7 @@ export namespace TsConfigJson {
 		/**
 		Enable lib replacement.
 
-		@default true
+		Default: `false` since TypeScript 6.0, `true` before.
 		*/
 		libReplacement?: boolean;
 	};
@@ -1234,7 +1266,7 @@ export namespace TsConfigJson {
 		exclude?: string[];
 
 		/**
-		Disable infering what types should be added based on filenames in a project.
+		Disable inferring what types should be added based on filenames in a project.
 		*/
 		disableFilenameBasedTypeAcquisition?: boolean;
 	};
@@ -1266,7 +1298,7 @@ export namespace TsConfigJson {
 }
 
 /**
-Type for [TypeScript's `tsconfig.json` file](https://www.typescriptlang.org/docs/handbook/tsconfig-json.html) (TypeScript 3.7).
+Type for [TypeScript's `tsconfig.json` file](https://www.typescriptlang.org/docs/handbook/tsconfig-json.html).
 
 @category File
 */

package/source/tuple-of.d.ts

@@ -1,6 +1,7 @@
 import type {If} from './if.d.ts';
 import type {IfNotAnyOrNever} from './internal/type.d.ts';
 import type {IsNegative} from './numeric.d.ts';
+import type {DigitCharacter} from './characters.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
 
 /**
@@ -30,7 +31,7 @@ type ZeroToFour = Range<0, 5>;
 //=> '0' | '1' | '2' | '3' | '4'
 
 type ThreeToEight = Range<3, 9>;
-//=> '5' | '3' | '4' | '6' | '7' | '8'
+//=> '3' | '4' | '5' | '6' | '7' | '8'
 ```
 
 Note: If the specified length is the non-literal `number` type, the result will not be a tuple but a regular array.
@@ -63,18 +64,51 @@ type EmptyTuple = TupleOf<-3, string>;
 //=> []
 ```
 
+Note: If the specified length has a decimal part, the decimal part will be ignored.
+
+@example
+```
+import type {TupleOf} from 'type-fest';
+
+type DecimalLength = TupleOf<3.5, string>;
+//=> [string, string, string]
+```
+
 Note: If you need a readonly tuple, simply wrap this type with `Readonly`, for example, to create `readonly [number, number, number]` use `Readonly<TupleOf<3, number>>`.
 
 @category Array
 */
-export type TupleOf<Length extends number, Fill = unknown> = IfNotAnyOrNever<Length,
-	_TupleOf<If<IsNegative<Length>, 0, Length>, Fill, []>,
-	Fill[], []>;
+export type TupleOf<Length extends number, Fill = unknown> = IfNotAnyOrNever<Length, {
+	ifNot: _TupleOf<If<IsNegative<Length>, 0, Length>, Fill>;
+	ifAny: Fill[];
+	ifNever: [];
+}>;
 
-type _TupleOf<L extends number, Fill, Accumulator extends UnknownArray> = number extends L
+type _TupleOf<Length extends number, Fill> = number extends Length
 	? Fill[]
-	: L extends Accumulator['length']
-		? Accumulator
-		: _TupleOf<L, Fill, [...Accumulator, Fill]>;
+	: BuildTupleDigitByDigit<`${Length}`, Fill>;
+
+type BuildTupleDigitByDigit<Length extends string, Fill, Accumulator extends UnknownArray = []> =
+	Length extends `${infer First extends DigitCharacter}${infer Rest}`
+		? BuildTupleDigitByDigit<Rest, Fill, [...RepeatTupleTenTimes<Accumulator>, ...DigitTupleOf<First, Fill>]>
+		: Accumulator;
+
+type RepeatTupleTenTimes<Tuple extends UnknownArray> = [
+	...Tuple, ...Tuple, ...Tuple, ...Tuple, ...Tuple,
+	...Tuple, ...Tuple, ...Tuple, ...Tuple, ...Tuple,
+];
+
+type DigitTupleOf<Digit extends DigitCharacter, Fill> = [
+	[],
+	[Fill],
+	[Fill, Fill],
+	[Fill, Fill, Fill],
+	[Fill, Fill, Fill, Fill],
+	[Fill, Fill, Fill, Fill, Fill],
+	[Fill, Fill, Fill, Fill, Fill, Fill],
+	[Fill, Fill, Fill, Fill, Fill, Fill, Fill],
+	[Fill, Fill, Fill, Fill, Fill, Fill, Fill, Fill],
+	[Fill, Fill, Fill, Fill, Fill, Fill, Fill, Fill, Fill],
+][Digit];
 
 export {};

package/source/typed-array.d.ts

@@ -1,6 +1,10 @@
+import type {FindGlobalType} from './find-global-type.d.ts';
+
 /**
 Matches any [typed array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray), like `Uint8Array` or `Float64Array`.
 
+`Float16Array` is included only when it exists in your TypeScript `lib` (`ESNext` or `ES2025` and later).
+
 @category Array
 */
 export type TypedArray =
@@ -11,6 +15,8 @@ export type TypedArray =
 	| Uint16Array
 	| Int32Array
 	| Uint32Array
+	// Looked up through `globalThis` so that a `lib` without `Float16Array` gets `never` here instead of a compile error. The `prototype` type is `Float16Array<ArrayBufferLike>`, matching the other members.
+	| FindGlobalType<'Float16Array'>['prototype']
 	| Float32Array
 	| Float64Array
 	| BigInt64Array

package/source/union-length.d.ts

@@ -0,0 +1,27 @@
+import type {UnionToTuple} from './union-to-tuple.d.ts';
+
+/**
+Returns the length of a union type.
+
+@example
+```
+import type {UnionLength} from 'type-fest';
+
+type T1 = UnionLength<'foo' | 'bar' | 'baz'>;
+//=> 3
+
+type T2 = UnionLength<[string, string, string] | {x: string; y: string; z: string}>;
+//=> 2
+
+type T3 = UnionLength<any>;
+//=> 1
+
+type T4 = UnionLength<never>;
+//=> 0
+```
+
+@category Type
+*/
+export type UnionLength<Union> = UnionToTuple<Union>['length'];
+
+export {};

package/source/union-max.d.ts

@@ -0,0 +1,56 @@
+import type {IsNever} from './is-never.d.ts';
+import type {Finite, NegativeInfinity, PositiveInfinity} from './numeric.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+import type {IsAnyOrNever} from './internal/type.d.ts';
+
+/**
+Returns the maximum number in a union of numbers.
+
+Use this to derive a maximum retry count or concurrency limit from a fixed set of supported values.
+
+Supports small non-negative integer literals, plus `PositiveInfinity` and `NegativeInfinity`. Negative finite numbers and fractional numbers are not supported. Large integers or unions can exceed TypeScript’s recursion limit.
+
+Returns `number`, `any`, or `never` when given those types.
+
+@example
+```
+import type {UnionMax} from 'type-fest';
+
+const retryCounts = [0, 2, 5] as const;
+type MaximumRetries = UnionMax<typeof retryCounts[number]>;
+//=> 5
+
+const maximumRetries: MaximumRetries = 5;
+```
+
+@example
+```
+import type {PositiveInfinity, UnionMax} from 'type-fest';
+
+type Unlimited = UnionMax<1 | 5 | PositiveInfinity>;
+//=> Infinity
+```
+
+The implementation counts upward using a tuple, removing each matching union member until none remain. Infinity and non-literal inputs are handled before counting.
+
+@see https://github.com/sindresorhus/type-fest/issues/676
+@category Numeric
+*/
+export type UnionMax<NumberUnion extends number> =
+	IsAnyOrNever<NumberUnion> extends true ? NumberUnion
+		: number extends NumberUnion ? number
+			: PositiveInfinity extends NumberUnion ? PositiveInfinity
+				: [NumberUnion] extends [NegativeInfinity] ? NegativeInfinity
+					: InternalUnionMax<Finite<NumberUnion>>;
+
+/**
+The actual implementation of `UnionMax`. It's private because it has some arguments that don't need to be exposed.
+*/
+type InternalUnionMax<NumberUnion extends number, Counter extends UnknownArray = []> =
+	IsNever<NumberUnion> extends true
+		? Counter['length']
+		: Counter['length'] extends NumberUnion
+			? InternalUnionMax<Exclude<NumberUnion, Counter['length']>, Counter>
+			: InternalUnionMax<NumberUnion, [...Counter, unknown]>;
+
+export {};

package/source/union-to-intersection.d.ts

@@ -1,5 +1,5 @@
 /**
-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).
+Convert a union type to an intersection type.
 
 Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
 

package/source/union-to-tuple.d.ts

@@ -1,6 +1,7 @@
 import type {ExcludeExactly} from './exclude-exactly.d.ts';
 import type {IsNever} from './is-never.d.ts';
 import type {UnionMember} from './union-member.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
 
 /**
 Convert a union type into an unordered tuple type of its elements.
@@ -37,9 +38,12 @@ const petList = Object.keys(pets) as UnionToTuple<Pet>;
 
 @category Array
 */
-export type UnionToTuple<T, L = UnionMember<T>> =
-IsNever<T> extends false
-	? [...UnionToTuple<ExcludeExactly<T, L>>, L]
-	: [];
+export type UnionToTuple<Union> =
+	_UnionToTuple<Union> extends infer Result extends UnknownArray ? Result : never; // Nudges the compiler that `UnionToTuple` always yields an array.
+
+type _UnionToTuple<Union, Accumulator extends UnknownArray = [], Member = UnionMember<Union>> =
+	IsNever<Union> extends true
+		? Accumulator
+		: _UnionToTuple<ExcludeExactly<Union, Member>, [Member, ...Accumulator]>;
 
 export {};

package/source/unwrap-required.d.ts

@@ -0,0 +1,37 @@
+import type {MapsSetsOrArrays, NonRecursiveType} from './internal/type.d.ts';
+
+/**
+Revert the `Required` modifier on an object type.
+
+Use-case: Infer the underlying type `T` when only `Required<T>` is available or the original type may not be directly accessible.
+
+@example
+```
+import type {UnwrapRequired} from 'type-fest';
+
+type ContactFormData = Required<{
+	email: string;
+	message?: string;
+}>;
+
+type DraftContactFormData = UnwrapRequired<ContactFormData>;
+//=> {email: string; message?: string}
+```
+
+Note:
+	- If the provided type isn’t of the form `Required<T>`, `UnwrapRequired` simply returns the input type.
+	- `UnwrapRequired` doesn't work with arrays, if instantiated with arrays, it simply returns the input type.
+
+@category Object
+*/
+export type UnwrapRequired<RequiredObjectType> =
+	RequiredObjectType extends NonRecursiveType | MapsSetsOrArrays
+		? RequiredObjectType
+		: _UnwrapRequired<RequiredObjectType>;
+
+type _UnwrapRequired<RequiredObjectType> =
+	RequiredObjectType extends Required<infer ObjectType>
+		? ObjectType
+		: RequiredObjectType;
+
+export {};