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

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/type-fest
 
 | Field | Value |
 |-------|-------|
-| Original | [type-fest](https://www.npmjs.com/package/type-fest) @ 5.9.0 |
-| Processed | 2026-09-06 |
+| Original | [type-fest](https://www.npmjs.com/package/type-fest) @ 5.10.0 |
+| Processed | 2026-09-27 |
 | Smoke test | failed |
 | Deps updated | 0 |
 

package/changes.json

@@ -1,5 +1,5 @@
 {
   "bumped": {},
-  "timestamp": "2026-09-06T01:00:53.768Z",
+  "timestamp": "2026-09-27T01:04:10.017Z",
   "totalUpdated": 0
 }

package/index.d.ts

@@ -99,6 +99,7 @@ export type {LessThan} from './source/less-than.d.ts';
 export type {LessThanOrEqual} from './source/less-than-or-equal.d.ts';
 export type {Sum} from './source/sum.d.ts';
 export type {Subtract} from './source/subtract.d.ts';
+export type {UnionMax} from './source/union-max.d.ts';
 export type {KeyAsString} from './source/key-as-string.d.ts';
 export type {Exact} from './source/exact.d.ts';
 export type {ReadonlyTuple} from './source/readonly-tuple.d.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@depup/type-fest",
-  "version": "5.9.0-depup.0",
+  "version": "5.10.0-depup.0",
   "description": "A collection of essential TypeScript types (with updated dependencies)",
   "license": "(MIT OR CC0-1.0)",
   "repository": "sindresorhus/type-fest",
@@ -26,6 +26,7 @@
   },
   "scripts": {
     "test:tsc": "node --max-old-space-size=6144 ./node_modules/.bin/tsc",
+    "test:minimum-lib": "node --max-old-space-size=6144 ./node_modules/.bin/tsc -p tsconfig.minimum-lib.json",
     "test:tsd": "node --max-old-space-size=6144 ./node_modules/.bin/tsd",
     "test:xo": "node --max-old-space-size=6144 ./node_modules/.bin/xo --ignores=lint-processors/fixtures/**/*.d.ts '**/*.{js,ts,md}'",
     "test:linter": "node --test",
@@ -84,8 +85,8 @@
     "changes": {},
     "depsUpdated": 0,
     "originalPackage": "type-fest",
-    "originalVersion": "5.9.0",
-    "processedAt": "2026-09-06T01:00:57.924Z",
+    "originalVersion": "5.10.0",
+    "processedAt": "2026-09-27T01:04:16.083Z",
     "smokeTest": "failed"
   }
 }

package/readme.md

@@ -29,17 +29,6 @@
 					<sup>An open-source framework that supports any programming language, cloud provider, or deployment automation tool.</sup>
 				</div>
 			</a>
-			<br>
-			<br>
-			<a href="https://circleback.ai?utm_source=sindresorhus&utm_medium=sponsorship&utm_campaign=awesome-list&utm_id=type-fest">
-				<div>
-					<img width="300" src="https://sindresorhus.com/assets/thanks/circleback-logo.png?x" alt="Circleback logo">
-				</div>
-				<b>Get the most out of every conversation.</b>
-				<div>
-					<sup>AI-powered meeting notes, automations, and search. Give AI agents the context they need to get things done.</sup>
-				</div>
-			</a>
 		</p>
 	</div>
 	<br>
@@ -312,6 +301,7 @@ Click the type names for complete docs.
 - [`LessThanOrEqual`](source/less-than-or-equal.d.ts) - Returns a boolean for whether a given number is less than or equal to another number.
 - [`Sum`](source/sum.d.ts) - Returns the sum of two numbers.
 - [`Subtract`](source/subtract.d.ts) - Returns the difference between two numbers.
+- [`UnionMax`](source/union-max.d.ts) - Returns the maximum number in a union of numbers.
 - [`Absolute`](source/absolute.d.ts) - Returns the absolute value of the specified number or bigint.
 - [`StringToNumber`](source/string-to-number.d.ts) - Converts a numeric string to a number.
 

package/source/all-extend.d.ts

