type-fest 5.4.4 → 5.6.0

package/source/array-length.d.ts

@@ -0,0 +1,36 @@
+/**
+Return the length of an array. Equivalent to `T['length']` where `T` extends any array.
+
+Tuples resolve to numeric literals, while non-tuples resolve to the `number` type.
+
+@example
+```
+import type {ArrayLength} from 'type-fest';
+
+type TupleLength = ArrayLength<[1, 2, 3]>;
+//=> 3
+
+type TupleWithOptionalMembersLength = ArrayLength<[1, 2, number?]>;
+//=> 2 | 3
+
+type NonTupleArrayLength = ArrayLength<string[]>;
+//=> number
+
+type TupleWithRestElementLength = ArrayLength<[1, 2, ...string[]]>;
+//=> number
+
+// Distinguish between arrays with fixed and non-fixed lengths
+type IsFixedLengthArray<T extends readonly unknown[]> = number extends ArrayLength<T> ? false : true;
+
+type A = IsFixedLengthArray<number[]>;
+//=> false
+
+type B = IsFixedLengthArray<[1, 2, 3]>;
+//=> true
+```
+
+@category Array
+*/
+export type ArrayLength<T extends readonly unknown[]> = T['length'];
+
+export {};

package/source/array-splice.d.ts

@@ -8,13 +8,13 @@ import type {TupleOf} from './tuple-of.d.ts';
 The implementation of `SplitArrayByIndex` for fixed length arrays.
 */
 type SplitFixedArrayByIndex<T extends UnknownArray, SplitIndex extends number> =
-SplitIndex extends 0
-	? [[], T]
-	: T extends readonly [...TupleOf<SplitIndex>, ...infer V]
-		? T extends readonly [...infer U, ...V]
-			? [U, V]
-			: [never, never]
-		: [never, never];
+	SplitIndex extends 0
+		? [[], T]
+		: T extends readonly [...TupleOf<SplitIndex>, ...infer V]
+			? T extends readonly [...infer U, ...V]
+				? [U, V]
+				: [never, never]
+			: [never, never];
 
 /**
 The implementation of `SplitArrayByIndex` for variable length arrays.
@@ -26,23 +26,23 @@ type SplitVariableArrayByIndex<T extends UnknownArray,
 		? TupleOf<GreaterThanOrEqual<T1, 0> extends true ? T1 : number, VariablePartOfArray<T>[number]>
 		: [],
 > =
-SplitIndex extends 0
-	? [[], T]
-	: GreaterThanOrEqual<StaticPartOfArray<T>['length'], SplitIndex> extends true
-		? [
-			SplitFixedArrayByIndex<StaticPartOfArray<T>, SplitIndex>[0],
-			[
-				...SplitFixedArrayByIndex<StaticPartOfArray<T>, SplitIndex>[1],
-				...VariablePartOfArray<T>,
-			],
-		]
-		: [
-			[
-				...StaticPartOfArray<T>,
-				...(T2 extends UnknownArray ? T2 : []),
-			],
-			VariablePartOfArray<T>,
-		];
+	SplitIndex extends 0
+		? [[], T]
+		: GreaterThanOrEqual<StaticPartOfArray<T>['length'], SplitIndex> extends true
+			? [
+				SplitFixedArrayByIndex<StaticPartOfArray<T>, SplitIndex>[0],
+				[
+					...SplitFixedArrayByIndex<StaticPartOfArray<T>, SplitIndex>[1],
+					...VariablePartOfArray<T>,
+				],
+			]
+			: [
+				[
+					...StaticPartOfArray<T>,
+					...(T2 extends UnknownArray ? T2 : []),
+				],
+				VariablePartOfArray<T>,
+			];
 
 /**
 Split the given array `T` by the given `SplitIndex`.
@@ -50,10 +50,10 @@ Split the given array `T` by the given `SplitIndex`.
 @example
 ```
 type A = SplitArrayByIndex<[1, 2, 3, 4], 2>;
-// type A = [[1, 2], [3, 4]];
+//=> [[1, 2], [3, 4]];
 
 type B = SplitArrayByIndex<[1, 2, 3, 4], 0>;
-// type B = [[], [1, 2, 3, 4]];
+//=> [[], [1, 2, 3, 4]];
 ```
 */
 type SplitArrayByIndex<T extends UnknownArray, SplitIndex extends number> =

