type-fest 4.41.0 → 5.0.0

package/readme.md

@@ -20,34 +20,6 @@
 			<sup>Special thanks to:</sup>
 			<br>
 			<br>
-			<a href="https://workos.com/?utm_campaign=github_repo&utm_medium=referral&utm_content=type-fest&utm_source=github">
-				<div>
-					<img src="https://sindresorhus.com/assets/thanks/workos-logo-white-bg.svg" width="220" alt="WorkOS">
-				</div>
-				<b>Your app, enterprise-ready.</b>
-				<div>
-					<sub>Start selling to enterprise customers with just a few lines of code.</sub>
-					<br>
-					<sup>Add Single Sign-On (and more) in minutes instead of months.</sup>
-				</div>
-			</a>
-			<br>
-			<br>
-			<a href="https://logto.io/?ref=sindre">
-				<div>
-					<picture>
-						<source width="200" media="(prefers-color-scheme: dark)" srcset="https://sindresorhus.com/assets/thanks/logto-logo-dark.svg?x">
-						<source width="200" media="(prefers-color-scheme: light)" srcset="https://sindresorhus.com/assets/thanks/logto-logo-light.svg?x">
-						<img width="200" src="https://sindresorhus.com/assets/thanks/logto-logo-light.svg?x" alt="Logto logo">
-					</picture>
-				</div>
-				<b>The better identity infrastructure for developers</b>
-				<div>
-					<sup>Logto is an open-source Auth0 alternative designed for every app.</sup>
-				</div>
-			</a>
-			<br>
-			<br>
 			<a href="https://nitric.io/?utm_campaign=github_repo&utm_medium=referral&utm_content=sindresorhus&utm_source=github">
 				<div>
 					<img width="230" src="https://sindresorhus.com/assets/thanks/nitric-logo.svg" alt="nitric logo">