@@ -101,10 +101,15 @@ type B = AllExtend<[1?, 2?, 3?], number | undefined>;
 @category Array
 */
 export type AllExtend<TArray extends UnknownArray, Type, Options extends AllExtendOptions = {}> =
-	_AllExtend<CollapseRestElement<TArray>, Type, ApplyDefaultOptions<AllExtendOptions, DefaultAllExtendOptions, Options>>;
-
-type _AllExtend<TArray extends UnknownArray, Type, Options extends Required<AllExtendOptions>> = IfNotAnyOrNever<TArray, {
-	ifNot: TArray extends readonly [infer First, ...infer Rest]
+	IfNotAnyOrNever<CollapseRestElement<TArray>, {
+		ifNot: _AllExtend<CollapseRestElement<TArray>, Type, ApplyDefaultOptions<AllExtendOptions, DefaultAllExtendOptions, Options>>;
+		ifAny: false;
+		ifNever: false;
+	}>;
+
+// Kept free of `IfNotAnyOrNever` so that it stays tail-recursive, which allows it to handle long arrays.
+type _AllExtend<TArray extends UnknownArray, Type, Options extends Required<AllExtendOptions>> =
+	TArray extends readonly [infer First, ...infer Rest]
 		? IsNever<First> extends true
 			? Or<Or<IsNever<Type>, IsAny<Type>>, Not<Options['strictNever']>> extends true
 				// If target `Type` is also `never`, or is `any`, or `strictNever` is disabled, recurse further.
@@ -114,8 +119,5 @@ type _AllExtend<TArray extends UnknownArray, Type, Options extends Required<AllE
 				? _AllExtend<Rest, Type, Options>
 				: false
 		: true;
-	ifAny: false;
-	ifNever: false;
-}>;
 
 export {};

package/source/array-reverse.d.ts

@@ -1,7 +1,6 @@
 import type {If} from './if.d.ts';
 import type {IsArrayReadonly} from './internal/array.d.ts';
 import type {IfNotAnyOrNever, IsExactOptionalPropertyTypesEnabled} from './internal/type.d.ts';
