From de546a296f4d8ccee6a6f86a8a1f99e9d0c8a625 Mon Sep 17 00:00:00 2001
From: unional <homawong@gmail.com>
Date: Sun, 24 Sep 2023 21:24:21 -0700
Subject: [PATCH] feat: udpate IsBigint IsNotBigint

---
 type-plus/ts/bigint/bigint_type.spec.ts     |  57 ---------
 type-plus/ts/bigint/bigint_type.ts          |  21 ----
 type-plus/ts/bigint/is_bigint.spec.ts       |  42 +++++--
 type-plus/ts/bigint/is_bigint.ts            |  72 +++++++++--
 type-plus/ts/bigint/is_not_bigint.spec.ts   |  40 +++++--
 type-plus/ts/bigint/is_not_bigint.ts        |  68 ++++++++++-
 type-plus/ts/bigint/not_bigint_type.spec.ts |  55 ---------
 type-plus/ts/bigint/not_bigint_type.ts      |  15 ---
 type-plus/ts/bigint/readme.md               | 126 ++++++++++++++++++--
 type-plus/ts/index.ts                       |   2 -
 type-plus/ts/math/abs.ts                    |   5 +-
 type-plus/ts/mix_types/box.ts               |   2 +-
 type-plus/ts/undefined/is_not_undefined.ts  |   1 +
 13 files changed, 308 insertions(+), 198 deletions(-)
 delete mode 100644 type-plus/ts/bigint/bigint_type.spec.ts
 delete mode 100644 type-plus/ts/bigint/bigint_type.ts
 delete mode 100644 type-plus/ts/bigint/not_bigint_type.spec.ts
 delete mode 100644 type-plus/ts/bigint/not_bigint_type.ts

diff --git a/type-plus/ts/bigint/bigint_type.spec.ts b/type-plus/ts/bigint/bigint_type.spec.ts
deleted file mode 100644
index 97fde0d5a0..0000000000
--- a/type-plus/ts/bigint/bigint_type.spec.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-import { it } from '@jest/globals'
-import { testType, type BigintType } from '../index.js'
-
-it('returns T if T is bigint', () => {
-	testType.equal<BigintType<bigint>, bigint>(true)
-})
-
-it('returns T if T is bigint literals', () => {
-	testType.equal<BigintType<0n>, 0n>(true)
-	testType.equal<BigintType<1n>, 1n>(true)
-	testType.equal<BigintType<-1n>, -1n>(true)
-	testType.equal<BigintType<11111111111111111111111111111111n>, 11111111111111111111111111111111n>(true)
-})
-
-it('returns never for special types', () => {
-	testType.never<BigintType<any>>(true)
-	testType.never<BigintType<unknown>>(true)
-	testType.never<BigintType<void>>(true)
-	testType.never<BigintType<never>>(true)
-})
-
-it('returns never for other types', () => {
-	testType.never<BigintType<undefined>>(true)
-	testType.never<BigintType<null>>(true)
-	testType.never<BigintType<boolean>>(true)
-	testType.never<BigintType<true>>(true)
-	testType.never<BigintType<false>>(true)
-	testType.never<BigintType<number>>(true)
-	testType.never<BigintType<1>>(true)
-	testType.never<BigintType<string>>(true)
-	testType.never<BigintType<''>>(true)
-	testType.never<BigintType<symbol>>(true)
-	testType.never<BigintType<{}>>(true)
-	testType.never<BigintType<string[]>>(true)
-	testType.never<BigintType<[]>>(true)
-	testType.never<BigintType<Function>>(true)
-	testType.never<BigintType<() => void>>(true)
-})
-
-it('returns never for union type', () => {
-	testType.never<BigintType<bigint | 1>>(true)
-	testType.never<BigintType<bigint | 'a'>>(true)
-})
-
-it('returns T for intersection type', () => {
-	testType.equal<BigintType<bigint & { a: 1 }>, bigint & { a: 1 }>(true)
-})
-
-it('can override Then/Else', () => {
-	testType.equal<BigintType<bigint, 1, 2>, 1>(true)
-	testType.equal<BigintType<1n, 1, 2>, 1>(true)
-
-	testType.equal<BigintType<any, 1, 2>, 2>(true)
-	testType.equal<BigintType<unknown, 1, 2>, 2>(true)
-	testType.equal<BigintType<never, 1, 2>, 2>(true)
-	testType.equal<BigintType<void, 1, 2>, 2>(true)
-})
diff --git a/type-plus/ts/bigint/bigint_type.ts b/type-plus/ts/bigint/bigint_type.ts
deleted file mode 100644
index 6ac54de0ee..0000000000
--- a/type-plus/ts/bigint/bigint_type.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-import type { IsAnyOrNever } from '../mix_types/is_any_or_never.js'
-import type { $Else, $SelectionBranch, $Then } from '../type_plus/branch/selection.js'
-
-/**
- * Check if the type `T` is exactly `bigint`.
- *
- * ```ts
- * type R = BigintType<bigint> // bigint
- *
- * type R = BigintType<1n> // never
- * type R = BigintType<number> // never
- * type R = BigintType<bigint | boolean> // never
- * type R = BigintType<unknown> // never
- * ```
- */
-export type BigintType<T, Then = T, Else = never> = IsAnyOrNever<
-T,
-$SelectionBranch> extends infer R
-? R extends $Then ? Else
-: R extends $Else ? [T] extends [bigint] ? Then : Else
-: never : never
diff --git a/type-plus/ts/bigint/is_bigint.spec.ts b/type-plus/ts/bigint/is_bigint.spec.ts
index 1d8ed573ff..0496fab0ab 100644
--- a/type-plus/ts/bigint/is_bigint.spec.ts
+++ b/type-plus/ts/bigint/is_bigint.spec.ts
@@ -1,5 +1,5 @@
 import { it } from '@jest/globals'
