type-plus 6.5.0 → 6.7.0

package/esm/undefined/undefined_type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"undefined_type.d.ts","sourceRoot":"","sources":["../../ts/undefined/undefined_type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAE/C;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,KAAK,CAC3D,CAAC,EACD,IAAI,EACJ;IAAC,CAAC;IAAE,SAAS;CAAC,SAAS,CAAC,SAAS,EAAE,CAAC,CAAC,GAAG,IAAI,GAAG,IAAI,CACnD,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAEpF;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAEtF;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA"}
+{"version":3,"file":"undefined_type.d.ts","sourceRoot":"","sources":["../../ts/undefined/undefined_type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAE/C;;;;;;;;;;GAUG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,KAAK,CAC3D,CAAC,EACD,IAAI,EACJ;IAAC,CAAC;IAAE,SAAS;CAAC,SAAS,CAAC,SAAS,EAAE,CAAC,CAAC,GAAG,IAAI,GAAG,IAAI,CACnD,CAAA;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAEpF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAEtF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA"}

package/esm/unknown/unknown_type.d.ts

@@ -2,9 +2,7 @@ import type { IsAny } from '../any/any_type.js';
 /**
  * Check if the type `T` is exactly `unknown`.
  *
- * ```
- * import type { UnknownType } from 'type-plus'
- *
+ * ```ts
  * type R = UnknownType<unknown> // unknown
  *
  * type R = UnknownType<number> // never
@@ -18,9 +16,7 @@ export type UnknownType<T, Then = T, Else = never> = IsAny<T, Else, [
 /**
  * Is the type `T` exactly `unknown`.
  *
- * ```
- * import type { IsUnknown } from 'type-plus'
- *
+ * ```ts
  * type R = IsUnknown<unknown> // true
  *
  * type R = IsUnknown<number> // false
@@ -31,9 +27,7 @@ export type IsUnknown<T, Then = true, Else = false> = UnknownType<T, Then, Else>
 /**
  * Check if the type `T` is not `unknown`.
  *
- * ```
- * import type { NotUnknownType } from 'type-plus'
- *
+ * ```ts
  * type R = NotUnknownType<unknown> // never
  *
  * type R = NotUnknownType<never> // never
@@ -45,9 +39,7 @@ export type NotUnknownType<T, Then = T, Else = never> = UnknownType<T, Else, The
 /**
  * Is the type `T` not exactly `unknown`.
  *
- * ```
- * import type { IsNotUnknown } from 'type-plus'
- *
+ * ```ts
  * type R = IsNotUnknown<unknown> // false
  *
  * type R = IsNotUnknown<never> // true

package/esm/unknown/unknown_type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unknown_type.d.ts","sourceRoot":"","sources":["../../ts/unknown/unknown_type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAE/C;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,KAAK,CACzD,CAAC,EACD,IAAI,EACJ;IAAC,CAAC;IAAE,OAAO;CAAC,SAAS,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,IAAI,GAAG,IAAI,CAC/C,CAAA;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAEhF;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAElF;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA"}
+{"version":3,"file":"unknown_type.d.ts","sourceRoot":"","sources":["../../ts/unknown/unknown_type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAE/C;;;;;;;;;GASG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,KAAK,CACzD,CAAC,EACD,IAAI,EACJ;IAAC,CAAC;IAAE,OAAO;CAAC,SAAS,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,IAAI,GAAG,IAAI,CAC/C,CAAA;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAEhF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAElF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA"}

package/esm/void/void_type.d.ts

@@ -4,8 +4,6 @@ import type { IsUndefined } from '../undefined/undefined_type.js';
  * Check if `T` is `void`.
  *
  * ```ts
- * import type { VoidType } from 'type-plus'
- *
  * type R = VoidType<void> // void
  *
  * type R = VoidType<1> // never
@@ -16,8 +14,6 @@ export type VoidType<T, Then = T, Else = never> = IsAnyOrNever<T, Else, IsUndefi
  * Check if `T` is not `void`.
  *
  * ```ts
- * import type { VoidType } from 'type-plus'
- *
  * type R = VoidType<void> // never
  *
  * type R = VoidType<1> // 1
@@ -28,8 +24,6 @@ export type NotVoidType<T, Then = T, Else = never> = VoidType<T, Else, Then>;
  * Is `T` `void`.
  *
  * ```ts
- * import type { IsVoid } from 'type-plus'
- *
  * type R = IsVoid<void> // true
  *
  * type R = IsVoid<1> // false
@@ -40,8 +34,6 @@ export type IsVoid<T, Then = true, Else = false> = VoidType<T, Then, Else>;
  * Is `T` not `void`.
  *
  * ```ts
- * import type { IsNotVoid } from 'type-plus'
- *
  * type R = IsNotVoid<void> // false
  *
  * type R = IsNotVoid<1> // true

package/esm/void/void_type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"void_type.d.ts","sourceRoot":"","sources":["../../ts/void/void_type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAA;AAEjE;;;;;;;;;;GAUG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,YAAY,CAC7D,CAAC,EACD,IAAI,EACJ,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC,CACtD,CAAA;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAE5E;;;;;;;;;;GAUG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAE1E;;;;;;;;;;GAUG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA"}
+{"version":3,"file":"void_type.d.ts","sourceRoot":"","sources":["../../ts/void/void_type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAA;AAEjE;;;;;;;;GAQG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,YAAY,CAC7D,CAAC,EACD,IAAI,EACJ,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC,CACtD,CAAA;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAE5E;;;;;;;;GAQG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAE1E;;;;;;;;GAQG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "type-plus",
-  "version": "6.5.0",
+  "version": "6.7.0",
   "description": "Provides additional types for TypeScript.",
   "homepage": "https://github.com/unional/type-plus",
   "bugs": {
@@ -62,7 +62,7 @@
     "ncp": "^2.0.0",
     "npm-run-all": "^4.1.5",
     "pinst": "^3.0.0",
-    "rimraf": "^3.0.2",
+    "rimraf": "^5.0.0",
     "satisfier": "^5.2.2",
     "size-limit": "^8.2.4",
     "ts-jest": "^29.1.0",
@@ -71,7 +71,7 @@
     "typedoc-plugin-extras": "^2.3.2",
     "typescript": "^5.0.2"
   },
-  "packageManager": "pnpm@8.2.0",
+  "packageManager": "pnpm@8.3.1",
   "scripts": {
     "build": "run-p build:cjs build:esm build:tslib",
     "build:cjs": "tsc -p tsconfig.cjs.json && ncp package.cjs.json cjs/package.json",

package/ts/any/any_or_never.ts

@@ -5,8 +5,6 @@ import type { IsAny } from './any_type.js'
  * Is `T` type `any` or `never`.
  *
  * ```ts
- * import type { IsAnyOrNever } from 'type-plus'
- *
  * type R = IsAnyOrNever<any> // true
  * type R = IsAnyOrNever<never> // true
  *

package/ts/any/any_type.ts

@@ -2,9 +2,7 @@
 /**
  * Check if the type `T` is exactly `any`.
  *
- * ```
- * import type { AnyType } from 'type-plus'
- *
+ * ```ts
  * type R = AnyType<any> // any
  *
  * type R = AnyType<never> // never
@@ -17,9 +15,7 @@ export type AnyType<T, Then = T, Else = never> = 0 extends 1 & T ? Then : Else
 /**
  * Is the type `T` exactly `any`.
  *
- * ```
- * import type { IsAny } from 'type-plus'
- *
+ * ```ts
  * type R = IsAny<any> // true
  *
  * type R = IsAny<never> // false

package/ts/array/array.ts

@@ -9,8 +9,6 @@ import type { IndexAt } from './array_index.js'
  * @see https://github.com/microsoft/TypeScript/issues/53345#issuecomment-1477138167
  *
  * ```ts
- * import type { At } from 'type-plus'
- *
  * type R = At<[1, 2, 3], 2> // 3
  * type R = At<[1, 2, 3], -1> // 3
  * ```
@@ -29,8 +27,6 @@ export type At<A extends unknown[], N extends number, Fail = never> = IndexAt<A,
  * @alias ArrayPlus.Concat
  *
  * ```ts
- * import type { Concat } form 'type-plus'
- *
  * type R = Concat<[1], [2, 3]> // [1, 2, 3]
  * ```
  */

package/ts/array/array_index.ts

@@ -11,14 +11,12 @@ import type { StrictNumberType } from '../number/strict_number_type.js'
 /**
  * Gets the normalized index to access the element of an array or tuple.
  *
- * ```
- * import type { ArrayPlus } from 'type-plus'
- *
- * type R = ArrayPlus.IndexAt<['a', 'b', 'c'], 2> // 2
- * type R = ArrayPlus.IndexAt<['a', 'b', 'c'], -2> // 1
+ * ```ts
+ * type R = IndexAt<['a', 'b', 'c'], 2> // 2
+ * type R = IndexAt<['a', 'b', 'c'], -2> // 1
  *
- * type R = ArrayPlus.IndexAt<['a', 'b', 'c'], 3> // never
- * type R = ArrayPlus.IndexAt<['a', 'b', 'c'], -4> // never
+ * type R = IndexAt<['a', 'b', 'c'], 3> // never
+ * type R = IndexAt<['a', 'b', 'c'], -4> // never
  * ```
  */
 export type IndexAt<A extends Array<unknown>, N extends number, Fail = never> = Equal<
@@ -54,14 +52,13 @@ export type IndexAt<A extends Array<unknown>, N extends number, Fail = never> =
 /**
  * Is N an out of bound index of A.
  *
- * ```
- * import { IsIndexOutOfBound } from 'type-plus'
- *
+ * ```ts
  * type R = IsIndexOutOfBound<[1], 0> // false
  * type R = IsIndexOutOfBound<[1], -1> // false
 
  * type R = IsIndexOutOfBound<[1], 1> // true
  * type R = IsIndexOutOfBound<[1], -2> // true
+ * ```
  */
 export type IsIndexOutOfBound<A extends unknown[], N extends number, Then = true, Else = false> = IsNever<
 	IndexAt<A, N>,

package/ts/array/array_type.ts

@@ -5,8 +5,6 @@ import type { StrictNumberType } from '../number/strict_number_type.js'
  * Check if the type `T` is an array and not a tuple.
  *
  * ```ts
- * import type { ArrayType } from 'type-plus'
- *
  * type R = ArrayType<number[]> // number[]
  *
  * type R = ArrayType<[1]> // never
@@ -22,8 +20,6 @@ export type ArrayType<T, Then = T, Else = never> = IsNever<
  * Check if the type `T` is not an array.
  *
  * ```ts
- * import type { NotArrayType } from 'type-plus'
- *
  * type R = NotArrayType<number[]> // never
  *
  * type R = NotArrayType<number> // number
@@ -36,8 +32,6 @@ export type NotArrayType<T, Then = T, Else = never> = ArrayType<T, Else, Then>
  * Is `T` an array?
  *
  * ```ts
- * import type { IsArray } from 'type-plus'
- *
  * type R = IsArray<number[]> // true
  *
  * type R = IsArray<number> // false
@@ -50,8 +44,6 @@ export type IsArray<T, Then = true, Else = false> = ArrayType<T, Then, Else>
  * Is `T` not an array?
  *
  * ```ts
- * import type { IsNotArray } from 'type-plus'
- *
  * type R = IsNotArray<number[]> // false
  *
  * type R = IsNotArray<number> // true

package/ts/bigint/bigint_type.ts

@@ -3,9 +3,7 @@ import type { IsAnyOrNever } from '../any/any_or_never.js'
 /**
  * Check if the type `T` is exactly `bigint`.
  *
- * ```
- * import type { BigintType } from 'type-plus'
- *
+ * ```ts
  * type R = BigintType<bigint> // bigint
  *
  * type R = BigintType<1n> // never
@@ -19,9 +17,7 @@ export type BigintType<T, Then = T, Else = never> = IsAnyOrNever<T, Else, [T] ex
 /**
  * Is the type `T` exactly `bigint`.
  *
- * ```
- * import type { IsBigint } from 'type-plus'
- *
+ * ```ts
  * type R = IsBigint<bigint> // true
  *
  * type R = IsBigint<1n> // false
@@ -35,9 +31,7 @@ export type IsBigint<T, Then = true, Else = false> = BigintType<T, Then, Else>
 /**
  * Check if the type `T` is not exactly `null`.
  *
- * ```
- * import type { NotBigintType } from 'type-plus'
- *
+ * ```ts
  * type R = NotBigintType<bigint> // never
  *
  * type R = NotBigintType<1n> // 1n
@@ -51,9 +45,7 @@ export type NotBigintType<T, Then = T, Else = never> = BigintType<T, Else, Then>
 /**
  * Is the type `T` not exactly `null`.
  *
- * ```
- * import type { IsNotBigint } from 'type-plus'
- *
+ * ```ts
  * type R = IsNotBigint<bigint> // false
  *
  * type R = IsNotBigint<1n> // true

package/ts/bigint/strict_bigint_type.ts

@@ -3,9 +3,7 @@ import type { IsAnyOrNever } from '../any/any_or_never.js'
 /**
  * Check if the type `T` is exactly `bigint`.
  *
- * ```
- * import type { StrictBigintType } from 'type-plus'
- *
+ * ```ts
  * type R = StrictBigintType<bigint> // bigint
  *
  * type R = StrictBigintType<1n> // never
@@ -23,9 +21,7 @@ export type StrictBigintType<T, Then = T, Else = never> = IsAnyOrNever<
 /**
  * Is the type `T` exactly `bigint`.
  *
- * ```
- * import type { IsStrictBigint } from 'type-plus'
- *
+ * ```ts
  * type R = IsStrictBigint<bigint> // true
  *
  * type R = IsStrictBigint<1n> // false
@@ -39,9 +35,7 @@ export type IsStrictBigint<T, Then = true, Else = false> = StrictBigintType<T, T
 /**
  * Check if the type `T` is not exactly `bigint`.
  *
- * ```
- * import type { NotStrictBigintType } from 'type-plus'
- *
+ * ```ts
  * type R = NotStrictBigintType<bigint> // never
  *
  * type R = NotStrictBigintType<1n> // 1n
@@ -55,9 +49,7 @@ export type NotStrictBigintType<T, Then = T, Else = never> = StrictBigintType<T,
 /**
  * Is the type `T` not exactly `bigint`.
  *
- * ```
- * import type { IsNotStrictBigint } from 'type-plus'
- *
+ * ```ts
  * type R = IsNotStrictBigint<bigint> // false
  *
  * type R = IsNotStrictBigint<1n> // true

package/ts/boolean/boolean_type.ts

@@ -4,8 +4,6 @@ import type { IsAnyOrNever } from '../any/any_or_never.js'
  * Check if the type `T` is `boolean`, including `true` and `false`.
  *
  * ```ts
- * import type { BooleanType } from 'type-plus'
- *
  * type R = BooleanType<boolean> // boolean
  * type R = BooleanType<true> // true
  * type R = BooleanType<false> // false
@@ -24,8 +22,6 @@ export type BooleanType<T, Then = T, Else = never> = IsAnyOrNever<
  * Check if the type `T` is not `boolean`, including `true` and `false`.
  *
  * ```ts
- * import type { NotBooleanType } from 'type-plus'
- *
  * type R = NotBooleanType<boolean> // never
  * type R = NotBooleanType<true> // never
  * type R = NotBooleanType<false> // never
@@ -40,8 +36,6 @@ export type NotBooleanType<T, Then = T, Else = never> = BooleanType<T, Else, The
  * Is the type `T` `boolean`, including `true` and `false`.
  *
  * ```ts
- * import type { IsBoolean } from 'type-plus'
- *
  * type R = IsBoolean<boolean> // true
  * type R = IsBoolean<true> // true
  * type R = IsBoolean<false> // true
@@ -56,8 +50,6 @@ export type IsBoolean<T, Then = true, Else = false> = BooleanType<T, Then, Else>
  * Is the type `T` not `boolean`, including `true` and `false`.
  *
  * ```ts
- * import type { IsNotBoolean } from 'type-plus'
- *
  * type R = IsNotBoolean<boolean> // false
  * type R = IsNotBoolean<true> // false
  * type R = IsNotBoolean<false> // false

package/ts/boolean/false_type.ts

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

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,12 +81,15 @@ 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 { NoInfer } from './type/no_infer.js'
 export type {
 	IsNotUndefined,
 	IsUndefined,

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