-import type {IsOptionalKeyOf} from './is-optional-key-of.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
 
 /**
@@ -65,21 +64,23 @@ type _ArrayReverse<
 	AfterRestAcc extends UnknownArray = [],
 	Result extends UnknownArray = never,
 > =
-	keyof TArray & `${number}` extends never
-		// Enters this branch, if `TArray` is empty (e.g., `[]`),
-		// or `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
-		? TArray extends readonly [...infer Rest, infer Last]
-			? _ArrayReverse<Rest, BeforeRestAcc, [...AfterRestAcc, Last], Result> // Accumulate elements that are present after the rest element in reverse order.
-			: Result | [...AfterRestAcc, ...TArray, ...BeforeRestAcc] // Add the rest element between the accumulated elements.
-		: TArray extends readonly [(infer First)?, ...infer Rest]
-			? IsOptionalKeyOf<TArray, '0'> extends true
-				? _ArrayReverse<
+	'0' extends keyof TArray
+		// Enters this branch, if `TArray` starts with a non-rest element (e.g., `[string, number]` or `[string, ...number[]]`).
+		? TArray extends readonly [(infer First)?, ...infer Rest]
+			// A tuple allows fewer than one element only when its first element is optional. Written in exactly this shape because equivalent ones, such as `[] extends TArray`, are several times slower.
+			? TArray extends readonly [unknown, ...unknown[]]
+				? _ArrayReverse<Rest, [First, ...BeforeRestAcc], AfterRestAcc, Result>
+				: _ArrayReverse<
 					Rest,
 					[First | (If<IsExactOptionalPropertyTypesEnabled, never, undefined>), ...BeforeRestAcc], // Add `| undefined` for optional elements, if `exactOptionalPropertyTypes` is disabled.
 					AfterRestAcc,
 					Result | BeforeRestAcc
 				>
-				: _ArrayReverse<Rest, [First, ...BeforeRestAcc], AfterRestAcc, Result>
-			: never; // Should never happen, since `readonly [(infer First)?, ...infer Rest]` is a top-type for arrays.
+			: never // Should never happen, since `readonly [(infer First)?, ...infer Rest]` is a top-type for arrays.
+		// Enters this branch, if `TArray` is empty (e.g., `[]`),
+		// or `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
+		: TArray extends readonly [...infer Rest, infer Last]
+			? _ArrayReverse<Rest, BeforeRestAcc, [...AfterRestAcc, Last], Result> // Accumulate elements that are present after the rest element in reverse order.
+			: Result | [...AfterRestAcc, ...TArray, ...BeforeRestAcc]; // Add the rest element between the accumulated elements.
 
 export {};

package/source/array-tail.d.ts

@@ -60,11 +60,11 @@ export type ArrayTail<TArray extends UnknownArray> = IfNotAnyOrNever<TArray, {
 }>;
 
 type _ArrayTail<TArray extends UnknownArray> = TArray extends readonly [unknown?, ...infer Tail]
-	? keyof TArray & `${number}` extends never
-		? TArray extends readonly []
+	? '0' extends keyof TArray
+		? Tail
+		: TArray extends readonly []
 			? []
 			: TArray // Happens when `TArray` is a non-tuple array (e.g., `string[]`) or has a leading rest element (e.g., `[...string[], number]`)
-		: Tail
 	: [];
 
 export {};

package/source/int-closed-range.d.ts

@@ -6,7 +6,7 @@ Generate a union of numbers between a specified start and end (both inclusive),
 
 You skip over numbers using the `Step` parameter (defaults to `1`). For example, `IntClosedRange<0, 10, 2>` will create a union of `0 | 2 | 4 | 6 | 8 | 10`.
 
-Note: `Start` or `End` must be non-negative and smaller than `999`.
+Note: `Start` and `End` must each be between `-998` and `998`. The maximum is one less than for `IntRange` because the end is incremented internally to make it inclusive. If `Start` is greater than `End`, the result is `never`.
 
 Use-cases:
 1. This can be used to define a set of valid input/output values. for example:
@@ -23,6 +23,9 @@ type FontSize = IntClosedRange<10, 20>;
 
 type EvenNumber = IntClosedRange<0, 10, 2>;
 //=> 0 | 2 | 4 | 6 | 8 | 10
+
+type Offset = IntClosedRange<-3, 3>;
+//=> -3 | -2 | -1 | 0 | 1 | 2 | 3
 ```
 
 2. This can be used to define random numbers in a range. For example, `type RandomNumber = IntClosedRange<0, 100>;`

package/source/int-range.d.ts

@@ -1,12 +1,16 @@
 import type {TupleOf} from './tuple-of.d.ts';
 import type {Subtract} from './subtract.d.ts';
+import type {Absolute} from './absolute.d.ts';
+import type {IsNegative} from './numeric.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+import type {ReverseSign} from './internal/index.d.ts';
 
 /**
 Generate a union of numbers between a specified start (inclusive) and end (exclusive), with an optional step.
 
 You skip over numbers using the `Step` parameter (defaults to `1`). For example, `IntRange<0, 10, 2>` will create a union of `0 | 2 | 4 | 6 | 8`.
 
-Note: `Start` or `End` must be non-negative and smaller than `1000`.
+Note: `Start` and `End` must each be between `-998` and `999`. Negative ranges reach TypeScript's instantiation-depth limit one value earlier, so their supported minimum is one smaller in magnitude than the maximum. If `Start` is greater than `End`, the result is `never`.
 
 Use-cases:
 1. This can be used to define a set of valid input/output values. for example:
@@ -23,6 +27,9 @@ type FontSize = IntRange<10, 20>;
 
 type EvenNumber = IntRange<0, 11, 2>;
 //=> 0 | 2 | 4 | 6 | 8 | 10
+
+type Offset = IntRange<-3, 3>;
+//=> -3 | -2 | -1 | 0 | 1 | 2
 ```
 
 2. This can be used to define random numbers in a range. For example, `type RandomNumber = IntRange<0, 100>;`
@@ -40,7 +47,41 @@ type Hundreds = IntRange<100, 901, 100>;
 
 @see {@link IntClosedRange}
 */
