type-fest 4.41.0 → 5.0.1

package/source/schema.d.ts

@@ -1,3 +1,49 @@
+import type {ApplyDefaultOptions} from './internal/object.d.ts';
+import type {IfNotAnyOrNever, NonRecursiveType} from './internal/type.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';
+
+/**
+@see {@link Schema}
+*/
+export type SchemaOptions = {
+	/**
+	By default, this affects elements in array and tuple types. You can change this by passing `{recurseIntoArrays: false}` as the third type argument:
+	- If `recurseIntoArrays` is set to `true` (default), array elements will be recursively processed as well.
+	- If `recurseIntoArrays` is set to `false`, arrays will not be recursively processed, and the entire array will be replaced with the given value type.
+
+	@example
+	```
+	import type {Schema} from 'type-fest';
+
+	type Participants = {
+		attendees: string[];
+		speakers: string[];
+	};
+
+	type ParticipantsWithMetadata = Schema<Participants, {id: number; name: string}, {recurseIntoArrays: true}>;
+	//=> {
+	// 	attendees: Array<{id: number; name: string}>;
+	// 	speakers: Array<{id: number; name: string}>;
+	// };
+
+	type ParticipantsCount = Schema<Participants, number, {recurseIntoArrays: false}>;
+	//=> {
+	// 	attendees: number;
+	// 	speakers: number;
+	// };
+	```
+
+	@default true
+	*/
+	recurseIntoArrays?: boolean;
+};
+
+type DefaultSchemaOptions = {
+	recurseIntoArrays: true;
+};
+
 /**
 Create a deep version of another object type where property values are recursively replaced into a given value type.
 
@@ -10,7 +56,7 @@ Use-cases:
 ```
 import type {Schema} from 'type-fest';
 
-interface User {
+type User = {
 	id: string;
 	name: {
 		firstname: string;
@@ -19,8 +65,8 @@ interface User {
 	created: Date;
 	active: boolean;
 	passwordHash: string;
-	attributes: ['Foo', 'Bar']
-}
+	location: [latitude: number, longitude: number];
+};
 
 type UserMask = Schema<User, 'mask' | 'hide' | 'show'>;
 
@@ -33,82 +79,36 @@ const userMaskSettings: UserMask = {
 	created: 'show',
 	active: 'show',
 	passwordHash: 'hide',
-	attributes: ['mask', 'show']
-}
+	location: ['hide', 'hide'],
+};
 ```
 
+@see {@link SchemaOptions}
+
 @category Object
 */
-export type Schema<ObjectType, ValueType, Options extends SchemaOptions = {}> = ObjectType extends string
-	? ValueType
-	: ObjectType extends Map<unknown, unknown>
-		? ValueType
-		: ObjectType extends Set<unknown>
-			? ValueType
-			: ObjectType extends ReadonlyMap<unknown, unknown>
-				? ValueType
-				: ObjectType extends ReadonlySet<unknown>
-					? ValueType
-					: ObjectType extends Array<infer U>
-						? Options['recurseIntoArrays'] extends false | undefined
-							? ValueType
-							: Array<Schema<U, ValueType>>
-						: ObjectType extends (...arguments_: unknown[]) => unknown
-							? ValueType
-							: ObjectType extends Date
-								? ValueType
-								: ObjectType extends Function
-									? ValueType
-									: ObjectType extends RegExp
-										? ValueType
-										: ObjectType extends object
-											? SchemaObject<ObjectType, ValueType, Options>
-											: ValueType;
+export type Schema<Type, Value, Options extends SchemaOptions = {}> =
+	IfNotAnyOrNever<Type,
+		_Schema<Type, Value, ApplyDefaultOptions<SchemaOptions, DefaultSchemaOptions, Options>>,
+		Value, Value>;
 
