@tstdl/base 0.72.0-beta1 → 0.78.0-beta3

package/utils/type-guards.js

@@ -1,217 +1,442 @@
+"use strict";
 /* eslint-disable @typescript-eslint/ban-types, @typescript-eslint/restrict-template-expressions, max-statements-per-line */
-import { AssertionError } from "../error/assertion.error.js";
-export function assert(condition, message = 'assertion failed') {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertNotFunctionPass = exports.assertFunctionPass = exports.assertNotFunction = exports.assertFunction = exports.isNotFunction = exports.isFunction = exports.assertNotBigIntPass = exports.assertBigIntPass = exports.assertNotBigInt = exports.assertBigInt = exports.isNotBigInt = exports.isBigInt = exports.assertNotBooleanPass = exports.assertBooleanPass = exports.assertNotBoolean = exports.assertBoolean = exports.isNotBoolean = exports.isBoolean = exports.assertNotStringPass = exports.assertStringPass = exports.assertNotString = exports.assertString = exports.isNotString = exports.isString = exports.assertNotNumberPass = exports.assertNumberPass = exports.assertNotNumber = exports.assertNumber = exports.isNotNumber = exports.isNumber = exports.assertNotNullOrUndefinedPass = exports.assertNullOrUndefinedPass = exports.assertNotNullOrUndefined = exports.assertNullOrUndefined = exports.isNotNullOrUndefined = exports.isNullOrUndefined = exports.assertNotNullPass = exports.assertNullPass = exports.assertNotNull = exports.assertNull = exports.isNotNull = exports.isNull = exports.assertDefinedPass = exports.assertUndefinedPass = exports.assertDefined = exports.assertUndefined = exports.isDefined = exports.isUndefined = exports.assertNot = exports.assert = void 0;
+exports.isNotWritableArray = exports.isWritableArray = exports.assertNotArrayPass = exports.assertArrayPass = exports.assertNotArray = exports.assertArray = exports.isNotArray = exports.isArray = exports.assertNotRegExpPass = exports.assertRegExpPass = exports.assertNotRegExp = exports.assertRegExp = exports.isNotRegExp = exports.isRegExp = exports.assertNotValidDatePass = exports.assertValidDatePass = exports.assertNotValidDate = exports.assertValidDate = exports.isNotValidDate = exports.isValidDate = exports.assertNotDatePass = exports.assertDatePass = exports.assertNotDate = exports.assertDate = exports.isNotDate = exports.isDate = exports.assertNotJsonPrimitivePass = exports.assertJsonPrimitivePass = exports.assertNotJsonPrimitive = exports.assertJsonPrimitive = exports.isNotJsonPrimitive = exports.isJsonPrimitive = exports.assertNotPrimitivePass = exports.assertPrimitivePass = exports.assertNotPrimitive = exports.assertPrimitive = exports.isNotPrimitive = exports.isPrimitive = exports.assertNotObjectPass = exports.assertObjectPass = exports.assertNotObject = exports.assertObject = exports.isNotObject = exports.isObject = exports.assertNotSymbolPass = exports.assertSymbolPass = exports.assertNotSymbol = exports.assertSymbol = exports.isNotSymbol = exports.isSymbol = void 0;
+exports.assertNotUint16Array = exports.assertUint16Array = exports.isNotUint16Array = exports.isUint16Array = exports.assertNotInt16ArrayPass = exports.assertInt16ArrayPass = exports.assertNotInt16Array = exports.assertInt16Array = exports.isNotInt16Array = exports.isInt16Array = exports.assertNotUint8ClampedArrayPass = exports.assertUint8ClampedArrayPass = exports.assertNotUint8ClampedArray = exports.assertUint8ClampedArray = exports.isNotUint8ClampedArray = exports.isUint8ClampedArray = exports.assertNotUint8ArrayPass = exports.assertUint8ArrayPass = exports.assertNotUint8Array = exports.assertUint8Array = exports.isNotUint8Array = exports.isUint8Array = exports.assertNotInt8ArrayPass = exports.assertInt8ArrayPass = exports.assertNotInt8Array = exports.assertInt8Array = exports.isNotInt8Array = exports.isInt8Array = exports.assertNotTypedArrayPass = exports.assertTypedArrayPass = exports.assertNotTypedArray = exports.assertTypedArray = exports.isNotTypedArray = exports.isTypedArray = exports.assertNotArrayBufferViewPass = exports.assertArrayBufferViewPass = exports.assertNotArrayBufferView = exports.assertArrayBufferView = exports.isNotArrayBufferView = exports.isArrayBufferView = exports.assertNotArrayBufferPass = exports.assertArrayBufferPass = exports.assertNotArrayBuffer = exports.assertArrayBuffer = exports.isNotArrayBuffer = exports.isArrayBuffer = exports.assertNotWritableArrayPass = exports.assertWritableArrayPass = exports.assertNotWritableArray = exports.assertWritableArray = void 0;
+exports.assertNotSetPass = exports.assertSetPass = exports.assertNotSet = exports.assertSet = exports.isNotSet = exports.isSet = exports.assertNotDataViewPass = exports.assertDataViewPass = exports.assertNotDataView = exports.assertDataView = exports.isNotDataView = exports.isDataView = exports.assertNotBigUint64ArrayPass = exports.assertBigUint64ArrayPass = exports.assertNotBigUint64Array = exports.assertBigUint64Array = exports.isNotBigUint64Array = exports.isBigUint64Array = exports.assertNotBigInt64ArrayPass = exports.assertBigInt64ArrayPass = exports.assertNotBigInt64Array = exports.assertBigInt64Array = exports.isNotBigInt64Array = exports.isBigInt64Array = exports.assertNotFloat64ArrayPass = exports.assertFloat64ArrayPass = exports.assertNotFloat64Array = exports.assertFloat64Array = exports.isNotFloat64Array = exports.isFloat64Array = exports.assertNotFloat32ArrayPass = exports.assertFloat32ArrayPass = exports.assertNotFloat32Array = exports.assertFloat32Array = exports.isNotFloat32Array = exports.isFloat32Array = exports.assertNotUint32ArrayPass = exports.assertUint32ArrayPass = exports.assertNotUint32Array = exports.assertUint32Array = exports.isNotUint32Array = exports.isUint32Array = exports.assertNotInt32ArrayPass = exports.assertInt32ArrayPass = exports.assertNotInt32Array = exports.assertInt32Array = exports.isNotInt32Array = exports.isInt32Array = exports.assertNotUint16ArrayPass = exports.assertUint16ArrayPass = void 0;
+exports.assertNotPromisePass = exports.assertPromisePass = exports.assertNotPromise = exports.assertPromise = exports.isNotPromise = exports.isPromise = exports.assertNotMapPass = exports.assertMapPass = exports.assertNotMap = exports.assertMap = exports.isNotMap = exports.isMap = void 0;
+const error_1 = require("../error");
+function assert(condition, message = 'assertion failed') {
     if (!condition) {
-        throw new AssertionError(isFunction(message) ? message() : message);
+        throw new error_1.AssertionError(isFunction(message) ? message() : message);
     }
 }
-export function assertNot(condition, message = 'assertion failed') {
+exports.assert = assert;
+function assertNot(condition, message = 'assertion failed') {
     if (condition) {
-        throw new AssertionError(isFunction(message) ? message() : message);
+        throw new error_1.AssertionError(isFunction(message) ? message() : message);
     }
 }
-export function isUndefined(value) { return value === undefined; }
-export function isDefined(value) { return !isUndefined(value); }
-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 !isNull(value); }
-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 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 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; }
+exports.assertNot = assertNot;
+function isUndefined(value) { return value === undefined; }
+exports.isUndefined = isUndefined;
+function isDefined(value) { return !isUndefined(value); }
+exports.isDefined = isDefined;
+function assertUndefined(value, message = 'expected value to be undefined') { assert(isUndefined(value), message); }
+exports.assertUndefined = assertUndefined;
+function assertDefined(value, message = 'expected value to not be undefined') { assert(isDefined(value), message); }
+exports.assertDefined = assertDefined;
+function assertUndefinedPass(value, message) { assertUndefined(value, message); return value; }
+exports.assertUndefinedPass = assertUndefinedPass;
+function assertDefinedPass(value, message) { assertDefined(value, message); return value; }
+exports.assertDefinedPass = assertDefinedPass;
+function isNull(value) { return value === null; }
+exports.isNull = isNull;
+function isNotNull(value) { return !isNull(value); }
+exports.isNotNull = isNotNull;
+function assertNull(value, message = 'expected value to be null') { assert(isNull(value), message); }
+exports.assertNull = assertNull;
+function assertNotNull(value, message = 'expected value to not be null') { assert(isNotNull(value), message); }
+exports.assertNotNull = assertNotNull;
+function assertNullPass(value, message) { assertNull(value, message); return value; }
+exports.assertNullPass = assertNullPass;
+function assertNotNullPass(value, message) { assertNotNull(value, message); return value; }
+exports.assertNotNullPass = assertNotNullPass;
+function isNullOrUndefined(value) { return (value === null) || (value === undefined); }
+exports.isNullOrUndefined = isNullOrUndefined;
+function isNotNullOrUndefined(value) { return !isNullOrUndefined(value); }
+exports.isNotNullOrUndefined = isNotNullOrUndefined;
+function assertNullOrUndefined(value, message = 'expected value to be null or undefined') { assert(isNullOrUndefined(value), message); }
+exports.assertNullOrUndefined = assertNullOrUndefined;
+function assertNotNullOrUndefined(value, message = 'expected value to not be null or undefined') { assert(isNotNullOrUndefined(value), message); }
+exports.assertNotNullOrUndefined = assertNotNullOrUndefined;
+function assertNullOrUndefinedPass(value, message) { assertNullOrUndefined(value, message); return value; }
+exports.assertNullOrUndefinedPass = assertNullOrUndefinedPass;
+function assertNotNullOrUndefinedPass(value, message) { assertNotNullOrUndefined(value, message); return value; }
+exports.assertNotNullOrUndefinedPass = assertNotNullOrUndefinedPass;
+function isNumber(value) { return (typeof value == 'number'); }
+exports.isNumber = isNumber;
+function isNotNumber(value) { return !isNumber(value); }
+exports.isNotNumber = isNotNumber;
+function assertNumber(value, message = 'expected value to be number') { assert(isNumber(value), message); }
+exports.assertNumber = assertNumber;
+function assertNotNumber(value, message = 'expected value to not be number') { assert(isNotNumber(value), message); }
+exports.assertNotNumber = assertNotNumber;
+function assertNumberPass(value, message) { assertNumber(value, message); return value; }
+exports.assertNumberPass = assertNumberPass;
+function assertNotNumberPass(value, message) { assertNotNumber(value, message); return value; }
+exports.assertNotNumberPass = assertNotNumberPass;
+function isString(value) { return (typeof value == 'string'); }
+exports.isString = isString;
+function isNotString(value) { return !isString(value); }
+exports.isNotString = isNotString;
+function assertString(value, message = 'expected value to be string') { assert(isString(value), message); }
+exports.assertString = assertString;
+function assertNotString(value, message = 'expected value to not be string') { assert(isNotString(value), message); }
+exports.assertNotString = assertNotString;
+function assertStringPass(value, message) { assertString(value, message); return value; }
+exports.assertStringPass = assertStringPass;
+function assertNotStringPass(value, message) { assertNotString(value, message); return value; }
+exports.assertNotStringPass = assertNotStringPass;
+function isBoolean(value) { return (typeof value == 'boolean'); }
+exports.isBoolean = isBoolean;
+function isNotBoolean(value) { return !isBoolean(value); }
+exports.isNotBoolean = isNotBoolean;
+function assertBoolean(value, message = 'expected value to be boolean') { assert(isBoolean(value), message); }
+exports.assertBoolean = assertBoolean;
+function assertNotBoolean(value, message = 'expected value to not be boolean') { assert(isNotBoolean(value), message); }
+exports.assertNotBoolean = assertNotBoolean;
+function assertBooleanPass(value, message) { assertBoolean(value, message); return value; }
+exports.assertBooleanPass = assertBooleanPass;
+function assertNotBooleanPass(value, message) { assertNotBoolean(value, message); return value; }
+exports.assertNotBooleanPass = assertNotBooleanPass;
+function isBigInt(value) { return (typeof value == 'bigint'); }
+exports.isBigInt = isBigInt;
+function isNotBigInt(value) { return !isBigInt(value); }
+exports.isNotBigInt = isNotBigInt;
+function assertBigInt(value, message = 'expected value to be bigint') { assert(isBigInt(value), message); }
+exports.assertBigInt = assertBigInt;
+function assertNotBigInt(value, message = 'expected value to not be bigint') { assert(isNotBigInt(value), message); }
+exports.assertNotBigInt = assertNotBigInt;
+function assertBigIntPass(value, message) { assertBigInt(value, message); return value; }
+exports.assertBigIntPass = assertBigIntPass;
+function assertNotBigIntPass(value, message) { assertNotBigInt(value, message); return value; }
+exports.assertNotBigIntPass = assertNotBigIntPass;
+function isFunction(value) { return (typeof value == 'function'); }
+exports.isFunction = isFunction;
+function isNotFunction(value) { return !isFunction(value); }
+exports.isNotFunction = isNotFunction;
+function assertFunction(value, message = 'expected value to be function') { assert(isFunction(value), message); }
+exports.assertFunction = assertFunction;
+function assertNotFunction(value, message = 'expected value to not be function') { assert(isNotFunction(value), message); }
+exports.assertNotFunction = assertNotFunction;
+function assertFunctionPass(value, message) { assertFunction(value, message); return value; }
+exports.assertFunctionPass = assertFunctionPass;
+function assertNotFunctionPass(value, message) { assertNotFunction(value, message); return value; }
+exports.assertNotFunctionPass = assertNotFunctionPass;
+function isSymbol(value) { return (typeof value == 'symbol'); }
+exports.isSymbol = isSymbol;
+function isNotSymbol(value) { return !isSymbol(value); }
+exports.isNotSymbol = isNotSymbol;
+function assertSymbol(value, message = 'expected value to be symbol') { assert(isSymbol(value), message); }
+exports.assertSymbol = assertSymbol;
+function assertNotSymbol(value, message = 'expected value to not be symbol') { assert(isNotSymbol(value), message); }
+exports.assertNotSymbol = assertNotSymbol;
+function assertSymbolPass(value, message) { assertSymbol(value, message); return value; }
+exports.assertSymbolPass = assertSymbolPass;
+function assertNotSymbolPass(value, message) { assertNotSymbol(value, message); return value; }
+exports.assertNotSymbolPass = assertNotSymbolPass;
+function isObject(value) { return (value?.constructor == Object); }
+exports.isObject = isObject;
+function isNotObject(value) { return !isObject(value); }
+exports.isNotObject = isNotObject;
+function assertObject(value, message = 'expected value to be object') { assert(isObject(value), message); }
+exports.assertObject = assertObject;
+function assertNotObject(value, message = 'expected value to not be object') { assert(isNotObject(value), message); }
+exports.assertNotObject = assertNotObject;
+function assertObjectPass(value, message) { assertObject(value, message); return value; }
+exports.assertObjectPass = assertObjectPass;
+function assertNotObjectPass(value, message) { assertNotObject(value, message); return value; }
+exports.assertNotObjectPass = assertNotObjectPass;
+function isPrimitive(value) { const type = typeof value; return type == 'string' || type == 'number' || type == 'boolean' || type == 'bigint' || type == 'symbol' || value === null || value === undefined; }
+exports.isPrimitive = isPrimitive;
+function isNotPrimitive(value) { return !isPrimitive(value); }
+exports.isNotPrimitive = isNotPrimitive;
+function assertPrimitive(value, message = 'expected value to be primitive') { assert(isPrimitive(value), message); }
+exports.assertPrimitive = assertPrimitive;
+function assertNotPrimitive(value, message = 'expected value to not be primitive') { assert(isNotPrimitive(value), message); }
+exports.assertNotPrimitive = assertNotPrimitive;
+function assertPrimitivePass(value, message) { assertPrimitive(value, message); return value; }
+exports.assertPrimitivePass = assertPrimitivePass;
+function assertNotPrimitivePass(value, message) { assertNotPrimitive(value, message); return value; }
+exports.assertNotPrimitivePass = assertNotPrimitivePass;
+function isJsonPrimitive(value) { const type = typeof value; return type == 'string' || type == 'number' || type == 'boolean' || value === null; }
+exports.isJsonPrimitive = isJsonPrimitive;
+function isNotJsonPrimitive(value) { return !isJsonPrimitive(value); }
+exports.isNotJsonPrimitive = isNotJsonPrimitive;
+function assertJsonPrimitive(value, message = 'expected value to be json-primitive') { assert(isJsonPrimitive(value), message); }
+exports.assertJsonPrimitive = assertJsonPrimitive;
+function assertNotJsonPrimitive(value, message = 'expected value to not be json-primitive') { assert(isNotJsonPrimitive(value), message); }
+exports.assertNotJsonPrimitive = assertNotJsonPrimitive;
+function assertJsonPrimitivePass(value, message) { assertJsonPrimitive(value, message); return value; }
+exports.assertJsonPrimitivePass = assertJsonPrimitivePass;
+function assertNotJsonPrimitivePass(value, message) { assertNotJsonPrimitive(value, message); return value; }
+exports.assertNotJsonPrimitivePass = assertNotJsonPrimitivePass;
+function isDate(value) { return (value instanceof Date); }
+exports.isDate = isDate;
+function isNotDate(value) { return !isDate(value); }
+exports.isNotDate = isNotDate;
+function assertDate(value, message = 'expected value to be Date') { assert(isDate(value), message); }
+exports.assertDate = assertDate;
+function assertNotDate(value, message = 'expected value to not be Date') { assert(isNotDate(value), message); }
+exports.assertNotDate = assertNotDate;
+function assertDatePass(value, message) { assertDate(value, message); return value; }
+exports.assertDatePass = assertDatePass;
+function assertNotDatePass(value, message) { assertNotDate(value, message); return value; }
+exports.assertNotDatePass = assertNotDatePass;
+function isValidDate(value) { return isDate(value) && !Number.isNaN(value.getTime()); }
+exports.isValidDate = isValidDate;
+function isNotValidDate(value) { return !isValidDate(value); }
+exports.isNotValidDate = isNotValidDate;
+function assertValidDate(value, message = 'expected value to be a valid Date') { assert(isValidDate(value), message); }
+exports.assertValidDate = assertValidDate;
+function assertNotValidDate(value, message = 'expected value to not be a valid Date') { assert(isNotValidDate(value), message); }
+exports.assertNotValidDate = assertNotValidDate;
+function assertValidDatePass(value, message) { assertValidDate(value, message); return value; }
+exports.assertValidDatePass = assertValidDatePass;
+function assertNotValidDatePass(value, message) { assertNotValidDate(value, message); return value; }
+exports.assertNotValidDatePass = assertNotValidDatePass;
+function isRegExp(value) { return (value instanceof RegExp); }
+exports.isRegExp = isRegExp;
+function isNotRegExp(value) { return !isRegExp(value); }
+exports.isNotRegExp = isNotRegExp;
+function assertRegExp(value, message = 'expected value to be RegExp') { assert(isRegExp(value), message); }
+exports.assertRegExp = assertRegExp;
+function assertNotRegExp(value, message = 'expected value to not be RegExp') { assert(isNotRegExp(value), message); }
+exports.assertNotRegExp = assertNotRegExp;
+function assertRegExpPass(value, message) { assertRegExp(value, message); return value; }
+exports.assertRegExpPass = assertRegExpPass;
+function assertNotRegExpPass(value, message) { assertNotRegExp(value, message); return value; }
+exports.assertNotRegExpPass = assertNotRegExpPass;
+function isArray(value) { return Array.isArray(value); }
+exports.isArray = isArray;
+function isNotArray(value) { return !isArray(value); }
+exports.isNotArray = isNotArray;
+function assertArray(value, message = 'expected value to be Array') { assert(isArray(value), message); }
+exports.assertArray = assertArray;
+function assertNotArray(value, message = 'expected value to not be Array') { assert(isNotArray(value), message); }
+exports.assertNotArray = assertNotArray;
+function assertArrayPass(value, message) { assertArray(value, message); return value; }
+exports.assertArrayPass = assertArrayPass;
+function assertNotArrayPass(value, message) { assertNotArray(value, message); return value; }
+exports.assertNotArrayPass = assertNotArrayPass;
+function isWritableArray(value) { return isArray(value); }
+exports.isWritableArray = isWritableArray;
+function isNotWritableArray(value) { return isNotArray(value); }
+exports.isNotWritableArray = isNotWritableArray;
+function assertWritableArray(value, message = 'expected value to be Array') { assertArray(value, message); }
+exports.assertWritableArray = assertWritableArray;
+function assertNotWritableArray(value, message = 'expected value to not be Array') { assertNotArray(value, message); }
+exports.assertNotWritableArray = assertNotWritableArray;
+function assertWritableArrayPass(value, message) { return assertArrayPass(value, message); }
+exports.assertWritableArrayPass = assertWritableArrayPass;
+function assertNotWritableArrayPass(value, message) { return assertNotArrayPass(value, message); }
+exports.assertNotWritableArrayPass = assertNotWritableArrayPass;
+function isArrayBuffer(value) { return (value instanceof ArrayBuffer); }
+exports.isArrayBuffer = isArrayBuffer;
+function isNotArrayBuffer(value) { return !isArrayBuffer(value); }
+exports.isNotArrayBuffer = isNotArrayBuffer;
+function assertArrayBuffer(value, message = 'expected value to be ArrayBuffer') { assert(isArrayBuffer(value), message); }
+exports.assertArrayBuffer = assertArrayBuffer;
+function assertNotArrayBuffer(value, message = 'expected value to not be ArrayBuffer') { assert(isNotArrayBuffer(value), message); }
+exports.assertNotArrayBuffer = assertNotArrayBuffer;
+function assertArrayBufferPass(value, message) { assertArrayBuffer(value, message); return value; }
+exports.assertArrayBufferPass = assertArrayBufferPass;
+function assertNotArrayBufferPass(value, message) { assertNotArrayBuffer(value, message); return value; }
+exports.assertNotArrayBufferPass = assertNotArrayBufferPass;
+function isArrayBufferView(value) { return ArrayBuffer.isView(value); }
+exports.isArrayBufferView = isArrayBufferView;
+function isNotArrayBufferView(value) { return !isArrayBufferView(value); }
+exports.isNotArrayBufferView = isNotArrayBufferView;
+function assertArrayBufferView(value, message = 'expected value to be ArrayBufferView') { assert(isArrayBufferView(value), message); }
+exports.assertArrayBufferView = assertArrayBufferView;
+function assertNotArrayBufferView(value, message = 'expected value to not be ArrayBufferView') { assert(isNotArrayBufferView(value), message); }
+exports.assertNotArrayBufferView = assertNotArrayBufferView;
+function assertArrayBufferViewPass(value, message) { assertArrayBufferView(value, message); return value; }
+exports.assertArrayBufferViewPass = assertArrayBufferViewPass;
+function assertNotArrayBufferViewPass(value, message) { assertNotArrayBufferView(value, message); return value; }
+exports.assertNotArrayBufferViewPass = assertNotArrayBufferViewPass;
+function isTypedArray(value) { return ArrayBuffer.isView(value) && isNotDataView(value); }
+exports.isTypedArray = isTypedArray;
+function isNotTypedArray(value) { return !isTypedArray(value); }
+exports.isNotTypedArray = isNotTypedArray;
+function assertTypedArray(value, message = 'expected value to be TypedArray') { assert(isTypedArray(value), message); }
+exports.assertTypedArray = assertTypedArray;
+function assertNotTypedArray(value, message = 'expected value to not be TypedArray') { assert(isNotTypedArray(value), message); }
+exports.assertNotTypedArray = assertNotTypedArray;
+function assertTypedArrayPass(value, message) { assertTypedArray(value, message); return value; }
+exports.assertTypedArrayPass = assertTypedArrayPass;
+function assertNotTypedArrayPass(value, message) { assertNotTypedArray(value, message); return value; }
+exports.assertNotTypedArrayPass = assertNotTypedArrayPass;
+function isInt8Array(value) { return (value instanceof Int8Array); }
+exports.isInt8Array = isInt8Array;
+function isNotInt8Array(value) { return !isInt8Array(value); }
+exports.isNotInt8Array = isNotInt8Array;
+function assertInt8Array(value, message = 'expected value to be Int8Array') { assert(isInt8Array(value), message); }
+exports.assertInt8Array = assertInt8Array;
+function assertNotInt8Array(value, message = 'expected value to not be Int8Array') { assert(isNotInt8Array(value), message); }
+exports.assertNotInt8Array = assertNotInt8Array;
+function assertInt8ArrayPass(value, message) { assertInt8Array(value, message); return value; }
+exports.assertInt8ArrayPass = assertInt8ArrayPass;
+function assertNotInt8ArrayPass(value, message) { assertNotInt8Array(value, message); return value; }
+exports.assertNotInt8ArrayPass = assertNotInt8ArrayPass;
+function isUint8Array(value) { return (value instanceof Uint8Array); }
+exports.isUint8Array = isUint8Array;
+function isNotUint8Array(value) { return !isUint8Array(value); }
+exports.isNotUint8Array = isNotUint8Array;
+function assertUint8Array(value, message = 'expected value to be Uint8Array') { assert(isUint8Array(value), message); }
+exports.assertUint8Array = assertUint8Array;
+function assertNotUint8Array(value, message = 'expected value to not be Uint8Array') { assert(isNotUint8Array(value), message); }
+exports.assertNotUint8Array = assertNotUint8Array;
+function assertUint8ArrayPass(value, message) { assertUint8Array(value, message); return value; }
+exports.assertUint8ArrayPass = assertUint8ArrayPass;
+function assertNotUint8ArrayPass(value, message) { assertNotUint8Array(value, message); return value; }
+exports.assertNotUint8ArrayPass = assertNotUint8ArrayPass;
+function isUint8ClampedArray(value) { return (value instanceof Uint8ClampedArray); }
+exports.isUint8ClampedArray = isUint8ClampedArray;
+function isNotUint8ClampedArray(value) { return !isUint8ClampedArray(value); }
+exports.isNotUint8ClampedArray = isNotUint8ClampedArray;
+function assertUint8ClampedArray(value, message = 'expected value to be Uint8ClampedArray') { assert(isUint8ClampedArray(value), message); }
+exports.assertUint8ClampedArray = assertUint8ClampedArray;
+function assertNotUint8ClampedArray(value, message = 'expected value to not be Uint8ClampedArray') { assert(isNotUint8ClampedArray(value), message); }
+exports.assertNotUint8ClampedArray = assertNotUint8ClampedArray;
+function assertUint8ClampedArrayPass(value, message) { assertUint8ClampedArray(value, message); return value; }
+exports.assertUint8ClampedArrayPass = assertUint8ClampedArrayPass;
+function assertNotUint8ClampedArrayPass(value, message) { assertNotUint8ClampedArray(value, message); return value; }
+exports.assertNotUint8ClampedArrayPass = assertNotUint8ClampedArrayPass;
+function isInt16Array(value) { return (value instanceof Int16Array); }
+exports.isInt16Array = isInt16Array;
+function isNotInt16Array(value) { return !isInt16Array(value); }
+exports.isNotInt16Array = isNotInt16Array;
+function assertInt16Array(value, message = 'expected value to be Int16Array') { assert(isInt16Array(value), message); }
+exports.assertInt16Array = assertInt16Array;
+function assertNotInt16Array(value, message = 'expected value to not be Int16Array') { assert(isNotInt16Array(value), message); }
+exports.assertNotInt16Array = assertNotInt16Array;
+function assertInt16ArrayPass(value, message) { assertInt16Array(value, message); return value; }
+exports.assertInt16ArrayPass = assertInt16ArrayPass;
+function assertNotInt16ArrayPass(value, message) { assertNotInt16Array(value, message); return value; }
+exports.assertNotInt16ArrayPass = assertNotInt16ArrayPass;
+function isUint16Array(value) { return (value instanceof Uint16Array); }
+exports.isUint16Array = isUint16Array;
+function isNotUint16Array(value) { return !isUint16Array(value); }
+exports.isNotUint16Array = isNotUint16Array;
+function assertUint16Array(value, message = 'expected value to be Uint16Array') { assert(isUint16Array(value), message); }
+exports.assertUint16Array = assertUint16Array;
+function assertNotUint16Array(value, message = 'expected value to not be Uint16Array') { assert(isNotUint16Array(value), message); }
+exports.assertNotUint16Array = assertNotUint16Array;
+function assertUint16ArrayPass(value, message) { assertUint16Array(value, message); return value; }
+exports.assertUint16ArrayPass = assertUint16ArrayPass;
+function assertNotUint16ArrayPass(value, message) { assertNotUint16Array(value, message); return value; }
+exports.assertNotUint16ArrayPass = assertNotUint16ArrayPass;
+function isInt32Array(value) { return (value instanceof Int32Array); }
+exports.isInt32Array = isInt32Array;
+function isNotInt32Array(value) { return !isInt32Array(value); }
+exports.isNotInt32Array = isNotInt32Array;
+function assertInt32Array(value, message = 'expected value to be Int32Array') { assert(isInt32Array(value), message); }
+exports.assertInt32Array = assertInt32Array;
+function assertNotInt32Array(value, message = 'expected value to not be Int32Array') { assert(isNotInt32Array(value), message); }
+exports.assertNotInt32Array = assertNotInt32Array;
+function assertInt32ArrayPass(value, message) { assertInt32Array(value, message); return value; }
+exports.assertInt32ArrayPass = assertInt32ArrayPass;
+function assertNotInt32ArrayPass(value, message) { assertNotInt32Array(value, message); return value; }
+exports.assertNotInt32ArrayPass = assertNotInt32ArrayPass;
+function isUint32Array(value) { return (value instanceof Uint32Array); }
+exports.isUint32Array = isUint32Array;
+function isNotUint32Array(value) { return !isUint32Array(value); }
+exports.isNotUint32Array = isNotUint32Array;
+function assertUint32Array(value, message = 'expected value to be Uint32Array') { assert(isUint32Array(value), message); }
+exports.assertUint32Array = assertUint32Array;
+function assertNotUint32Array(value, message = 'expected value to not be Uint32Array') { assert(isNotUint32Array(value), message); }
+exports.assertNotUint32Array = assertNotUint32Array;
+function assertUint32ArrayPass(value, message) { assertUint32Array(value, message); return value; }
+exports.assertUint32ArrayPass = assertUint32ArrayPass;
+function assertNotUint32ArrayPass(value, message) { assertNotUint32Array(value, message); return value; }
+exports.assertNotUint32ArrayPass = assertNotUint32ArrayPass;
+function isFloat32Array(value) { return (value instanceof Float32Array); }
+exports.isFloat32Array = isFloat32Array;
+function isNotFloat32Array(value) { return !isFloat32Array(value); }
+exports.isNotFloat32Array = isNotFloat32Array;
+function assertFloat32Array(value, message = 'expected value to be Float32Array') { assert(isFloat32Array(value), message); }
+exports.assertFloat32Array = assertFloat32Array;
+function assertNotFloat32Array(value, message = 'expected value to not be Float32Array') { assert(isNotFloat32Array(value), message); }
+exports.assertNotFloat32Array = assertNotFloat32Array;
+function assertFloat32ArrayPass(value, message) { assertFloat32Array(value, message); return value; }
+exports.assertFloat32ArrayPass = assertFloat32ArrayPass;
+function assertNotFloat32ArrayPass(value, message) { assertNotFloat32Array(value, message); return value; }
+exports.assertNotFloat32ArrayPass = assertNotFloat32ArrayPass;
+function isFloat64Array(value) { return (value instanceof Float64Array); }
+exports.isFloat64Array = isFloat64Array;
+function isNotFloat64Array(value) { return !isFloat64Array(value); }
+exports.isNotFloat64Array = isNotFloat64Array;
+function assertFloat64Array(value, message = 'expected value to be Float64Array') { assert(isFloat64Array(value), message); }
+exports.assertFloat64Array = assertFloat64Array;
+function assertNotFloat64Array(value, message = 'expected value to not be Float64Array') { assert(isNotFloat64Array(value), message); }
+exports.assertNotFloat64Array = assertNotFloat64Array;
+function assertFloat64ArrayPass(value, message) { assertFloat64Array(value, message); return value; }
+exports.assertFloat64ArrayPass = assertFloat64ArrayPass;
+function assertNotFloat64ArrayPass(value, message) { assertNotFloat64Array(value, message); return value; }
+exports.assertNotFloat64ArrayPass = assertNotFloat64ArrayPass;
+function isBigInt64Array(value) { return (value instanceof BigInt64Array); }
+exports.isBigInt64Array = isBigInt64Array;
+function isNotBigInt64Array(value) { return !isBigInt64Array(value); }
+exports.isNotBigInt64Array = isNotBigInt64Array;
+function assertBigInt64Array(value, message = 'expected value to be BigInt64Array') { assert(isBigInt64Array(value), message); }
+exports.assertBigInt64Array = assertBigInt64Array;
+function assertNotBigInt64Array(value, message = 'expected value to not be BigInt64Array') { assert(isNotBigInt64Array(value), message); }
+exports.assertNotBigInt64Array = assertNotBigInt64Array;
+function assertBigInt64ArrayPass(value, message) { assertBigInt64Array(value, message); return value; }
+exports.assertBigInt64ArrayPass = assertBigInt64ArrayPass;
+function assertNotBigInt64ArrayPass(value, message) { assertNotBigInt64Array(value, message); return value; }
+exports.assertNotBigInt64ArrayPass = assertNotBigInt64ArrayPass;
+function isBigUint64Array(value) { return (value instanceof BigUint64Array); }
+exports.isBigUint64Array = isBigUint64Array;
+function isNotBigUint64Array(value) { return !isBigUint64Array(value); }
+exports.isNotBigUint64Array = isNotBigUint64Array;
+function assertBigUint64Array(value, message = 'expected value to be BigUint64Array') { assert(isBigUint64Array(value), message); }
+exports.assertBigUint64Array = assertBigUint64Array;
+function assertNotBigUint64Array(value, message = 'expected value to not be BigUint64Array') { assert(isNotBigUint64Array(value), message); }
+exports.assertNotBigUint64Array = assertNotBigUint64Array;
+function assertBigUint64ArrayPass(value, message) { assertBigUint64Array(value, message); return value; }
+exports.assertBigUint64ArrayPass = assertBigUint64ArrayPass;
+function assertNotBigUint64ArrayPass(value, message) { assertNotBigUint64Array(value, message); return value; }
+exports.assertNotBigUint64ArrayPass = assertNotBigUint64ArrayPass;
+function isDataView(value) { return (value instanceof DataView); }
+exports.isDataView = isDataView;
+function isNotDataView(value) { return !isDataView(value); }
+exports.isNotDataView = isNotDataView;
+function assertDataView(value, message = 'expected value to be DataView') { assert(isDataView(value), message); }
+exports.assertDataView = assertDataView;
+function assertNotDataView(value, message = 'expected value to not be DataView') { assert(isNotDataView(value), message); }
+exports.assertNotDataView = assertNotDataView;
+function assertDataViewPass(value, message) { assertDataView(value, message); return value; }
+exports.assertDataViewPass = assertDataViewPass;
+function assertNotDataViewPass(value, message) { assertNotDataView(value, message); return value; }
+exports.assertNotDataViewPass = assertNotDataViewPass;
+function isSet(value) { return (value instanceof Set); }
+exports.isSet = isSet;
+function isNotSet(value) { return !isSet(value); }
+exports.isNotSet = isNotSet;
+function assertSet(value, message = 'expected value to be Set') { assert(isSet(value), message); }
+exports.assertSet = assertSet;
+function assertNotSet(value, message = 'expected value to not be Set') { assert(isNotSet(value), message); }
+exports.assertNotSet = assertNotSet;
+function assertSetPass(value, message) { assertSet(value, message); return value; }
+exports.assertSetPass = assertSetPass;
+function assertNotSetPass(value, message) { assertNotSet(value, message); return value; }
+exports.assertNotSetPass = assertNotSetPass;
+function isMap(value) { return (value instanceof Map); }
+exports.isMap = isMap;
+function isNotMap(value) { return !isMap(value); }
+exports.isNotMap = isNotMap;
+function assertMap(value, message = 'expected value to be Map') { assert(isMap(value), message); }
+exports.assertMap = assertMap;
+function assertNotMap(value, message = 'expected value to not be Map') { assert(isNotMap(value), message); }
+exports.assertNotMap = assertNotMap;
+function assertMapPass(value, message) { assertMap(value, message); return value; }
+exports.assertMapPass = assertMapPass;
+function assertNotMapPass(value, message) { assertNotMap(value, message); return value; }
+exports.assertNotMapPass = assertNotMapPass;
+function isPromise(value) { return (value instanceof Promise); }
+exports.isPromise = isPromise;
+function isNotPromise(value) { return !isPromise(value); }
+exports.isNotPromise = isNotPromise;
+function assertPromise(value, message = 'expected value to be Promise') { assert(isPromise(value), message); }
+exports.assertPromise = assertPromise;
+function assertNotPromise(value, message = 'expected value to not be Promise') { assert(isNotPromise(value), message); }
+exports.assertNotPromise = assertNotPromise;
+function assertPromisePass(value, message) { assertPromise(value, message); return value; } // eslint-disable-line @typescript-eslint/promise-function-async
+exports.assertPromisePass = assertPromisePass;
+function assertNotPromisePass(value, message) { assertNotPromise(value, message); return value; }
+exports.assertNotPromisePass = assertNotPromisePass;
 //# sourceMappingURL=type-guards.js.map