package/source/camel-case.d.ts

@@ -1,5 +1,5 @@
 import type {ApplyDefaultOptions} from './internal/index.d.ts';
-import type {Words, WordsOptions} from './words.d.ts';
+import type {_DefaultWordsOptions, Words, WordsOptions} from './words.d.ts';
 
 /**
 CamelCase options.
@@ -13,13 +13,39 @@ export type CamelCaseOptions = WordsOptions & {
 	@default false
 	*/
 	preserveConsecutiveUppercase?: boolean;
+
+	/**
+	Whether to preserve leading underscores.
+
+	This matches the behavior of the [`camelcase`](https://github.com/sindresorhus/camelcase) package v9+.
+
+	@default false
+	*/
+	preserveLeadingUnderscores?: boolean;
 };
 
-export type _DefaultCamelCaseOptions = {
-	splitOnNumbers: true;
+export type _DefaultCamelCaseOptions = _DefaultWordsOptions & {
 	preserveConsecutiveUppercase: false;
+	preserveLeadingUnderscores: false;
 };
 
+/**
+Extract leading underscores from a string.
+
+@example
+```
+type A = LeadingUnderscores<'__foo_bar'>;
+//=> '__'
+
+type B = LeadingUnderscores<'foo_bar'>;
+//=> ''
+```
+*/
+type LeadingUnderscores<Type extends string, Underscores extends string = ''> =
+	Type extends `_${infer Rest}`
+		? LeadingUnderscores<Rest, `_${Underscores}`>
+		: Underscores;
+
 /**
 Convert an array of words to camel-case.
 */
@@ -43,6 +69,8 @@ This can be useful when, for example, converting some kebab-cased command-line f
 
 By default, consecutive uppercase letter are preserved. See {@link CamelCaseOptions.preserveConsecutiveUppercase preserveConsecutiveUppercase} option to change this behaviour.
 
+Use the `preserveLeadingUnderscores` option to retain leading underscores, matching the runtime behavior of [`camelcase`](https://github.com/sindresorhus/camelcase) v9+.
+
 @example
 ```
 import type {CamelCase} from 'type-fest';
@@ -51,6 +79,8 @@ import type {CamelCase} from 'type-fest';
 
 const someVariable: CamelCase<'foo-bar'> = 'fooBar';
 const preserveConsecutiveUppercase: CamelCase<'foo-BAR-baz', {preserveConsecutiveUppercase: true}> = 'fooBARBaz';
+const splitOnPunctuation: CamelCase<'foo-bar:BAZ', {splitOnPunctuation: true}> = 'fooBarBaz';
+const preserveLeadingUnderscores: CamelCase<'_foo_bar', {preserveLeadingUnderscores: true}> = '_fooBar';
 
 // Advanced
 
@@ -83,10 +113,13 @@ const dbResult: CamelCasedProperties<RawOptions> = {
 export type CamelCase<Type, Options extends CamelCaseOptions = {}> = Type extends string
 	? string extends Type
 		? Type
-		: Uncapitalize<CamelCaseFromArray<
+		: `${Options['preserveLeadingUnderscores'] extends true
+			? LeadingUnderscores<Type>
+			: ''
+		}${Uncapitalize<CamelCaseFromArray<
 			Words<Type extends Uppercase<Type> ? Lowercase<Type> : Type, Options>,
 			ApplyDefaultOptions<CamelCaseOptions, _DefaultCamelCaseOptions, Options>
-		>>
+		>>}`
 	: Type;
 
 export {};

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

@@ -48,6 +48,13 @@ const preserveConsecutiveUppercase: CamelCasedPropertiesDeep<{fooBAR: {fooBARBiz
 		}],
 	},
 };
+
+const splitOnPunctuation: CamelCasedPropertiesDeep<{'user@info': {'user::id': number; 'user::name': string}}, {splitOnPunctuation: true}> = {
+	userInfo: {
+		userId: 1,
+		userName: 'Tom',
+	},
+};
 ```
 
 @category Change case
@@ -86,11 +93,11 @@ type CamelCasedPropertiesArrayDeep<
 		? [_CamelCasedPropertiesDeep<U, Options>, ..._CamelCasedPropertiesDeep<V, Options>]
 		: Value extends readonly [infer U, ...infer V]
 			? readonly [_CamelCasedPropertiesDeep<U, Options>, ..._CamelCasedPropertiesDeep<V, Options>]
-			: // Leading spread array
-			Value extends readonly [...infer U, infer V]
+			// Leading spread array
+			: Value extends readonly [...infer U, infer V]
 				? [..._CamelCasedPropertiesDeep<U, Options>, _CamelCasedPropertiesDeep<V, Options>]
-				: // Array
-				Value extends Array<infer U>
+				// Array
+				: Value extends Array<infer U>
 					? Array<_CamelCasedPropertiesDeep<U, Options>>
 					: Value extends ReadonlyArray<infer U>
 						? ReadonlyArray<_CamelCasedPropertiesDeep<U, Options>>

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

@@ -2,7 +2,7 @@ import type {CamelCase, CamelCaseOptions, _DefaultCamelCaseOptions} from './came
 import type {ApplyDefaultOptions} from './internal/index.d.ts';
 
 /**
-Convert object properties to camel case but not recursively.
+Convert top-level object properties to camel case.
 
 This can be useful when, for example, converting some API types from a different style.
 
@@ -26,6 +26,10 @@ const result: CamelCasedProperties<User> = {
 const preserveConsecutiveUppercase: CamelCasedProperties<{fooBAR: string}, {preserveConsecutiveUppercase: true}> = {
 	fooBAR: 'string',
 };
+
+const splitOnPunctuation: CamelCasedProperties<{'foo::bar': string}, {splitOnPunctuation: true}> = {
+	fooBar: 'string',
+};
 ```
 
 @category Change case

package/source/conditional-pick-deep.d.ts

@@ -74,7 +74,7 @@ type BooleanPick = ConditionalPickDeep<Example, boolean | undefined>;
 //=> {c: {e: {g?: boolean}; j: boolean}}
 
 type NumberPick = ConditionalPickDeep<Example, number>;
-//=> {}
+//=> never
 
 type StringOrBooleanPick = ConditionalPickDeep<Example, string | boolean>;
 //=> {
@@ -99,11 +99,13 @@ export type ConditionalPickDeep<
 	Type,
 	Condition,
 	Options extends ConditionalPickDeepOptions = {},
-> = _ConditionalPickDeep<
+> = _NeverIfEmpty<_ConditionalPickDeep<
 	Type,
 	Condition,
 	ApplyDefaultOptions<ConditionalPickDeepOptions, DefaultConditionalPickDeepOptions, Options>
->;
+>>;
+
+type _NeverIfEmpty<Type> = Type extends EmptyObject ? never : Type;
 
 type _ConditionalPickDeep<
 	Type,

package/source/conditional-pick.d.ts

@@ -1,4 +1,5 @@
 import type {ConditionalKeys} from './conditional-keys.d.ts';
+import type {IsNever} from './is-never.d.ts';
 
 /**
 Pick keys from the shape that matches the given `Condition`.
@@ -38,9 +39,10 @@ type StringKeysOnly = ConditionalPick<Example, string>;
 
 @category Object
 */
-export type ConditionalPick<Base, Condition> = Pick<
-	Base,
-	ConditionalKeys<Base, Condition>
->;
+export type ConditionalPick<Base, Condition> = ConditionalKeys<Base, Condition> extends infer Keys
+	? IsNever<Keys> extends true
+		? never
+		: Pick<Base, Keys & keyof Base>
+	: never;
 
 export {};

package/source/delimiter-case.d.ts

@@ -38,6 +38,7 @@ import type {DelimiterCase} from 'type-fest';
 
 const someVariable: DelimiterCase<'fooBar', '#'> = 'foo#bar';
 const someVariableNoSplitOnNumbers: DelimiterCase<'p2pNetwork', '#', {splitOnNumbers: false}> = 'p2p#network';
+const someVariableWithPunctuation: DelimiterCase<'div.card::after', '#', {splitOnPunctuation: true}> = 'div#card#after';
 
 // Advanced
 

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

@@ -4,7 +4,7 @@ import type {UnknownArray} from './unknown-array.d.ts';
 import type {WordsOptions} from './words.d.ts';
 
 /**
-Convert object properties to delimiter case recursively.
+Convert object properties to a custom string delimiter casing recursively.
 
 This can be useful when, for example, converting some API types from a different style.
 
@@ -51,6 +51,13 @@ const splitOnNumbers: DelimiterCasedPropertiesDeep<{line1: {line2: [{line3: stri
 		],
 	},
 };
+
+const splitOnPunctuation: DelimiterCasedPropertiesDeep<{'user@info': {'user::id': number; 'user::name': string}}, '-', {splitOnPunctuation: true}> = {
+	'user-info': {
+		'user-id': 1,
+		'user-name': 'Tom',
+	},
+};
 ```
 
 @category Change case

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

@@ -3,7 +3,7 @@ import type {ApplyDefaultOptions} from './internal/index.d.ts';
 import type {WordsOptions} from './words.d.ts';
 
 /**
-Convert object properties to delimiter case but not recursively.
+Convert object properties to a custom string delimiter casing.
 
 This can be useful when, for example, converting some API types from a different style.
 
@@ -27,6 +27,10 @@ const result: DelimiterCasedProperties<User, '-'> = {
 const splitOnNumbers: DelimiterCasedProperties<{line1: string}, '-', {splitOnNumbers: true}> = {
 	'line-1': 'string',
 };
+
+const splitOnPunctuation: DelimiterCasedProperties<{'foo::bar': string}, '-', {splitOnPunctuation: true}> = {
+	'foo-bar': 'string',
+};
 ```
 
 @category Change case

package/source/empty-object.d.ts

@@ -32,7 +32,7 @@ Unfortunately, `Record<string, never>`, `Record<keyof any, never>` and `Record<n
 export type EmptyObject = {[emptyObjectSymbol]?: never};
 
 /**
-Returns a `boolean` for whether the type is strictly equal to an empty plain object, the `{}` value.
+Returns a boolean for whether the type is strictly equal to an empty plain object, the `{}` value.
 
 @example
 ```

package/source/entries.d.ts

@@ -6,7 +6,7 @@ type ObjectEntries<BaseType> = Array<_ObjectEntry<BaseType>>;
 type SetEntries<BaseType extends Set<unknown>> = Array<_SetEntry<BaseType>>;
 
 /**
-Many collections have an `entries` method which returns an array of a given object's own enumerable string-keyed property [key, value] pairs. The `Entries` type will return the type of that collection's entries.
+Create a type that describes the key-value pairs produced when calling a collection’s `entries` method.
 
 For example the {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries|`Object`}, {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries|`Map`}, {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/entries|`Array`}, and {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/entries|`Set`} collections all have this method. Note that `WeakMap` and `WeakSet` do not have this method since their entries are not enumerable.
 

package/source/entry.d.ts

@@ -7,7 +7,7 @@ export type _ObjectEntry<BaseType> = [keyof BaseType, BaseType[keyof BaseType]];
 export type _SetEntry<BaseType> = BaseType extends Set<infer ItemType> ? [ItemType, ItemType] : never;
 
 /**
-Many collections have an `entries` method which returns an array of a given object's own enumerable string-keyed property [key, value] pairs. The `Entry` type will return the type of that collection's entry.
+Create a type that describes a single key-value pair produced when calling a collection’s `entries` method.
 
 For example the {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries|`Object`}, {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries|`Map`}, {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/entries|`Array`}, and {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/entries|`Set`} collections all have this method. Note that `WeakMap` and `WeakSet` do not have this method since their entries are not enumerable.
 

package/source/exclude-exactly.d.ts

@@ -0,0 +1,57 @@
+import type {IsNever} from './is-never.d.ts';
+import type {IsAny} from './is-any.d.ts';
+import type {If} from './if.d.ts';
+import type {IsEqual} from './is-equal.d.ts';
+import type {IfNotAnyOrNever} from './internal/type.d.ts';
+
+/**
+A stricter version of `Exclude<T, U>` that excludes types only when they are exactly identical.
+
+@example
+```
+import type {ExcludeExactly} from 'type-fest';
+
+type TestExclude1 = Exclude<'a' | 'b' | 'c' | 1 | 2 | 3, string>;
+//=> 1 | 2 | 3
+
+type TestExcludeExactly1 = ExcludeExactly<'a' | 'b' | 'c' | 1 | 2 | 3, string>;
+//=> 'a' | 'b' | 'c' | 1 | 2 | 3
+
+type TestExclude2 = Exclude<'a' | 'b' | 'c' | 1 | 2 | 3, any>;
+//=> never
+
+type TestExcludeExactly2 = ExcludeExactly<'a' | 'b' | 'c' | 1 | 2 | 3, any>;
+//=> 'a' | 'b' | 'c' | 1 | 2 | 3
+
+type TestExclude3 = Exclude<{a: string} | {a: string; b: string}, {a: string}>;
+//=> never
+
+type TestExcludeExactly3 = ExcludeExactly<{a: string} | {a: string; b: string}, {a: string}>;
+//=> {a: string; b: string}
+```
+
+@category Improved Built-in
+*/
+export type ExcludeExactly<Union, Delete> =
+	IfNotAnyOrNever<
+		Union,
+		_ExcludeExactly<Union, Delete>,
+		// If `Union` is `any`, then if `Delete` is `any`, return `never`, else return `Union`.
+		If<IsAny<Delete>, never, Union>,
+		// If `Union` is `never`, then if `Delete` is `never`, return `never`, else return `Union`.
+		If<IsNever<Delete>, never, Union>
+	>;
+
+type _ExcludeExactly<Union, Delete> =
+	IfNotAnyOrNever<Delete,
+		Union extends unknown // For distributing `Union`
+			? [Delete extends unknown // For distributing `Delete`
+				? If<IsEqual<Union, Delete>, true, never>
+				: never] extends [never] ? Union : never
+			: never,
+		// If `Delete` is `any` or `never`, then return `Union`,
+		// because `Union` cannot be `any` or `never` here.
+		Union, Union
+	>;
+
+export {};

package/source/get.d.ts

@@ -161,7 +161,7 @@ type PropertyOf<BaseType, Key extends string, Options extends Required<GetOption
 
 // This works by first splitting the path based on `.` and `[...]` characters into a tuple of string keys. Then it recursively uses the head key to get the next property of the current object, until there are no keys left. Number keys extract the item type from arrays, or are converted to strings to extract types from tuples and dictionaries with number keys.
 /**
-Get a deeply-nested property from an object using a key path, like Lodash's `.get()` function.
+Get a deeply-nested property from an object using a key path, like [Lodash's `.get()`](https://lodash.com/docs/latest#get) function.
 
 Use-case: Retrieve a property from deep inside an API response or some other complex object.
 

package/source/greater-than-or-equal.d.ts

@@ -16,9 +16,42 @@ type B = GreaterThanOrEqual<1, 1>;
 type C = GreaterThanOrEqual<1, 5>;
 //=> false
 ```
+
+Note: If either argument is the non-literal `number` type, the result is `boolean`.
+
+@example
+```
+import type {GreaterThanOrEqual} from 'type-fest';
+
+type A = GreaterThanOrEqual<number, 1>;
+//=> boolean
+
+type B = GreaterThanOrEqual<1, number>;
+//=> boolean
+
+type C = GreaterThanOrEqual<number, number>;
+//=> boolean
+```
+
+@example
+```
+import type {GreaterThanOrEqual} from 'type-fest';
+
+// Use `GreaterThanOrEqual` to constrain a function parameter to non-negative numbers.
+declare function setNonNegative<N extends number>(value: GreaterThanOrEqual<N, 0> extends true ? N : never): void;
+
+setNonNegative(0); // ✅ Allowed
+setNonNegative(1); // ✅ Allowed
+
+// @ts-expect-error
+setNonNegative(-1);
+
+// @ts-expect-error
+setNonNegative(-2);
+```
 */
 export type GreaterThanOrEqual<A extends number, B extends number> = number extends A | B
-	? never
+	? boolean
 	: A extends number // For distributing `A`
 		? B extends number // For distributing `B`
 			? A extends B

package/source/greater-than.d.ts

@@ -1,8 +1,9 @@
-import type {NumberAbsolute, PositiveNumericStringGt} from './internal/index.d.ts';
+import type {PositiveNumericStringGt} from './internal/index.d.ts';
 import type {IsEqual} from './is-equal.d.ts';
 import type {PositiveInfinity, NegativeInfinity, IsNegative} from './numeric.d.ts';
 import type {And} from './and.d.ts';
 import type {Or} from './or.d.ts';
+import type {Absolute} from './absolute.d.ts';
 
 /**
 Returns a boolean for whether a given number is greater than another number.
@@ -20,12 +21,45 @@ type B = GreaterThan<1, 1>;
 type C = GreaterThan<1, 5>;
 //=> false
 ```
+
+Note: If either argument is the non-literal `number` type, the result is `boolean`.
+
+@example
+```
+import type {GreaterThan} from 'type-fest';
+
+type A = GreaterThan<number, 1>;
+//=> boolean
+
+type B = GreaterThan<1, number>;
+//=> boolean
+
+type C = GreaterThan<number, number>;
+//=> boolean
+```
+
+@example
+```
+import type {GreaterThan} from 'type-fest';
+
+// Use `GreaterThan` to constrain a function parameter to positive numbers.
+declare function setPositive<N extends number>(value: GreaterThan<N, 0> extends true ? N : never): void;
+
+setPositive(1); // ✅ Allowed
+setPositive(2); // ✅ Allowed
+
+// @ts-expect-error
+setPositive(0);
+
+// @ts-expect-error
+setPositive(-1);
+```
 */
 export type GreaterThan<A extends number, B extends number> =
 	A extends number // For distributing `A`
 		? B extends number // For distributing `B`
 			? number extends A | B
-				? never
+				? boolean
 				: [
 					IsEqual<A, PositiveInfinity>, IsEqual<A, NegativeInfinity>,
 					IsEqual<B, PositiveInfinity>, IsEqual<B, NegativeInfinity>,
@@ -49,7 +83,7 @@ export type GreaterThan<A extends number, B extends number> =
 											? true
 											: [false, false] extends R
 												? PositiveNumericStringGt<`${A}`, `${B}`>
-												: PositiveNumericStringGt<`${NumberAbsolute<B>}`, `${NumberAbsolute<A>}`>
+												: PositiveNumericStringGt<`${Absolute<B>}`, `${Absolute<A>}`>
 									: never
 					: never
 			: never // Should never happen

package/source/has-optional-keys.d.ts

@@ -1,7 +1,7 @@
 import type {OptionalKeysOf} from './optional-keys-of.d.ts';
 
 /**
-Creates a type that represents `true` or `false` depending on whether the given type has any optional fields.
+Returns a boolean for whether the given type has any optional fields.
 
 This is useful when you want to create an API whose behavior depends on the presence or absence of optional fields.
 

package/source/has-readonly-keys.d.ts

@@ -1,7 +1,7 @@
 import type {ReadonlyKeysOf} from './readonly-keys-of.d.ts';
 
 /**
-Creates a type that represents `true` or `false` depending on whether the given type has any readonly fields.
+Returns a boolean for whether the given type has any readonly fields.
 
 This is useful when you want to create an API whose behavior depends on the presence or absence of readonly fields.
 

package/source/has-required-keys.d.ts

@@ -1,7 +1,7 @@
 import type {RequiredKeysOf} from './required-keys-of.d.ts';
 
 /**
-Creates a type that represents `true` or `false` depending on whether the given type has any required fields.
+Returns a boolean for whether the given type has any required fields.
 
 This is useful when you want to create an API whose behavior depends on the presence or absence of required fields.
 

package/source/has-writable-keys.d.ts

@@ -1,7 +1,7 @@
 import type {WritableKeysOf} from './writable-keys-of.d.ts';
 
 /**
-Creates a type that represents `true` or `false` depending on whether the given type has any writable fields.
+Returns a boolean for whether the given type has any writable fields.
 
 This is useful when you want to create an API whose behavior depends on the presence or absence of writable fields.
 

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

@@ -2,9 +2,7 @@ import type {IntRange} from './int-range.d.ts';
 import type {Sum} from './sum.d.ts';
 
 /**
-Generate a union of numbers.
-
-The numbers are created from the given `Start` (inclusive) parameter to the given `End` (inclusive) parameter.
+Generate a union of numbers between a specified start and end (both inclusive), with an optional step.
 
 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`.
 

package/source/int-range.d.ts

@@ -2,9 +2,7 @@ import type {TupleOf} from './tuple-of.d.ts';
 import type {Subtract} from './subtract.d.ts';
 
 /**
-Generate a union of numbers.
-
-The numbers are created from the given `Start` (inclusive) parameter to the given `End` (exclusive) parameter.
+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`.
 
@@ -56,9 +54,9 @@ 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 ?
+> = Gap extends 0
 	// Handle the case that without `Step`
-	List['length'] extends End // The result of "List[length] === End"
+	? 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'] ]>
 	// Handle the case that with `Step`