-/**
-Same as `Schema`, but accepts only `object`s as inputs. Internal helper for `Schema`.
-*/
-type SchemaObject<
-	ObjectType extends object,
-	K,
-	Options extends SchemaOptions,
-> = {
-	[KeyType in keyof ObjectType]: ObjectType[KeyType] extends
-	| readonly unknown[]
-	| unknown[]
-		? Options['recurseIntoArrays'] extends false | undefined
-			? K
-			: Schema<ObjectType[KeyType], K, Options>
-		: Schema<ObjectType[KeyType], K, Options> | K;
-};
+type _Schema<Type, Value, Options extends Required<SchemaOptions>> =
+	Type extends NonRecursiveType | Map<unknown, unknown> | Set<unknown> | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown>
+		? Value
+		: Type extends UnknownArray
+			? Options['recurseIntoArrays'] extends false
+				? Value
+				: SchemaHelper<Type, Value, Options>
+			: SchemaHelper<Type, Value, Options>;
 
 /**
-@see Schema
-*/
-export type SchemaOptions = {
-	/**
-	By default, this affects elements in array and tuple types. You can change this by passing `{recurseIntoArrays: false}` as the third type argument:
-	- If `recurseIntoArrays` is set to `true` (default), array elements will be recursively processed as well.
-	- If `recurseIntoArrays` is set to `false`, arrays will not be recursively processed, and the entire array will be replaced with the given value type.
-
-	@example
-	```
-	type UserMask = Schema<User, 'mask' | 'hide' | 'show', {recurseIntoArrays: false}>;
-
-	const userMaskSettings: UserMask = {
-		id: 'show',
-		name: {
-			firstname: 'show',
-			lastname: 'mask',
-		},
-		created: 'show',
-		active: 'show',
-		passwordHash: 'hide',
-		attributes: 'hide'
-	}
-	```
+Internal helper for {@link _Schema}.
 
-	@default true
-	*/
-	readonly recurseIntoArrays?: boolean | undefined;
-};
+Recursively transforms the value of each property in objects and arrays.
+*/
+type SchemaHelper<Type, Value, Options extends Required<SchemaOptions>> = Simplify<{
+	[Key in keyof Type]: _Schema<
+		Key extends OptionalKeysOf<Type & object> ? Exclude<Type[Key], undefined> : Type[Key], // Remove `| undefined` when accessing optional properties
+		Value,
+		Options>
+}>;

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

@@ -1,7 +1,7 @@
-import type {DefaultDelimiterCaseOptions} from './delimiter-case';
-import type {ApplyDefaultOptions} from './internal';
-import type {SnakeCase} from './snake-case';
-import type {WordsOptions} from './words';
+import type {DefaultDelimiterCaseOptions} from './delimiter-case.d.ts';
+import type {ApplyDefaultOptions} from './internal/index.d.ts';
+import type {SnakeCase} from './snake-case.d.ts';
+import type {WordsOptions} from './words.d.ts';
 
 /**
 Convert a string literal to screaming-snake-case.

package/source/set-field-type.d.ts

@@ -1,5 +1,5 @@
-import type {ApplyDefaultOptions} from './internal';
-import type {Simplify} from './simplify';
+import type {ApplyDefaultOptions} from './internal/index.d.ts';
+import type {Simplify} from './simplify.d.ts';
 
 type SetFieldTypeOptions = {
 	/**

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

@@ -1,9 +1,9 @@
-import type {NonRecursiveType, StringToNumber} from './internal';
-import type {Paths} from './paths';
-import type {SetNonNullable} from './set-non-nullable';
-import type {Simplify} from './simplify';
-import type {UnionToTuple} from './union-to-tuple';
-import type {UnknownArray} from './unknown-array';
+import type {NonRecursiveType, StringToNumber} from './internal/index.d.ts';
+import type {Paths} from './paths.d.ts';
+import type {SetNonNullable} from './set-non-nullable.d.ts';
+import type {Simplify} from './simplify.d.ts';
+import type {UnionToTuple} from './union-to-tuple.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
 
 /**
 Create a type that makes the specified keys non-nullable (removes `null` and `undefined`), supports deeply nested key paths, and leaves all other keys unchanged.

package/source/set-optional.d.ts

@@ -1,6 +1,6 @@
-import type {Except} from './except';
-import type {HomomorphicPick} from './internal';
-import type {Simplify} from './simplify';
+import type {Except} from './except.d.ts';
+import type {HomomorphicPick} from './internal/index.d.ts';
+import type {Simplify} from './simplify.d.ts';
 
 /**
 Create a type that makes the given keys optional. The remaining keys are kept as is. The sister of the `SetRequired` type.
@@ -28,11 +28,17 @@ type SomeOptional = SetOptional<Foo, 'b' | 'c'>;
 @category Object
 */
 export type SetOptional<BaseType, Keys extends keyof BaseType> =
