type-plus 6.4.0 → 6.6.0

package/ts/boolean/strict_boolean_type.ts

@@ -4,8 +4,6 @@ import type { IsAnyOrNever } from '../any/any_or_never.js'
  * Check if the type `T` is exactly `boolean`.
  *
  * ```ts
- * import type { StrictBooleanType } from 'type-plus'
- *
  * type R = StrictBooleanType<boolean> // true
  *
  * type R = StrictBooleanType<true> // never
@@ -23,8 +21,6 @@ export type StrictBooleanType<T, Then = T, Else = never> = IsAnyOrNever<
  * Check if the type `T` is not exactly `boolean`.
  *
  * ```ts
- * import type { NotStrictBooleanType } from 'type-plus'
- *
  * type R = NotStrictBooleanType<boolean> // never
  *
  * type R = NotStrictBooleanType<true> // true
@@ -38,8 +34,6 @@ export type NotStrictBooleanType<T, Then = T, Else = never> = StrictBooleanType<
  * Is the type `T` exactly `boolean`.
  *
  * ```ts
- * import type { IsStrictBoolean } from 'type-plus'
- *
  * type R = IsStrictBoolean<boolean> // true
  *
  * type R = IsStrictBoolean<true> // false
@@ -53,8 +47,6 @@ export type IsStrictBoolean<T, Then = true, Else = false> = StrictBooleanType<T,
  * Is the type `T` not exactly `false`.
  *
  * ```ts
- * import type { IsNotStrictBoolean } from 'type-plus'
- *
  * type R = IsNotStrictBoolean<boolean> // false
  *
  * type R = IsNotStrictBoolean<true> // true

package/ts/boolean/true_type.ts

@@ -4,8 +4,6 @@ import type { IsAnyOrNever } from '../any/any_or_never.js'
  * Check if the type `T` is exactly `true`.
  *
  * ```ts
- * import type { TrueType } from 'type-plus'
- *
  * type R = TrueType<true> // true
  *
  * type R = TrueType<false> // never
@@ -22,8 +20,6 @@ export type TrueType<T, Then = T, Else = never> = IsAnyOrNever<
  * Check if the type `T` is not exactly `true`.
  *
  * ```ts
- * import type { NotTrueType } from 'type-plus'
- *
  * type R = NotTrueType<true> // never
  *
  * type R = NotTrueType<false> // false
@@ -36,8 +32,6 @@ export type NotTrueType<T, Then = T, Else = never> = TrueType<T, Else, Then>
  * Is the type `T` exactly `true`.
  *
  * ```ts
- * import type { IsTrue } from 'type-plus'
- *
  * type R = IsTrue<true> // true
  *
  * type R = IsTrue<false> // false
@@ -50,8 +44,6 @@ export type IsTrue<T, Then = true, Else = false> = TrueType<T, Then, Else>
  * Is the type `T` not exactly `true`.
  *
  * ```ts
- * import type { IsNotTrue } from 'type-plus'
- *
  * type R = IsNotTrue<true> // false
  *
  * type R = IsNotTrue<false> // true

package/ts/equal/equal.ts

@@ -26,8 +26,6 @@ type IdentityEqual<A, B, Then, Else> = (<_>() => _ extends (A & _) | _ ? 1 : 2)
  * Checks `A` and `B` are equal.
  *
  * ```ts
- * import { type Equal } from 'type-plus'
- *
  * type R = Equal<1, 1> // true
  * type R = Equal<any, any> // true
  * type R = Equal<boolean, boolean> // true
@@ -58,8 +56,16 @@ export type Equal<A, B, Then = true, Else = false> = [A, B] extends [B, A]
 					And<
 						IsObject<A>,
 						IsObject<B>,
-						IdentityEqual<Properties<A>, Properties<B>, Then, Else>,
+						IdentityEqual<
+							Properties<A>,
+							Properties<B>,
+							[A, B] extends [(...args: infer P1) => any, (...args: infer P2) => any]
+								? Equal<P1, P2, Then, Else>
+								: Then,
+							Else
+						>,
 						// `A` and `B` are narrowed, need to check again.
+						// This is fixed in TS 5.0.2, but keeping it to support older versions.
 						[A, B] extends [B, A] ? Then : Else
 					>
 				>
@@ -71,8 +77,6 @@ export type Equal<A, B, Then = true, Else = false> = [A, B] extends [B, A]
  * Checks `A` and `B` are not equal.
  *
  * ```ts