-export type IntRange<Start extends number, End extends number, Step extends number = 1> = PrivateIntRange<Start, End, Step>;
+export type IntRange<Start extends number, End extends number, Step extends number = 1> =
+	IsNegative<Start> extends true
+		? PrivateNegativeIntRange<Start, End, Step>
+		: PrivateIntRange<Start, End, Step>;
+
+/**
+Removes `StepTuple['length']` elements from the front of `Tuple`, or empties it when it is too short.
+*/
+type DropStep<Tuple extends UnknownArray, StepTuple extends UnknownArray> =
+	Tuple extends [...StepTuple, ...infer Rest extends UnknownArray] ? Rest : [];
+
+/**
+The implementation of `IntRange` for a negative `Start`.
+
+A tuple length can never be negative, so instead of counting up to the value, `Magnitude` counts down from `-Start` and the value is `-Magnitude['length']`. Once `Magnitude` is too short to step again, the range has crossed zero and the rest is delegated to `PrivateIntRange`.
+*/
+type PrivateNegativeIntRange<
+	Start extends number,
+	End extends number,
+	Step extends number,
+	// A `Step` below `1` cannot advance the range, so fall back to `1` like `PrivateIntRange` does
+	StepTuple extends UnknownArray = TupleOf<Step> extends [] ? [unknown] : TupleOf<Step>,
+	// How much of the range is left to generate, shortened by `Step` each time, so the range stops at `End`
+	Remaining extends UnknownArray = TupleOf<Subtract<End, Start>>,
+	// The magnitude of the current value, so the value itself is `-Magnitude['length']`
+	Magnitude extends UnknownArray = TupleOf<Absolute<Start>>,
+	Result = never,
+> = Remaining extends []
+	? Result
+	: Magnitude extends [...StepTuple, ...infer NextMagnitude extends UnknownArray]
+		? PrivateNegativeIntRange<Start, End, Step, StepTuple, DropStep<Remaining, StepTuple>, NextMagnitude, Result | ReverseSign<Magnitude['length']>>
+		// Less than a step is left below zero, so `Crossover` is the amount the next step overshoots it by, and counting up can take over from there
+		: StepTuple extends [...Magnitude, ...infer Crossover extends UnknownArray]
+			? Result | ReverseSign<Magnitude['length']> | PrivateIntRange<Crossover['length'], End, Step>
+			: never;
 
 /**
 The actual implementation of `IntRange`. It's private because it has some arguments that don't need to be exposed.
@@ -54,14 +95,20 @@ type PrivateIntRange<
 	// The final `List` is `[...StartLengthTuple, ...[number, ...GapLengthTuple], ...[number, ...GapLengthTuple], ... ...]`, so can initialize the `List` with `[...StartLengthTuple]`
 	List extends unknown[] = TupleOf<Start, never>,
 	EndLengthTuple extends unknown[] = TupleOf<End>,
-> = Gap extends 0
+	// Avoid `GreaterThan<Start, End>` here because the extra type instantiations would make `IntRange<0, 999>` exceed TypeScript's instantiation-depth limit
+	// `TupleOf` represents a negative length as an empty tuple, so a negative `End` must be detected before comparing the tuple lengths
+	// Recursive calls pass `false` because reversal only depends on the initial bounds; the termination checks below still handle reaching or overshooting `End` without repeating this tuple comparison
+	IsReversed extends boolean = IsNegative<End> extends true ? true : List extends [...EndLengthTuple, unknown, ...unknown[]] ? true : false,
+> = IsReversed extends true
+	? never
+	: Gap extends 0
 	// Handle the case that without `Step`
-	? List['length'] extends End // The result of "List[length] === End"
-		? Exclude<List[number], never> // All unused elements are `never`, so exclude them
-		: PrivateIntRange<Start, End, Step, Gap, [...List, List['length'] ]>
+		? List['length'] extends End // The result of "List[length] === End"
+			? Exclude<List[number], never> // All unused elements are `never`, so exclude them
+			: PrivateIntRange<Start, End, Step, Gap, [...List, List['length'] ], EndLengthTuple, false>
 	// Handle the case that with `Step`
-	: List extends [...(infer U), ...EndLengthTuple] // The result of "List[length] >= End", because the `...TupleOf<Gap, never>` maybe make `List` too long.
-		? Exclude<List[number], never>
-		: PrivateIntRange<Start, End, Step, Gap, [...List, List['length'], ...TupleOf<Gap, never>]>;
+		: List extends [...(infer U), ...EndLengthTuple] // The result of "List[length] >= End", because the `...TupleOf<Gap, never>` maybe make `List` too long.
+			? Exclude<List[number], never>
+			: PrivateIntRange<Start, End, Step, Gap, [...List, List['length'], ...TupleOf<Gap, never>], EndLengthTuple, false>;
 
 export {};

package/source/internal/array.d.ts

@@ -1,6 +1,5 @@
 import type {If} from '../if.d.ts';
 import type {IsNever} from '../is-never.d.ts';
-import type {OptionalKeysOf} from '../optional-keys-of.d.ts';
 import type {UnknownArray} from '../unknown-array.d.ts';
 import type {IsExactOptionalPropertyTypesEnabled, IfNotAnyOrNever} from './type.d.ts';
 
@@ -119,26 +118,28 @@ type _CollapseRestElement<
 	BackwardAccumulator extends UnknownArray = [],
 > =
 	TArray extends UnknownArray // For distributing `TArray`
-		? keyof TArray & `${number}` extends never
-			// Enters this branch, if `TArray` is empty (e.g., []),
-			// or `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
-			? TArray extends readonly [...infer Rest, infer Last]
-				? _CollapseRestElement<Rest, ForwardAccumulator, [Last, ...BackwardAccumulator]> // Accumulate elements that are present after the rest element.
-				: TArray extends readonly []
-					? [...ForwardAccumulator, ...BackwardAccumulator]
-					: [...ForwardAccumulator, TArray[number], ...BackwardAccumulator] // Add the rest element between the accumulated elements.
-			: TArray extends readonly [(infer First)?, ...infer Rest]
+		? '0' extends keyof TArray
+			// Enters this branch, if `TArray` starts with a non-rest element (e.g., `[string, number]` or `[string, ...number[]]`).
+			? TArray extends readonly [(infer First)?, ...infer Rest]
 				? _CollapseRestElement<
 					Rest,
 					[
 						...ForwardAccumulator,
-						'0' extends OptionalKeysOf<TArray>
-							? If<IsExactOptionalPropertyTypesEnabled, First, First | undefined> // Add `| undefined` for optional elements, if `exactOptionalPropertyTypes` is disabled.
-							: First,
+						// A tuple allows fewer than one element only when its first element is optional. Written in exactly this shape because equivalent ones, such as `[] extends TArray`, are several times slower.
+						TArray extends readonly [unknown, ...unknown[]]
+							? First
+							: If<IsExactOptionalPropertyTypesEnabled, First, First | undefined>, // Add `| undefined` for optional elements, if `exactOptionalPropertyTypes` is disabled.
 					],
 					BackwardAccumulator
 				>
 				: never // Should never happen, since `[(infer First)?, ...infer Rest]` is a top-type for arrays.
+			// Enters this branch, if `TArray` is empty (e.g., []),
+			// or `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
+			: TArray extends readonly [...infer Rest, infer Last]
+				? _CollapseRestElement<Rest, ForwardAccumulator, [Last, ...BackwardAccumulator]> // Accumulate elements that are present after the rest element.
+				: TArray extends readonly []
+					? [...ForwardAccumulator, ...BackwardAccumulator]
+					: [...ForwardAccumulator, TArray[number], ...BackwardAccumulator] // Add the rest element between the accumulated elements.
 		: never; // Should never happen
 
 export {};

package/source/internal/numeric.d.ts

@@ -1,4 +1,3 @@
-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 {IfNotAnyOrNever, IsAnyOrNever} from './type.d.ts';
@@ -69,43 +68,6 @@ type InternalUnionMin<N extends number, T extends UnknownArray = []> =
 		? T['length']
 		: InternalUnionMin<N, [...T, unknown]>;
 
-/**
-Returns the maximum number in the given union of numbers.
-
-Note: Just supports numbers from 0 to 999.
-
-@example
-```
-type A = UnionMax<1 | 3 | 2>;
-//=> 3
-
-type B = UnionMax<number>;
-//=> number
-
-type C = UnionMax<any>;
-//=> any
-
-type D = UnionMax<never>;
-//=> never
-```
-*/
-export type UnionMax<N extends number> =
-	IsAnyOrNever<N> extends true ? N
-		: number extends N ? number
-			: PositiveInfinity extends N ? PositiveInfinity
-				: [N] extends [NegativeInfinity] ? NegativeInfinity
-					: InternalUnionMax<Finite<N>>;
-
-/**
-The actual implementation of `UnionMax`. It's private because it has some arguments that don't need to be exposed.
-*/
-type InternalUnionMax<N extends number, T extends UnknownArray = []> =
-	IsNever<N> extends true
-		? T['length']
-		: T['length'] extends N
-			? InternalUnionMax<Exclude<N, T['length']>, T>
-			: InternalUnionMax<N, [...T, unknown]>;
-
 /**
 Returns the number with reversed sign.
 

package/source/is-tuple.d.ts

@@ -81,9 +81,9 @@ type _IsTuple<
 		TArray extends unknown // For distributing `TArray`
 			? number extends TArray['length']
 				? Options['fixedLengthOnly'] extends false
-					? If<IsNever<keyof TArray & `${number}`>,
-						TArray extends readonly [...any, any] ? true : false, // To handle cases where a non-rest element follows a rest element, e.g., `[...number[], number]`
-						true>
+					? '0' extends keyof TArray
+						? true
+						: TArray extends readonly [...any, any] ? true : false // To handle cases where a non-rest element follows a rest element, e.g., `[...number[], number]`
 					: false
 				: true
 			: false

package/source/merge-deep.d.ts

@@ -18,9 +18,9 @@ type Writable<TArray extends UnknownArray> = {-readonly [Key in keyof TArray]: T
 
 // Using the default `ArrayTail` type causes issues, refer https://github.com/sindresorhus/type-fest/pull/1175/files#r2134694728.
 type ArrayTail<TArray extends UnknownArray> = TArray extends unknown // For distributing `TArray`
-	? keyof TArray & `${number}` extends never
-		? []
-		: Writable<_ArrayTail<TArray>>
+	? '0' extends keyof TArray
+		? Writable<_ArrayTail<TArray>>
+		: []
 	: never; // Should never happen
 
 type SimplifyDeepExcludeArray<T> = SimplifyDeep<T, UnknownArray>;

package/source/set-required.d.ts

@@ -1,7 +1,6 @@
 import type {Except} from './except.d.ts';
 import type {If} from './if.d.ts';
 import type {HomomorphicPick, IsArrayReadonly} from './internal/index.d.ts';
-import type {OptionalKeysOf} from './optional-keys-of.d.ts';
 import type {Simplify} from './simplify.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
 
@@ -57,19 +56,21 @@ type SetArrayRequired<
 	Counter extends any[] = [],
 	Accumulator extends UnknownArray = [],
 > = TArray extends unknown // For distributing `TArray` when it's a union
-	? keyof TArray & `${number}` extends never
-		// Exit if `TArray` is empty (e.g., []), or
-		// `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
-		? [...Accumulator, ...TArray]
-		: TArray extends readonly [(infer First)?, ...infer Rest]
-			? '0' extends OptionalKeysOf<TArray> // If the first element of `TArray` is optional
-				? `${Counter['length']}` extends `${Keys & (string | number)}` // If the current index needs to be required
+	? '0' extends keyof TArray
+		? TArray extends readonly [(infer First)?, ...infer Rest]
+			// A tuple allows fewer than one element only when its first element is optional. Written in exactly this shape because equivalent ones, such as `[] extends TArray`, are several times slower.
+			// Unlike the other array loops, this one has no `any` guard above it, so the check is wrapped in tuples to stop `any` from matching both branches.
+			? [TArray] extends [readonly [unknown, ...unknown[]]]
+				? SetArrayRequired<Rest, Keys, [...Counter, any], [...Accumulator, First]>
+				: `${Counter['length']}` extends `${Keys & (string | number)}` // If the current index needs to be required
 					? SetArrayRequired<Rest, Keys, [...Counter, any], [...Accumulator, First]>
 					// If the current element is optional, but it doesn't need to be required,
 					// then we can exit early, since no further elements can now be made required.
 					: [...Accumulator, ...TArray]
-				: SetArrayRequired<Rest, Keys, [...Counter, any], [...Accumulator, TArray[0]]>
 			: never // Should never happen, since `[(infer F)?, ...infer R]` is a top-type for arrays.
+		// Exit if `TArray` is empty (e.g., []), or
+		// `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
+		: [...Accumulator, ...TArray]
 	: never; // Should never happen
 
 export {};

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

@@ -1,4 +1,5 @@
-import type {NonRecursiveType, UnionMin, UnionMax, TupleLength, StaticPartOfArray, VariablePartOfArray, IsArrayReadonly, SetArrayAccess, ApplyDefaultOptions} from './internal/index.d.ts';
+import type {NonRecursiveType, UnionMin, TupleLength, StaticPartOfArray, VariablePartOfArray, IsArrayReadonly, SetArrayAccess, ApplyDefaultOptions} from './internal/index.d.ts';
+import type {UnionMax} from './union-max.d.ts';
 import type {IsNever} from './is-never.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
 

package/source/some-extend.d.ts

@@ -95,10 +95,15 @@ type B = SomeExtend<[1?, 2?, '3'?], string | undefined>;
 @category Array
 */
 export type SomeExtend<TArray extends UnknownArray, Type, Options extends SomeExtendOptions = {}> =