+	(BaseType extends (...arguments_: never) => any
+		? (...arguments_: Parameters<BaseType>) => ReturnType<BaseType>
+		: unknown)
+	& _SetOptional<BaseType, Keys>;
+
+type _SetOptional<BaseType, Keys extends keyof BaseType> =
 	BaseType extends unknown // To distribute `BaseType` when it's a union type.
 		? Simplify<
 		// Pick just the keys that are readonly from the base type.
-		Except<BaseType, Keys> &
+			Except<BaseType, Keys> &
 		// Pick the keys that should be mutable from the base type and make them mutable.
-		Partial<HomomorphicPick<BaseType, Keys>>
+			Partial<HomomorphicPick<BaseType, Keys>>
 		>
 		: never;

package/source/set-parameter-type.d.ts

@@ -1,6 +1,6 @@
-import type {IsUnknown} from './is-unknown';
-import type {StaticPartOfArray, VariablePartOfArray} from './internal';
-import type {UnknownArray} from './unknown-array';
+import type {IsUnknown} from './is-unknown.d.ts';
+import type {StaticPartOfArray, VariablePartOfArray} from './internal/index.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
 
 /**
 Create an array that replaces the given `TArray`'s elements with the given `TObject`'s values at the given indices.
@@ -78,7 +78,7 @@ Use-case:
 ```
 import type {SetParameterType} from 'type-fest';
 
-type HandleMessage = (data: Data, message: string, ...arguments: any[]) => void;
+type HandleMessage = (data: Data, message: string, ...arguments_: any[]) => void;
 
 type HandleOk = SetParameterType<HandleMessage, {0: SuccessData, 1: 'ok'}>;
 //=> type HandleOk = (data: SuccessData, message: 'ok') => void;
@@ -94,12 +94,12 @@ type HandleWarn = SetParameterType<HandleMessage, {1: 'warn'}>;
 // Change rest parameter type.
 
 // Way 1: Input full parameter type.
-type HandleLog = SetParameterType<HandleMessage, [data: Data, message: 'log', ...arguments: string[]]>;
-//=> type HandleLog = (data: Data, message: 'log', ...arguments: string[]) => void;
+type HandleLog = SetParameterType<HandleMessage, [data: Data, message: 'log', ...arguments_: string[]]>;
+//=> type HandleLog = (data: Data, message: 'log', ...arguments_: string[]) => void;
 
 // Way 2: Input rest parameter type by Object index.
 type HandleLog2 = SetParameterType<HandleMessage, {2: string}>;
-//=> type HandleLog2 = (data: Data, message: string, ...arguments: string[]) => void;
+//=> type HandleLog2 = (data: Data, message: string, ...arguments_: string[]) => void;
 ```
 
 @category Function

package/source/set-readonly.d.ts

@@ -1,6 +1,6 @@
-import type {Except} from './except';
-import type {HomomorphicPick} from './internal';
-import type {Simplify} from './simplify';
+import type {Except} from './except.d.ts';
+import type {HomomorphicPick} from './internal/index.d.ts';
+import type {Simplify} from './simplify.d.ts';
 
 /**
 Create a type that makes the given keys readonly. The remaining keys are kept as is.
@@ -28,12 +28,15 @@ type SomeReadonly = SetReadonly<Foo, 'b' | 'c'>;
 @category Object
 */
 export type SetReadonly<BaseType, Keys extends keyof BaseType> =
-	// `extends unknown` is always going to be the case and is used to convert any
-	// union into a [distributive conditional
-	// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
-	BaseType extends unknown
+	(BaseType extends (...arguments_: never) => any
+		? (...arguments_: Parameters<BaseType>) => ReturnType<BaseType>
+		: unknown)
+	& _SetReadonly<BaseType, Keys>;
+
+export type _SetReadonly<BaseType, Keys extends keyof BaseType> =
+	BaseType extends unknown // To distribute `BaseType` when it's a union type.
 		? Simplify<
-		Except<BaseType, Keys> &
-		Readonly<HomomorphicPick<BaseType, Keys>>
+			Except<BaseType, Keys> &
+			Readonly<HomomorphicPick<BaseType, Keys>>
 		>
 		: never;

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