-import { testType, type IsBigint } from '../index.js'
+import { testType, type IsBigint, type $Then, type $Else } from '../index.js'
 
 it('returns true for bigint', () => {
 	testType.true<IsBigint<bigint>>(true)
@@ -35,20 +35,42 @@ it('returns false for other types', () => {
 	testType.false<IsBigint<() => void>>(true)
 })
 
-it('returns false for union type', () => {
-	testType.false<IsBigint<bigint | 1>>(true)
+it('distributes for union type', () => {
+	testType.equal<IsBigint<bigint | 1>, boolean>(true)
+	testType.equal<IsBigint<1n | 1>, boolean>(true)
 })
 
 it('returns true for interaction type', () => {
 	testType.true<IsBigint<bigint & { a: 1 }>>(true)
+	testType.true<IsBigint<1n & { a: 1 }>>(true)
 })
 
-it('can override Then/Else', () => {
-	testType.equal<IsBigint<bigint, 1, 2>, 1>(true)
-	testType.equal<IsBigint<0n, 1, 2>, 1>(true)
+it('works as filter', () => {
+	testType.equal<IsBigint<1n, { selection: 'filter' }>, 1n>(true)
 
-	testType.equal<IsBigint<any, 1, 2>, 2>(true)
-	testType.equal<IsBigint<unknown, 1, 2>, 2>(true)
-	testType.equal<IsBigint<never, 1, 2>, 2>(true)
-	testType.equal<IsBigint<void, 1, 2>, 2>(true)
+	testType.equal<IsBigint<never, { selection: 'filter' }>, never>(true)
+	testType.equal<IsBigint<unknown, { selection: 'filter' }>, never>(true)
+	testType.equal<IsBigint<string | boolean, { selection: 'filter' }>, never>(true)
+
+	testType.equal<IsBigint<string | 1n, { selection: 'filter' }>, 1n>(true)
+
+	testType.equal<IsBigint<string | boolean, { selection: 'filter-unknown' }>, unknown>(true)
+	testType.equal<IsBigint<string | 1n, { selection: 'filter-unknown' }>, unknown>(true)
+})
+
+it('can disable union distribution', () => {
+	testType.equal<IsBigint<1n | 1>, boolean>(true)
+	testType.equal<IsBigint<1n | 1, { distributive: false }>, false>(true)
+})
+
+it('works with unique branches', () => {
+	testType.equal<IsBigint<bigint, IsBigint.$Branch>, $Then>(true)
+	testType.equal<IsBigint<1n, IsBigint.$Branch>, $Then>(true)
+
+	testType.equal<IsBigint<any, IsBigint.$Branch>, $Else>(true)
+	testType.equal<IsBigint<unknown, IsBigint.$Branch>, $Else>(true)
+	testType.equal<IsBigint<never, IsBigint.$Branch>, $Else>(true)
+	testType.equal<IsBigint<void, IsBigint.$Branch>, $Else>(true)
+
+	testType.equal<IsBigint<1n | 1, IsBigint.$Branch>, $Then | $Else>(true)
 })
diff --git a/type-plus/ts/bigint/is_bigint.ts b/type-plus/ts/bigint/is_bigint.ts
index 31477c5499..7a7fa2c6d3 100644
--- a/type-plus/ts/bigint/is_bigint.ts
+++ b/type-plus/ts/bigint/is_bigint.ts
@@ -1,15 +1,71 @@
-import type { BigintType } from './bigint_type.js'
+import type { SelectWithDistribute } from '../type_plus/branch/select_with_distribute.js'
 
 /**
- * Is the type `T` exactly `bigint`.
+ * 🎭 *predicate*
  *
+ * Validate if `T` is `bigint` or `bigint` literals.
+ *
+ * @example
  * ```ts
- * type R = IsBigint<bigint> // true
+ * type R = isBigint<bigint> // true
+ * type R = isBigint<1n> // true
+ *
+ * type R = isBigint<never> // false
+ * type R = isBigint<unknown> // false
+ * type R = isBigint<string | boolean> // false
  *
- * type R = IsBigint<1n> // false
- * type R = IsBigint<number> // false
- * type R = IsBigint<bigint | boolean> // false
- * type R = IsBigint<unknown> // false
+ * type R = isBigint<string | bigint> // boolean
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Filter to ensure `T` is `bigint` or `bigint` literals, otherwise returns `never`.
+ *
+ * @example
+ * ```ts
+ * type R = isBigint<bigint, { selection: 'filter' }> // bigint
+ * type R = isBigint<1n, { selection: 'filter' }> // bigint
+ *
+ * type R = isBigint<never, { selection: 'filter' }> // never
+ * type R = isBigint<unknown, { selection: 'filter' }> // never
+ * type R = isBigint<string | boolean, { selection: 'filter' }> // never
+ *
+ * type R = isBigint<string | bigint> // bigint
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Filter to ensure `T` is `bigint` or `bigint` literals, otherwise returns `unknown`.
+ *
+ * @example
+ * ```ts
+ * type R = isBigint<string | boolean, { selection: 'filter-unknown' }> // unknown
+ * type R = isBigint<string | bigint, { selection: 'filter-unknown' }> // unknown
+ * ```
+ *
+ * 🔢 *customize*:
+ *
+ * Disable distribution of union types.
+ *
+ * ```ts
+ * type R = isBigint<bigint | 1> // boolean
+ * type R = isBigint<bigint | 1, { distributive: false }> // false
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Use unique branch identifiers to allow precise processing of the result.
+ *
+ * @example
+ * ```ts
+ * type R = isBigint<bigint, $SelectionBranch> // $Then
+ * type R = isBigint<string, $SelectionBranch> // $Else
  * ```
  */
-export type IsBigint<T, Then = true, Else = false> = BigintType<T, Then, Else>
+export type IsBigint<T, $O extends IsBigint.$Options = {}> = SelectWithDistribute<T, bigint, $O>
+
+export namespace IsBigint {
+	export type $Options = SelectWithDistribute.$Options
+	export type $Default = SelectWithDistribute.$Default
+	export type $Branch = SelectWithDistribute.$Branch
+}
diff --git a/type-plus/ts/bigint/is_not_bigint.spec.ts b/type-plus/ts/bigint/is_not_bigint.spec.ts
index 05bb631198..3daf87fa8e 100644
--- a/type-plus/ts/bigint/is_not_bigint.spec.ts
+++ b/type-plus/ts/bigint/is_not_bigint.spec.ts
@@ -1,5 +1,5 @@
 import { it } from '@jest/globals'
-import { testType, type IsNotBigint } from '../index.js'
+import { testType, type $Else, type $Then, type IsNotBigint } from '../index.js'
 
 it('returns false for bigint', () => {
 	testType.false<IsNotBigint<bigint>>(true)
@@ -35,20 +35,40 @@ it('returns true for other types', () => {
 	testType.true<IsNotBigint<() => void>>(true)
 })
 
-it('returns true for union type', () => {
-	testType.true<IsNotBigint<bigint | 1>>(true)
+it('distributes over union type', () => {
+	testType.equal<IsNotBigint<bigint | 1>, boolean>(true)
+})
+
+it('can disable union distribution', () => {
+	testType.equal<IsNotBigint<1n | 1>, boolean>(true)
+	testType.equal<IsNotBigint<1n | 1, { distributive: false }>, true>(true)
 })
 
 it('returns false for interaction type', () => {
 	testType.false<IsNotBigint<bigint & { a: 1 }>>(true)
 })
 
-it('can override Then/Else', () => {
-	testType.equal<IsNotBigint<bigint, 1, 2>, 2>(true)
-	testType.equal<IsNotBigint<0n, 1, 2>, 2>(true)
+it('works as filter', () => {
+	testType.equal<IsNotBigint<1n, { selection: 'filter' }>, never>(true)
+
+	testType.equal<IsNotBigint<never, { selection: 'filter' }>, never>(true)
+	testType.equal<IsNotBigint<unknown, { selection: 'filter' }>, unknown>(true)
+	testType.equal<IsNotBigint<string | boolean, { selection: 'filter' }>, string | boolean>(true)
+
+	testType.equal<IsNotBigint<string | 1n, { selection: 'filter' }>, string>(true)
+
+	testType.equal<IsNotBigint<string | boolean, { selection: 'filter-unknown' }>, string | boolean>(true)
+	testType.equal<IsNotBigint<string | 1n, { selection: 'filter-unknown' }>, unknown>(true)
+})
+
+it('works with unique branches', () => {
+	testType.equal<IsNotBigint<bigint, IsNotBigint.$Branch>, $Else>(true)
+	testType.equal<IsNotBigint<1n, IsNotBigint.$Branch>, $Else>(true)
+
+	testType.equal<IsNotBigint<any, IsNotBigint.$Branch>, $Then>(true)
+	testType.equal<IsNotBigint<unknown, IsNotBigint.$Branch>, $Then>(true)
+	testType.equal<IsNotBigint<never, IsNotBigint.$Branch>, $Then>(true)
+	testType.equal<IsNotBigint<void, IsNotBigint.$Branch>, $Then>(true)
 
-	testType.equal<IsNotBigint<any, 1, 2>, 1>(true)
-	testType.equal<IsNotBigint<unknown, 1, 2>, 1>(true)
-	testType.equal<IsNotBigint<never, 1, 2>, 1>(true)
-	testType.equal<IsNotBigint<void, 1, 2>, 1>(true)
+	testType.equal<IsNotBigint<1n | 1, IsNotBigint.$Branch>, $Then | $Else>(true)
 })
diff --git a/type-plus/ts/bigint/is_not_bigint.ts b/type-plus/ts/bigint/is_not_bigint.ts
index d4bf803d84..900d3b73d5 100644
--- a/type-plus/ts/bigint/is_not_bigint.ts
+++ b/type-plus/ts/bigint/is_not_bigint.ts
@@ -1,15 +1,71 @@
-import type { BigintType } from './bigint_type.js'
+import type { SelectInvertWithDistribute } from '../type_plus/branch/select_invert_with_distribute.js'
 
 /**
- * Is the type `T` not exactly `null`.
+ * 🎭 *predicate*
  *
+ * Validate if `T` is not `bigint` nor `bigint` literals.
+ *
+ * @example
  * ```ts
  * type R = IsNotBigint<bigint> // false
+ * type R = IsNotBigint<1n> // false
  *
- * type R = IsNotBigint<1n> // true
- * type R = IsNotBigint<number> // true
- * type R = IsNotBigint<bigint | boolean> // true
+ * type R = IsNotBigint<never> // true
  * type R = IsNotBigint<unknown> // true
+ * type R = IsNotBigint<string | boolean> // true
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Filter to ensure `T` is not `bigint` nor `bigint` literals, otherwise returns `never`.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotBigint<bigint, { selection: 'filter' }> // never
+ * type R = IsNotBigint<1n, { selection: 'filter' }> // never
+ *
+ * type R = IsNotBigint<never, { selection: 'filter' }> // never
+ * type R = IsNotBigint<unknown, { selection: 'filter' }> // unknown
+ * type R = IsNotBigint<string | boolean, { selection: 'filter' }> // string | boolean
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Filter to ensure `T` is not `bigint` nor `bigint` literals, otherwise returns `unknown`.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotBigint<bigint, { selection: 'filter-unknown' }> // unknown
+ * type R = IsNotBigint<1n, { selection: 'filter-unknown' }> // unknown
+ *
+ * type R = IsNotBigint<string | boolean, { selection: 'filter-unknown' }> // string | boolean
+ * type R = IsNotBigint<string | bigint, { selection: 'filter-unknown' }> // unknown
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Disable distribution of union types.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotBigint<bigint | 1> // boolean
+ * type R = IsNotBigint<bigint | 1, { distributive: false }> // true
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Use unique branch identifiers to allow precise processing of the result.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotBigint<string, $SelectionBranch> // $Then
+ * type R = IsNotBigint<bigint, $SelectionBranch> // $Else
  * ```
  */
-export type IsNotBigint<T, Then = true, Else = false> = BigintType<T, Else, Then>
+export type IsNotBigint<T, $O extends IsNotBigint.$Options = {}> = SelectInvertWithDistribute<T, bigint, $O>
+
+export namespace IsNotBigint {
+	export type $Options = SelectInvertWithDistribute.$Options
+	export type $Default = SelectInvertWithDistribute.$Default
+	export type $Branch = SelectInvertWithDistribute.$Branch
+}
diff --git a/type-plus/ts/bigint/not_bigint_type.spec.ts b/type-plus/ts/bigint/not_bigint_type.spec.ts
deleted file mode 100644
index f3f0332b90..0000000000
--- a/type-plus/ts/bigint/not_bigint_type.spec.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-import { it } from '@jest/globals'
-import { testType, type NotBigintType } from '../index.js'
-
-it('returns never if T is bigint', () => {
-	testType.never<NotBigintType<bigint>>(true)
-})
-
-it('returns never if T is bigint literals', () => {
-	testType.equal<NotBigintType<0n>, never>(true)
-	testType.equal<NotBigintType<11111111111111111111111111111111n>, never>(true)
-})
-
-it('returns T for special types', () => {
-	testType.equal<NotBigintType<any>, any>(true)
-	testType.equal<NotBigintType<unknown>, unknown>(true)
-	testType.equal<NotBigintType<void>, void>(true)
-	testType.equal<NotBigintType<never>, never>(true)
-})
-
-it('returns T for other types', () => {
-	testType.equal<NotBigintType<undefined>, undefined>(true)
-	testType.equal<NotBigintType<null>, null>(true)
-	testType.equal<NotBigintType<boolean>, boolean>(true)
-	testType.equal<NotBigintType<true>, true>(true)
-	testType.equal<NotBigintType<false>, false>(true)
-	testType.equal<NotBigintType<number>, number>(true)
-	testType.equal<NotBigintType<1>, 1>(true)
-	testType.equal<NotBigintType<string>, string>(true)
-	testType.equal<NotBigintType<''>, ''>(true)
-	testType.equal<NotBigintType<symbol>, symbol>(true)
-	testType.equal<NotBigintType<{}>, {}>(true)
-	testType.equal<NotBigintType<string[]>, string[]>(true)
-	testType.equal<NotBigintType<[]>, []>(true)
-	testType.equal<NotBigintType<Function>, Function>(true)
-	testType.equal<NotBigintType<() => void>, () => void>(true)
-})
-
-it('returns T for union type', () => {
-	testType.equal<NotBigintType<bigint | 1>, bigint | 1>(true)
-	testType.equal<NotBigintType<bigint | 'a'>, bigint | 'a'>(true)
-})
-
-it('returns never for intersection type', () => {
-	testType.equal<NotBigintType<bigint & { a: 1 }>, never>(true)
-})
-
-it('can override Then/Else', () => {
-	testType.equal<NotBigintType<bigint, 1, 2>, 2>(true)
-	testType.equal<NotBigintType<0n, 1, 2>, 2>(true)
-
-	testType.equal<NotBigintType<any, 1, 2>, 1>(true)
-	testType.equal<NotBigintType<unknown, 1, 2>, 1>(true)
-	testType.equal<NotBigintType<never, 1, 2>, 1>(true)
-	testType.equal<NotBigintType<void, 1, 2>, 1>(true)
-})
diff --git a/type-plus/ts/bigint/not_bigint_type.ts b/type-plus/ts/bigint/not_bigint_type.ts
deleted file mode 100644
index 04ee98c146..0000000000
--- a/type-plus/ts/bigint/not_bigint_type.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import type { BigintType } from './bigint_type.js'
-
-/**
- * Check if the type `T` is not exactly `null`.
- *
- * ```ts
- * type R = NotBigintType<bigint> // never
- *
- * type R = NotBigintType<1n> // 1n
- * type R = NotBigintType<number> // number
- * type R = NotBigintType<bigint | boolean> // string | boolean
- * type R = NotBigintType<unknown> // unknown
- * ```
- */
-export type NotBigintType<T, Then = T, Else = never> = BigintType<T, Else, Then>
diff --git a/type-plus/ts/bigint/readme.md b/type-plus/ts/bigint/readme.md
index cfa23ee44a..7e2abf9d90 100644
--- a/type-plus/ts/bigint/readme.md
+++ b/type-plus/ts/bigint/readme.md
@@ -2,26 +2,128 @@
 
 `bigint` is a type to represent integers that are too large to be represented by a `number`.
 
-## Type Checking
+## [IsBigint](./is_bigint.ts)
+
+`IsBigint<T, { distributive: true, selection: 'predicate' | 'filter' | 'filter-unknown', $then: true, $else: false }>`
+
+🎭 *predicate*
+
+Validate if `T` is `bigint` or `bigint` literals.
+
+```ts
+type R = isBigint<bigint> // true
+type R = isBigint<1n> // true
+
+type R = isBigint<never> // false
+type R = isBigint<unknown> // false
+type R = isBigint<string | boolean> // false
+
+type R = isBigint<string | bigint> // boolean
+```
+
+🔢 *customize*
+
+Filter to ensure `T` is `bigint` or `bigint` literals, otherwise returns `never`.
+
+```ts
+type R = isBigint<bigint, { selection: 'filter' }> // bigint
+type R = isBigint<1n, { selection: 'filter' }> // bigint
+
+type R = isBigint<never, { selection: 'filter' }> // never
+type R = isBigint<unknown, { selection: 'filter' }> // never
+type R = isBigint<string | boolean, { selection: 'filter' }> // never
 
-The `BigintType<T>` and friends are used to check if a type is `bigint` or not.
+type R = isBigint<string | bigint> // bigint
+```
+
+🔢 *customize*
+
+Filter to ensure `T` is `bigint` or `bigint` literals, otherwise returns `unknown`.
+
+```ts
+type R = isBigint<string | boolean, { selection: 'filter-unknown' }> // unknown
+type R = isBigint<string | bigint, { selection: 'filter-unknown' }> // unknown
+```
+
+🔢 *customize*:
 
-They are loose type checks, meaning they match `bigint` and bigint literals,
-as well as intersection types.
+Disable distribution of union types.
 
 ```ts
-import type { BigintType } from 'type-plus'
+type R = isBigint<bigint | 1> // boolean
+type R = isBigint<bigint | 1, { distributive: false }> // false
+```
+
+🔢 *customize*
 
-type R = BigintType<bigint> // bigint
+Use unique branch identifiers to allow precise processing of the result.
 
-type R = BigintType<1n> // bigint
-type R = BigintType<bigint & { a: 1}> // bigint
+```ts
+type R = isBigint<bigint, $SelectionBranch> // $Then
+type R = isBigint<string, $SelectionBranch> // $Else
 ```
 
-- [`BigintType<T, Then = T, Else = never>`](bigint_type.ts#L15): check if `T` is `bigint` or bigint literal.
-- [`IsBigint<T, Then = true, Else = false`](bigint_type.ts#L33): is `T` `bigint`.
-- [`NotBigintType<T, Then = T, Else = never>`](bigint_type.ts#L47): check if `T` is not `bigint`.
-- [`IsNotBigInt<T, Then = true, Else = false>`](bigint_type.ts#L61): is `T` not `bigint`.
+## [IsNotBigint](./is_not_bigint.ts)
+
+`IsNotBigint<T, { distributive: true, selection: 'predicate' | 'filter' | 'filter-unknown', $then: false, $else: true }>`
+
+🎭 *predicate*
+
+Validate if `T` is not `bigint` nor `bigint` literals.
+
+```ts
+type R = IsNotBigint<bigint> // false
+type R = IsNotBigint<1n> // false
+
+type R = IsNotBigint<never> // true
+type R = IsNotBigint<unknown> // true
+type R = IsNotBigint<string | boolean> // true
+```
+
+🔢 *customize*
+
+Filter to ensure `T` is not `bigint` nor `bigint` literals, otherwise returns `never`.
+
+```ts
+type R = IsNotBigint<bigint, { selection: 'filter' }> // never
+type R = IsNotBigint<1n, { selection: 'filter' }> // never
+
+type R = IsNotBigint<never, { selection: 'filter' }> // never
+type R = IsNotBigint<unknown, { selection: 'filter' }> // unknown
+type R = IsNotBigint<string | boolean, { selection: 'filter' }> // string | boolean
+```
+
+🔢 *customize*
+
+Filter to ensure `T` is not `bigint` nor `bigint` literals, otherwise returns `unknown`.
+
+```ts
+type R = IsNotBigint<bigint, { selection: 'filter-unknown' }> // unknown
+type R = IsNotBigint<1n, { selection: 'filter-unknown' }> // unknown
+
+type R = IsNotBigint<string | boolean, { selection: 'filter-unknown' }> // string | boolean
+type R = IsNotBigint<string | bigint, { selection: 'filter-unknown' }> // unknown
+```
+
+🔢 *customize*
+
+Disable distribution of union types.
+
+```ts
+type R = IsNotBigint<bigint | 1> // boolean
+type R = IsNotBigint<bigint | 1, { distributive: false }> // true
+```
+
+🔢 *customize*
+
+Use unique branch identifiers to allow precise processing of the result.
+
+```ts
+type R = IsNotBigint<string, $SelectionBranch> // $Then
+type R = IsNotBigint<bigint, $SelectionBranch> // $Else
+```
+
+## Type Checking
 
 ---
 
diff --git a/type-plus/ts/index.ts b/type-plus/ts/index.ts
index 84e98c4d6d..2e03361b58 100644
--- a/type-plus/ts/index.ts
+++ b/type-plus/ts/index.ts
@@ -21,11 +21,9 @@ export type { IsNotStrictArray, IsStrictArray, NotStrictArrayType, StrictArrayTy
 export type { PropUnion, UnionOfProps } from './array/union_of_props.js'
 export type { UnionOfValues } from './array/union_of_values.js'
 export { assertType } from './assertion/assert_type.js'
-export type * from './bigint/bigint_type.js'
 export type { StringToBigint } from './bigint/cast.js'
 export type * from './bigint/is_bigint.js'
 export type * from './bigint/is_not_bigint.js'
-export type * from './bigint/not_bigint_type.js'
 export type {
 	IsNotStrictBigint,
 	IsStrictBigint,
diff --git a/type-plus/ts/math/abs.ts b/type-plus/ts/math/abs.ts
index 6f059eedb3..9302da5905 100644
--- a/type-plus/ts/math/abs.ts
+++ b/type-plus/ts/math/abs.ts
@@ -14,5 +14,8 @@ import type { IsNumber } from '../number/number_type.js'
 export type Abs<N extends number | bigint, Fail = never> = IsNumber<
 	N,
 	[number] extends [N] ? Fail : `${N}` extends `-${infer P extends number}` ? P : N,
-	IsBigint<N, [bigint] extends [N] ? Fail : `${N}` extends `-${infer P extends bigint}` ? P : N, Fail>
+	IsBigint<N> extends infer R
+	? R extends true ? [bigint] extends [N] ? Fail : `${N}` extends `-${infer P extends bigint}` ? P : N
+	: Fail
+	: never
 >
diff --git a/type-plus/ts/mix_types/box.ts b/type-plus/ts/mix_types/box.ts
index 1ac3e745aa..7d67b0d043 100644
--- a/type-plus/ts/mix_types/box.ts
+++ b/type-plus/ts/mix_types/box.ts
@@ -44,7 +44,7 @@ export type Box<T, Options extends Box.Options = Box.DefaultOptions> =
 						IsSymbol<
 							T,
 							Symbol,
-							IsBigint<T, BigInt, Options['$notBoxable']>
+							IsBigint<T, { $then: BigInt, $else: Options['$notBoxable'] }>
 						>
 					>
 				>
diff --git a/type-plus/ts/undefined/is_not_undefined.ts b/type-plus/ts/undefined/is_not_undefined.ts
index a6452e5a5f..762005bb31 100644
--- a/type-plus/ts/undefined/is_not_undefined.ts
+++ b/type-plus/ts/undefined/is_not_undefined.ts
@@ -5,6 +5,7 @@ import type { SelectInvertWithDistribute } from '../type_plus/branch/select_inve
  *
  * Validate if `T` is not `undefined`.
  *
+ * @example
  * ```ts
  * type R = IsNotUndefined<undefined> // false
  *