-	_SomeExtend<CollapseRestElement<TArray>, Type, ApplyDefaultOptions<SomeExtendOptions, DefaultSomeExtendOptions, Options>>;
-
-type _SomeExtend<TArray extends UnknownArray, Type, Options extends Required<SomeExtendOptions>> = IfNotAnyOrNever<TArray, {
-	ifNot: TArray extends readonly [infer First, ...infer Rest]
+	IfNotAnyOrNever<CollapseRestElement<TArray>, {
+		ifNot: _SomeExtend<CollapseRestElement<TArray>, Type, ApplyDefaultOptions<SomeExtendOptions, DefaultSomeExtendOptions, Options>>;
+		ifAny: false;
+		ifNever: false;
+	}>;
+
+// Kept free of `IfNotAnyOrNever` so that it stays tail-recursive, which allows it to handle long arrays.
+type _SomeExtend<TArray extends UnknownArray, Type, Options extends Required<SomeExtendOptions>> =
+	TArray extends readonly [infer First, ...infer Rest]
 		? IsNever<First> extends true
 			? Or<Or<IsNever<Type>, IsAny<Type>>, Not<Options['strictNever']>> extends true
 				// If target `Type` is also `never`, or is `any`, or `strictNever` is disabled, return `true`.
@@ -108,8 +113,5 @@ type _SomeExtend<TArray extends UnknownArray, Type, Options extends Required<Som
 				? true
 				: _SomeExtend<Rest, Type, Options>
 		: false;
-	ifAny: false;
-	ifNever: false;
-}>;
 
 export {};