@@ -1,11 +1,11 @@
-import type {IsAny} from './is-any';
-import type {NonRecursiveType, StringToNumber} from './internal';
-import type {Paths} from './paths';
-import type {SetRequired} from './set-required';
-import type {SimplifyDeep} from './simplify-deep';
-import type {UnionToTuple} from './union-to-tuple';
-import type {RequiredDeep} from './required-deep';
-import type {UnknownArray} from './unknown-array';
+import type {IsAny} from './is-any.d.ts';
+import type {NonRecursiveType, StringToNumber} from './internal/index.d.ts';
+import type {Paths} from './paths.d.ts';
+import type {SetRequired} from './set-required.d.ts';
+import type {SimplifyDeep} from './simplify-deep.d.ts';
+import type {UnionToTuple} from './union-to-tuple.d.ts';
+import type {RequiredDeep} from './required-deep.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
 
 /**
 Create a type that makes the given keys required. You can specify deeply nested key paths. The remaining keys are kept as is.
@@ -25,12 +25,12 @@ type Foo = {
 }
 
 type SomeRequiredDeep = SetRequiredDeep<Foo, 'a' | `c.${number}.d`>;
-// type SomeRequiredDeep = {
+//=> {
 // 	a: number; // Is now required
 // 	b?: string;
-// 	c: {
-// 		d: number // Is now required
-// 	}[]
+// 	c?: {
+// 		d: number; // Is now required
+// 	}[];
 // }
 
 // Set specific indices in an array to be required.

package/source/set-required.d.ts

@@ -1,8 +1,9 @@
-import type {Except} from './except';
-import type {HomomorphicPick, IfArrayReadonly} from './internal';
-import type {OptionalKeysOf} from './optional-keys-of';
-import type {Simplify} from './simplify';
-import type {UnknownArray} from './unknown-array';
+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';
 
 /**
 Create a type that makes the given keys required. The remaining keys are kept as is. The sister of the `SetOptional` type.
@@ -34,15 +35,21 @@ type ArrayExample = SetRequired<[number?, number?, number?], 0 | 1>;
 @category Object
 */
 export type SetRequired<BaseType, Keys extends keyof BaseType> =
+	(BaseType extends (...arguments_: never) => any
+		? (...arguments_: Parameters<BaseType>) => ReturnType<BaseType>
+		: unknown)
+	& _SetRequired<BaseType, Keys>;
+
+type _SetRequired<BaseType, Keys extends keyof BaseType> =
 	BaseType extends UnknownArray
 		? SetArrayRequired<BaseType, Keys> extends infer ResultantArray
-			? IfArrayReadonly<BaseType, Readonly<ResultantArray>, ResultantArray>
+			? If<IsArrayReadonly<BaseType>, Readonly<ResultantArray>, ResultantArray>
 			: never
 		: Simplify<
 		// Pick just the keys that are optional from the base type.
-		Except<BaseType, Keys> &
+			Except<BaseType, Keys> &
 		// Pick the keys that should be required from the base type and make them required.