@@ -83,7 +55,10 @@ PR welcome for additional commonly needed types and docs improvements. Read the
 npm install type-fest
 ```
 
-*Requires TypeScript >=5.1 and [`{strict: true}`](https://www.typescriptlang.org/tsconfig#strict) in your tsconfig.*
+*Requires TypeScript >=5.9, [ESM](https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c), and [`{strict: true}`](https://www.typescriptlang.org/tsconfig#strict) in your tsconfig.*
+
+> [!NOTE]
+> This readme shows the current development version. For docs about the latest version, see the [npm page](https://www.npmjs.com/package/type-fest).
 
 ## Usage
 
@@ -108,10 +83,14 @@ Click the type names for complete docs.
 - [`Primitive`](source/primitive.d.ts) - Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
 - [`Class`](source/basic.d.ts) - Matches a [`class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
 - [`Constructor`](source/basic.d.ts) - Matches a [`class` constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
-- [`AbstractClass`](source/basic.d.ts) - Matches an [`abstract class`](https://www.typescriptlang.org/docs/handbook/classes.html#abstract-classes).
+- [`AbstractClass`](source/basic.d.ts) - Matches an [`abstract class`](https://www.typescriptlang.org/docs/handbook/2/classes.html#abstract-classes-and-members).
 - [`AbstractConstructor`](source/basic.d.ts) - Matches an [`abstract class`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-2.html#abstract-construct-signatures) constructor.
 - [`TypedArray`](source/typed-array.d.ts) - Matches any [typed array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray), like `Uint8Array` or `Float64Array`.
-- [`ObservableLike`](source/observable-like.d.ts) - Matches a value that is like an [Observable](https://github.com/tc39/proposal-observable).
+- [`ObservableLike`](source/globals/observable-like.d.ts) - Matches a value that is like an [Observable](https://github.com/tc39/proposal-observable).
+- [`LowercaseLetter`](source/characters.d.ts) - Matches any lowercase letter in the basic Latin alphabet (a-z).
+- [`UppercaseLetter`](source/characters.d.ts) - Matches any uppercase letter in the basic Latin alphabet (A-Z).
+- [`DigitCharacter`](source/characters.d.ts) - Matches any digit as a string ('0'-'9').
+- [`Alphanumeric`](source/characters.d.ts) - Matches any lowercase letter (a-z), uppercase letter (A-Z), or digit ('0'-'9') in the basic Latin alphabet.
 
 ### Utilities
 
@@ -169,11 +148,11 @@ Click the type names for complete docs.
 - [`Simplify`](source/simplify.d.ts) - Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
 - [`SimplifyDeep`](source/simplify-deep.d.ts) - Deeply simplifies an object type.
 - [`Get`](source/get.d.ts) - Get a deeply-nested property from an object using a key path, like [Lodash's `.get()`](https://lodash.com/docs/latest#get) function.
-- [`StringKeyOf`](source/string-key-of.d.ts) - Get keys of the given type as strings.
+- [`KeyAsString`](source/key-as-string.d.ts) - Get keys of the given type as strings.
 - [`Schema`](source/schema.d.ts) - Create a deep version of another object type where property values are recursively replaced into a given value type.
 - [`Exact`](source/exact.d.ts) - Create a type that does not allow extra properties.
-- [`OptionalKeysOf`](source/optional-keys-of.d.ts) - Extract all optional keys from the given type.
 - [`KeysOfUnion`](source/keys-of-union.d.ts) - Create a union of all keys from a given type, even those exclusive to specific union members.
+- [`OptionalKeysOf`](source/optional-keys-of.d.ts) - Extract all optional keys from the given type.
 - [`HasOptionalKeys`](source/has-optional-keys.d.ts) - Create a `true`/`false` type depending on whether the given type has any optional fields.
 - [`RequiredKeysOf`](source/required-keys-of.d.ts) - Extract all required keys from the given type.
 - [`HasRequiredKeys`](source/has-required-keys.d.ts) - Create a `true`/`false` type depending on whether the given type has any required fields.
@@ -199,58 +178,47 @@ Click the type names for complete docs.
 - [`DistributedPick`](source/distributed-pick.d.ts) - Picks keys from a type, distributing the operation over a union.
 - [`And`](source/and.d.ts) - Returns a boolean for whether two given types are both true.
 - [`Or`](source/or.d.ts) - Returns a boolean for whether either of two given types are true.
+- [`AllExtend`](source/all-extend.d.ts) - Returns a boolean for whether every element in an array type extends another type.
 - [`NonEmptyTuple`](source/non-empty-tuple.d.ts) - Matches any non-empty tuple.
 - [`NonEmptyString`](source/non-empty-string.d.ts) - Matches any non-empty string.
 - [`FindGlobalType`](source/find-global-type.d.ts) - Tries to find the type of a global with the given name.
 - [`FindGlobalInstanceType`](source/find-global-type.d.ts) - Tries to find one or more types from their globally-defined constructors.
+- [`ConditionalSimplify`](source/conditional-simplify.d.ts) - Simplifies a type while including and/or excluding certain types from being simplified.
+- [`ConditionalSimplifyDeep`](source/conditional-simplify-deep.d.ts) - Recursively simplifies a type while including and/or excluding certain types from being simplified.
 
 ### Type Guard
 
-#### `IsType` vs. `IfType`
-
-For every `IsT` type (e.g. `IsAny`), there is an associated `IfT` type that can help simplify conditional types. While the `IsT` types return a `boolean`, the `IfT` types act like an `If`/`Else` - they resolve to the given `TypeIfT` or `TypeIfNotT` depending on whether `IsX` is `true` or not. By default, `IfT` returns a `boolean`:
-
-```ts
-type IfAny<T, TypeIfAny = true, TypeIfNotAny = false> = (
-	IsAny<T> extends true ? TypeIfAny : TypeIfNotAny
-);
-```
-
-#### Usage
-
-```ts
-import type {IsAny, IfAny} from 'type-fest';
-
-type ShouldBeTrue = IsAny<any> extends true ? true : false;
-//=> true
-
-type ShouldBeFalse = IfAny<'not any'>;
-//=> false
-
-type ShouldBeNever = IfAny<'not any', 'not never', 'never'>;
-//=> 'never'
-```
-
+- [`If`](source/if.d.ts) - An if-else-like type that resolves depending on whether the given `boolean` type is `true` or `false`.
 - [`IsLiteral`](source/is-literal.d.ts) - Returns a boolean for whether the given type is a [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
 - [`IsStringLiteral`](source/is-literal.d.ts) - Returns a boolean for whether the given type is a `string` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
 - [`IsNumericLiteral`](source/is-literal.d.ts) - Returns a boolean for whether the given type is a `number` or `bigint` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
 - [`IsBooleanLiteral`](source/is-literal.d.ts) - Returns a boolean for whether the given type is a `true` or `false` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
 - [`IsSymbolLiteral`](source/is-literal.d.ts) - Returns a boolean for whether the given type is a `symbol` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
-- [`IsAny`](source/is-any.d.ts) - Returns a boolean for whether the given type is `any`. (Conditional version: [`IfAny`](source/if-any.d.ts))
-- [`IsNever`](source/is-never.d.ts) - Returns a boolean for whether the given type is `never`. (Conditional version: [`IfNever`](source/if-never.d.ts))
-- [`IsUnknown`](source/is-unknown.d.ts) - Returns a boolean for whether the given type is `unknown`. (Conditional version: [`IfUnknown`](source/if-unknown.d.ts))
-- [`IsEmptyObject`](source/empty-object.d.ts) - Returns a boolean for whether the type is strictly equal to an empty plain object, the `{}` value. (Conditional version: [`IfEmptyObject`](source/if-empty-object.d.ts))
-- [`IsNull`](source/is-null.d.ts) - Returns a boolean for whether the given type is `null`. (Conditional version: [`IfNull`](source/if-null.d.ts))
+- [`IsAny`](source/is-any.d.ts) - Returns a boolean for whether the given type is `any`.
+- [`IsNever`](source/is-never.d.ts) - Returns a boolean for whether the given type is `never`.
+- [`IsUnknown`](source/is-unknown.d.ts) - Returns a boolean for whether the given type is `unknown`.
+- [`IsEmptyObject`](source/empty-object.d.ts) - Returns a boolean for whether the type is strictly equal to an empty plain object, the `{}` value.
+- [`IsNull`](source/is-null.d.ts) - Returns a boolean for whether the given type is `null`.
+- [`IsUndefined`](source/is-undefined.d.ts) - Returns a boolean for whether the given type is `undefined`.
 - [`IsTuple`](source/is-tuple.d.ts) - Returns a boolean for whether the given array is a tuple.
+- [`IsUnion`](source/is-union.d.ts) - Returns a boolean for whether the given type is a union.
+- [`IsLowercase`](source/is-lowercase.d.ts) - Returns a boolean for whether the given string literal is lowercase.
+- [`IsUppercase`](source/is-uppercase.d.ts) - Returns a boolean for whether the given string literal is uppercase.
+- [`IsOptional`](source/is-optional.d.ts) - Returns a boolean for whether the given type includes `undefined`.
+- [`IsNullable`](source/is-nullable.d.ts) - Returns a boolean for whether the given type includes `null`.
+- [`IsOptionalKeyOf`](source/is-optional-key-of.d.ts) - Returns a boolean for whether the given key is an optional key of type.
+- [`IsRequiredKeyOf`](source/is-required-key-of.d.ts) - Returns a boolean for whether the given key is a required key of type.
+- [`IsReadonlyKeyOf`](source/is-readonly-key-of.d.ts) - Returns a boolean for whether the given key is a readonly key of type.
+- [`IsWritableKeyOf`](source/is-writable-key-of.d.ts) - Returns a boolean for whether the given key is a writable key of type.
 
 ### JSON
 
 - [`Jsonify`](source/jsonify.d.ts) - Transform a type to one that is assignable to the `JsonValue` type.
 - [`Jsonifiable`](source/jsonifiable.d.ts) - Matches a value that can be losslessly converted to JSON.
-- [`JsonPrimitive`](source/basic.d.ts) - Matches a JSON primitive.
-- [`JsonObject`](source/basic.d.ts) - Matches a JSON object.
-- [`JsonArray`](source/basic.d.ts) - Matches a JSON array.
-- [`JsonValue`](source/basic.d.ts) - Matches any valid JSON value.
+- [`JsonPrimitive`](source/json-value.d.ts) - Matches a JSON primitive.
+- [`JsonObject`](source/json-value.d.ts) - Matches a JSON object.
+- [`JsonArray`](source/json-value.d.ts) - Matches a JSON array.
+- [`JsonValue`](source/json-value.d.ts) - Matches any valid JSON value.
 
 ### Structured clone
 
@@ -270,6 +238,7 @@ type ShouldBeNever = IfAny<'not any', 'not never', 'never'>;
 - [`Replace`](source/replace.d.ts) - Represents a string with some or all matches replaced by a replacement.
 - [`StringSlice`](source/string-slice.d.ts) - Returns a string slice of a given range, just like `String#slice()`.
 - [`StringRepeat`](source/string-repeat.d.ts) - Returns a new string which contains the specified number of copies of a given string, just like `String#repeat()`.
+- [`RemovePrefix`](source/remove-prefix.d.ts) - Removes the specified prefix from the start of a string.
 
 ### Array
 
@@ -333,6 +302,12 @@ type ShouldBeNever = IfAny<'not any', 'not never', 'never'>;
 - [`PackageJson`](source/package-json.d.ts) - Type for [npm's `package.json` file](https://docs.npmjs.com/creating-a-package-json-file). It also includes support for [TypeScript Declaration Files](https://www.typescriptlang.org/docs/handbook/declaration-files/publishing.html).
 - [`TsConfigJson`](source/tsconfig-json.d.ts) - Type for [TypeScript's `tsconfig.json` file](https://www.typescriptlang.org/docs/handbook/tsconfig-json.html).
 
+### Improved built-in
+
+- [`ExtendsStrict`](source/extends-strict.d.ts) - A stricter, non-distributive version of `extends` for checking whether one type is assignable to another.
+- [`ExtractStrict`](source/extract-strict.d.ts) - A stricter version of `Extract<T, U>` that ensures every member of `U` can successfully extract something from `T`.
+- [`ExcludeStrict`](source/exclude-strict.d.ts) - A stricter version of `Exclude<T, U>` that ensures every member of `U` can successfully exclude something from `T`.
+
 ## Declined types
 
 *If we decline a type addition, we will make sure to document the better solution here.*
@@ -365,6 +340,8 @@ type ShouldBeNever = IfAny<'not any', 'not never', 'never'>;
 - `SetValues` - See [`IterableElement`](source/iterable-element.d.ts)
 - `PickByTypes` - See [`ConditionalPick`](source/conditional-pick.d.ts)
 - `HomomorphicOmit` - See [`Except`](source/except.d.ts)
+- `IfAny`, `IfNever`, `If*` - See [`If`](source/if.d.ts)
+- `MaybePromise` - See [`Promisable`](source/promisable.d.ts)
 
 ## Tips
 
@@ -389,7 +366,7 @@ type ShouldBeNever = IfAny<'not any', 'not never', 'never'>;
 ### Related
 
 - [typed-query-selector](https://github.com/g-plane/typed-query-selector) - Enhances `document.querySelector` and `document.querySelectorAll` with a template literal type that matches element types returned from an HTML element query selector.
-- [`Linter.Config`](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/eslint/index.d.ts) - Definitions for the [ESLint configuration schema](https://eslint.org/docs/user-guide/configuring/language-options).
+- [`Linter.Config`](https://github.com/eslint/eslint/blob/main/lib/types/index.d.ts) - Definitions for the [ESLint configuration schema](https://eslint.org/docs/user-guide/configuring/language-options).
 
 ### Built-in types
 

package/source/all-extend.d.ts

@@ -0,0 +1,115 @@
+import type {If} from './if.d.ts';
+import type {CollapseRestElement} from './internal/array.d.ts';
+import type {ApplyDefaultOptions} from './internal/object.d.ts';
+import type {IfNotAnyOrNever, Not} from './internal/type.d.ts';
+import type {IsAny} from './is-any.d.ts';
+import type {IsNever} from './is-never.d.ts';
+import type {Or} from './or.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+
+/**
+@see {@link AllExtend}
+*/
+type AllExtendOptions = {
+	/**
+	Consider `never` elements to match the target type only if the target type itself is `never` (or `any`).
+
+	- When set to `true` (default), `never` is _not_ treated as a bottom type, instead, it is treated as a type that matches only itself (or `any`).
+	- When set to `false`, `never` is treated as a bottom type, and behaves as it normally would.
+
+	@default true
+
+	@example
+	```
+	import type {AllExtend} from 'type-fest';
+
+	type A = AllExtend<[1, 2, never], number, {strictNever: true}>;
+	//=> false
+
+	type B = AllExtend<[1, 2, never], number, {strictNever: false}>;
+	//=> true
+
+	type C = AllExtend<[never, never], never, {strictNever: true}>;
+	//=> true
+
+	type D = AllExtend<[never, never], never, {strictNever: false}>;
+	//=> true
+
+	type E = AllExtend<['a', 'b', never], any, {strictNever: true}>;
+	//=> true
+
+	type F = AllExtend<['a', 'b', never], any, {strictNever: false}>;
+	//=> true
+
+	type G = AllExtend<[never, 1], never, {strictNever: true}>;
+	//=> false
+
+	type H = AllExtend<[never, 1], never, {strictNever: false}>;
+	//=> false
+	```
+	*/
+	strictNever?: boolean;
+};
+
+type DefaultAllExtendOptions = {
+	strictNever: true;
+};
+
+/**
+Returns a boolean for whether every element in an array type extends another type.
+
+@example
+```
+import type {AllExtend} from 'type-fest';
+
+type A = AllExtend<[1, 2, 3], number>;
+//=> true
+
+type B = AllExtend<[1, 2, '3'], number>;
+//=> false
+
+type C = AllExtend<[number, number | string], number>;
+//=> boolean
+
+type D = AllExtend<[true, boolean, true], true>;
+//=> boolean
+```
+
+Note: Behaviour of optional elements depend on the `exactOptionalPropertyTypes` compiler option. When the option is disabled, the target type must include `undefined` for a successful match.
+
+```
+import type {AllExtend} from 'type-fest';
+
+// `exactOptionalPropertyTypes` enabled
+type A = AllExtend<[1?, 2?, 3?], number>;
+//=> true
+
+// `exactOptionalPropertyTypes` disabled
+type B = AllExtend<[1?, 2?, 3?], number>;
+//=> false
+
+// `exactOptionalPropertyTypes` disabled
+type C = AllExtend<[1?, 2?, 3?], number | undefined>;
+//=> true
+```
+
+@see {@link AllExtendOptions}
+
+@category Utilities
+@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, If<IsAny<Type>, true,
+	TArray extends readonly [infer First, ...infer Rest]
+		? IsNever<First> extends true
+			? Or<IsNever<Type>, Not<Options['strictNever']>> extends true
+				// If target `Type` is also `never` OR `strictNever` is disabled, recurse further.
+				? _AllExtend<Rest, Type, Options>
+				: false
+			: First extends Type
+				? _AllExtend<Rest, Type, Options>
+				: false
+		: true
+>, false, false>;

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

@@ -1,8 +1,8 @@
-import type {NonRecursiveType, ReadonlyKeysOfUnion, ValueOfUnion} from './internal';
-import type {KeysOfUnion} from './keys-of-union';
-import type {SharedUnionFields} from './shared-union-fields';
-import type {Simplify} from './simplify';
-import type {UnknownArray} from './unknown-array';
+import type {NonRecursiveType, ReadonlyKeysOfUnion, ValueOfUnion} from './internal/index.d.ts';
+import type {KeysOfUnion} from './keys-of-union.d.ts';
+import type {SharedUnionFields} from './shared-union-fields.d.ts';
+import type {Simplify} from './simplify.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
 
 /**
 Create a type with all fields from a union of object types.
@@ -74,15 +74,15 @@ Extract<Union, NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<un
 		| SkippedMembers
 		| Simplify<
 		// Include fields that are common in all union members
-		SharedUnionFields<RelevantMembers> &
+			SharedUnionFields<RelevantMembers> &
 		// Include readonly fields present in any union member
-		{
-			readonly [P in ReadonlyKeysOfUnion<RelevantMembers>]?: ValueOfUnion<RelevantMembers, P & KeysOfUnion<RelevantMembers>>
-		} &
+			{
+				readonly [P in ReadonlyKeysOfUnion<RelevantMembers>]?: ValueOfUnion<RelevantMembers, P & KeysOfUnion<RelevantMembers>>
+			} &
 		// Include remaining fields that are neither common nor readonly
-		{
-			[P in Exclude<KeysOfUnion<RelevantMembers>, ReadonlyKeysOfUnion<RelevantMembers> | keyof RelevantMembers>]?: ValueOfUnion<RelevantMembers, P>
-		}
+			{
+				[P in Exclude<KeysOfUnion<RelevantMembers>, ReadonlyKeysOfUnion<RelevantMembers> | keyof RelevantMembers>]?: ValueOfUnion<RelevantMembers, P>
+			}
 		>
 		: never
 	: never;

package/source/and.d.ts

@@ -1,4 +1,4 @@
-import type {IsEqual} from './is-equal';
+import type {AllExtend} from './all-extend.d.ts';
 
 /**
 Returns a boolean for whether two given types are both true.
@@ -9,17 +9,69 @@ Use-case: Constructing complex conditional types where multiple conditions must
 ```
 import type {And} from 'type-fest';
 
-And<true, true>;
+type TT = And<true, true>;
 //=> true
 
-And<true, false>;
+type TF = And<true, false>;
+//=> false
+
+type FT = And<false, true>;
+//=> false
+
+type FF = And<false, false>;
+//=> false
+```
+
+Note: When `boolean` is passed as an argument, it is distributed into separate cases, and the final result is a union of those cases.
+For example, `And<true, boolean>` expands to `And<true, true> | And<true, false>`, which simplifies to `true | false` (i.e., `boolean`).
+
+@example
+```
+import type {And} from 'type-fest';
+
+type A = And<true, boolean>;
+//=> boolean
+
+type B = And<boolean, true>;
+//=> boolean
+
+type C = And<false, boolean>;
+//=> false
+
+type D = And<boolean, false>;
+//=> false
+
+type E = And<boolean, boolean>;
+//=> boolean
+```
+
+Note: If either of the types is `never`, the result becomes `false`.
+@example
+```
+import type {And} from 'type-fest';
+
+type A = And<true, never>;
+//=> false
+
+type B = And<never, true>;
+//=> false
+
+type C = And<false, never>;
+//=> false
+
+type D = And<never, false>;
+//=> false
+
+type E = And<boolean, never>;
+//=> false
+
+type F = And<never, boolean>;
+//=> false
+
+type G = And<never, never>;
 //=> false
 ```
 
 @see {@link Or}
 */
-export type And<A extends boolean, B extends boolean> = [A, B][number] extends true
-	? true
-	: true extends [IsEqual<A, false>, IsEqual<B, false>][number]
-		? false
-		: never;
+export type And<A extends boolean, B extends boolean> = AllExtend<[A, B], true>;

package/source/array-slice.d.ts

@@ -1,12 +1,12 @@
-import type {Sum} from './sum';
-import type {LessThanOrEqual} from './less-than-or-equal';
-import type {GreaterThanOrEqual} from './greater-than-or-equal';
-import type {GreaterThan} from './greater-than';
-import type {IsNegative} from './numeric';
-import type {Not, TupleMin} from './internal';
-import type {IsEqual} from './is-equal';
-import type {And} from './and';
-import type {ArraySplice} from './array-splice';
+import type {Sum} from './sum.d.ts';
+import type {LessThanOrEqual} from './less-than-or-equal.d.ts';
+import type {GreaterThanOrEqual} from './greater-than-or-equal.d.ts';
+import type {GreaterThan} from './greater-than.d.ts';
+import type {IsNegative} from './numeric.d.ts';
+import type {Not, TupleMin} from './internal/index.d.ts';
+import type {IsEqual} from './is-equal.d.ts';
+import type {And} from './and.d.ts';
+import type {ArraySplice} from './array-splice.d.ts';
 
 /**
 Returns an array slice of a given range, just like `Array#slice()`.
@@ -74,8 +74,8 @@ type VariableLengthArraySliceHelper<
 > = And<Not<IsNegative<Start>>, IsEqual<End, never>> extends true
 	? ArraySplice<Array_, 0, Start>
 	: And<
-	And<Not<IsNegative<Start>>, Not<IsNegative<End>>>,
-	IsEqual<GreaterThan<End, Start>, true>
+		And<Not<IsNegative<Start>>, Not<IsNegative<End>>>,
+		IsEqual<GreaterThan<End, Start>, true>
 	> extends true
 		? ArraySliceByPositiveIndex<Array_, Start, End>
 		: [];

package/source/array-splice.d.ts

@@ -1,7 +1,7 @@
-import type {BuildTuple, StaticPartOfArray, VariablePartOfArray} from './internal';
-import type {GreaterThanOrEqual} from './greater-than-or-equal';
-import type {Subtract} from './subtract';
-import type {UnknownArray} from './unknown-array';
+import type {BuildTuple, StaticPartOfArray, VariablePartOfArray} from './internal/index.d.ts';
+import type {GreaterThanOrEqual} from './greater-than-or-equal.d.ts';
+import type {Subtract} from './subtract.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
 
 /**
 The implementation of `SplitArrayByIndex` for fixed length arrays.

package/source/array-tail.d.ts

@@ -1,76 +1,68 @@
-import type {ApplyDefaultOptions, IfArrayReadonly} from './internal';
-import type {UnknownArray} from './unknown-array';
+import type {If} from './if.d.ts';
+import type {IfNotAnyOrNever, IsArrayReadonly} from './internal/index.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
 
 /**
-@see {@link ArrayTail}
-*/
-type ArrayTailOptions = {
-	/**
-	Return a readonly array if the input array is readonly.
+Extracts the type of an array or tuple minus the first element.
 
-	@default false
+@example
+```
+import type {ArrayTail} from 'type-fest';
 
-	@example
-	```
-	import type {ArrayTail} from 'type-fest';
+type A = ArrayTail<[1, 2, 3]>;
+//=> [2, 3]
 
-	type Example1 = ArrayTail<readonly [string, number, boolean], {preserveReadonly: true}>;
-	//=> readonly [number, boolean]
+type B = ArrayTail<readonly [1, 2, 3]>;
+//=> readonly [2, 3]
 
-	type Example2 = ArrayTail<[string, number, boolean], {preserveReadonly: true}>;
-	//=> [number, boolean]
+type C = ArrayTail<[1, 2, 3?, ...string[]]>;
+//=> [2, 3?, ...string[]]
 
-	type Example3 = ArrayTail<readonly [string, number, boolean], {preserveReadonly: false}>;
-	//=> [number, boolean]
+type D = ArrayTail<readonly [1]>;
+//=> readonly []
 
-	type Example4 = ArrayTail<[string, number, boolean], {preserveReadonly: false}>;
-	//=> [number, boolean]
-	```
-	*/
-	preserveReadonly?: boolean;
-};
+type E = ArrayTail<[]>;
+//=> []
 
-type DefaultArrayTailOptions = {
-	preserveReadonly: false;
-};
+type F = ArrayTail<string[]>;
+//=> string[]
 
-/**
-Extracts the type of an array or tuple minus the first element.
+type G = ArrayTail<readonly [...string[], 1, 2]>;
+//=> readonly [...string[], 1, 2]
+```
 
 @example
 ```
 import type {ArrayTail} from 'type-fest';
 
-declare const curry: <Arguments extends unknown[], Return>(
-	function_: (...arguments_: Arguments) => Return,
-	...arguments_: ArrayTail<Arguments>
-) => (...arguments_: ArrayTail<Arguments>) => Return;
+type Curry<Func> = Func extends (...agruments_: infer Arguments) => infer Return
+	? Arguments extends readonly []
+		? Return
+		: (agrument: Arguments[0]) => Curry<(...agruments_: ArrayTail<Arguments>) => Return>
+	: never;
 
-const add = (a: number, b: number) => a + b;
+declare function curry<Func extends Function>(fn: Func): Curry<Func>;
 
-const add3 = curry(add, 3);
+declare function searchBooks(genre: string, minRating: number, available: boolean): string[];
 
-add3(4);
-//=> 7
+const availableTopSciFi = curry(searchBooks)('sci-fi')(4.5)(true);
+//=> string[]
 ```
 
-@see {@link ArrayTailOptions}
-
 @category Array
 */
-export type ArrayTail<TArray extends UnknownArray, Options extends ArrayTailOptions = {}> =
-	ApplyDefaultOptions<ArrayTailOptions, DefaultArrayTailOptions, Options> extends infer ResolvedOptions extends Required<ArrayTailOptions>
-		? TArray extends UnknownArray // For distributing `TArray`
-			? _ArrayTail<TArray> extends infer Result
-				? ResolvedOptions['preserveReadonly'] extends true
-					? IfArrayReadonly<TArray, Readonly<Result>, Result>
-					: Result
-				: never // Should never happen
+export type ArrayTail<TArray extends UnknownArray> = IfNotAnyOrNever<TArray,
+	TArray extends UnknownArray // For distributing `TArray`
+		? _ArrayTail<TArray> extends infer Result
+			? If<IsArrayReadonly<TArray>, Readonly<Result>, Result>
 			: never // Should never happen
-		: never; // Should never happen
+		: never
+>;
 
 type _ArrayTail<TArray extends UnknownArray> = TArray extends readonly [unknown?, ...infer Tail]
 	? keyof TArray & `${number}` extends never
-		? []
+		? 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
 	: [];

package/source/arrayable.d.ts

@@ -24,6 +24,6 @@ bundle('src/index.js', ['dist/index.cjs', 'dist/index.mjs']);
 @category Array
 */
 export type Arrayable<T> =
-T
+	T
 // TODO: Use `readonly T[]` when this issue is resolved: https://github.com/microsoft/TypeScript/issues/17002
-| T[];
+	| T[];

package/source/asyncify.d.ts

@@ -1,4 +1,4 @@
-import type {SetReturnType} from './set-return-type';
+import type {SetReturnType} from './set-return-type.d.ts';
 
 /**
 Create an async version of the given function type, by boxing the return type in `Promise` while keeping the same parameter types.