package/source/split-on-rest-element.d.ts

@@ -1,6 +1,5 @@
 import type {IfNotAnyOrNever, IsExactOptionalPropertyTypesEnabled} from './internal/type.d.ts';
 import type {ApplyDefaultOptions} from './internal/object.d.ts';
-import type {IsOptionalKeyOf} from './is-optional-key-of.d.ts';
 import type {IsArrayReadonly} from './internal/array.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
 import type {If} from './if.d.ts';
@@ -84,25 +83,27 @@ export type _SplitOnRestElement<
 	HeadAcc extends UnknownArray = [],
 	TailAcc extends UnknownArray = [],
 > =
-	keyof Array_ & `${number}` extends never
-		// Enters this branch, if `Array_` is empty (e.g., []),
-		// or `Array_` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
-		? Array_ extends readonly [...infer Rest, infer Last]
-			? _SplitOnRestElement<Rest, Options, HeadAcc, [Last, ...TailAcc]> // Accumulate elements that are present after the rest element.
-			: [HeadAcc, Array_ extends readonly [] ? [] : Array_, TailAcc] // Add the rest element between the accumulated elements.
-		: Array_ extends readonly [(infer First)?, ...infer Rest]
+	'0' extends keyof Array_
+		// Enters this branch, if `Array_` starts with a non-rest element (e.g., `[string, number]` or `[string, ...number[]]`).
+		? Array_ extends readonly [(infer First)?, ...infer Rest]
 			? _SplitOnRestElement<
 				Rest, Options,
 				[
 					...HeadAcc,
-					...IsOptionalKeyOf<Array_, '0'> extends true
-						? Options['preserveOptionalModifier'] extends false
+					// A tuple allows fewer than one element only when its first element is optional. Written in exactly this shape because equivalent ones, such as `[] extends Array_`, are several times slower.
+					...Array_ extends readonly [unknown, ...unknown[]]
+						? [First]
+						: Options['preserveOptionalModifier'] extends false
 							? [If<IsExactOptionalPropertyTypesEnabled, First, First | undefined>] // Add `| undefined` for optional elements, if `exactOptionalPropertyTypes` is disabled.
-							: [First?]
-						: [First],
+							: [First?],
 				],
 				TailAcc
 			> // Accumulate elements that are present before the rest element.