-		Required<HomomorphicPick<BaseType, Keys>>
+			Required<HomomorphicPick<BaseType, Keys>>
 		>;
 
 /**

package/source/set-return-type.d.ts

@@ -1,4 +1,4 @@
-import type {IsUnknown} from './is-unknown';
+import type {IsUnknown} from './is-unknown.d.ts';
 
 /**
 Create a function type with a return type of your choice and the same parameters as the given function type.

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

@@ -1,6 +1,6 @@
-import type {NonRecursiveType, UnionMin, UnionMax, TupleLength, StaticPartOfArray, VariablePartOfArray, IsArrayReadonly, SetArrayAccess, ApplyDefaultOptions} from './internal';
-import type {IsNever} from './is-never';
-import type {UnknownArray} from './unknown-array';
+import type {NonRecursiveType, UnionMin, UnionMax, TupleLength, StaticPartOfArray, VariablePartOfArray, IsArrayReadonly, SetArrayAccess, ApplyDefaultOptions} from './internal/index.d.ts';
+import type {IsNever} from './is-never.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
 
 /**
 SharedUnionFieldsDeep options.
@@ -128,8 +128,8 @@ Same as `SharedUnionFieldsDeep`, but accepts only `UnknownArray`s and as inputs.
 type SharedArrayUnionFieldsDeep<Union extends UnknownArray, Options extends Required<SharedUnionFieldsDeepOptions>> =
 	// Restore the readonly modifier of the array.
 	SetArrayAccess<
-	InternalSharedArrayUnionFieldsDeep<Union, Options>,
-	IsArrayReadonly<Union>
+		InternalSharedArrayUnionFieldsDeep<Union, Options>,
+		IsArrayReadonly<Union>
 	>;
 
 /**
@@ -155,13 +155,13 @@ type InternalSharedArrayUnionFieldsDeep<
 				// Due to `ResultTuple` is the maximum possible fixed-length part of the tuple,
 				// so we can use `StaticPartOfArray` to get the rest of the union.
 				...Array<
-				SharedUnionFieldsDeep<VariablePartOfArray<Union>[number], Options>
+					SharedUnionFieldsDeep<VariablePartOfArray<Union>[number], Options>
 				>,
 			]
 			// Build the fixed-length tuple recursively.
 			: InternalSharedArrayUnionFieldsDeep<
-			Union, Options,
-			[...ResultTuple, SharedUnionFieldsDeep<Union[ResultTuple['length']], Options>]
+				Union, Options,
+				[...ResultTuple, SharedUnionFieldsDeep<Union[ResultTuple['length']], Options>]
 			>
 		// Rule 2: If at least one of the arrays in the union have fixed lengths,
 		// like `Array<string> | [number, string]`,
@@ -173,6 +173,6 @@ type InternalSharedArrayUnionFieldsDeep<
 			? ResultTuple
 			// As above, build tuple recursively.
 			: InternalSharedArrayUnionFieldsDeep<
-			Union, Options,
-			[...ResultTuple, SharedUnionFieldsDeep<Union[ResultTuple['length']], Options>]
+				Union, Options,
+				[...ResultTuple, SharedUnionFieldsDeep<Union[ResultTuple['length']], Options>]
 			>;

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

@@ -1,7 +1,8 @@
-import type {NonRecursiveType, IsUnion} from './internal';
-import type {IsNever} from './is-never';
-import type {Simplify} from './simplify';
-import type {UnknownArray} from './unknown-array';
+import type {NonRecursiveType} from './internal/index.d.ts';
+import type {IsNever} from './is-never.d.ts';
+import type {IsUnion} from './is-union.d.ts';
+import type {Simplify} from './simplify.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
 
 /**
 Create a type with shared fields from a union of object types.

package/source/simplify-deep.d.ts

@@ -1,5 +1,5 @@
-import type {ConditionalSimplifyDeep} from './conditional-simplify';
-import type {NonRecursiveType} from './internal';
+import type {ConditionalSimplifyDeep} from './conditional-simplify-deep.d.ts';
+import type {NonRecursiveType} from './internal/index.d.ts';
 
 /**
 Deeply simplifies an object type.
@@ -109,7 +109,7 @@ type SimplifyDeepProperties = SimplifyDeep<Properties1 & Properties2, ComplexTyp
 */
 export type SimplifyDeep<Type, ExcludeType = never> =
 	ConditionalSimplifyDeep<
-	Type,
+		Type,
 	ExcludeType | NonRecursiveType | Set<unknown> | Map<unknown, unknown>,
 	object
 	>;

package/source/single-key-object.d.ts

