type-plus 3.12.2 → 3.15.0

package/README.md

@@ -13,10 +13,6 @@
 
 Provides additional types and type adjusted utilities for [TypeScript](https://www.typescriptlang.org/).
 
-## What's new
-
-Please check out the [release note](./docs/releases/whats-new-in-3.9.md) to see what's new in 3.9!
-
 ## Feature Highlights
 
 - [Runtime type checker](#runtime-type-checker)
@@ -35,8 +31,8 @@ yarn add type-plus
 ## Runtime type checker
 
 Bringing the power of TypeScript to JavaScript runtime.
-At the moment, this provide some basic functionalities.
-If you need more feature, I would recommend other excellent type checking library such as [zod](https://github.com/colinhacks/zod).
+At the moment, this provides some basic functionalities.
+If you need more features, I would recommend other excellent type checking libraries such as [zod](https://github.com/colinhacks/zod).
 
 ```ts
 const eslintConfig = T.object.create({
@@ -74,13 +70,13 @@ Types supported: `any`, `array`, `boolean`, `null`, `number`, `object`, `record`
 i.e., most of the basic types are supported except `bigint`.
 It is left out for backward compatibility reasons.
 
-You can use one of the three functions to perform type check:
+You can use one of the three functions to perform type-check:
 
 `satisfy(type, subject)`:
 A loose type check that permits extra elements in `Tuple` and properties in `Object`.
 
 `conform(type, subject)`:
-A strick type check that does not allow extra elements in `Tuple` and properties in `Object`.
+A strict type check that does not allow extra elements in `Tuple` and properties in `Object`.
 
 `check(options, type, subject)`:
 A general form of `satisfy()` and `conform()`.
@@ -107,7 +103,7 @@ Use the one that fits your specific needs.
 ✔️ `immediate`
 
 It ensures `subject` satisfies `T`.
-It is similar to `const x: T = subject` without introducing unused variable.
+It is similar to `const x: T = subject` without introducing an unused variable.
 You need to specify `T` for it to work.
 
 `assertType<T>(subject, validator)`:
@@ -116,7 +112,7 @@ You need to specify `T` for it to work.
 
 ✔️ `assertion function`, `runtime`
 
-These overloads of `assertType` allows you to specify a `validator`.
+These overloads of `assertType` allow you to specify a `validator`.
 With these overloads, `subject` can be `unknown` or `any`.
 
 If `subject` fails the assertion,
@@ -163,7 +159,7 @@ const s: number | undefined = undefined
 assertType.isUndefined(s) // TypeScript complains
 ```
 
-They accepts `any` and will be narrowed to the specific type.
+They accept `any` and will be narrowed to the specific type.
 
 ```ts
 const s: any = undefined
@@ -177,9 +173,9 @@ s // type is undefined
 
 Check if the subject type is `never`.
 This function is not very useful in actual code as TypeScript will indicate the error.
-But it can be useful when writing tests for type.
+But it can be useful when writing tests for types.
 
-This is useful for variable. For type level only check, do the following:
+This is useful for variables. For type level only check, do the following:
 
 ```ts
 assertType.isTrue(true as Equal<YourType, never>)
@@ -214,8 +210,8 @@ const s: number | undefined = 1
 assertType.noUndefined(s) // TypeScript complains
 ```
 
-They accepts `subject` with type `any` or `unknown`,
-assertion will happens in runtime to ensure `subject` is the specific type.
+They accept `subject` with type `any` or `unknown`,
+the assertion will happen in runtime to ensure `subject` is the specific type.
 
 `isType<T>(subject: T)`:
 
@@ -250,11 +246,11 @@ It returns `true` when passes (which is the only case when used in TypeScript).
 ✔️ `immediate`
 
 Slightly easier to use then `isType.t<>()` and `isType.f<>()`,
-when doing type level only equality comparison as you don't have to import `Equal<>`.
+when doing type-level only equality comparison as you don't have to import `Equal<>`.
 
 ✔️ `type guard`, `runtime`
 
-These overloads of `isType` allows you to specify a `validator`.
+These overloads of `isType` allow you to specify a `validator`.
 With these overloads, `subject` can be `unknown` or `any`.
 
 `Equal<A, B>`:
@@ -302,7 +298,7 @@ assertType.isTrue(true as CanAssign<{ a:string, b:number }, { a: string }>)
 
 ✔️ `immediate`, `logical`
 
-Returns a compile time validating function to ensure `subject` is assignable to `T`.
+Returns a compile-time validating function to ensure `subject` is assignable to `T`.
 
 ```ts
 const isConfig = canAssign<{ a: string }>()
@@ -313,7 +309,7 @@ assertType.isTrue(isConfig({ a: 'a' }))
 
 ✔️ `immediate`, `logical`
 
-Returns a compile time validating function to ensure `subject` is not assignable to `T`.
+Returns a compile-time validating function to ensure `subject` is not assignable to `T`.
 
 ```ts
 const notA = canAssign<{ a: string }>(false)
@@ -324,7 +320,7 @@ notA({ a: '' }) // TypeScript complains
 
 ## Nominal Type
 
-TypeScript type system is structural.
+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`.
@@ -383,12 +379,12 @@ nominalMatch(b1, b2) // false
 
 ## Functional Types
 
-- `ChainFn<T>: T`: chain function that return the input type.
+- `ChainFn<T>: T`: chain function that returns the input type.
 
 ## Type Utilities
 
 `type-plus` also provides additional type utilities.
-These utilities includes utility types and type adjusted functions.
+These utilities include utility types and type-adjusted functions.
 
 Note that most `predicate` types (such as `IsAny<>`) have a `Then` and `Else` that you can override.
 
@@ -406,13 +402,13 @@ type No = IsAny<1, 'yes', 'no'> // 'no'
 - `CreateTuple<L, T>`: creates `Tuple<T>` with `L` number of elements.
 - `DropFirst<A>`: drops the first value type of `A`.
 - `DropLast<A>`: drops the last value type of `A`.
-- `Filter<A, Criteria>`: gets array of types satisfying `Criteria` in `A`.
-- `FindFirst<A, Criteria>`: gets first type satisfying `Criteria`.
-- `FindLast<A, Criteria>`: gets last type satisfying `Criteria`.
+- `Filter<A, Criteria>`: gets the array of types satisfying `Criteria` in `A`.
+- `FindFirst<A, Criteria>`: gets the first type satisfying `Criteria`.
+- `FindLast<A, Criteria>`: gets the last type satisfying `Criteria`.
 - `Head<A>`: gets the first entry in the array.
 - `IntersectOfProps<A, K>`: gets the intersect of `A[K]` types (deprecate `MapToProp`)
 - `IsArray<T>`: `logical` predicate for `Array`.
-- `literalArray(...entries)`: return an array those items are restricted to the provided literals.
+- `literalArray(...entries)`: return an array whose items are restricted to the provided literals.
 - `PadLeft<A, Total, PadWith>`: pads `A` with `PadWith` if the length of `A` is less than `L`.
 - `reduceWhile()`: `reduce()` with predicate for early termination. \
   A simple version of the same function in the `ramda` package.
@@ -426,6 +422,8 @@ type No = IsAny<1, 'yes', 'no'> // 'no'
 
 - `KeyTypes`: type of all keys.
 - `PrimitiveTypes`: all primitive types, including `Function`, `symbol`, and `bigint`.
+- `ComposableTypes`: Types that can contain custom properties. i.e. `object`, `array`, `function`.
+- `NonComposableTypes`: Types that cannot contain custom properties. i.e. not composable.
 
 ### JSON Support
 
@@ -467,9 +465,9 @@ JSONTypes.get<string>(someJson, 'a', 'b', 1, 'c') // miku
 
 ### Type manipulation
 
-- `ANotB<A, B>`: get object with properties in `A` and not in `B`, including properties with different value type.
+- `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 issue such as `;(x as any).abc`
+- `as<T>(subject)`: assert `subject` as `T`. Avoid ASI issues such as `;(x as any).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`.
@@ -481,13 +479,13 @@ JSONTypes.get<string>(someJson, 'a', 'b', 1, 'c') // miku
 - `PartialExcept<T, U>`: Deprecated. Same as `PartialOmit<T, U>`.
 - `PartialOmit<T, U>`: makes the properties not specified in `U` becomes optional.
 - `PartialPick<T, U>`: makes the properties specified in `U` becomes optional.
-- `Pick<T, K>`: pick properties `K` from `T`. Works with union.
+- `Pick<T, K>`: pick properties `K` from `T`. Works with unions.
 - `RecursivePartial<T>`: make type `T` optional recursively.
 - `RecursiveRequired<T>`: make type `T` required recursively.
 - `ReplaceProperty<T, K, V>`: replace property `K` in `T` with `V`.
 - `RequiredKeys<T>`: gets keys of required properties in `T`.
-- `RequiredPick<T, U>`: makes the properties specified in `U` becomes required.
-- `RequiredExcept<T, U>`: makes the properties not specified in `U` becomes required.
+- `RequiredPick<T, U>`: makes the properties specified in `U` become required.
+- `RequiredExcept<T, U>`: makes the properties not specified in `U` become required.
 - `RecursiveIntersect<T, U>`: intersect type `U` onto `T` recursively.
 - `ValueOf<T>`: type of the value of the properties of `T`.
 - `Widen<T>`: widen literal types.
@@ -502,6 +500,7 @@ They can be used to compose complex types.
 - `IsAny<T>`: `T === any`.
 - `IsBoolean<T>`: check for `boolean`, but not for `true` nor `false`.
 - `IsDisjoint<A, B>`: is `A` and `B` is a disjoint set.
+- `IsEmptyObject<T>`: is `T === {}`.
 - `IsLiteral<T>`: is `T` a literal type (literal string or number).
 
 #### Logical
@@ -512,7 +511,7 @@ They can be used to compose complex types.
 - `Xor<A, B>`: logical `XOR`.
 - `Not<X>`: logical `NOT`.
 
-Note that these types work correctly with `boolean` type.
+Note that these types work correctly with the `boolean` type.
 e.g.:
 
 - `And<boolean, true> -> boolean`
@@ -532,8 +531,7 @@ So you may encounter some weird behavior if your logic is complex.
 #### Arithmetics
 
 - `Add<A, B, Fail=never>`: `A + B` for positive and whole numbers, `Fail` otherwise.
-- `Subtract<A, B, Fail=never>`: `A - B` for positive and whole numbers, `Fail` otherwise.\
-  Negative result also returns `Fail`.
+- `Subtract<A, B, Fail=never>`: `A - B` for positive and whole numbers, `Fail` otherwise.
 - `Increment<A, Fail=never>`: alias of `Add<A, 1, Fail>`.
 - `Decrement<A, Fail=never>`: alias of `Subtract<A, 1, Fail>`.
 
@@ -544,6 +542,7 @@ So you may encounter some weird behavior if your logic is complex.
 - `hasKey()`: function of `HasKey`.
 - `hasProperty(value, prop)`: assert `value` has property `prop`. This will pick the correct union type.
 - `isConstructor(subject)`: type guard `subject` is a constructor.
+- `isSystemError(code, err)`: type guard `err` with Nodejs error code.
 - `pick(obj, ...props)`: pick properties from `obj`.
 - `omit(obj, ...props)`: omit properties from `obj`.
 - `required(...)`: merge options and removing `Partial<T>`. From [`unpartial`](https://github.com/unional/unpartial)
@@ -570,9 +569,9 @@ overrider(source, { foo: !!source.foo })
 
 ## Attribution
 
-Some of the code in this library are created by other people in the TypeScript community.
-I merely adding them in and may be making some adjustments.
-When ever possible, I add attribution to the person who created those code in the file.
+Some of the code in this library is created by other people in the TypeScript community.
+I merely adding them in and maybe making some adjustments.
+Whenever possible, I add attribution to the person who created those **codes** in the file.
 
 ## Similar projects
 

package/cjs/ComposableTypes.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Types that can contain custom properties.
+ */
+export declare type ComposableTypes = object | Function;
+/**
+ * Types that cannot contain custom properties.
+ */
+export declare type NonComposableTypes = boolean | number | string | symbol | bigint | undefined | null;

package/cjs/ComposableTypes.js

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

package/cjs/ComposableTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComposableTypes.js","sourceRoot":"","sources":["../ts/ComposableTypes.ts"],"names":[],"mappings":""}

package/cjs/JSONTypes.js

@@ -0,0 +1,27 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONTypes = void 0;
+exports.JSONTypes = { get: get };
+function get(obj) {
+    var props = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        props[_i - 1] = arguments[_i];
+    }
+    if (props.length === 0)
+        return obj;
+    if (typeof obj !== 'object' || obj === null)
+        return undefined;
+    var p = props.shift();
+    // @ts-ignore
+    return get.apply(void 0, __spreadArray([obj[p]], props, false));
+}
+//# sourceMappingURL=JSONTypes.js.map

package/cjs/JSONTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JSONTypes.js","sourceRoot":"","sources":["../ts/JSONTypes.ts"],"names":[],"mappings":";;;;;;;;;;;;AASa,QAAA,SAAS,GAAG,EAAE,GAAG,KAAA,EAAE,CAAA;AAEhC,SAAS,GAAG,CAAsB,GAAc;IAAE,eAAgC;SAAhC,UAAgC,EAAhC,qBAAgC,EAAhC,IAAgC;QAAhC,8BAAgC;;IAChF,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,GAAQ,CAAA;IACvC,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,IAAI;QAAE,OAAO,SAAS,CAAA;IAC7D,IAAM,CAAC,GAAG,KAAK,CAAC,KAAK,EAAG,CAAA;IACxB,aAAa;IACb,OAAO,GAAG,8BAAC,GAAG,CAAC,CAAC,CAAC,GAAK,KAAK,SAAM,CAAA;AACnC,CAAC"}

package/cjs/PrimitiveTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimitiveTypes.js","sourceRoot":"","sources":["../ts/PrimitiveTypes.ts"],"names":[],"mappings":""}

package/cjs/UnionKeys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UnionKeys.js","sourceRoot":"","sources":["../ts/UnionKeys.ts"],"names":[],"mappings":""}

package/cjs/array/CommonPropKeys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CommonPropKeys.js","sourceRoot":"","sources":["../../ts/array/CommonPropKeys.ts"],"names":[],"mappings":""}

package/cjs/array/Concat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Concat.js","sourceRoot":"","sources":["../../ts/array/Concat.ts"],"names":[],"mappings":""}

package/cjs/array/CreateTuple.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreateTuple.js","sourceRoot":"","sources":["../../ts/array/CreateTuple.ts"],"names":[],"mappings":""}

package/cjs/array/DropFirst.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DropFirst.js","sourceRoot":"","sources":["../../ts/array/DropFirst.ts"],"names":[],"mappings":""}

package/cjs/array/DropLast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DropLast.js","sourceRoot":"","sources":["../../ts/array/DropLast.ts"],"names":[],"mappings":""}

package/cjs/array/Filter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Filter.js","sourceRoot":"","sources":["../../ts/array/Filter.ts"],"names":[],"mappings":""}

package/cjs/array/FindFirst.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FindFirst.js","sourceRoot":"","sources":["../../ts/array/FindFirst.ts"],"names":[],"mappings":""}

package/cjs/array/FindLast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FindLast.js","sourceRoot":"","sources":["../../ts/array/FindLast.ts"],"names":[],"mappings":""}

package/cjs/array/Head.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Head.js","sourceRoot":"","sources":["../../ts/array/Head.ts"],"names":[],"mappings":""}

package/cjs/array/IntersectOfProps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IntersectOfProps.js","sourceRoot":"","sources":["../../ts/array/IntersectOfProps.ts"],"names":[],"mappings":""}

package/cjs/array/IsArray.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsArray.js","sourceRoot":"","sources":["../../ts/array/IsArray.ts"],"names":[],"mappings":""}

package/cjs/array/PadLeft.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PadLeft.js","sourceRoot":"","sources":["../../ts/array/PadLeft.ts"],"names":[],"mappings":""}

package/cjs/array/Reverse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Reverse.js","sourceRoot":"","sources":["../../ts/array/Reverse.ts"],"names":[],"mappings":""}

package/cjs/array/Some.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Some.js","sourceRoot":"","sources":["../../ts/array/Some.ts"],"names":[],"mappings":""}

package/cjs/array/Tail.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tail.js","sourceRoot":"","sources":["../../ts/array/Tail.ts"],"names":[],"mappings":""}

package/cjs/array/UnionOfProps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UnionOfProps.js","sourceRoot":"","sources":["../../ts/array/UnionOfProps.ts"],"names":[],"mappings":""}

package/cjs/array/UnionOfValues.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UnionOfValues.js","sourceRoot":"","sources":["../../ts/array/UnionOfValues.ts"],"names":[],"mappings":""}

package/cjs/array/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../ts/array/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,mDAAgC;AAChC,2CAAwB;AACxB,gDAA6B;AAC7B,8CAA2B;AAC3B,6CAA0B;AAC1B,2CAAwB;AACxB,8CAA2B;AAC3B,6CAA0B;AAC1B,yCAAsB;AACtB,qDAAkC;AAClC,4CAAyB;AACzB,iDAA8B;AAC9B,4CAAyB;AACzB,gDAA6B;AAC7B,4CAAyB;AACzB,yCAAsB;AACtB,yCAAsB;AACtB,iDAA8B;AAC9B,kDAA+B"}

package/cjs/array/literalArray.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"literalArray.js","sourceRoot":"","sources":["../../ts/array/literalArray.ts"],"names":[],"mappings":";;;AAEA,SAAgB,YAAY;IAAqB,iBAAe;SAAf,UAAe,EAAf,qBAAe,EAAf,IAAe;QAAf,4BAAe;;IAC9D,OAAO,OAAO,CAAA;AAChB,CAAC;AAFD,oCAEC"}

package/cjs/array/reduceWhile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reduceWhile.js","sourceRoot":"","sources":["../../ts/array/reduceWhile.ts"],"names":[],"mappings":";;;AAAA,SAAgB,WAAW,CACzB,SAA+C,EAC/C,UAAsF,EACtF,YAAe,EACf,KAAU;IAEV,IAAI,GAAG,GAAG,YAAY,CAAA;IACtB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACrC,IAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;QACtB,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,KAAK,CAAC;YAAE,OAAO,GAAG,CAAA;QACtC,GAAG,GAAG,UAAU,CAAC,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,CAAC,CAAA;KACvC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC;AAbD,kCAaC"}

package/cjs/assertion/assertType.d.ts

@@ -0,0 +1,32 @@
+import { AnyConstructor } from '../class';
+import { AnyFunction } from '../function';
+/**
+ * assert the subject satisfies the specified type T
+ * @type T the type to check against.
+ */
+export declare function assertType<T>(subject: T): asserts subject is T;
+export declare function assertType<T>(subject: unknown, validator: (s: T) => boolean): asserts subject is T;
+export declare function assertType<T extends new (...args: any) => any>(subject: unknown, constructor: T): asserts subject is InstanceType<T>;
+export declare namespace assertType {
+    var isUndefined: (subject: undefined) => asserts subject is undefined;
+    var noUndefined: <S>(subject: Exclude<S, undefined>) => void;
+    var isNull: (subject: null) => asserts subject is null;
+    var noNull: <S>(subject: Exclude<S, null>) => void;
+    var isNumber: (subject: number) => asserts subject is number;
+    var noNumber: <S>(subject: Exclude<S, number>) => void;
+    var isBoolean: (subject: boolean) => asserts subject is boolean;
+    var noBoolean: <S>(subject: Exclude<S, boolean>) => void;
+    var isTrue: (subject: true) => asserts subject is true;
+    var noTrue: <S>(subject: Exclude<S, true>) => void;
+    var isFalse: (subject: false) => asserts subject is false;
+    var noFalse: <S>(subject: Exclude<S, false>) => void;
+    var isString: (subject: string) => asserts subject is string;
+    var noString: <S>(subject: Exclude<S, string>) => void;
+    var isFunction: (subject: AnyFunction<any[], any>) => asserts subject is AnyFunction<any[], any>;
+    var noFunction: <S>(subject: Exclude<S, AnyFunction<any[], any>>) => void;
+    var isConstructor: (subject: AnyConstructor<any[]>) => asserts subject is AnyConstructor<any[]>;
+    var isError: (subject: Error) => asserts subject is Error;
+    var noError: <S>(subject: Exclude<S, Error>) => void;
+    var isNever: (subject: never) => asserts subject is never;
+    var custom: <T>(validator: (s: T) => boolean) => (subject: unknown) => asserts subject is T;
+}

package/cjs/assertion/assertType.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertType = void 0;
+var tersify_1 = require("tersify");
+var class_1 = require("../class");
+function assertType(subject, validator) {
+    if (validator) {
+        if (((0, class_1.isConstructor)(validator) && !(subject instanceof validator)) || !validator(subject))
+            throw new TypeError("subject fails to satisfy ".concat((0, tersify_1.tersify)(validator)));
+    }
+    return;
+}
+exports.assertType = assertType;
+assertType.isUndefined = function (subject) {
+    if (typeof subject !== 'undefined')
+        throw TypeError("subject is not undefined");
+};
+assertType.noUndefined = function (subject) {
+    if (typeof subject === 'undefined')
+        throw TypeError("subject is undefined");
+};
+assertType.isNull = function (subject) {
+    if (subject !== null)
+        throw TypeError("subject is not null");
+};
+assertType.noNull = function (subject) {
+    if (subject === null)
+        throw TypeError("subject is null");
+};
+assertType.isNumber = function (subject) {
+    if (typeof subject !== 'number')
+        throw TypeError("subject is not number");
+};
+assertType.noNumber = function (subject) {
+    if (typeof subject === 'number')
+        throw TypeError("subject is number");
+};
+assertType.isBoolean = function (subject) {
+    if (typeof subject !== 'boolean')
+        throw TypeError("subject is not boolean");
+};
+assertType.noBoolean = function (subject) {
+    if (typeof subject === 'boolean')
+        throw TypeError("subject is boolean");
+};
+assertType.isTrue = function (subject) {
+    if (subject !== true)
+        throw TypeError("subject is not true");
+};
+assertType.noTrue = function (subject) {
+    // @ts-ignore
+    if (subject === true)
+        throw TypeError("subject is true");
+};
+assertType.isFalse = function (subject) {
+    if (subject !== false)
+        throw TypeError("subject is not false");
+};
+assertType.noFalse = function (subject) {
+    // @ts-ignore
+    if (subject === false)
+        throw TypeError("subject is false");
+};
+assertType.isString = function (subject) {
+    if (typeof subject !== 'string')
+        throw TypeError("subject is not string");
+};
+assertType.noString = function (subject) {
+    if (typeof subject === 'string')
+        throw TypeError("subject is string");
+};
+assertType.isFunction = function (subject) {
+    if (typeof subject !== 'function')
+        throw TypeError("subject is not function");
+};
+assertType.noFunction = function (subject) {
+    if (typeof subject === 'function')
+        throw TypeError("subject is function");
+};
+assertType.isConstructor = function (subject) {
+    if (!(0, class_1.isConstructor)(subject))
+        throw TypeError("subject is not a constructor");
+};
+assertType.isError = function (subject) {
+    if (!(subject instanceof Error))
+        throw TypeError("subject is not an Error");
+};
+assertType.noError = function (subject) {
+    if (subject instanceof Error)
+        throw TypeError("subject is an Error");
+};
+assertType.isNever = function (subject) {
+};
+/**
+ * creates a custom assertion function with standard TypeError.
+ * Currently this requires explicity type annotation,
+ * thus making it hard to use:
+ * https://github.com/microsoft/TypeScript/issues/41047
+ */
+assertType.custom = function (validator) {
+    return function (subject) {
+        if (!validator(subject))
+            throw new TypeError("subject fails to satisfy ".concat((0, tersify_1.tersify)(validator)));
+        return;
+    };
+};
+//# sourceMappingURL=assertType.js.map