-			: never; // Should never happen, since `[(infer First)?, ...infer Rest]` is a top-type for arrays.
+			: never // Should never happen, since `[(infer First)?, ...infer Rest]` is a top-type for arrays.
+		// Enters this branch, if `Array_` is empty (e.g., []),
+		// or `Array_` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
+		: Array_ extends readonly [...infer Rest, infer Last]
+			? _SplitOnRestElement<Rest, Options, HeadAcc, [Last, ...TailAcc]> // Accumulate elements that are present after the rest element.
+			: [HeadAcc, Array_ extends readonly [] ? [] : Array_, TailAcc]; // Add the rest element between the accumulated elements.
 
 export {};

package/source/split.d.ts

@@ -64,27 +64,38 @@ export type Split<
 	Delimiter extends string,
 	Options extends SplitOptions = {},
 > =
-	SplitHelper<S, Delimiter, ApplyDefaultOptions<SplitOptions, DefaultSplitOptions, Options>>;
+	_Split<S, Delimiter, ApplyDefaultOptions<SplitOptions, DefaultSplitOptions, Options>>;
 
-type SplitHelper<
+type _Split<
 	S extends string,
 	Delimiter extends string,
 	Options extends Required<SplitOptions>,
-	Accumulator extends string[] = [],
 > = S extends string // For distributing `S`
 	? Delimiter extends string // For distributing `Delimiter`
 		// If `strictLiteralChecks` is `false` OR `S` and `Delimiter` both are string literals, then perform the split
 		? Or<Not<Options['strictLiteralChecks']>, And<IsStringLiteral<S>, IsStringLiteral<Delimiter>>> extends true