- * import { type NotEqual } from 'type-plus'
- *
  * type R = NotEqual<1, 1> // false
  * type R = NotEqual<any, any> // false
  * type R = NotEqual<boolean, boolean> // false

package/ts/equal/readme.md

@@ -26,6 +26,9 @@ type R = Equal<{ a: 1 }, { a: 1; b: 2 }> // false
 ---
 
 [![Just Code: Equality is hard][equality-is-hard]][equality-is-hard-url]
+[![Just Code: Equality is hard part 2][equality-is-hard-2]][equality-is-hard-2-url]
 
 [equality-is-hard]: https://img.youtube.com/vi/VEqrFzCzo28/0.jpg
 [equality-is-hard-url]: https://www.youtube.com/watch?v=VEqrFzCzo28
+[equality-is-hard-2]: https://img.youtube.com/vi/l6G6Rz1n9Sw/0.jpg
+[equality-is-hard-2-url]: https://www.youtube.com/watch?v=l6G6Rz1n9Sw

package/ts/function/function_type.ts

@@ -4,8 +4,6 @@ import type { IsAnyOrNever } from '../any/any_or_never.js'
  * Check if `T` is a `Function`.
  *
  * ```ts
- * import type { FunctionType } from 'type-plus'
- *
  * type R = FunctionType<Function> // Function
  * type R = FunctionType<() => void> // () => void
  * type R = FunctionType<(() => void) | { a: 1 }> // (() => void) | { a: 1 }
@@ -25,8 +23,6 @@ export type FunctionType<T, Then = T, Else = never> = IsAnyOrNever<
  * Is `T` a `Function`.
  *
  * ```ts
- * import type { IsFunction } from 'type-plus'
- *
  * type R = IsFunction<Function> // Function
  * type R = IsFunction<() => void> // () => void
  * type R = IsFunction<(() => void) | { a: 1 }> // (() => void) | { a: 1 }
@@ -42,8 +38,6 @@ export type IsFunction<T, Then = true, Else = false> = FunctionType<T, Then, Els
  * Check if `T` is not a `Function`.
  *
  * ```ts
- * import type { NotFunctionType } from 'type-plus'
- *
  * type R = NotFunctionType<Function> // never
  * type R = NotFunctionType<() => void> // never
  * type R = NotFunctionType<(() => void) | { a: 1 }> // never
@@ -59,8 +53,6 @@ export type NotFunctionType<T, Then = T, Else = never> = FunctionType<T, Else, T
  * Is `T` not a `Function`.
  *
  * ```ts
- * import type { IsNotFunction } from 'type-plus'
- *
  * type R = IsNotFunction<Function> // false
  * type R = IsNotFunction<() => void> // false
  * type R = IsNotFunction<(() => void) | { a: 1 }> // false

package/ts/function/strict_function_type.ts

@@ -4,8 +4,6 @@ import type { IsAnyOrNever } from '../any/any_or_never.js'
  * Check if `T` is exactly `Function`.
  *
  * ```ts
- * import type { StrictFunctionType } from 'type-plus'
- *
  * type R = StrictFunctionType<Function> // Function
  *
  * type R = StrictFunctionType<() => void> // never
@@ -22,8 +20,6 @@ export type StrictFunctionType<T, Then = T, Else = never> = IsAnyOrNever<
  * Check if `T` is not exactly `Function`.
  *
  * ```ts
- * import type { NotStrictFunctionType } from 'type-plus'
- *
  * type R = NotStrictFunctionType<Function> // never
  * type R = NotStrictFunctionType<() => void> // () => void
  *
