type-plus 4.3.0 → 4.4.0

package/README.md

@@ -15,9 +15,10 @@ Provides additional types and type adjusted utilities for [TypeScript](https://w
 
 ## Feature Highlights
 
-- [Type assertion](#type-assertion)
-- [Nominal Types](#nominal-type)
+- [Type assertions](#type-assertions)
 - [Type Utilities](#type-utilities)
+- [Nominal Types](#nominal-types)
+- [Functional Types](#functional-types)
 
 ## Installation
 
@@ -27,12 +28,11 @@ npm install type-plus
 yarn add type-plus
 ```
 
-## Type Assertion
+## Type Assertions
 
-Besides the [runtime type checker](#runtime-type-checker),
-`type-plus` also provides a few other ways to do type assertions.
+Type assertion is one of the main features of `type-plus`.
 
-There are actually at least 5 kinds of type assertions:
+There are 5 kinds of type assertions:
 
 - `runtime`: validates during runtime.
 - `immediate`: validates at compile time.
@@ -264,70 +264,6 @@ assertType.isTrue(notA({ a: 1 }))
 notA({ a: '' }) // TypeScript complains
 ```
 
-## Nominal Type
-
-The TypeScript type system is structural.
-
-In some cases, we want to express a type with nominal behavior.
-`type-plus` provides two kinds of nominal types: `Brand` and `Flavor`.
-
-`Brand<B, T>`:
-
-`brand(type, subject?)`:
-
-Branded nominal type is the stronger nominal type of the two.
-It disallows unbranded type assigned to it:
-
-```ts
-const a = brand('a', { a: 1 })
-const b = { a: 1 }
-a = b // error
-```
-
-`subject` can be any type, from primitive to strings to objects.
-
-`brand(type)`:
-
-If you do not provide `subject`, `brand(type)` will return a brand creator,
-so that you can use it to create multiple branded values:
-
-```ts
-const nike = brand('nike')
-const shirt = nike('shirt')
-const socks = nike('socks')
-```
-
-`Flavor<F, T>`:
-
-`flavor(type, subject?)`:
-
-The key difference between `Flavor` and `Brand` is that
-unflavored type can be assigned to `Flavor`:
-
-```ts
-let f = flavor('orange', 'soda')
-f = 'mist' // ok
-```
-
-Also, `Brand` of the same name can be assigned to `Flavor`,
-but `Flavor` of the same name cannot be assigned to `Brand`.
-
-`nominalMatch(a, b)`:
-
-`nominalMatch()` can be used to compare `Brand` or `Flavor`.
-
-```ts
-const b1 = brand('x', 1)
-const b2 = brand('y', 1)
-
-nominalMatch(b1, b2) // false
-```
-
-## Functional Types
-
-- `ChainFn<T>: T`: chain function that returns the input type.
-- `compose(...fns): F`: compose functions
-
 ## Type Utilities
 
 `type-plus` also provides additional type utilities.
@@ -415,7 +351,7 @@ JSONTypes.get<string>(someJson, 'a', 'b', 1, 'c') // miku
 
 - `ANotB<A, B>`: get object with properties in `A` and not in `B`, including properties with a different value type.
 - `BNotA<A, B>`: flip of `ANotB`
-- `as<T>(subject)`: assert `subject` as `T`. Avoid ASI issues such as `;(x as any).abc`
+- `as<T>(subject)`: assert `subject` as `T`. Avoid ASI issues such as `;(x as T).abc`
 - `asAny(subject)`: assert `subject` as `any`. Avoid ASI issue such as `;(x as any).abc`
 - `Except<T, K>`: Deprecated. Same as `Omit<T, K>`.
 - `ExcludePropType<T, U>`: excludes type `U` from properties in `T`.
@@ -496,6 +432,7 @@ So you may encounter some weird behavior if your logic is complex.
 - `required(...)`: merge options and removing `Partial<T>`. From [`unpartial`](https://github.com/unional/unpartial)
 - `requiredDeep(...)`: merge options deeply and removing `Partial<T>`. From [`unpartial`](https://github.com/unional/unpartial)
 - `split(target, ...splitters)`: split one object into multiple objects.
+- `stub<T>(value)`: stub a particular type `T`.
 - `typeOverrideIncompatible<T>()`: override only the incompatible portion between two types.
 
 ```ts
@@ -516,6 +453,70 @@ const source = {
 overrider(source, { foo: !!source.foo })
 ```
 
+## Nominal Types
+
+The TypeScript type system is structural.
+
+In some cases, we want to express a type with nominal behavior.
+`type-plus` provides two kinds of nominal types: `Brand` and `Flavor`.
+
+`Brand<B, T>`:
+
+`brand(type, subject?)`:
+
+Branded nominal type is the stronger nominal type of the two.
+It disallows unbranded type assigned to it:
+
+```ts
+const a = brand('a', { a: 1 })
+const b = { a: 1 }
+a = b // error
+```
+
+`subject` can be any type, from primitive to strings to objects.
+
+`brand(type)`:
+
+If you do not provide `subject`, `brand(type)` will return a brand creator,
+so that you can use it to create multiple branded values:
+
+```ts
+const nike = brand('nike')
+const shirt = nike('shirt')
+const socks = nike('socks')
+```
+
+`Flavor<F, T>`:
+
+`flavor(type, subject?)`:
+
+The key difference between `Flavor` and `Brand` is that
+unflavored type can be assigned to `Flavor`:
+
+```ts
+let f = flavor('orange', 'soda')
+f = 'mist' // ok
+```
+
+Also, `Brand` of the same name can be assigned to `Flavor`,
+but `Flavor` of the same name cannot be assigned to `Brand`.
+
+`nominalMatch(a, b)`:
+
+`nominalMatch()` can be used to compare `Brand` or `Flavor`.
+
+```ts
+const b1 = brand('x', 1)
+const b2 = brand('y', 1)
+
+nominalMatch(b1, b2) // false
+```
+
+## Functional Types
+
+- `ChainFn<T>: T`: chain function that returns the input type.
+- `compose(...fns): F`: compose functions
+
 ## Attribution
 
 Some of the code in this library is created by other people in the TypeScript community.

package/cjs/array/CreateTuple.d.ts

@@ -1,7 +1,8 @@
-import { IsPositive } from '../math';
+import type { IsPositive } from '../math';
 /**
  * Creates `Tuple<T>` with `L` number of elements.
  */
-export declare type CreateTuple<L extends number, T = any> = IsPositive<L> extends true ? Device<[], L, T> : never;
-declare type Device<R extends any[], L extends number, T> = R['length'] extends L ? R : Device<[T, ...R], L, T>;
-export {};
+export declare type CreateTuple<L extends number, T = any> = IsPositive<L> extends true ? CreateTuple.Device<[], L, T> : never;
+export declare namespace CreateTuple {
+    type Device<R extends any[], L extends number, T> = R['length'] extends L ? R : Device<[T, ...R], L, T>;
+}

package/cjs/array/Some.d.ts

@@ -1,6 +1,7 @@
-import { Equal } from '../predicates';
-import { Tail } from './Tail';
-import { UnionOfValues } from './UnionOfValues';
-export declare type Some<A extends any[], Criteria, Mode extends 'strict' | 'loose' = 'loose', Then = true, Else = false> = Mode extends 'strict' ? SomeStrict<A, Criteria, Then, Else> : number extends A['length'] ? UnionOfValues<A> extends Criteria ? Then : Else : A['length'] extends 0 ? Else : A[0] extends Criteria ? Then : Some<Tail<A>, Criteria, 'loose', Then, Else>;
-declare type SomeStrict<A extends any[], Criteria, Then, Else> = number extends A['length'] ? (Equal<UnionOfValues<A>, Criteria> extends true ? Then : Else) : (A['length'] extends 0 ? Else : (Equal<A[0], Criteria> extends true ? Then : SomeStrict<Tail<A>, Criteria, Then, Else>));
-export {};
+import type { Equal } from '../predicates';
+import type { Tail } from './Tail';
+import type { UnionOfValues } from './UnionOfValues';
+export declare type Some<A extends any[], Criteria, Mode extends 'strict' | 'loose' = 'loose', Then = true, Else = false> = Mode extends 'strict' ? Some.Strict<A, Criteria, Then, Else> : number extends A['length'] ? UnionOfValues<A> extends Criteria ? Then : Else : A['length'] extends 0 ? Else : A[0] extends Criteria ? Then : Some<Tail<A>, Criteria, 'loose', Then, Else>;
+export declare namespace Some {
+    type Strict<A extends any[], Criteria, Then, Else> = number extends A['length'] ? (Equal<UnionOfValues<A>, Criteria> extends true ? Then : Else) : (A['length'] extends 0 ? Else : (Equal<A[0], Criteria> extends true ? Then : Strict<Tail<A>, Criteria, Then, Else>));
+}

package/cjs/index.d.ts

@@ -13,5 +13,6 @@ export * from './object';
 export * from './predicates';
 export type { PrimitiveTypes } from './PrimitiveTypes';
 export * from './promise';
+export * from './testing';
 export type { UnionKeys } from './UnionKeys';
 export * from './utils';

package/cjs/index.js

@@ -31,6 +31,7 @@ __exportStar(require("./nominal-types"), exports);
 __exportStar(require("./object"), exports);
 __exportStar(require("./predicates"), exports);
 __exportStar(require("./promise"), exports);
+__exportStar(require("./testing"), exports);
 __exportStar(require("./utils"), exports);
 // export { types, types as T }
 //# sourceMappingURL=index.js.map

package/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,mCAAmC;AACnC,uCAAkD;AAAzC,qGAAA,QAAQ,OAAA;AAAE,yGAAA,YAAY,OAAA;AAC/B,0CAAuB;AACvB,8CAA2B;AAC3B,0CAAuB;AAEvB,6CAA0B;AAC1B,+CAA4B;AAC5B,8CAA2B;AAC3B,yCAAsB;AACtB,2CAAwB;AACxB,kDAA+B;AAC/B,2CAAwB;AACxB,+CAA4B;AAE5B,4CAAyB;AAIzB,0CAAuB;AACvB,+BAA+B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,mCAAmC;AACnC,uCAAkD;AAAzC,qGAAA,QAAQ,OAAA;AAAE,yGAAA,YAAY,OAAA;AAC/B,0CAAuB;AACvB,8CAA2B;AAC3B,0CAAuB;AAEvB,6CAA0B;AAC1B,+CAA4B;AAC5B,8CAA2B;AAC3B,yCAAsB;AACtB,2CAAwB;AACxB,kDAA+B;AAC/B,2CAAwB;AACxB,+CAA4B;AAE5B,4CAAyB;AACzB,4CAAyB;AAIzB,0CAAuB;AACvB,+BAA+B"}

package/cjs/math/Abs.d.ts

@@ -1,2 +1,2 @@
-import { DigitArray } from './Digit';
+import type { DigitArray } from './Digit';
 export declare type Abs<N extends number, Fail = never> = number extends N ? Fail : `${N}` extends `-${infer P}` ? DigitArray.ToNumber<DigitArray.FromString<P>> : N;

package/cjs/math/Add.d.ts

@@ -1,17 +1,21 @@
-import { PadLeft } from '../array';
-import { And } from '../predicates';
-import { Digit, DigitArray } from './Digit';
-import { IsPositive } from './IsPositive';
-import { IsWhole } from './IsWhole';
-import { Max } from './Max';
+import type { PadLeft } from '../array';
+import type { And } from '../predicates';
+import type { Digit, DigitArray } from './Digit';
+import type { IsPositive } from './IsPositive';
+import type { IsWhole } from './IsWhole';
+import type { Max } from './Max';
 /**
  * Add two number literals.
  */
-export declare type Add<A extends number, B extends number, Fail = never> = And<And<IsPositive<A>, IsWhole<A>>, And<IsPositive<B>, IsWhole<B>>> extends false ? Fail : DigitArray.FromNumber<A> extends infer DA ? DA extends number[] ? DigitArray.FromNumber<B> extends infer DB ? DB extends number[] ? Max<DA['length'], DB['length']> extends infer M ? M extends number ? PadLeft<DA, M, 0> extends infer PDA ? PDA extends number[] ? PadLeft<DB, M, 0> extends infer PDB ? PDB extends number[] ? DigitArray.ToNumber<AddDigitArray<PDA, PDB>> : Fail : Fail : Fail : Fail : Fail : Fail : Fail : Fail : Fail : Fail;
-declare type AddDigitArray<A extends number[], B extends number[]> = (A extends [any, ...infer ATail] ? (ATail extends number[] ? (B extends [any, ...infer BTail] ? (BTail extends number[] ? [AddDigit<A[0], B[0]>, ...AddDigitArray<ATail, BTail>] : []) : [A[0], ...AddDigitArray<[], ATail>]) : []) : (B extends [any, ...infer BTail] ? (BTail extends number[] ? [B[0], ...AddDigitArray<[], BTail>] : []) : []));
-declare type AddDigit<A extends number, B extends number> = [...Digit.ToTuple[A], ...Digit.ToTuple[B]]['length'];
+export declare type Add<A extends number, B extends number, Fail = never> = And<And<IsPositive<A>, IsWhole<A>>, And<IsPositive<B>, IsWhole<B>>> extends false ? Fail : DigitArray.FromNumber<A> extends infer DA ? DA extends number[] ? DigitArray.FromNumber<B> extends infer DB ? DB extends number[] ? Max<DA['length'], DB['length']> extends infer M ? M extends number ? PadLeft<DA, M, 0> extends infer PDA ? PDA extends number[] ? PadLeft<DB, M, 0> extends infer PDB ? PDB extends number[] ? DigitArray.ToNumber<Add.DigitArray<PDA, PDB>> : Fail : Fail : Fail : Fail : Fail : Fail : Fail : Fail : Fail : Fail;
+export declare namespace Add {
+    type DigitArray<A extends number[], B extends number[]> = (A extends [any, ...infer ATail] ? (ATail extends number[] ? (B extends [any, ...infer BTail] ? (BTail extends number[] ? [Digit<A[0], B[0]>, ...DigitArray<ATail, BTail>] : []) : [A[0], ...DigitArray<[], ATail>]) : []) : (B extends [any, ...infer BTail] ? (BTail extends number[] ? [B[0], ...DigitArray<[], BTail>] : []) : []));
+    type Digit<A extends number, B extends number> = [
+        ...Digit.ToTuple[A],
+        ...Digit.ToTuple[B]
+    ]['length'];
+}
 /**
  * Increment `A` by 1.
  */
 export declare type Increment<A extends number, Fail = never> = Add<A, 1, Fail>;
-export {};

package/cjs/math/Digit.d.ts

@@ -3,7 +3,7 @@ import { And } from '../predicates';
 import { IsPositive } from './IsPositive';
 import { IsWhole } from './IsWhole';
 export declare namespace Digit {
-    export type ToTuple = {
+    type ToTuple = {
         [k in number]: any[];
     } & {
         0: [];
@@ -30,7 +30,7 @@ export declare namespace Digit {
     /**
      * A > B for [1-9]
      */
-    export type GreaterThan<A extends number, B extends number> = B extends GreaterThanMap[A] ? true : false;
+    type GreaterThan<A extends number, B extends number> = B extends GreaterThanMap[A] ? true : false;
     type GreaterThanMap = {
         [k in number]: number;
     } & {
@@ -45,16 +45,15 @@ export declare namespace Digit {
         8: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7;
         9: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
     };
-    export {};
 }
 export declare namespace DigitArray {
-    export type ToNumber<C extends number[]> = ToTuple<[], C>['length'];
-    export type ToTuple<R extends any[], S extends number[]> = S['length'] extends 0 ? R : (S['length'] extends 1 ? [...R, ...Digit.ToTuple[S[0]]] : (S extends [any, ...infer T] ? (T extends any[] ? ToTuple<Multi10<[...R, ...Digit.ToTuple[S[0]]]>, T> : never) : never));
+    type ToNumber<C extends number[]> = ToTuple<[], C>['length'];
+    type ToTuple<R extends any[], S extends number[]> = S['length'] extends 0 ? R : (S['length'] extends 1 ? [...R, ...Digit.ToTuple[S[0]]] : (S extends [any, ...infer T] ? (T extends any[] ? ToTuple<Multi10<[...R, ...Digit.ToTuple[S[0]]]>, T> : never) : never));
     type Multi10<C extends any[]> = [...C, ...C, ...C, ...C, ...C, ...C, ...C, ...C, ...C, ...C];
-    export type FromNumber<N extends number> = FromString<NumberToString<N>>;
+    type FromNumber<N extends number> = FromString<NumberToString<N>>;
     type NumberToString<N extends number> = (And<IsPositive<N>, IsWhole<N>>) extends true ? `${N}` : never;
-    export type FromString<S extends string> = S extends `1${infer L}` ? [1, ...FromString<L>] : S extends `2${infer L}` ? [2, ...FromString<L>] : S extends `3${infer L}` ? [3, ...FromString<L>] : S extends `4${infer L}` ? [4, ...FromString<L>] : S extends `5${infer L}` ? [5, ...FromString<L>] : S extends `6${infer L}` ? [6, ...FromString<L>] : S extends `7${infer L}` ? [7, ...FromString<L>] : S extends `8${infer L}` ? [8, ...FromString<L>] : S extends `9${infer L}` ? [9, ...FromString<L>] : S extends `0${infer L}` ? [0, ...FromString<L>] : [];
-    export type Shift10<DA extends number[]> = TrimLeadingZero<Shift10State<[], DA>>;
+    type FromString<S extends string> = S extends `1${infer L}` ? [1, ...FromString<L>] : S extends `2${infer L}` ? [2, ...FromString<L>] : S extends `3${infer L}` ? [3, ...FromString<L>] : S extends `4${infer L}` ? [4, ...FromString<L>] : S extends `5${infer L}` ? [5, ...FromString<L>] : S extends `6${infer L}` ? [6, ...FromString<L>] : S extends `7${infer L}` ? [7, ...FromString<L>] : S extends `8${infer L}` ? [8, ...FromString<L>] : S extends `9${infer L}` ? [9, ...FromString<L>] : S extends `0${infer L}` ? [0, ...FromString<L>] : [];
+    type Shift10<DA extends number[]> = TrimLeadingZero<Shift10State<[], DA>>;
     type Shift10State<R extends number[], DA extends number[]> = DA['length'] extends 0 ? R : (DA['length'] extends 1 ? [...R, ...DA] : (DA extends [any, ...infer T] ? (T extends number[] ? (DA[0] extends 0 ? Shift10State<[...R, DA[0]], T> : (T extends [any, ...infer Y] ? (Y extends number[] ? Shift10State<[...R, MinusOne[DA[0]]], [Plus10[T[0]], ...Y]> : []) : [])) : []) : []));
     type TrimLeadingZero<A extends number[]> = A['length'] extends 0 ? A : A[0] extends 0 ? TrimLeadingZero<Tail<A>> : A;
     type MinusOne = {
@@ -95,5 +94,4 @@ export declare namespace DigitArray {
         8: 18;
         9: 19;
     };
-    export {};
 }

package/cjs/math/GreaterThan.d.ts

@@ -1,10 +1,11 @@
-import { Head, PadLeft, Tail } from '../array';
-import { And, Equal } from '../predicates';
-import { Digit, DigitArray } from './Digit';
-import { IsPositive } from './IsPositive';
-import { IsWhole } from './IsWhole';
-import { Max } from './Max';
-export declare type GreaterThan<A extends number, B extends number, Fail = never> = And<And<IsPositive<A>, IsWhole<A>>, And<IsPositive<B>, IsWhole<B>>> extends false ? Fail : number extends A ? Fail : number extends B ? Fail : Equal<A, B> extends true ? false : GreaterThanOnPositiveWhole<A, B>;
-declare type GreaterThanOnPositiveWhole<A extends number, B extends number> = (DigitArray.FromNumber<A> extends infer DA ? DA extends number[] ? DigitArray.FromNumber<B> extends infer DB ? DB extends number[] ? Max<DA['length'], DB['length']> extends infer M ? M extends number ? PadLeft<DA, M, 0> extends infer PDA ? PDA extends number[] ? PadLeft<DB, M, 0> extends infer PDB ? PDB extends number[] ? GreaterThanOnDigitArray<PDA, PDB> : never : never : never : never : never : never : never : never : never : never);
-declare type GreaterThanOnDigitArray<DA extends number[], DB extends number[]> = (Equal<Head<DA>, Head<DB>> extends true ? GreaterThanOnDigitArray<Tail<DA>, Tail<DB>> extends Tail<DA> ? true : false : Digit.GreaterThan<Head<DA>, Head<DB>> extends true ? true : false);
-export {};
+import type { Head, PadLeft, Tail } from '../array';
+import type { And, Equal } from '../predicates';
+import type { Digit, DigitArray } from './Digit';
+import type { IsPositive } from './IsPositive';
+import type { IsWhole } from './IsWhole';
+import type { Max } from './Max';
+export declare type GreaterThan<A extends number, B extends number, Fail = never> = And<And<IsPositive<A>, IsWhole<A>>, And<IsPositive<B>, IsWhole<B>>> extends false ? Fail : number extends A ? Fail : number extends B ? Fail : Equal<A, B> extends true ? false : GreaterThan.OnPositiveWhole<A, B>;
+export declare namespace GreaterThan {
+    type OnPositiveWhole<A extends number, B extends number> = (DigitArray.FromNumber<A> extends infer DA ? DA extends number[] ? DigitArray.FromNumber<B> extends infer DB ? DB extends number[] ? Max<DA['length'], DB['length']> extends infer M ? M extends number ? PadLeft<DA, M, 0> extends infer PDA ? PDA extends number[] ? PadLeft<DB, M, 0> extends infer PDB ? PDB extends number[] ? OnDigitArray<PDA, PDB> : never : never : never : never : never : never : never : never : never : never);
+    type OnDigitArray<DA extends number[], DB extends number[]> = (Equal<Head<DA>, Head<DB>> extends true ? OnDigitArray<Tail<DA>, Tail<DB>> extends Tail<DA> ? true : false : Digit.GreaterThan<Head<DA>, Head<DB>> extends true ? true : false);
+}

package/cjs/math/Max.d.ts

@@ -1,9 +1,10 @@
-import { Head, Tail } from '../array';
-import { And, Equal } from '../predicates';
-import { Digit, DigitArray } from './Digit';
-import { IsPositive } from './IsPositive';
-import { IsWhole } from './IsWhole';
-export declare type Max<A extends number, B extends number, Fail = never> = And<IsPositive<A>, IsWhole<A>> extends false ? Fail : And<IsPositive<B>, IsWhole<B>> extends false ? Fail : number extends A ? Fail : number extends B ? Fail : Equal<A, B> extends true ? A : MaxOnPositiveWhole<A, B>;
-declare type MaxOnPositiveWhole<A extends number, B extends number> = (DigitArray.FromNumber<A> extends infer DA ? DA extends number[] ? DigitArray.FromNumber<B> extends infer DB ? DB extends number[] ? MaxOnDigitArray<DA, DB> extends DA ? A : B : never : never : never : never);
-declare type MaxOnDigitArray<DA extends number[], DB extends number[]> = Equal<DA['length'], DB['length']> extends true ? (Equal<Head<DA>, Head<DB>> extends true ? (Tail<DA> extends infer TDA ? TDA extends number[] ? MaxOnDigitArray<TDA, Tail<DB>> extends TDA ? DA : DB : never : never) : Digit.GreaterThan<Head<DA>, Head<DB>> extends true ? DA : DB) : MaxOnPositiveWhole<DA['length'], DB['length']> extends DA['length'] ? DA : DB;
-export {};
+import type { Head, Tail } from '../array';
+import type { And, Equal } from '../predicates';
+import type { Digit, DigitArray } from './Digit';
+import type { IsPositive } from './IsPositive';
+import type { IsWhole } from './IsWhole';
+export declare type Max<A extends number, B extends number, Fail = never> = And<IsPositive<A>, IsWhole<A>> extends false ? Fail : And<IsPositive<B>, IsWhole<B>> extends false ? Fail : number extends A ? Fail : number extends B ? Fail : Equal<A, B> extends true ? A : Max.OnPositiveWhole<A, B>;
+export declare namespace Max {
+    type OnPositiveWhole<A extends number, B extends number> = (DigitArray.FromNumber<A> extends infer DA ? DA extends number[] ? DigitArray.FromNumber<B> extends infer DB ? DB extends number[] ? OnDigitArray<DA, DB> extends DA ? A : B : never : never : never : never);
+    type OnDigitArray<DA extends number[], DB extends number[]> = Equal<DA['length'], DB['length']> extends true ? (Equal<Head<DA>, Head<DB>> extends true ? (Tail<DA> extends infer TDA ? TDA extends number[] ? OnDigitArray<TDA, Tail<DB>> extends TDA ? DA : DB : never : never) : Digit.GreaterThan<Head<DA>, Head<DB>> extends true ? DA : DB) : OnPositiveWhole<DA['length'], DB['length']> extends DA['length'] ? DA : DB;
+}

package/cjs/math/Subtract.d.ts

@@ -1,14 +1,15 @@
-import { PadLeft, Some, Tail } from '../array';
-import { And } from '../predicates';
-import { Digit, DigitArray } from './Digit';
-import { IsPositive } from './IsPositive';
-import { IsWhole } from './IsWhole';
-import { Max } from './Max';
-export declare type Subtract<A extends number, B extends number, Fail = never> = And<And<IsPositive<A>, IsWhole<A>>, And<IsPositive<B>, IsWhole<B>>> extends true ? (DigitArray.Shift10<DigitArray.FromNumber<A>> extends infer DA ? DA extends number[] ? DigitArray.FromNumber<B> extends infer DB ? DB extends number[] ? Max<DA['length'], DB['length']> extends infer M ? M extends number ? PadLeft<DA, M, 0> extends infer PDA ? PDA extends number[] ? PadLeft<DB, M, 0> extends infer PDB ? PDB extends number[] ? SubtractDigitArray<[], PDA, PDB> extends infer Result ? Result extends number[] ? Some<Result, never, 'strict'> extends true ? Fail : DigitArray.ToNumber<Result> : Fail : Fail : Fail : Fail : Fail : Fail : Fail : Fail : Fail : Fail : Fail : Fail) : Fail;
-declare type SubtractDigitArray<R extends number[], A extends number[], B extends number[]> = A['length'] extends 0 ? R : SubtractDigitArray<[...R, SubtractDigit<A[0], B[0]>], Tail<A>, Tail<B>>;
-declare type SubtractDigit<A extends number, B extends number> = Digit.ToTuple[A] extends [...(infer U), ...Digit.ToTuple[B]] ? U['length'] : never;
+import type { PadLeft, Some, Tail } from '../array';
+import type { And } from '../predicates';
+import type { Digit, DigitArray } from './Digit';
+import type { IsPositive } from './IsPositive';
+import type { IsWhole } from './IsWhole';
+import type { Max } from './Max';
+export declare type Subtract<A extends number, B extends number, Fail = never> = And<And<IsPositive<A>, IsWhole<A>>, And<IsPositive<B>, IsWhole<B>>> extends true ? (DigitArray.Shift10<DigitArray.FromNumber<A>> extends infer DA ? DA extends number[] ? DigitArray.FromNumber<B> extends infer DB ? DB extends number[] ? Max<DA['length'], DB['length']> extends infer M ? M extends number ? PadLeft<DA, M, 0> extends infer PDA ? PDA extends number[] ? PadLeft<DB, M, 0> extends infer PDB ? PDB extends number[] ? Subtract.DigitArray<[], PDA, PDB> extends infer Result ? Result extends number[] ? Some<Result, never, 'strict'> extends true ? Fail : DigitArray.ToNumber<Result> : Fail : Fail : Fail : Fail : Fail : Fail : Fail : Fail : Fail : Fail : Fail : Fail) : Fail;
+export declare namespace Subtract {
+    type DigitArray<R extends number[], A extends number[], B extends number[]> = A['length'] extends 0 ? R : DigitArray<[...R, Digit<A[0], B[0]>], Tail<A>, Tail<B>>;
+    type Digit<A extends number, B extends number> = Digit.ToTuple[A] extends [...(infer U), ...Digit.ToTuple[B]] ? U['length'] : never;
+}
 /**
  * A - 1
  */
 export declare type Decrement<A extends number, Fail = never> = Subtract<A, 1, Fail>;
-export {};

package/cjs/math/index.d.ts

@@ -1,5 +1,6 @@
 export type { Abs } from './Abs';
 export type { Add, Increment } from './Add';
+export type { Digit, DigitArray } from './Digit';
 export type { GreaterThan } from './GreaterThan';
 export type { IsPositive } from './IsPositive';
 export type { IsWhole } from './IsWhole';

package/cjs/nodejs/isNodeError.d.ts

@@ -1,4 +1,4 @@
-declare type SystemErrors = {
+export declare type SystemErrors = {
     'EACCES': Error & {
         code: 'EACCES';
     };
@@ -28,4 +28,3 @@ export declare type SystemErrorCodes = keyof SystemErrors;
  * Feel free to contribute.
  */
 export declare function isSystemError<C extends SystemErrorCodes>(code: C, err: unknown): err is SystemErrors[C];
-export {};

package/cjs/nodejs/isNodeError.js.map

@@ -1 +1 @@
-{"version":3,"file":"isNodeError.js","sourceRoot":"","sources":["../../ts/nodejs/isNodeError.ts"],"names":[],"mappings":";;;AAoBA;;;;GAIG;AACH,SAAgB,aAAa,CAA6B,IAAO,EAAE,GAAY;IAC7E,OAAO,CAAC,CAAC,GAAG,IAAK,GAAW,CAAC,IAAI,KAAK,IAAI,CAAA;AAC5C,CAAC;AAFD,sCAEC"}
+{"version":3,"file":"isNodeError.js","sourceRoot":"","sources":["../../ts/nodejs/isNodeError.ts"],"names":[],"mappings":";;;AAmBA;;;;GAIG;AACH,SAAgB,aAAa,CAA6B,IAAO,EAAE,GAAY;IAC7E,OAAO,CAAC,CAAC,GAAG,IAAK,GAAW,CAAC,IAAI,KAAK,IAAI,CAAA;AAC5C,CAAC;AAFD,sCAEC"}

package/cjs/object/split.d.ts

@@ -2,7 +2,7 @@ import { AnyRecord, Omit } from '..';
 declare type Splitter<T extends AnyRecord> = Partial<{
     [k in keyof T]: T[k] | undefined;
 }>;
-declare type Split<T extends AnyRecord, S extends AnyRecord> = {
+export declare type Split<T extends AnyRecord, S extends AnyRecord> = {
     [k in keyof S]: NonNullable<T[k]> | S[k];
 };
 /**

package/cjs/testing/index.d.ts

@@ -0,0 +1 @@
+export * from './stub';

package/cjs/testing/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./stub"), exports);
+//# sourceMappingURL=index.js.map

package/cjs/testing/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../ts/testing/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,yCAAsB"}

package/cjs/testing/stub.d.ts

@@ -0,0 +1,4 @@
+import { AnyFunction } from '../function';
+import { RecursivePartial } from '../object';
+export declare type Stub<T> = T extends AnyFunction ? T : RecursivePartial<T>;
+export declare function stub<T>(stub: Stub<T>): T;

package/cjs/testing/stub.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stub = void 0;
+function stub(stub) {
+    return stub;
+}
+exports.stub = stub;
+//# sourceMappingURL=stub.js.map

package/cjs/testing/stub.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stub.js","sourceRoot":"","sources":["../../ts/testing/stub.ts"],"names":[],"mappings":";;;AAKA,SAAgB,IAAI,CAAI,IAAa;IACnC,OAAO,IAAS,CAAA;AAClB,CAAC;AAFD,oBAEC"}

package/cjs/utils/as.d.ts

@@ -1,2 +1,2 @@
-export declare function as<T>(subject: unknown): subject is T;
-export declare function asAny(subject: unknown): subject is any;
+export declare function as<T>(subject: unknown): T;
+export declare function asAny(subject: unknown): any;

package/cjs/utils/as.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.asAny = exports.as = void 0;
 function as(subject) {
-    return true;
+    return subject;
 }
 exports.as = as;
 function asAny(subject) {
-    return true;
+    return subject;
 }
 exports.asAny = asAny;
 //# sourceMappingURL=as.js.map

package/cjs/utils/as.js.map

@@ -1 +1 @@
-{"version":3,"file":"as.js","sourceRoot":"","sources":["../../ts/utils/as.ts"],"names":[],"mappings":";;;AAAA,SAAgB,EAAE,CAAI,OAAgB;IACpC,OAAO,IAAI,CAAA;AACb,CAAC;AAFD,gBAEC;AAED,SAAgB,KAAK,CAAC,OAAgB;IACpC,OAAO,IAAI,CAAA;AACb,CAAC;AAFD,sBAEC"}
+{"version":3,"file":"as.js","sourceRoot":"","sources":["../../ts/utils/as.ts"],"names":[],"mappings":";;;AAAA,SAAgB,EAAE,CAAI,OAAgB;IACpC,OAAO,OAAY,CAAA;AACrB,CAAC;AAFD,gBAEC;AAED,SAAgB,KAAK,CAAC,OAAgB;IACpC,OAAO,OAAO,CAAA;AAChB,CAAC;AAFD,sBAEC"}

package/esm/index.js

@@ -12,6 +12,7 @@ export * from './nominal-types';
 export * from './object';
 export * from './predicates';
 export * from './promise';
+export * from './testing';
 export * from './utils';
 // export { types, types as T }
 //# sourceMappingURL=index.js.map

package/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":"AAAA,mCAAmC;AACnC,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAClD,cAAc,SAAS,CAAA;AACvB,cAAc,aAAa,CAAA;AAC3B,cAAc,SAAS,CAAA;AAEvB,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA;AAC5B,cAAc,aAAa,CAAA;AAC3B,cAAc,QAAQ,CAAA;AACtB,cAAc,UAAU,CAAA;AACxB,cAAc,iBAAiB,CAAA;AAC/B,cAAc,UAAU,CAAA;AACxB,cAAc,cAAc,CAAA;AAE5B,cAAc,WAAW,CAAA;AAIzB,cAAc,SAAS,CAAA;AACvB,+BAA+B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":"AAAA,mCAAmC;AACnC,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAClD,cAAc,SAAS,CAAA;AACvB,cAAc,aAAa,CAAA;AAC3B,cAAc,SAAS,CAAA;AAEvB,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA;AAC5B,cAAc,aAAa,CAAA;AAC3B,cAAc,QAAQ,CAAA;AACtB,cAAc,UAAU,CAAA;AACxB,cAAc,iBAAiB,CAAA;AAC/B,cAAc,UAAU,CAAA;AACxB,cAAc,cAAc,CAAA;AAE5B,cAAc,WAAW,CAAA;AACzB,cAAc,WAAW,CAAA;AAIzB,cAAc,SAAS,CAAA;AACvB,+BAA+B"}

package/esm/nodejs/isNodeError.js.map

@@ -1 +1 @@
-{"version":3,"file":"isNodeError.js","sourceRoot":"","sources":["../../ts/nodejs/isNodeError.ts"],"names":[],"mappings":"AAoBA;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAA6B,IAAO,EAAE,GAAY;IAC7E,OAAO,CAAC,CAAC,GAAG,IAAK,GAAW,CAAC,IAAI,KAAK,IAAI,CAAA;AAC5C,CAAC"}
+{"version":3,"file":"isNodeError.js","sourceRoot":"","sources":["../../ts/nodejs/isNodeError.ts"],"names":[],"mappings":"AAmBA;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAA6B,IAAO,EAAE,GAAY;IAC7E,OAAO,CAAC,CAAC,GAAG,IAAK,GAAW,CAAC,IAAI,KAAK,IAAI,CAAA;AAC5C,CAAC"}

package/esm/testing/index.js

@@ -0,0 +1,2 @@
+export * from './stub';
+//# sourceMappingURL=index.js.map

package/esm/testing/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../ts/testing/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAA"}

package/esm/testing/stub.js

@@ -0,0 +1,4 @@
+export function stub(stub) {
+    return stub;
+}
+//# sourceMappingURL=stub.js.map

package/esm/testing/stub.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stub.js","sourceRoot":"","sources":["../../ts/testing/stub.ts"],"names":[],"mappings":"AAKA,MAAM,UAAU,IAAI,CAAI,IAAa;IACnC,OAAO,IAAS,CAAA;AAClB,CAAC"}

package/esm/utils/as.js

@@ -1,7 +1,7 @@
 export function as(subject) {
-    return true;
+    return subject;
 }
 export function asAny(subject) {
-    return true;
+    return subject;
 }
 //# sourceMappingURL=as.js.map

package/esm/utils/as.js.map

@@ -1 +1 @@
-{"version":3,"file":"as.js","sourceRoot":"","sources":["../../ts/utils/as.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,EAAE,CAAI,OAAgB;IACpC,OAAO,IAAI,CAAA;AACb,CAAC;AAED,MAAM,UAAU,KAAK,CAAC,OAAgB;IACpC,OAAO,IAAI,CAAA;AACb,CAAC"}
+{"version":3,"file":"as.js","sourceRoot":"","sources":["../../ts/utils/as.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,EAAE,CAAI,OAAgB;IACpC,OAAO,OAAY,CAAA;AACrB,CAAC;AAED,MAAM,UAAU,KAAK,CAAC,OAAgB;IACpC,OAAO,OAAO,CAAA;AAChB,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "type-plus",
-  "version": "4.3.0",
-  "description": "Provides additional types for `typescript`.",
+  "version": "4.4.0",
+  "description": "Provides additional types for TypeScript.",
   "homepage": "https://github.com/unional/type-plus",
   "bugs": {
     "url": "https://github.com/unional/type-plus/issues"
@@ -29,6 +29,7 @@
     "build": "run-p build:cjs build:esm",
     "build:cjs": "tsc -p tsconfig.cjs.json",
     "build:esm": "tsc -p tsconfig.esm.json",
+    "build:doc": "typedoc",
     "clean": "rimraf cjs esm coverage lib libm",
     "coverage": "jest --coverage",
     "depcheck": "yarn dependency-check",
@@ -43,12 +44,8 @@
     "test:types": "tsc",
     "verify": "run-p verify:build lint test:types coverage",
     "verify:build": "npm-run-all clean build --parallel dependency-check size-limit",
-    "watch": "jest --watch"
-  },
-  "husky": {
-    "hooks": {
-      "commit-msg": "commitlint -E HUSKY_GIT_PARAMS"
-    }
+    "watch": "jest --watch",
+    "prepare": "husky install"
   },
   "dependencies": {
     "tersify": "^3.8.2",
@@ -71,7 +68,7 @@
     "dependency-check": "^4.1.0",
     "eslint": "^8.11.0",
     "eslint-plugin-harmony": "^6.0.0",
-    "husky": "^7.0.4",
+    "husky": "^7.0.0",
     "jest": "^27.5.1",
     "jest-progress-tracker": "^3.0.3",
     "jest-validate": "^27.5.1",
@@ -83,6 +80,8 @@
     "rimraf": "^3.0.2",
     "satisfier": "^5.1.2",
     "size-limit": "^7.0.8",
+    "typedoc": "^0.22.13",
+    "typedoc-plugin-extras": "^2.2.3",
     "typescript": "^4.6.2"
   },
   "size-limit": [