@tstdl/base 0.88.0-alpha5 → 0.88.0

package/utils/type-guards.js

@@ -1,253 +1,329 @@
-/* eslint-disable @typescript-eslint/ban-types, @typescript-eslint/restrict-template-expressions, max-statements-per-line */
+/* eslint-disable @typescript-eslint/ban-types, @typescript-eslint/restrict-template-expressions, max-statements-per-line, no-eq-null */
 import { supportsBlob, supportsReadableStream } from '../supports.js';
 import { AssertionError } from '../error/assertion.error.js';
 export function assert(condition, message = 'assertion failed') {
     if (!condition) {
-        throw new AssertionError(isFunction(message) ? message() : message);
+        throw new AssertionError((typeof message == 'function') ? message() : message);
     }
 }
 export function assertNot(condition, message = 'assertion failed') {
     if (condition) {
-        throw new AssertionError(isFunction(message) ? message() : message);
+        throw new AssertionError((typeof message == 'function') ? message() : message);
     }
 }
-export function isType(type, value) { return (value instanceof type); }
-export function isNotType(type, value) { return !isType(type, value); }
-export function assertType(type, value, message = () => `Expected value to be of type ${type.name}.`) { assert(isType(type, value), message); }
-export function assertNotType(type, value, message = () => `Expected value to be not of type ${type.name}.`) { assert(isNotType(type, value), message); }
-export function assertTypePass(type, value, message) { assertType(type, value, message); return value; }
-export function assertNotTypePass(type, value, message) { assertNotType(type, value, message); return value; }
-export function isUndefined(value) { return value === undefined; }
-export function isDefined(value) { return value !== undefined; }
-export function assertUndefined(value, message = 'Expected value to be undefined.') { assert(isUndefined(value), message); }
-export function assertDefined(value, message = 'Expected value to not be undefined.') { assert(isDefined(value), message); }
-export function assertUndefinedPass(value, message) { assertUndefined(value, message); return value; }
-export function assertDefinedPass(value, message) { assertDefined(value, message); return value; }
-export function isNull(value) { return value === null; }
-export function isNotNull(value) { return value !== null; }
-export function assertNull(value, message = 'Expected value to be null.') { assert(isNull(value), message); }
-export function assertNotNull(value, message = 'Expected value to not be null.') { assert(isNotNull(value), message); }
-export function assertNullPass(value, message) { assertNull(value, message); return value; }
-export function assertNotNullPass(value, message) { assertNotNull(value, message); return value; }
-export function isNullOrUndefined(value) { return (value === null) || (value === undefined); }
-export function isNotNullOrUndefined(value) { return !isNullOrUndefined(value); }
-export function assertNullOrUndefined(value, message = 'Expected value to be null or undefined.') { assert(isNullOrUndefined(value), message); }
-export function assertNotNullOrUndefined(value, message = 'Expected value to not be null or undefined.') { assert(isNotNullOrUndefined(value), message); }
-export function assertNullOrUndefinedPass(value, message) { assertNullOrUndefined(value, message); return value; }
-export function assertNotNullOrUndefinedPass(value, message) { assertNotNullOrUndefined(value, message); return value; }
-export function isNumber(value) { return (typeof value == 'number'); }
-export function isNotNumber(value) { return !isNumber(value); }
-export function assertNumber(value, message = 'Expected value to be number.') { assert(isNumber(value), message); }
-export function assertNotNumber(value, message = 'Expected value to not be number.') { assert(isNotNumber(value), message); }
-export function assertNumberPass(value, message) { assertNumber(value, message); return value; }
-export function assertNotNumberPass(value, message) { assertNotNumber(value, message); return value; }
-export function isString(value) { return (typeof value == 'string'); }
-export function isNotString(value) { return !isString(value); }
-export function assertString(value, message = 'Expected value to be string.') { assert(isString(value), message); }
-export function assertNotString(value, message = 'Expected value to not be string.') { assert(isNotString(value), message); }
-export function assertStringPass(value, message) { assertString(value, message); return value; }
-export function assertNotStringPass(value, message) { assertNotString(value, message); return value; }
-export function isBoolean(value) { return (typeof value == 'boolean'); }
-export function isNotBoolean(value) { return !isBoolean(value); }
-export function assertBoolean(value, message = 'Expected value to be boolean.') { assert(isBoolean(value), message); }
-export function assertNotBoolean(value, message = 'Expected value to not be boolean.') { assert(isNotBoolean(value), message); }
-export function assertBooleanPass(value, message) { assertBoolean(value, message); return value; }
-export function assertNotBooleanPass(value, message) { assertNotBoolean(value, message); return value; }
-export function isBigInt(value) { return (typeof value == 'bigint'); }
-export function isNotBigInt(value) { return !isBigInt(value); }
-export function assertBigInt(value, message = 'Expected value to be bigint.') { assert(isBigInt(value), message); }
-export function assertNotBigInt(value, message = 'Expected value to not be bigint.') { assert(isNotBigInt(value), message); }
-export function assertBigIntPass(value, message) { assertBigInt(value, message); return value; }
-export function assertNotBigIntPass(value, message) { assertNotBigInt(value, message); return value; }
-export function isFunction(value) { return (typeof value == 'function'); }
-export function isNotFunction(value) { return !isFunction(value); }
-export function assertFunction(value, message = 'Expected value to be function.') { assert(isFunction(value), message); }
-export function assertNotFunction(value, message = 'Expected value to not be function.') { assert(isNotFunction(value), message); }
-export function assertFunctionPass(value, message) { assertFunction(value, message); return value; }
-export function assertNotFunctionPass(value, message) { assertNotFunction(value, message); return value; }
-export function isSymbol(value) { return (typeof value == 'symbol'); }
-export function isNotSymbol(value) { return !isSymbol(value); }
-export function assertSymbol(value, message = 'Expected value to be symbol.') { assert(isSymbol(value), message); }
-export function assertNotSymbol(value, message = 'Expected value to not be symbol.') { assert(isNotSymbol(value), message); }
-export function assertSymbolPass(value, message) { assertSymbol(value, message); return value; }
-export function assertNotSymbolPass(value, message) { assertNotSymbol(value, message); return value; }
-export function isObject(value) { return value?.constructor == Object; }
-export function isNotObject(value) { return !isObject(value); }
-export function assertObject(value, message = 'Expected value to be object.') { assert(isObject(value), message); }
-export function assertNotObject(value, message = 'Expected value to not be object.') { assert(isNotObject(value), message); }
-export function assertObjectPass(value, message) { assertObject(value, message); return value; }
-export function assertNotObjectPass(value, message) { assertNotObject(value, message); return value; }
-export function isPrimitive(value) { const type = typeof value; return type == 'string' || type == 'number' || type == 'boolean' || type == 'bigint' || type == 'symbol' || value === null || value === undefined; }
-export function isNotPrimitive(value) { return !isPrimitive(value); }
-export function assertPrimitive(value, message = 'Expected value to be primitive.') { assert(isPrimitive(value), message); }
-export function assertNotPrimitive(value, message = 'Expected value to not be primitive.') { assert(isNotPrimitive(value), message); }
-export function assertPrimitivePass(value, message) { assertPrimitive(value, message); return value; }
-export function assertNotPrimitivePass(value, message) { assertNotPrimitive(value, message); return value; }
-export function isJsonPrimitive(value) { const type = typeof value; return type == 'string' || type == 'number' || type == 'boolean' || value === null; }
-export function isNotJsonPrimitive(value) { return !isJsonPrimitive(value); }
-export function assertJsonPrimitive(value, message = 'Expected value to be json-primitive.') { assert(isJsonPrimitive(value), message); }
-export function assertNotJsonPrimitive(value, message = 'Expected value to not be json-primitive.') { assert(isNotJsonPrimitive(value), message); }
-export function assertJsonPrimitivePass(value, message) { assertJsonPrimitive(value, message); return value; }
-export function assertNotJsonPrimitivePass(value, message) { assertNotJsonPrimitive(value, message); return value; }
-export function isDate(value) { return (value instanceof Date); }
-export function isNotDate(value) { return !isDate(value); }
-export function assertDate(value, message = 'Expected value to be Date.') { assert(isDate(value), message); }
-export function assertNotDate(value, message = 'Expected value to not be Date.') { assert(isNotDate(value), message); }
-export function assertDatePass(value, message) { assertDate(value, message); return value; }
-export function assertNotDatePass(value, message) { assertNotDate(value, message); return value; }
-export function isValidDate(value) { return isDate(value) && !Number.isNaN(value.getTime()); }
-export function isNotValidDate(value) { return !isValidDate(value); }
-export function assertValidDate(value, message = 'Expected value to be a valid Date.') { assert(isValidDate(value), message); }
-export function assertNotValidDate(value, message = 'Expected value to not be a valid Date.') { assert(isNotValidDate(value), message); }
-export function assertValidDatePass(value, message) { assertValidDate(value, message); return value; }
-export function assertNotValidDatePass(value, message) { assertNotValidDate(value, message); return value; }
-export function isRegExp(value) { return (value instanceof RegExp); }
-export function isNotRegExp(value) { return !isRegExp(value); }
-export function assertRegExp(value, message = 'Expected value to be RegExp.') { assert(isRegExp(value), message); }
-export function assertNotRegExp(value, message = 'Expected value to not be RegExp.') { assert(isNotRegExp(value), message); }
-export function assertRegExpPass(value, message) { assertRegExp(value, message); return value; }
-export function assertNotRegExpPass(value, message) { assertNotRegExp(value, message); return value; }
-export function isArray(value) { return Array.isArray(value); }
-export function isNotArray(value) { return !isArray(value); }
-export function assertArray(value, message = 'Expected value to be Array.') { assert(isArray(value), message); }
-export function assertNotArray(value, message = 'Expected value to not be Array.') { assert(isNotArray(value), message); }
-export function assertArrayPass(value, message) { assertArray(value, message); return value; }
-export function assertNotArrayPass(value, message) { assertNotArray(value, message); return value; }
-export function isWritableArray(value) { return isArray(value); }
-export function isNotWritableArray(value) { return isNotArray(value); }
-export function assertWritableArray(value, message = 'Expected value to be Array.') { assertArray(value, message); }
-export function assertNotWritableArray(value, message = 'Expected value to not be Array.') { assertNotArray(value, message); }
-export function assertWritableArrayPass(value, message) { return assertArrayPass(value, message); }
-export function assertNotWritableArrayPass(value, message) { return assertNotArrayPass(value, message); }
-export function isBlob(value) { return (supportsBlob && (value instanceof Blob)); }
-export function isNotBlob(value) { return !isBlob(value); }
-export function assertBlob(value, message = 'Expected value to be Blob.') { assert(isBlob(value), message); }
-export function assertNotBlob(value, message = 'Expected value to not be Blob.') { assert(isNotBlob(value), message); }
-export function assertBlobPass(value, message) { assertBlob(value, message); return value; }
-export function assertNotBlobPass(value, message) { assertNotBlob(value, message); return value; }
-export function isBinaryData(value) { return isArrayBuffer(value) || isArrayBufferView(value); }
-export function isNotBinaryData(value) { return !isBinaryData(value); }
-export function assertBinaryData(value, message = 'Expected value to be BinaryData.') { assert(isBinaryData(value), message); }
-export function assertNotBinaryData(value, message = 'Expected value to not be BinaryData.') { assert(isNotBinaryData(value), message); }
-export function assertBinaryDataPass(value, message) { assertBinaryData(value, message); return value; }
-export function assertNotBinaryDataPass(value, message) { assertNotBinaryData(value, message); return value; }
-export function isArrayBuffer(value) { return (value instanceof ArrayBuffer); }
-export function isNotArrayBuffer(value) { return !isArrayBuffer(value); }
-export function assertArrayBuffer(value, message = 'Expected value to be ArrayBuffer.') { assert(isArrayBuffer(value), message); }
-export function assertNotArrayBuffer(value, message = 'Expected value to not be ArrayBuffer.') { assert(isNotArrayBuffer(value), message); }
-export function assertArrayBufferPass(value, message) { assertArrayBuffer(value, message); return value; }
-export function assertNotArrayBufferPass(value, message) { assertNotArrayBuffer(value, message); return value; }
-export function isArrayBufferView(value) { return ArrayBuffer.isView(value); }
-export function isNotArrayBufferView(value) { return !isArrayBufferView(value); }
-export function assertArrayBufferView(value, message = 'Expected value to be ArrayBufferView.') { assert(isArrayBufferView(value), message); }
-export function assertNotArrayBufferView(value, message = 'Expected value to not be ArrayBufferView.') { assert(isNotArrayBufferView(value), message); }
-export function assertArrayBufferViewPass(value, message) { assertArrayBufferView(value, message); return value; }
-export function assertNotArrayBufferViewPass(value, message) { assertNotArrayBufferView(value, message); return value; }
-export function isTypedArray(value) { return ArrayBuffer.isView(value) && isNotDataView(value); }
-export function isNotTypedArray(value) { return !isTypedArray(value); }
-export function assertTypedArray(value, message = 'Expected value to be TypedArray.') { assert(isTypedArray(value), message); }
-export function assertNotTypedArray(value, message = 'Expected value to not be TypedArray.') { assert(isNotTypedArray(value), message); }
-export function assertTypedArrayPass(value, message) { assertTypedArray(value, message); return value; }
-export function assertNotTypedArrayPass(value, message) { assertNotTypedArray(value, message); return value; }
-export function isInt8Array(value) { return (value instanceof Int8Array); }
-export function isNotInt8Array(value) { return !isInt8Array(value); }
-export function assertInt8Array(value, message = 'Expected value to be Int8Array.') { assert(isInt8Array(value), message); }
-export function assertNotInt8Array(value, message = 'Expected value to not be Int8Array.') { assert(isNotInt8Array(value), message); }
-export function assertInt8ArrayPass(value, message) { assertInt8Array(value, message); return value; }
-export function assertNotInt8ArrayPass(value, message) { assertNotInt8Array(value, message); return value; }
-export function isUint8Array(value) { return (value instanceof Uint8Array); }
-export function isNotUint8Array(value) { return !isUint8Array(value); }
-export function assertUint8Array(value, message = 'Expected value to be Uint8Array.') { assert(isUint8Array(value), message); }
-export function assertNotUint8Array(value, message = 'Expected value to not be Uint8Array.') { assert(isNotUint8Array(value), message); }
-export function assertUint8ArrayPass(value, message) { assertUint8Array(value, message); return value; }
-export function assertNotUint8ArrayPass(value, message) { assertNotUint8Array(value, message); return value; }
-export function isUint8ClampedArray(value) { return (value instanceof Uint8ClampedArray); }
-export function isNotUint8ClampedArray(value) { return !isUint8ClampedArray(value); }
-export function assertUint8ClampedArray(value, message = 'Expected value to be Uint8ClampedArray.') { assert(isUint8ClampedArray(value), message); }
-export function assertNotUint8ClampedArray(value, message = 'Expected value to not be Uint8ClampedArray.') { assert(isNotUint8ClampedArray(value), message); }
-export function assertUint8ClampedArrayPass(value, message) { assertUint8ClampedArray(value, message); return value; }
-export function assertNotUint8ClampedArrayPass(value, message) { assertNotUint8ClampedArray(value, message); return value; }
-export function isInt16Array(value) { return (value instanceof Int16Array); }
-export function isNotInt16Array(value) { return !isInt16Array(value); }
-export function assertInt16Array(value, message = 'Expected value to be Int16Array.') { assert(isInt16Array(value), message); }
-export function assertNotInt16Array(value, message = 'Expected value to not be Int16Array.') { assert(isNotInt16Array(value), message); }
-export function assertInt16ArrayPass(value, message) { assertInt16Array(value, message); return value; }
-export function assertNotInt16ArrayPass(value, message) { assertNotInt16Array(value, message); return value; }
-export function isUint16Array(value) { return (value instanceof Uint16Array); }
-export function isNotUint16Array(value) { return !isUint16Array(value); }
-export function assertUint16Array(value, message = 'Expected value to be Uint16Array.') { assert(isUint16Array(value), message); }
-export function assertNotUint16Array(value, message = 'Expected value to not be Uint16Array.') { assert(isNotUint16Array(value), message); }
-export function assertUint16ArrayPass(value, message) { assertUint16Array(value, message); return value; }
-export function assertNotUint16ArrayPass(value, message) { assertNotUint16Array(value, message); return value; }
-export function isInt32Array(value) { return (value instanceof Int32Array); }
-export function isNotInt32Array(value) { return !isInt32Array(value); }
-export function assertInt32Array(value, message = 'Expected value to be Int32Array.') { assert(isInt32Array(value), message); }
-export function assertNotInt32Array(value, message = 'Expected value to not be Int32Array.') { assert(isNotInt32Array(value), message); }
-export function assertInt32ArrayPass(value, message) { assertInt32Array(value, message); return value; }
-export function assertNotInt32ArrayPass(value, message) { assertNotInt32Array(value, message); return value; }
-export function isUint32Array(value) { return (value instanceof Uint32Array); }
-export function isNotUint32Array(value) { return !isUint32Array(value); }
-export function assertUint32Array(value, message = 'Expected value to be Uint32Array.') { assert(isUint32Array(value), message); }
-export function assertNotUint32Array(value, message = 'Expected value to not be Uint32Array.') { assert(isNotUint32Array(value), message); }
-export function assertUint32ArrayPass(value, message) { assertUint32Array(value, message); return value; }
-export function assertNotUint32ArrayPass(value, message) { assertNotUint32Array(value, message); return value; }
-export function isFloat32Array(value) { return (value instanceof Float32Array); }
-export function isNotFloat32Array(value) { return !isFloat32Array(value); }
-export function assertFloat32Array(value, message = 'Expected value to be Float32Array.') { assert(isFloat32Array(value), message); }
-export function assertNotFloat32Array(value, message = 'Expected value to not be Float32Array.') { assert(isNotFloat32Array(value), message); }
-export function assertFloat32ArrayPass(value, message) { assertFloat32Array(value, message); return value; }
-export function assertNotFloat32ArrayPass(value, message) { assertNotFloat32Array(value, message); return value; }
-export function isFloat64Array(value) { return (value instanceof Float64Array); }
-export function isNotFloat64Array(value) { return !isFloat64Array(value); }
-export function assertFloat64Array(value, message = 'Expected value to be Float64Array.') { assert(isFloat64Array(value), message); }
-export function assertNotFloat64Array(value, message = 'Expected value to not be Float64Array.') { assert(isNotFloat64Array(value), message); }
-export function assertFloat64ArrayPass(value, message) { assertFloat64Array(value, message); return value; }
-export function assertNotFloat64ArrayPass(value, message) { assertNotFloat64Array(value, message); return value; }
-export function isBigInt64Array(value) { return (value instanceof BigInt64Array); }
-export function isNotBigInt64Array(value) { return !isBigInt64Array(value); }
-export function assertBigInt64Array(value, message = 'Expected value to be BigInt64Array.') { assert(isBigInt64Array(value), message); }
-export function assertNotBigInt64Array(value, message = 'Expected value to not be BigInt64Array.') { assert(isNotBigInt64Array(value), message); }
-export function assertBigInt64ArrayPass(value, message) { assertBigInt64Array(value, message); return value; }
-export function assertNotBigInt64ArrayPass(value, message) { assertNotBigInt64Array(value, message); return value; }
-export function isBigUint64Array(value) { return (value instanceof BigUint64Array); }
-export function isNotBigUint64Array(value) { return !isBigUint64Array(value); }
-export function assertBigUint64Array(value, message = 'Expected value to be BigUint64Array.') { assert(isBigUint64Array(value), message); }
-export function assertNotBigUint64Array(value, message = 'Expected value to not be BigUint64Array.') { assert(isNotBigUint64Array(value), message); }
-export function assertBigUint64ArrayPass(value, message) { assertBigUint64Array(value, message); return value; }
-export function assertNotBigUint64ArrayPass(value, message) { assertNotBigUint64Array(value, message); return value; }
-export function isDataView(value) { return (value instanceof DataView); }
-export function isNotDataView(value) { return !isDataView(value); }
-export function assertDataView(value, message = 'Expected value to be DataView.') { assert(isDataView(value), message); }
-export function assertNotDataView(value, message = 'Expected value to not be DataView.') { assert(isNotDataView(value), message); }
-export function assertDataViewPass(value, message) { assertDataView(value, message); return value; }
-export function assertNotDataViewPass(value, message) { assertNotDataView(value, message); return value; }
-export function isSet(value) { return (value instanceof Set); }
-export function isNotSet(value) { return !isSet(value); }
-export function assertSet(value, message = 'Expected value to be Set.') { assert(isSet(value), message); }
-export function assertNotSet(value, message = 'Expected value to not be Set.') { assert(isNotSet(value), message); }
-export function assertSetPass(value, message) { assertSet(value, message); return value; }
-export function assertNotSetPass(value, message) { assertNotSet(value, message); return value; }
-export function isMap(value) { return (value instanceof Map); }
-export function isNotMap(value) { return !isMap(value); }
-export function assertMap(value, message = 'Expected value to be Map.') { assert(isMap(value), message); }
-export function assertNotMap(value, message = 'Expected value to not be Map.') { assert(isNotMap(value), message); }
-export function assertMapPass(value, message) { assertMap(value, message); return value; }
-export function assertNotMapPass(value, message) { assertNotMap(value, message); return value; }
-export function isPromise(value) { return (value instanceof Promise); }
-export function isNotPromise(value) { return !isPromise(value); }
-export function assertPromise(value, message = 'Expected value to be Promise.') { assert(isPromise(value), message); }
-export function assertNotPromise(value, message = 'Expected value to not be Promise.') { assert(isNotPromise(value), message); }
-export function assertPromisePass(value, message) { assertPromise(value, message); return value; } // eslint-disable-line @typescript-eslint/promise-function-async
-export function assertNotPromisePass(value, message) { assertNotPromise(value, message); return value; }
-export function isReadableStream(value) { return (supportsReadableStream && (value instanceof ReadableStream)); }
-export function isNotReadableStream(value) { return !isReadableStream(value); }
-export function assertReadableStream(value, message = 'Expected value to be ReadableStream.') { assert(isReadableStream(value), message); }
-export function assertNotReadableStream(value, message = 'Expected value to not be ReadableStream.') { assert(isNotReadableStream(value), message); }
-export function assertReadableStreamPass(value, message) { assertReadableStream(value, message); return value; }
-export function assertNotReadableStreamPass(value, message) { assertNotReadableStream(value, message); return value; }
-export function isError(value) { return (value instanceof Error); }
-export function isNotError(value) { return !isError(value); }
-export function assertError(value, message = 'Expected value to be Error.') { assert(isError(value), message); }
-export function assertNotError(value, message = 'Expected value to not be Error.') { assert(isNotError(value), message); }
-export function assertErrorPass(value, message) { assertError(value, message); return value; }
-export function assertNotErrorPass(value, message) { assertNotError(value, message); return value; }
+export function createGuards(name, testFn) {
+    const normalizedName = name.split(' ').map((slice) => slice[0].toUpperCase() + slice.slice(1)).join('');
+    const defaultMessage = `Expected value to be ${name}.`;
+    const defaultNotMessage = `Expected value to not be ${name}.`;
+    return {
+        [`is${normalizedName}`](value) {
+            return testFn(value);
+        },
+        [`isNot${normalizedName}`](value) {
+            return !testFn(value);
+        },
+        [`assert${normalizedName}`](value, message = defaultMessage) {
+            assert(testFn(value), message);
+        },
+        [`assertNot${normalizedName}`](value, message = defaultNotMessage) {
+            assertNot(testFn(value), message);
+        },
+        [`assert${normalizedName}Pass`](value, message = defaultMessage) {
+            assert(testFn(value), message);
+            return value;
+        },
+        [`assertNot${normalizedName}Pass`](value, message = defaultNotMessage) {
+            assertNot(testFn(value), message);
+            return value;
+        }
+    };
+}
+export function createInstanceGuards(name, type) {
+    return createGuards(name, (value) => value instanceof type);
+}
+const undefinedGuards = createGuards('undefined', (value) => (value === undefined));
+export const isUndefined = undefinedGuards.isUndefined;
+export const isDefined = undefinedGuards.isNotUndefined;
+export const assertUndefined = undefinedGuards.assertUndefined;
+export const assertDefined = undefinedGuards.assertNotUndefined;
+export const assertUndefinedPass = undefinedGuards.assertUndefinedPass;
+export const assertDefinedPass = undefinedGuards.assertNotUndefinedPass;
+const nullGuards = createGuards('null', (value) => (value === null));
+export const isNull = nullGuards.isNull;
+export const isNotNull = nullGuards.isNotNull;
+export const assertNull = nullGuards.assertNull;
+export const assertNotNull = nullGuards.assertNotNull;
+export const assertNullPass = nullGuards.assertNullPass;
+export const assertNotNullPass = nullGuards.assertNotNullPass;
+const nullOrUndefinedGuards = createGuards('null or undefined', (value) => (value === null) || (value === undefined));
+export const isNullOrUndefined = nullOrUndefinedGuards.isNullOrUndefined;
+export const isNotNullOrUndefined = nullOrUndefinedGuards.isNotNullOrUndefined;
+export const assertNullOrUndefined = nullOrUndefinedGuards.assertNullOrUndefined;
+export const assertNotNullOrUndefined = nullOrUndefinedGuards.assertNotNullOrUndefined;
+export const assertNullOrUndefinedPass = nullOrUndefinedGuards.assertNullOrUndefinedPass;
+export const assertNotNullOrUndefinedPass = nullOrUndefinedGuards.assertNotNullOrUndefinedPass;
+const numberGuards = createGuards('number', (value) => (typeof value == 'number'));
+export const isNumber = numberGuards.isNumber;
+export const isNotNumber = numberGuards.isNotNumber;
+export const assertNumber = numberGuards.assertNumber;
+export const assertNotNumber = numberGuards.assertNotNumber;
+export const assertNumberPass = numberGuards.assertNumberPass;
+export const assertNotNumberPass = numberGuards.assertNotNumberPass;
+const stringGuards = createGuards('string', (value) => (typeof value == 'string'));
+export const isString = stringGuards.isString;
+export const isNotString = stringGuards.isNotString;
+export const assertString = stringGuards.assertString;
+export const assertNotString = stringGuards.assertNotString;
+export const assertStringPass = stringGuards.assertStringPass;
+export const assertNotStringPass = stringGuards.assertNotStringPass;
+const booleanGuards = createGuards('boolean', (value) => (typeof value == 'boolean'));
+export const isBoolean = booleanGuards.isBoolean;
+export const isNotBoolean = booleanGuards.isNotBoolean;
+export const assertBoolean = booleanGuards.assertBoolean;
+export const assertNotBoolean = booleanGuards.assertNotBoolean;
+export const assertBooleanPass = booleanGuards.assertBooleanPass;
+export const assertNotBooleanPass = booleanGuards.assertNotBooleanPass;
+const bigintGuards = createGuards('bigint', (value) => (typeof value == 'bigint'));
+export const isBigInt = bigintGuards.isBigint;
+export const isNotBigInt = bigintGuards.isNotBigint;
+export const assertBigInt = bigintGuards.assertBigint;
+export const assertNotBigInt = bigintGuards.assertNotBigint;
+export const assertBigIntPass = bigintGuards.assertBigintPass;
+export const assertNotBigIntPass = bigintGuards.assertNotBigintPass;
+const functionGuards = createGuards('function', (value) => (typeof value == 'function'));
+export const isFunction = functionGuards.isFunction;
+export const isNotFunction = functionGuards.isNotFunction;
+export const assertFunction = functionGuards.assertFunction;
+export const assertNotFunction = functionGuards.assertNotFunction;
+export const assertFunctionPass = functionGuards.assertFunctionPass;
+export const assertNotFunctionPass = functionGuards.assertNotFunctionPass;
+const symbolGuards = createGuards('symbol', (value) => (typeof value == 'symbol'));
+export const isSymbol = symbolGuards.isSymbol;
+export const isNotSymbol = symbolGuards.isNotSymbol;
+export const assertSymbol = symbolGuards.assertSymbol;
+export const assertNotSymbol = symbolGuards.assertNotSymbol;
+export const assertSymbolPass = symbolGuards.assertSymbolPass;
+export const assertNotSymbolPass = symbolGuards.assertNotSymbolPass;
+const literalObjectGuards = createGuards('literal object', (value) => (typeof value == 'object') && (value != null) && (Reflect.getPrototypeOf(value) == Object.prototype) && (Reflect.getPrototypeOf(value).constructor == Object));
+export const isLiteralObject = literalObjectGuards.isLiteralObject;
+export const isNotLiteralObject = literalObjectGuards.isNotLiteralObject;
+export const assertLiteralObject = literalObjectGuards.assertLiteralObject;
+export const assertNotLiteralObject = literalObjectGuards.assertNotLiteralObject;
+export const assertLiteralObjectPass = literalObjectGuards.assertLiteralObjectPass;
+export const assertNotLiteralObjectPass = literalObjectGuards.assertNotLiteralObjectPass;
+const objectGuards = createGuards('object', (value) => (typeof value == 'object') && (value != null));
+export const isObject = objectGuards.isObject;
+export const isNotObject = objectGuards.isNotObject;
+export const assertObject = objectGuards.assertObject;
+export const assertNotObject = objectGuards.assertNotObject;
+export const assertObjectPass = objectGuards.assertObjectPass;
+export const assertNotObjectPass = objectGuards.assertNotObjectPass;
+const primitiveGuards = createGuards('primitive', (value) => {
+    const type = typeof value;
+    return (type == 'string') || (type == 'number') || (type == 'boolean') || (type == 'bigint') || (type == 'symbol') || (value === null) || (value === undefined);
+});
+export const isPrimitive = primitiveGuards.isPrimitive;
+export const isNotPrimitive = primitiveGuards.isNotPrimitive;
+export const assertPrimitive = primitiveGuards.assertPrimitive;
+export const assertNotPrimitive = primitiveGuards.assertNotPrimitive;
+export const assertPrimitivePass = primitiveGuards.assertPrimitivePass;
+export const assertNotPrimitivePass = primitiveGuards.assertNotPrimitivePass;
+const jsonPrimitiveGuards = createGuards('json primitive', (value) => {
+    const type = typeof value;
+    return (type == 'string') || (type == 'number') || (type == 'boolean') || (value === null);
+});
+export const isJsonPrimitive = jsonPrimitiveGuards.isJsonPrimitive;
+export const isNotJsonPrimitive = jsonPrimitiveGuards.isNotJsonPrimitive;
+export const assertJsonPrimitive = jsonPrimitiveGuards.assertJsonPrimitive;
+export const assertNotJsonPrimitive = jsonPrimitiveGuards.assertNotJsonPrimitive;
+export const assertJsonPrimitivePass = jsonPrimitiveGuards.assertJsonPrimitivePass;
+export const assertNotJsonPrimitivePass = jsonPrimitiveGuards.assertNotJsonPrimitivePass;
+const dateGuards = createInstanceGuards('date', Date);
+export const isDate = dateGuards.isDate;
+export const isNotDate = dateGuards.isNotDate;
+export const assertDate = dateGuards.assertDate;
+export const assertNotDate = dateGuards.assertNotDate;
+export const assertDatePass = dateGuards.assertDatePass;
+export const assertNotDatePass = dateGuards.assertNotDatePass;
+const validDateGuards = createGuards('valid date', (value) => isDate(value) && !Number.isNaN(value.getTime()));
+export const isValidDate = validDateGuards.isValidDate;
+export const isNotValidDate = validDateGuards.isNotValidDate;
+export const assertValidDate = validDateGuards.assertValidDate;
+export const assertNotValidDate = validDateGuards.assertNotValidDate;
+export const assertValidDatePass = validDateGuards.assertValidDatePass;
+export const assertNotValidDatePass = validDateGuards.assertNotValidDatePass;
+const regexpGuards = createInstanceGuards('regexp', RegExp);
+export const isRegExp = regexpGuards.isRegexp;
+export const isNotRegExp = regexpGuards.isNotRegexp;
+export const assertRegExp = regexpGuards.assertRegexp;
+export const assertNotRegExp = regexpGuards.assertNotRegexp;
+export const assertRegExpPass = regexpGuards.assertRegexpPass;
+export const assertNotRegExpPass = regexpGuards.assertNotRegexpPass;
+const arrayGuards = createGuards('array', (value) => Array.isArray(value));
+export const isArray = arrayGuards.isArray;
+export const isNotArray = arrayGuards.isNotArray;
+export const assertArray = arrayGuards.assertArray;
+export const assertNotArray = arrayGuards.assertNotArray;
+export const assertArrayPass = arrayGuards.assertArrayPass;
+export const assertNotArrayPass = arrayGuards.assertNotArrayPass;
+const writableArrayGuards = createGuards('writable array', (value) => Array.isArray(value));
+export const isWritableArray = writableArrayGuards.isWritableArray;
+export const isNotWritableArray = writableArrayGuards.isNotWritableArray;
+export const assertWritableArray = writableArrayGuards.assertWritableArray;
+export const assertNotWritableArray = writableArrayGuards.assertNotWritableArray;
+export const assertWritableArrayPass = writableArrayGuards.assertWritableArrayPass;
+export const assertNotWritableArrayPass = writableArrayGuards.assertNotWritableArrayPass;
+const blobGuards = createGuards('Blob', (value) => (supportsBlob && (value instanceof Blob)));
+export const isBlob = blobGuards.isBlob;
+export const isNotBlob = blobGuards.isNotBlob;
+export const assertBlob = blobGuards.assertBlob;
+export const assertNotBlob = blobGuards.assertNotBlob;
+export const assertBlobPass = blobGuards.assertBlobPass;
+export const assertNotBlobPass = blobGuards.assertNotBlobPass;
+const arrayBufferGuards = createInstanceGuards('ArrayBuffer', ArrayBuffer);
+export const isArrayBuffer = arrayBufferGuards.isArrayBuffer;
+export const isNotArrayBuffer = arrayBufferGuards.isNotArrayBuffer;
+export const assertArrayBuffer = arrayBufferGuards.assertArrayBuffer;
+export const assertNotArrayBuffer = arrayBufferGuards.assertNotArrayBuffer;
+export const assertArrayBufferPass = arrayBufferGuards.assertArrayBufferPass;
+export const assertNotArrayBufferPass = arrayBufferGuards.assertNotArrayBufferPass;
+const arrayBufferViewGuards = createGuards('ArrayBufferView', (value) => ArrayBuffer.isView(value));
+export const isArrayBufferView = arrayBufferViewGuards.isArrayBufferView;
+export const isNotArrayBufferView = arrayBufferViewGuards.isNotArrayBufferView;
+export const assertArrayBufferView = arrayBufferViewGuards.assertArrayBufferView;
+export const assertNotArrayBufferView = arrayBufferViewGuards.assertNotArrayBufferView;
+export const assertArrayBufferViewPass = arrayBufferViewGuards.assertArrayBufferViewPass;
+export const assertNotArrayBufferViewPass = arrayBufferViewGuards.assertNotArrayBufferViewPass;
+const binaryDataGuards = createGuards('BinaryData', (value) => (isArrayBuffer(value) || isArrayBufferView(value)));
+export const isBinaryData = binaryDataGuards.isBinaryData;
+export const isNotBinaryData = binaryDataGuards.isNotBinaryData;
+export const assertBinaryData = binaryDataGuards.assertBinaryData;
+export const assertNotBinaryData = binaryDataGuards.assertNotBinaryData;
+export const assertBinaryDataPass = binaryDataGuards.assertBinaryDataPass;
+export const assertNotBinaryDataPass = binaryDataGuards.assertNotBinaryDataPass;
+const int8ArrayGuards = createInstanceGuards('Int8Array', Int8Array);
+export const isInt8Array = int8ArrayGuards.isInt8Array;
+export const isNotInt8Array = int8ArrayGuards.isNotInt8Array;
+export const assertInt8Array = int8ArrayGuards.assertInt8Array;
+export const assertNotInt8Array = int8ArrayGuards.assertNotInt8Array;
+export const assertInt8ArrayPass = int8ArrayGuards.assertInt8ArrayPass;
+export const assertNotInt8ArrayPass = int8ArrayGuards.assertNotInt8ArrayPass;
+const uint8ArrayGuards = createInstanceGuards('Uint8Array', Uint8Array);
+export const isUint8Array = uint8ArrayGuards.isUint8Array;
+export const isNotUint8Array = uint8ArrayGuards.isNotUint8Array;
+export const assertUint8Array = uint8ArrayGuards.assertUint8Array;
+export const assertNotUint8Array = uint8ArrayGuards.assertNotUint8Array;
+export const assertUint8ArrayPass = uint8ArrayGuards.assertUint8ArrayPass;
+export const assertNotUint8ArrayPass = uint8ArrayGuards.assertNotUint8ArrayPass;
+const uint8ClampedArrayGuards = createInstanceGuards('Uint8ClampedArray', Uint8ClampedArray);
+export const isUint8ClampedArray = uint8ClampedArrayGuards.isUint8ClampedArray;
+export const isNotUint8ClampedArray = uint8ClampedArrayGuards.isNotUint8ClampedArray;
+export const assertUint8ClampedArray = uint8ClampedArrayGuards.assertUint8ClampedArray;
+export const assertNotUint8ClampedArray = uint8ClampedArrayGuards.assertNotUint8ClampedArray;
+export const assertUint8ClampedArrayPass = uint8ClampedArrayGuards.assertUint8ClampedArrayPass;
+export const assertNotUint8ClampedArrayPass = uint8ClampedArrayGuards.assertNotUint8ClampedArrayPass;
+const int16ArrayGuards = createInstanceGuards('Int16Array', Int16Array);
+export const isInt16Array = int16ArrayGuards.isInt16Array;
+export const isNotInt16Array = int16ArrayGuards.isNotInt16Array;
+export const assertInt16Array = int16ArrayGuards.assertInt16Array;
+export const assertNotInt16Array = int16ArrayGuards.assertNotInt16Array;
+export const assertInt16ArrayPass = int16ArrayGuards.assertInt16ArrayPass;
+export const assertNotInt16ArrayPass = int16ArrayGuards.assertNotInt16ArrayPass;
+const uint16ArrayGuards = createInstanceGuards('Uint16Array', Uint16Array);
+export const isUint16Array = uint16ArrayGuards.isUint16Array;
+export const isNotUint16Array = uint16ArrayGuards.isNotUint16Array;
+export const assertUint16Array = uint16ArrayGuards.assertUint16Array;
+export const assertNotUint16Array = uint16ArrayGuards.assertNotUint16Array;
+export const assertUint16ArrayPass = uint16ArrayGuards.assertUint16ArrayPass;
+export const assertNotUint16ArrayPass = uint16ArrayGuards.assertNotUint16ArrayPass;
+const int32ArrayGuards = createInstanceGuards('Int32Array', Int32Array);
+export const isInt32Array = int32ArrayGuards.isInt32Array;
+export const isNotInt32Array = int32ArrayGuards.isNotInt32Array;
+export const assertInt32Array = int32ArrayGuards.assertInt32Array;
+export const assertNotInt32Array = int32ArrayGuards.assertNotInt32Array;
+export const assertInt32ArrayPass = int32ArrayGuards.assertInt32ArrayPass;
+export const assertNotInt32ArrayPass = int32ArrayGuards.assertNotInt32ArrayPass;
+const uint32ArrayGuards = createInstanceGuards('Uint32Array', Uint32Array);
+export const isUint32Array = uint32ArrayGuards.isUint32Array;
+export const isNotUint32Array = uint32ArrayGuards.isNotUint32Array;
+export const assertUint32Array = uint32ArrayGuards.assertUint32Array;
+export const assertNotUint32Array = uint32ArrayGuards.assertNotUint32Array;
+export const assertUint32ArrayPass = uint32ArrayGuards.assertUint32ArrayPass;
+export const assertNotUint32ArrayPass = uint32ArrayGuards.assertNotUint32ArrayPass;
+const float32ArrayGuards = createInstanceGuards('Float32Array', Float32Array);
+export const isFloat32Array = float32ArrayGuards.isFloat32Array;
+export const isNotFloat32Array = float32ArrayGuards.isNotFloat32Array;
+export const assertFloat32Array = float32ArrayGuards.assertFloat32Array;
+export const assertNotFloat32Array = float32ArrayGuards.assertNotFloat32Array;
+export const assertFloat32ArrayPass = float32ArrayGuards.assertFloat32ArrayPass;
+export const assertNotFloat32ArrayPass = float32ArrayGuards.assertNotFloat32ArrayPass;
+const float64ArrayGuards = createInstanceGuards('Float64Array', Float64Array);
+export const isFloat64Array = float64ArrayGuards.isFloat64Array;
+export const isNotFloat64Array = float64ArrayGuards.isNotFloat64Array;
+export const assertFloat64Array = float64ArrayGuards.assertFloat64Array;
+export const assertNotFloat64Array = float64ArrayGuards.assertNotFloat64Array;
+export const assertFloat64ArrayPass = float64ArrayGuards.assertFloat64ArrayPass;
+export const assertNotFloat64ArrayPass = float64ArrayGuards.assertNotFloat64ArrayPass;
+const bigInt64ArrayGuards = createInstanceGuards('BigInt64Array', BigInt64Array);
+export const isBigInt64Array = bigInt64ArrayGuards.isBigInt64Array;
+export const isNotBigInt64Array = bigInt64ArrayGuards.isNotBigInt64Array;
+export const assertBigInt64Array = bigInt64ArrayGuards.assertBigInt64Array;
+export const assertNotBigInt64Array = bigInt64ArrayGuards.assertNotBigInt64Array;
+export const assertBigInt64ArrayPass = bigInt64ArrayGuards.assertBigInt64ArrayPass;
+export const assertNotBigInt64ArrayPass = bigInt64ArrayGuards.assertNotBigInt64ArrayPass;
+const bigUint64ArrayGuards = createInstanceGuards('BigUint64Array', BigUint64Array);
+export const isBigUint64Array = bigUint64ArrayGuards.isBigUint64Array;
+export const isNotBigUint64Array = bigUint64ArrayGuards.isNotBigUint64Array;
+export const assertBigUint64Array = bigUint64ArrayGuards.assertBigUint64Array;
+export const assertNotBigUint64Array = bigUint64ArrayGuards.assertNotBigUint64Array;
+export const assertBigUint64ArrayPass = bigUint64ArrayGuards.assertBigUint64ArrayPass;
+export const assertNotBigUint64ArrayPass = bigUint64ArrayGuards.assertNotBigUint64ArrayPass;
+const dataViewGuards = createInstanceGuards('DataView', DataView);
+export const isDataView = dataViewGuards.isDataView;
+export const isNotDataView = dataViewGuards.isNotDataView;
+export const assertDataView = dataViewGuards.assertDataView;
+export const assertNotDataView = dataViewGuards.assertNotDataView;
+export const assertDataViewPass = dataViewGuards.assertDataViewPass;
+export const assertNotDataViewPass = dataViewGuards.assertNotDataViewPass;
+const typedArrayGuards = createGuards('TypedArray', (value) => (ArrayBuffer.isView(value) && isNotDataView(value)));
+export const isTypedArray = typedArrayGuards.isTypedArray;
+export const isNotTypedArray = typedArrayGuards.isNotTypedArray;
+export const assertTypedArray = typedArrayGuards.assertTypedArray;
+export const assertNotTypedArray = typedArrayGuards.assertNotTypedArray;
+export const assertTypedArrayPass = typedArrayGuards.assertTypedArrayPass;
+export const assertNotTypedArrayPass = typedArrayGuards.assertNotTypedArrayPass;
+const setGuards = createInstanceGuards('Set', Set);
+export const isSet = setGuards.isSet;
+export const isNotSet = setGuards.isNotSet;
+export const assertSet = setGuards.assertSet;
+export const assertNotSet = setGuards.assertNotSet;
+export const assertSetPass = setGuards.assertSetPass;
+export const assertNotSetPass = setGuards.assertNotSetPass;
+const mapGuards = createInstanceGuards('Map', Map);
+export const isMap = mapGuards.isMap;
+export const isNotMap = mapGuards.isNotMap;
+export const assertMap = mapGuards.assertMap;
+export const assertNotMap = mapGuards.assertNotMap;
+export const assertMapPass = mapGuards.assertMapPass;
+export const assertNotMapPass = mapGuards.assertNotMapPass;
+const promiseGuards = createInstanceGuards('Promise', Promise);
+export const isPromise = promiseGuards.isPromise;
+export const isNotPromise = promiseGuards.isNotPromise;
+export const assertPromise = promiseGuards.assertPromise;
+export const assertNotPromise = promiseGuards.assertNotPromise;
+export const assertPromisePass = promiseGuards.assertPromisePass;
+export const assertNotPromisePass = promiseGuards.assertNotPromisePass;
+const errorGuards = createInstanceGuards('error', Error);
+export const isError = errorGuards.isError;
+export const isNotError = errorGuards.isNotError;
+export const assertError = errorGuards.assertError;
+export const assertNotError = errorGuards.assertNotError;
+export const assertErrorPass = errorGuards.assertErrorPass;
+export const assertNotErrorPass = errorGuards.assertNotErrorPass;
+const readableStreamGuards = createGuards('ReadableStream', (value) => (supportsReadableStream && (value instanceof ReadableStream)));
+export const isReadableStream = readableStreamGuards.isReadableStream;
+export const isNotReadableStream = readableStreamGuards.isNotReadableStream;
+export const assertReadableStream = readableStreamGuards.assertReadableStream;
+export const assertNotReadableStream = readableStreamGuards.assertNotReadableStream;
+export const assertReadableStreamPass = readableStreamGuards.assertReadableStreamPass;
+export const assertNotReadableStreamPass = readableStreamGuards.assertNotReadableStreamPass;