@@ -36,8 +32,6 @@ export type NotStrictFunctionType<T, Then = T, Else = never> = StrictFunctionTyp
  * Is `T` exactly `Function`.
  *
  * ```ts
- * import type { IsStrictFunction } from 'type-plus'
- *
  * type R = IsStrictFunction<Function> // true
  *
  * type R = IsStrictFunction<() => void> // false
@@ -50,8 +44,6 @@ export type IsStrictFunction<T, Then = true, Else = false> = StrictFunctionType<
  * Is `T` not exactly `Function`.
  *
  * ```ts
- * import type { IsNotStrictFunction } from 'type-plus'
- *
  * type R = IsNotStrictFunction<Function> // false
  *
  * type R = IsNotStrictFunction<() => void> // true

package/ts/index.ts

@@ -81,11 +81,14 @@ export type {
 	NotStrictStringType,
 	StrictStringType
 } from './string/strict_string_type.js'
+export type { StringIncludes, StringSplit } from './string/string.js'
+export type { StringPlus } from './string/string_plus.js'
 export type { IsNotString, IsString, NotStringType, StringType } from './string/string_type.js'
 export type { IsNotSymbol, IsSymbol, NotSymbolType, SymbolType } from './symbol/symbol_type.js'
 export * from './testing/stub.js'
 export * from './testing/test_type.js'
 export type { IsNotTuple, IsTuple, NotTupleType, TupleType } from './tuple/tuple_type.js'