-			? S extends `${infer Head}${Delimiter}${infer Tail}`
-				? SplitHelper<Tail, Delimiter, Options, [...Accumulator, Head]>
-				: Delimiter extends ''
-					? S extends ''
-						? Accumulator
-						: [...Accumulator, S]
-					: [...Accumulator, S]
+			// The `extends infer` step keeps `SplitOnDelimiter` out of this conditional's tail-recursion chain, so the loop gets the full recursion budget to itself.
+			? SplitOnDelimiter<S, Delimiter> extends infer Result ? Result : never
 			// Otherwise, return `string[]`
 			: string[]
 		: never // Should never happen
 	: never; // Should never happen
 
+/**
+Splits `S` on `Delimiter`.
+
+`S` and `Delimiter` must already be distributed, so that the checks performed by `_Split` do not have to be repeated on every recursion step.
+*/
+type SplitOnDelimiter<
+	S extends string,
+	Delimiter extends string,
+	Accumulator extends string[] = [],
+> = S extends `${infer Head}${Delimiter}${infer Tail}`
+	? SplitOnDelimiter<Tail, Delimiter, [...Accumulator, Head]>
+	: Delimiter extends ''
+		? S extends ''
+			? Accumulator
+			: [...Accumulator, S]
+		: [...Accumulator, S];
+
 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,7 +15,8 @@ export type TypedArray =
 	| Uint16Array
 	| Int32Array
 	| Uint32Array
-	| Float16Array
+	// 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-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 {};