@@ -1,5 +1,6 @@
-import type {IfEmptyObject} from './if-empty-object';
-import type {IsUnion} from './internal';
+import type {IsEmptyObject} from './empty-object.d.ts';
+import type {If} from './if.d.ts';
+import type {IsUnion} from './is-union.d.ts';
 
 /**
 Create a type that only accepts an object with a single key.
@@ -26,4 +27,4 @@ someFunction({
 export type SingleKeyObject<ObjectType> =
 	IsUnion<keyof ObjectType> extends true
 		? never
-		: IfEmptyObject<ObjectType, never, ObjectType>;
+		: If<IsEmptyObject<ObjectType>, never, ObjectType>;

package/source/snake-case.d.ts

@@ -1,6 +1,6 @@
-import type {DefaultDelimiterCaseOptions, DelimiterCase} from './delimiter-case';
-import type {ApplyDefaultOptions} from './internal';
-import type {WordsOptions} from './words';
+import type {DefaultDelimiterCaseOptions, DelimiterCase} from './delimiter-case.d.ts';
+import type {ApplyDefaultOptions} from './internal/index.d.ts';
+import type {WordsOptions} from './words.d.ts';
 
 /**
 Convert a string literal to snake-case.

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

@@ -1,7 +1,7 @@
-import type {DefaultDelimiterCaseOptions} from './delimiter-case';
-import type {DelimiterCasedPropertiesDeep} from './delimiter-cased-properties-deep';
-import type {ApplyDefaultOptions} from './internal';
-import type {WordsOptions} from './words';
+import type {DefaultDelimiterCaseOptions} from './delimiter-case.d.ts';
+import type {DelimiterCasedPropertiesDeep} from './delimiter-cased-properties-deep.d.ts';
+import type {ApplyDefaultOptions} from './internal/index.d.ts';
+import type {WordsOptions} from './words.d.ts';
 
 /**
 Convert object properties to snake case recursively.

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

@@ -1,7 +1,7 @@
-import type {DefaultDelimiterCaseOptions} from './delimiter-case';
-import type {DelimiterCasedProperties} from './delimiter-cased-properties';
-import type {ApplyDefaultOptions} from './internal';
-import type {WordsOptions} from './words';
+import type {DefaultDelimiterCaseOptions} from './delimiter-case.d.ts';
+import type {DelimiterCasedProperties} from './delimiter-cased-properties.d.ts';
+import type {ApplyDefaultOptions} from './internal/index.d.ts';
+import type {WordsOptions} from './words.d.ts';
 
 /**
 Convert object properties to snake case but not recursively.

package/source/split.d.ts

@@ -1,7 +1,7 @@
-import type {And} from './and';
-import type {ApplyDefaultOptions, Not} from './internal';
-import type {IsStringLiteral} from './is-literal';
-import type {Or} from './or';
+import type {And} from './and.d.ts';
+import type {ApplyDefaultOptions, Not} from './internal/index.d.ts';
+import type {IsStringLiteral} from './is-literal.d.ts';
+import type {Or} from './or.d.ts';
 
 /**
 Split options.
@@ -12,9 +12,7 @@ type SplitOptions = {
 	/**
 	When enabled, instantiations with non-literal string types (e.g., `string`, `Uppercase<string>`, `on${string}`) simply return back `string[]` without performing any splitting, as the exact structure cannot be statically determined.
 
-	Note: In the future, this option might be enabled by default, so if you currently rely on this being disabled, you should consider explicitly enabling it.
-
-	@default false
+	@default true
 
 	@example
 	```ts
@@ -35,7 +33,7 @@ type SplitOptions = {
 };
 
 type DefaultSplitOptions = {
-	strictLiteralChecks: false;
+	strictLiteralChecks: true;
 };
 
 /**
@@ -80,7 +78,9 @@ type SplitHelper<
 			? S extends `${infer Head}${Delimiter}${infer Tail}`
 				? SplitHelper<Tail, Delimiter, Options, [...Accumulator, Head]>
 				: Delimiter extends ''
-					? Accumulator
+					? S extends ''
+						? Accumulator
+						: [...Accumulator, S]
 					: [...Accumulator, S]
 			// Otherwise, return `string[]`
 			: string[]

package/source/spread.d.ts

@@ -1,12 +1,12 @@
-import type {RequiredKeysOf} from './required-keys-of';
-import type {Simplify} from './simplify';
+import type {RequiredKeysOf} from './required-keys-of.d.ts';
+import type {Simplify} from './simplify.d.ts';
 
 type SpreadObject<FirstType extends object, SecondType extends object> = {
 	[Key in keyof FirstType]: Key extends keyof SecondType
 		? FirstType[Key] | Required<SecondType>[Key]
 		: FirstType[Key];
 } & Pick<
-SecondType,
+	SecondType,
 RequiredKeysOf<SecondType> | Exclude<keyof SecondType, keyof FirstType>
 >;
 

package/source/string-repeat.d.ts

@@ -1,5 +1,5 @@
-import type {IsNumericLiteral} from './is-literal';
-import type {IsNegative} from './numeric';
+import type {IsNumericLiteral} from './is-literal.d.ts';
+import type {IsNegative} from './numeric.d.ts';
 
 /**
 Returns a new string which contains the specified number of copies of a given string, just like `String#repeat()`.

package/source/string-slice.d.ts

@@ -1,6 +1,6 @@
-import type {Join} from './join';
-import type {ArraySlice} from './array-slice';
-import type {StringToArray} from './internal';
+import type {Join} from './join.d.ts';
+import type {ArraySlice} from './array-slice.d.ts';
+import type {StringToArray} from './internal/index.d.ts';
 
 /**
 Returns a string slice of a given range, just like `String#slice()`.