+export type { Failed, FailedT } from './type/failed.js'
 export type {
 	IsNotUndefined,
 	IsUndefined,
@@ -96,3 +99,4 @@ export type { UnionKeys } from './union_keys.js'
 export type { IsNotUnknown, IsUnknown, NotUnknownType, UnknownType } from './unknown/unknown_type.js'
 export * from './utils/index.js'
 export type { IsNotVoid, IsVoid, NotVoidType, VoidType } from './void/void_type.js'
+

package/ts/never/never_type.ts

@@ -16,8 +16,6 @@ export type Is_Never = Brand<'is_never', symbol>
  * If it is not, returns `Not_Never`.
  *
  * ```ts
- * import type { NeverType } from 'type-plus'
- *
  * type R = NeverType<never> // never
  *
  * type R = NeverType<1> // 'not never'
@@ -30,8 +28,6 @@ export type NeverType<T, Then = T, Else = Not_Never> = [T, never] extends [never
  * If it is not, returns `Is_Never`.
  *
  * ```ts
- * import type { NotNeverType } from 'type-plus'
- *
  * type R = NotNeverType<1> // 1
  *
  * type R = NotNeverType<never> // 'is_never'
@@ -42,9 +38,7 @@ export type NotNeverType<T, Then = T, Else = Is_Never> = NeverType<T, Else, Then
 /**
  * Is `T` `never`.
  *
- * ```
- * import type { IsNever } from 'type-plus'
- *
+ * ```ts
  * type R = IsNever<never> // true
  *
  * type R = IsNever<1> // false
@@ -55,9 +49,7 @@ export type IsNever<T, Then = true, Else = false> = NeverType<T, Then, Else>
 /**
  * Is `T` not `never`.
  *
- * ```
- * import type { IsNotNever } from 'type-plus'
- *
+ * ```ts
  * type R = IsNotNever<1> // true
  *
  * type R = IsNotNever<never> // false

package/ts/nominal/brand.ts

@@ -3,15 +3,23 @@
 
 import { isType } from '../predicates/isType.js'
 import type { Widen } from '../utils/index.js'
-import { typeSym, valueSym } from './types.js'
+import { typeSym, valueSym } from './constants.js'
 
 /**
  * Create a "branded" version of a type.
  * TypeScript won't allow implicit conversion to this type
  */
-export type Brand<B extends string, T> = T extends object
-	? T & { [typeSym]: B }
-	: { [typeSym]: B; [valueSym]: T }
+export type Brand<B extends string, T = never> = [T] extends [null] | [undefined] | [symbol] | [void]
+	? Branded<B, T>
+	: Branded<B, T> & T
+
+/**
+ * A branded type of `B` with value of `T`.
+ */
+export interface Branded<B extends string, T> {
+	[typeSym]: B
+	[valueSym]: T
+}
 
 /**
  * Creates a brand creator with the specified type.
@@ -21,15 +29,15 @@ export function brand<B extends string>(type: B): <T>(subject: T) => Brand<B, Wi
  * Creates a branded value of specified type.
  */
 export function brand<B extends string, T>(type: B, subject: T): Brand<B, Widen<T>>
-export function brand(type: string, subject?: unknown) {
+export function brand(typeInput: string, subject?: unknown) {
 	if (subject === undefined)
 		return function <T>(subject: T) {
-			return brand(type, subject)
+			return brand(typeInput, subject)
 		}
 
 	if (isType<{ [typeSym]: string }>(subject, s => typeof s === 'object' && s !== null)) {
 		// if subject is not an object, the branding will exist only in type-level.
-		subject[typeSym] = type
+		subject[typeSym] = typeInput
 	}
 	return subject
 }

package/ts/nominal/flavor.ts

@@ -3,7 +3,7 @@
 
 import { isType } from '../predicates/isType.js'
 import type { Widen } from '../utils/index.js'
-import { typeSym } from './types.js'
+import { typeSym, valueSym } from './constants.js'
 
 /**
  * Create a "flavored" version of a type.
@@ -11,8 +11,23 @@ import { typeSym } from './types.js'
  * but will allow unflavored values of that type to be passed in where a flavored version is expected.
  * This is a less restrictive form of branding.
  */
-export type Flavor<F extends string, T> = T & {
+export type Flavor<F extends string, T> = [T] extends [null] | [undefined] | [symbol] | [void]
+	? FlavoredUnit<F, T>
+	: Flavored<F> & T
+
+/**
+ * A flavored type of `F`
+ */
+export interface Flavored<F extends string> {
+	[typeSym]?: F
+}
+
+/**
+ * A special flavored type for special types.
+ */
+export interface FlavoredUnit<F extends string, T> {
 	[typeSym]?: F
+	[valueSym]: T
 }
 
 /**

package/ts/nominal/nominal_match.ts

@@ -1,6 +1,6 @@
 import type { Brand } from './brand.js'
 import type { Flavor } from './flavor.js'
-import { typeSym } from './types.js'
+import { typeSym } from './constants.js'
 
 export function nominalMatch<A extends string, B extends A>(
 	a: Brand<A, unknown>,

package/ts/null/null_type.ts

@@ -3,9 +3,7 @@ import type { IsAny } from '../any/any_type.js'
 /**
  * Check if the type `T` is exactly `null`.
  *
- * ```
- * import type { NullType } from 'type-plus'
- *
+ * ```ts
  * type R = NullType<null> // null
  *
  * type R = NullType<never> // never
@@ -18,9 +16,7 @@ export type NullType<T, Then = T, Else = never> = IsAny<T, Else, [T, null] exten
 /**
  * Is the type `T` exactly `null`.
  *
- * ```
- * import type { IsNull } from 'type-plus'
- *
+ * ```ts
  * type R = IsNull<null> // true
  *
  * type R = IsNull<never> // false
@@ -33,9 +29,7 @@ export type IsNull<T, Then = true, Else = false> = NullType<T, Then, Else>
 /**
  * Check if the type `T` is not exactly `null`.
  *
- * ```
- * import type { NotNullType } from 'type-plus'
- *
+ * ```ts
  * type R = NotNullType<null> // never
  *
  * type R = NotNullType<never> // never
@@ -48,9 +42,7 @@ export type NotNullType<T, Then = T, Else = never> = NullType<T, Else, Then>
 /**
  * Is the type `T` not exactly `null`.
  *
- * ```
- * import type { IsNotNull } from 'type-plus'
- *
+ * ```ts
  * type R = IsNotNull<null> // false
  *
  * type R = IsNotNull<never> // true

package/ts/number/integer.ts

@@ -5,8 +5,6 @@ import type { Numeric } from './numeric_type.js'
  * Check if T is an integer, including bigint.
  *
  * ```ts
- * import type { Integer } from 'type-plus'
- *
  * type R = Integer<0> // 0
  * type R = Integer<1n> // 1n
  *
@@ -24,8 +22,6 @@ export type Integer<T, Then = T, Else = never> = IsAnyOrNever<
  * Is T an integer, including bigint.
  *
  * ```ts
- * import type { IsInteger } from 'type-plus'
- *
  * type R = IsInteger<0> // true
  * type R = IsInteger<1n> // true
  *
@@ -39,8 +35,6 @@ export type IsInteger<T, Then = true, Else = false> = Integer<T, Then, Else>
  * Check if T is not an integer, including bigint.
  *
  * ```ts
- * import type { NotInteger } from 'type-plus'
- *
  * type R = NotInteger<1.1> // 1.1
  * type R = NotInteger<number> // number as it contains non-integer
  *
@@ -68,9 +62,7 @@ export type IsNotInteger<T, Then = true, Else = false> = NotInteger<T, Else, The
 /**
  * Check if T is an integer, including bigint.
  *
- * ```
- * import type { IsWhole } from 'type-plus'
- *
+ * ```ts
  * type R = IsWhole<0> // 0
  * type R = IsWhole<1n> // 1n
  *

package/ts/number/negative.ts

@@ -6,8 +6,6 @@ import type { Zero } from './numeric_type.js'
  * Check if 'T' is a negative numeric type.
  *
  * ```ts
- * import type { Negative } from 'type-plus'
- *
  * type R = Negative<-1> // -1
  * type R = Negative<-1n> // -1n
  *
@@ -42,8 +40,6 @@ export type Negative<T, Then = T, Else = never> = IsAny<
  * Is 'T' a negative numeric type.
  *
  * ```ts
- * import type { IsNegative } from 'type-plus'
- *
  * type R = IsNegative<-1> // true
  * type R = IsNegative<-1n> // true
  *
@@ -60,8 +56,6 @@ export type IsNegative<T, Then = true, Else = false> = Negative<T, Then, Else>
  * Check if 'T' is not a negative numeric type.
  *
  * ```ts
- * import type { NotNegative } from 'type-plus'
- *
  * type R = NotNegative<-1> // never
  * type R = NotNegative<-1n> // never
  *
@@ -94,8 +88,6 @@ export type NotNegative<T, Then = T, Else = never> = IsAny<
  * Is 'T' not a negative numeric type.
  *
  * ```ts
- * import type { IsNotNegative } from 'type-plus'
- *
  * type R = IsNotNegative<-1> // false
  * type R = IsNotNegative<-1n> // false
  *

package/ts/number/number_type.ts

@@ -4,8 +4,6 @@ import type { IsAnyOrNever } from '../any/any_or_never.js'
  * Check if the type `T` is `number`.
  *
  * ```ts
- * import type { NumberType } from 'type-plus'
- *
  * type R = NumberType<number> // true
  * type R = NumberType<1> // true
  *
@@ -19,8 +17,6 @@ export type NumberType<T, Then = T, Else = never> = IsAnyOrNever<T, Else, [T] ex
  * Is the type `T` is `number`.
  *
  * ```ts
- * import type { IsNumber } from 'type-plus'
- *
  * type R = IsNumber<number> // true
  * type R = IsNumber<1> // true
  *
@@ -34,8 +30,6 @@ export type IsNumber<T, Then = true, Else = false> = NumberType<T, Then, Else>
  * Check if the type `T` is not `number`.
  *
  * ```ts
- * import type { NotNumberType } from 'type-plus'
- *
  * type R = NotNumberType<number> // false
  * type R = NotNumberType<1> // false
  *
@@ -49,8 +43,6 @@ export type NotNumberType<T, Then = T, Else = never> = NumberType<T, Else, Then>
  * Is the type `T` not `number`.
  *
  * ```ts
- * import type { IsNotNumber } from 'type-plus'
- *
  * type R = IsNotNumber<number> // false
  * type R = IsNotNumber<1> // false
  *

package/ts/number/numeric_type.ts

@@ -15,8 +15,6 @@ export type Zero = 0 | 0n
  * Meaning it is either a `number` or a `bigint`.
  *
  * ```ts
- * import type { NumericType } from 'type-plus'
- *
  * type R = NumericType<1> // 1
  * type R = NumericType<1.1> // 1.1
  *
@@ -30,8 +28,6 @@ export type NumericType<T, Then = T, Else = never> = IsAnyOrNever<T, Else, [T] e
  * Is `T` numeric.
  *
  * ```ts
- * import type { IsNumeric } from 'type-plus'
- *
  * type R = IsNumeric<1> // true
  * type R = IsNumeric<1.1> // true
  *
@@ -45,8 +41,6 @@ export type IsNumeric<T, Then = true, Else = false> = NumericType<T, Then, Else>
  * Check if `T` is not numeric.
  *
  * ```ts
- * import type { NotNumericType } from 'type-plus'
- *
  * type R = NotNumericType<1> // never
  * type R = NotNumericType<1.1> // never
  *
@@ -60,8 +54,6 @@ export type NotNumericType<T, Then = T, Else = never> = NumericType<T, Else, The
  * Is `T` not numeric.
  *
  * ```ts
- * import type { IsNotNumeric } from 'type-plus'
- *
  * type R = IsNotNumeric<1> // false
  * type R = IsNotNumeric<1.1> // false
  *

package/ts/number/positive.ts

@@ -5,8 +5,6 @@ import { IsNever } from '../index.js'
  * Check if `T` is a positive numeric type.
  *
  * ```ts
- * import type { Positive } from 'type-plus'
- *
  * type R = Positive<1> // 1
  * type R = Positive<0> // 0
  * type R = Positive<1n> // 1n
@@ -24,15 +22,13 @@ export type Positive<T, Then = T, Else = never> = IsAny<
  * Is `T` a positive numeric type.
  *
  * ```ts
- * import type { IsPositive } from 'type-plus'
- *
  * type R = IsPositive<1> // true
  * type R = IsPositive<0> // true
  * type R = IsPositive<1n> // true
  *
  * type R = IsPositive<number> // boolean
  * type R = IsPositive<bigint> // boolean
- * type R = IsPosistive<any> // boolean
+ * type R = IsPositive<any> // boolean
  *
  * type R = IsPositive<-1> // false
  * ```
@@ -43,8 +39,6 @@ export type IsPositive<T, Then = true, Else = false> = Positive<T, Then, Else>
  * Check if `T` is not a positive numeric type.
  *
  * ```ts
- * import type { NonPositive } from 'type-plus'
- *
  * type R = NonPositive<-1> // -1
  *
  * type R = NonPositive<0> // never
@@ -57,8 +51,6 @@ export type NonPositive<T, Then = T, Else = never> = Positive<T, Else, Then>
  * Is `T` not a positive numeric type.
  *
  * ```ts
- * import type { IsNotPositive } from 'type-plus'
- *
  * type R = IsNotPositive<-1> // true
  *
  * type R = IsNotPositive<0> // false

package/ts/number/strict_number_type.ts

@@ -4,8 +4,6 @@ import type { IsAny } from '../any/any_type.js'
  * Check if the type `T` is exactly the type `number` and not numeric literals.
  *
  * ```ts
- * import type { StrictNumberType } from 'type-plus'
- *
  * type R = StrictNumberType<number> // true
  * type R = StrictNumberType<1> // false
  *
@@ -23,8 +21,6 @@ export type StrictNumberType<T, Then = T, Else = never> = IsAny<
  * Is the type `T` exactly the type `number` and not numeric literals.
  *
  * ```ts
- * import type { IsStrictNumber } from 'type-plus'
- *
  * type R = IsStrictNumber<number> // true
  * type R = IsStrictNumber<1> // false
  *
@@ -38,13 +34,11 @@ export type IsStrictNumber<T, Then = true, Else = false> = StrictNumberType<T, T
  * Check if the type `T` is not the type `number` or numeric literals.
  *
  * ```ts
- * import type { NotStictNumberType } from 'type-plus'
+ * type R = NotStrictNumberType<number> // false
+ * type R = NotStrictNumberType<1> // true
  *
- * type R = NotStictNumberType<number> // false
- * type R = NotStictNumberType<1> // true
- *
- * type R = NotStictNumberType<never> // true
- * type R = NotStictNumberType<unknown> // true
+ * type R = NotStrictNumberType<never> // true
+ * type R = NotStrictNumberType<unknown> // true
  * ```
  */
 export type NotStrictNumberType<T, Then = T, Else = never> = StrictNumberType<T, Else, Then>
@@ -53,8 +47,6 @@ export type NotStrictNumberType<T, Then = T, Else = never> = StrictNumberType<T,
  * Is the type `T` not the type `number` or numeric literals.
  *
  * ```ts
- * import type { IsNotStrictNumber } from 'type-plus'
- *
  * type R = IsNotStrictNumber<number> // false
  * type R = IsNotStrictNumber<1> // true
  *

package/ts/object/object_type.ts

@@ -1,11 +1,9 @@
-import { IsAnyOrNever } from '../any/any_or_never.js'
+import type { IsAnyOrNever } from '../any/any_or_never.js'
 
 /**
  * Check if `T` is an `object`.
  *
  * ```ts
- * import { type ObjectType } from 'type-plus'
- *
  * type R = ObjectType<{}> // {}
  * type R = ObjectType<{ a: 1 }> // { a: 1 }
  * type R = ObjectType<Function> // Function
@@ -21,8 +19,6 @@ export type ObjectType<T, Then = T, Else = never> = IsAnyOrNever<T, Else, [T] ex
  * Note that `Function` is also an `object`.
  *
  * ```ts
- * import { type IsObject } from 'type-plus'
- *
  * type R = IsObject<{}> // true
  * type R = IsObject<{ a: 1 }> // true
  * type R = IsObject<Function> // true
@@ -36,8 +32,6 @@ export type IsObject<T, Then = true, Else = false> = ObjectType<T, Then, Else>
  * Check if `T` is not an `object`.
  *
  * ```ts
- * import { type NotObjectType } from 'type-plus'
- *
  * type R = NotObjectType<{}> // never
  * type R = NotObjectType<{ a: 1 }> // never
  * type R = NotObjectType<Function> // never
@@ -53,8 +47,6 @@ export type NotObjectType<T, Then = T, Else = never> = ObjectType<T, Else, Then>
  * Note that `Function` is also an `object`.
  *
  * ```ts
- * import { type IsNotObject } from 'type-plus'
- *
  * type R = IsNotObject<{}> // false
  * type R = IsNotObject<{ a: 1 }> // false
  * type R = IsNotObject<Function> // false

package/ts/string/readme.md

@@ -36,6 +36,11 @@ type R = StrictStringType<1> // never
 - [`NotStrictStringType<T, Then = T, Else = never>`](strict_string_type.ts#L52): check if `T` is not exactly `string`.
 - [`IsNotStrictString<T, Then = true, Else = false>`](strict_string_type.ts#L69): is `T` not exactly `string`.
 
+## String Utilities
+
+- [`StringIncludes<Subject, Search, Then = true, Else = false>`](./string.ts): check if `Subject` includes `Search`.
+- [`StringSplit<Subject, Separater>`](./string.ts): split `Subject` by `Separater`.
+
 ## References
 
 - [Handbook]