@tstdl/base 0.86.0-beta2 → 0.86.0-beta3

package/utils/type-guards.js

@@ -1,253 +1,1076 @@
-/* eslint-disable @typescript-eslint/ban-types, @typescript-eslint/restrict-template-expressions, max-statements-per-line */
-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);
-    }
-}
-export function assertNot(condition, message = 'assertion failed') {
-    if (condition) {
-        throw new AssertionError(isFunction(message) ? 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 !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 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; }
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var type_guards_exports = {};
+__export(type_guards_exports, {
+  assert: () => assert,
+  assertArray: () => assertArray,
+  assertArrayBuffer: () => assertArrayBuffer,
+  assertArrayBufferPass: () => assertArrayBufferPass,
+  assertArrayBufferView: () => assertArrayBufferView,
+  assertArrayBufferViewPass: () => assertArrayBufferViewPass,
+  assertArrayPass: () => assertArrayPass,
+  assertBigInt: () => assertBigInt,
+  assertBigInt64Array: () => assertBigInt64Array,
+  assertBigInt64ArrayPass: () => assertBigInt64ArrayPass,
+  assertBigIntPass: () => assertBigIntPass,
+  assertBigUint64Array: () => assertBigUint64Array,
+  assertBigUint64ArrayPass: () => assertBigUint64ArrayPass,
+  assertBinaryData: () => assertBinaryData,
+  assertBinaryDataPass: () => assertBinaryDataPass,
+  assertBlob: () => assertBlob,
+  assertBlobPass: () => assertBlobPass,
+  assertBoolean: () => assertBoolean,
+  assertBooleanPass: () => assertBooleanPass,
+  assertDataView: () => assertDataView,
+  assertDataViewPass: () => assertDataViewPass,
+  assertDate: () => assertDate,
+  assertDatePass: () => assertDatePass,
+  assertDefined: () => assertDefined,
+  assertDefinedPass: () => assertDefinedPass,
+  assertError: () => assertError,
+  assertErrorPass: () => assertErrorPass,
+  assertFloat32Array: () => assertFloat32Array,
+  assertFloat32ArrayPass: () => assertFloat32ArrayPass,
+  assertFloat64Array: () => assertFloat64Array,
+  assertFloat64ArrayPass: () => assertFloat64ArrayPass,
+  assertFunction: () => assertFunction,
+  assertFunctionPass: () => assertFunctionPass,
+  assertInt16Array: () => assertInt16Array,
+  assertInt16ArrayPass: () => assertInt16ArrayPass,
+  assertInt32Array: () => assertInt32Array,
+  assertInt32ArrayPass: () => assertInt32ArrayPass,
+  assertInt8Array: () => assertInt8Array,
+  assertInt8ArrayPass: () => assertInt8ArrayPass,
+  assertJsonPrimitive: () => assertJsonPrimitive,
+  assertJsonPrimitivePass: () => assertJsonPrimitivePass,
+  assertMap: () => assertMap,
+  assertMapPass: () => assertMapPass,
+  assertNot: () => assertNot,
+  assertNotArray: () => assertNotArray,
+  assertNotArrayBuffer: () => assertNotArrayBuffer,
+  assertNotArrayBufferPass: () => assertNotArrayBufferPass,
+  assertNotArrayBufferView: () => assertNotArrayBufferView,
+  assertNotArrayBufferViewPass: () => assertNotArrayBufferViewPass,
+  assertNotArrayPass: () => assertNotArrayPass,
+  assertNotBigInt: () => assertNotBigInt,
+  assertNotBigInt64Array: () => assertNotBigInt64Array,
+  assertNotBigInt64ArrayPass: () => assertNotBigInt64ArrayPass,
+  assertNotBigIntPass: () => assertNotBigIntPass,
+  assertNotBigUint64Array: () => assertNotBigUint64Array,
+  assertNotBigUint64ArrayPass: () => assertNotBigUint64ArrayPass,
+  assertNotBinaryData: () => assertNotBinaryData,
+  assertNotBinaryDataPass: () => assertNotBinaryDataPass,
+  assertNotBlob: () => assertNotBlob,
+  assertNotBlobPass: () => assertNotBlobPass,
+  assertNotBoolean: () => assertNotBoolean,
+  assertNotBooleanPass: () => assertNotBooleanPass,
+  assertNotDataView: () => assertNotDataView,
+  assertNotDataViewPass: () => assertNotDataViewPass,
+  assertNotDate: () => assertNotDate,
+  assertNotDatePass: () => assertNotDatePass,
+  assertNotError: () => assertNotError,
+  assertNotErrorPass: () => assertNotErrorPass,
+  assertNotFloat32Array: () => assertNotFloat32Array,
+  assertNotFloat32ArrayPass: () => assertNotFloat32ArrayPass,
+  assertNotFloat64Array: () => assertNotFloat64Array,
+  assertNotFloat64ArrayPass: () => assertNotFloat64ArrayPass,
+  assertNotFunction: () => assertNotFunction,
+  assertNotFunctionPass: () => assertNotFunctionPass,
+  assertNotInt16Array: () => assertNotInt16Array,
+  assertNotInt16ArrayPass: () => assertNotInt16ArrayPass,
+  assertNotInt32Array: () => assertNotInt32Array,
+  assertNotInt32ArrayPass: () => assertNotInt32ArrayPass,
+  assertNotInt8Array: () => assertNotInt8Array,
+  assertNotInt8ArrayPass: () => assertNotInt8ArrayPass,
+  assertNotJsonPrimitive: () => assertNotJsonPrimitive,
+  assertNotJsonPrimitivePass: () => assertNotJsonPrimitivePass,
+  assertNotMap: () => assertNotMap,
+  assertNotMapPass: () => assertNotMapPass,
+  assertNotNull: () => assertNotNull,
+  assertNotNullOrUndefined: () => assertNotNullOrUndefined,
+  assertNotNullOrUndefinedPass: () => assertNotNullOrUndefinedPass,
+  assertNotNullPass: () => assertNotNullPass,
+  assertNotNumber: () => assertNotNumber,
+  assertNotNumberPass: () => assertNotNumberPass,
+  assertNotObject: () => assertNotObject,
+  assertNotObjectPass: () => assertNotObjectPass,
+  assertNotPrimitive: () => assertNotPrimitive,
+  assertNotPrimitivePass: () => assertNotPrimitivePass,
+  assertNotPromise: () => assertNotPromise,
+  assertNotPromisePass: () => assertNotPromisePass,
+  assertNotReadableStream: () => assertNotReadableStream,
+  assertNotReadableStreamPass: () => assertNotReadableStreamPass,
+  assertNotRegExp: () => assertNotRegExp,
+  assertNotRegExpPass: () => assertNotRegExpPass,
+  assertNotSet: () => assertNotSet,
+  assertNotSetPass: () => assertNotSetPass,
+  assertNotString: () => assertNotString,
+  assertNotStringPass: () => assertNotStringPass,
+  assertNotSymbol: () => assertNotSymbol,
+  assertNotSymbolPass: () => assertNotSymbolPass,
+  assertNotType: () => assertNotType,
+  assertNotTypePass: () => assertNotTypePass,
+  assertNotTypedArray: () => assertNotTypedArray,
+  assertNotTypedArrayPass: () => assertNotTypedArrayPass,
+  assertNotUint16Array: () => assertNotUint16Array,
+  assertNotUint16ArrayPass: () => assertNotUint16ArrayPass,
+  assertNotUint32Array: () => assertNotUint32Array,
+  assertNotUint32ArrayPass: () => assertNotUint32ArrayPass,
+  assertNotUint8Array: () => assertNotUint8Array,
+  assertNotUint8ArrayPass: () => assertNotUint8ArrayPass,
+  assertNotUint8ClampedArray: () => assertNotUint8ClampedArray,
+  assertNotUint8ClampedArrayPass: () => assertNotUint8ClampedArrayPass,
+  assertNotValidDate: () => assertNotValidDate,
+  assertNotValidDatePass: () => assertNotValidDatePass,
+  assertNotWritableArray: () => assertNotWritableArray,
+  assertNotWritableArrayPass: () => assertNotWritableArrayPass,
+  assertNull: () => assertNull,
+  assertNullOrUndefined: () => assertNullOrUndefined,
+  assertNullOrUndefinedPass: () => assertNullOrUndefinedPass,
+  assertNullPass: () => assertNullPass,
+  assertNumber: () => assertNumber,
+  assertNumberPass: () => assertNumberPass,
+  assertObject: () => assertObject,
+  assertObjectPass: () => assertObjectPass,
+  assertPrimitive: () => assertPrimitive,
+  assertPrimitivePass: () => assertPrimitivePass,
+  assertPromise: () => assertPromise,
+  assertPromisePass: () => assertPromisePass,
+  assertReadableStream: () => assertReadableStream,
+  assertReadableStreamPass: () => assertReadableStreamPass,
+  assertRegExp: () => assertRegExp,
+  assertRegExpPass: () => assertRegExpPass,
+  assertSet: () => assertSet,
+  assertSetPass: () => assertSetPass,
+  assertString: () => assertString,
+  assertStringPass: () => assertStringPass,
+  assertSymbol: () => assertSymbol,
+  assertSymbolPass: () => assertSymbolPass,
+  assertType: () => assertType,
+  assertTypePass: () => assertTypePass,
+  assertTypedArray: () => assertTypedArray,
+  assertTypedArrayPass: () => assertTypedArrayPass,
+  assertUint16Array: () => assertUint16Array,
+  assertUint16ArrayPass: () => assertUint16ArrayPass,
+  assertUint32Array: () => assertUint32Array,
+  assertUint32ArrayPass: () => assertUint32ArrayPass,
+  assertUint8Array: () => assertUint8Array,
+  assertUint8ArrayPass: () => assertUint8ArrayPass,
+  assertUint8ClampedArray: () => assertUint8ClampedArray,
+  assertUint8ClampedArrayPass: () => assertUint8ClampedArrayPass,
+  assertUndefined: () => assertUndefined,
+  assertUndefinedPass: () => assertUndefinedPass,
+  assertValidDate: () => assertValidDate,
+  assertValidDatePass: () => assertValidDatePass,
+  assertWritableArray: () => assertWritableArray,
+  assertWritableArrayPass: () => assertWritableArrayPass,
+  isArray: () => isArray,
+  isArrayBuffer: () => isArrayBuffer,
+  isArrayBufferView: () => isArrayBufferView,
+  isBigInt: () => isBigInt,
+  isBigInt64Array: () => isBigInt64Array,
+  isBigUint64Array: () => isBigUint64Array,
+  isBinaryData: () => isBinaryData,
+  isBlob: () => isBlob,
+  isBoolean: () => isBoolean,
+  isDataView: () => isDataView,
+  isDate: () => isDate,
+  isDefined: () => isDefined,
+  isError: () => isError,
+  isFloat32Array: () => isFloat32Array,
+  isFloat64Array: () => isFloat64Array,
+  isFunction: () => isFunction,
+  isInt16Array: () => isInt16Array,
+  isInt32Array: () => isInt32Array,
+  isInt8Array: () => isInt8Array,
+  isJsonPrimitive: () => isJsonPrimitive,
+  isMap: () => isMap,
+  isNotArray: () => isNotArray,
+  isNotArrayBuffer: () => isNotArrayBuffer,
+  isNotArrayBufferView: () => isNotArrayBufferView,
+  isNotBigInt: () => isNotBigInt,
+  isNotBigInt64Array: () => isNotBigInt64Array,
+  isNotBigUint64Array: () => isNotBigUint64Array,
+  isNotBinaryData: () => isNotBinaryData,
+  isNotBlob: () => isNotBlob,
+  isNotBoolean: () => isNotBoolean,
+  isNotDataView: () => isNotDataView,
+  isNotDate: () => isNotDate,
+  isNotError: () => isNotError,
+  isNotFloat32Array: () => isNotFloat32Array,
+  isNotFloat64Array: () => isNotFloat64Array,
+  isNotFunction: () => isNotFunction,
+  isNotInt16Array: () => isNotInt16Array,
+  isNotInt32Array: () => isNotInt32Array,
+  isNotInt8Array: () => isNotInt8Array,
+  isNotJsonPrimitive: () => isNotJsonPrimitive,
+  isNotMap: () => isNotMap,
+  isNotNull: () => isNotNull,
+  isNotNullOrUndefined: () => isNotNullOrUndefined,
+  isNotNumber: () => isNotNumber,
+  isNotObject: () => isNotObject,
+  isNotPrimitive: () => isNotPrimitive,
+  isNotPromise: () => isNotPromise,
+  isNotReadableStream: () => isNotReadableStream,
+  isNotRegExp: () => isNotRegExp,
+  isNotSet: () => isNotSet,
+  isNotString: () => isNotString,
+  isNotSymbol: () => isNotSymbol,
+  isNotType: () => isNotType,
+  isNotTypedArray: () => isNotTypedArray,
+  isNotUint16Array: () => isNotUint16Array,
+  isNotUint32Array: () => isNotUint32Array,
+  isNotUint8Array: () => isNotUint8Array,
+  isNotUint8ClampedArray: () => isNotUint8ClampedArray,
+  isNotValidDate: () => isNotValidDate,
+  isNotWritableArray: () => isNotWritableArray,
+  isNull: () => isNull,
+  isNullOrUndefined: () => isNullOrUndefined,
+  isNumber: () => isNumber,
+  isObject: () => isObject,
+  isPrimitive: () => isPrimitive,
+  isPromise: () => isPromise,
+  isReadableStream: () => isReadableStream,
+  isRegExp: () => isRegExp,
+  isSet: () => isSet,
+  isString: () => isString,
+  isSymbol: () => isSymbol,
+  isType: () => isType,
+  isTypedArray: () => isTypedArray,
+  isUint16Array: () => isUint16Array,
+  isUint32Array: () => isUint32Array,
+  isUint8Array: () => isUint8Array,
+  isUint8ClampedArray: () => isUint8ClampedArray,
+  isUndefined: () => isUndefined,
+  isValidDate: () => isValidDate,
+  isWritableArray: () => isWritableArray
+});
+module.exports = __toCommonJS(type_guards_exports);
+var import_supports = require("../supports.js");
+var import_assertion_error = require("../error/assertion.error.js");
+function assert(condition, message = "assertion failed") {
+  if (!condition) {
+    throw new import_assertion_error.AssertionError(isFunction(message) ? message() : message);
+  }
+}
+function assertNot(condition, message = "assertion failed") {
+  if (condition) {
+    throw new import_assertion_error.AssertionError(isFunction(message) ? message() : message);
+  }
+}
+function isType(type, value) {
+  return value instanceof type;
+}
+function isNotType(type, value) {
+  return !isType(type, value);
+}
+function assertType(type, value, message = () => `Expected value to be of type ${type.name}.`) {
+  assert(isType(type, value), message);
+}
+function assertNotType(type, value, message = () => `Expected value to be not of type ${type.name}.`) {
+  assert(isNotType(type, value), message);
+}
+function assertTypePass(type, value, message) {
+  assertType(type, value, message);
+  return value;
+}
+function assertNotTypePass(type, value, message) {
+  assertNotType(type, value, message);
+  return value;
+}
+function isUndefined(value) {
+  return value === void 0;
+}
+function isDefined(value) {
+  return value !== void 0;
+}
+function assertUndefined(value, message = "Expected value to be undefined.") {
+  assert(isUndefined(value), message);
+}
+function assertDefined(value, message = "Expected value to not be undefined.") {
+  assert(isDefined(value), message);
+}
+function assertUndefinedPass(value, message) {
+  assertUndefined(value, message);
+  return value;
+}
+function assertDefinedPass(value, message) {
+  assertDefined(value, message);
+  return value;
+}
+function isNull(value) {
+  return value === null;
+}
+function isNotNull(value) {
+  return value !== null;
+}
+function assertNull(value, message = "Expected value to be null.") {
+  assert(isNull(value), message);
+}
+function assertNotNull(value, message = "Expected value to not be null.") {
+  assert(isNotNull(value), message);
+}
+function assertNullPass(value, message) {
+  assertNull(value, message);
+  return value;
+}
+function assertNotNullPass(value, message) {
+  assertNotNull(value, message);
+  return value;
+}
+function isNullOrUndefined(value) {
+  return value === null || value === void 0;
+}
+function isNotNullOrUndefined(value) {
+  return !isNullOrUndefined(value);
+}
+function assertNullOrUndefined(value, message = "Expected value to be null or undefined.") {
+  assert(isNullOrUndefined(value), message);
+}
+function assertNotNullOrUndefined(value, message = "Expected value to not be null or undefined.") {
+  assert(isNotNullOrUndefined(value), message);
+}
+function assertNullOrUndefinedPass(value, message) {
+  assertNullOrUndefined(value, message);
+  return value;
+}
+function assertNotNullOrUndefinedPass(value, message) {
+  assertNotNullOrUndefined(value, message);
+  return value;
+}
+function isNumber(value) {
+  return typeof value == "number";
+}
+function isNotNumber(value) {
+  return !isNumber(value);
+}
+function assertNumber(value, message = "Expected value to be number.") {
+  assert(isNumber(value), message);
+}
+function assertNotNumber(value, message = "Expected value to not be number.") {
+  assert(isNotNumber(value), message);
+}
+function assertNumberPass(value, message) {
+  assertNumber(value, message);
+  return value;
+}
+function assertNotNumberPass(value, message) {
+  assertNotNumber(value, message);
+  return value;
+}
+function isString(value) {
+  return typeof value == "string";
+}
+function isNotString(value) {
+  return !isString(value);
+}
+function assertString(value, message = "Expected value to be string.") {
+  assert(isString(value), message);
+}
+function assertNotString(value, message = "Expected value to not be string.") {
+  assert(isNotString(value), message);
+}
+function assertStringPass(value, message) {
+  assertString(value, message);
+  return value;
+}
+function assertNotStringPass(value, message) {
+  assertNotString(value, message);
+  return value;
+}
+function isBoolean(value) {
+  return typeof value == "boolean";
+}
+function isNotBoolean(value) {
+  return !isBoolean(value);
+}
+function assertBoolean(value, message = "Expected value to be boolean.") {
+  assert(isBoolean(value), message);
+}
+function assertNotBoolean(value, message = "Expected value to not be boolean.") {
+  assert(isNotBoolean(value), message);
+}
+function assertBooleanPass(value, message) {
+  assertBoolean(value, message);
+  return value;
+}
+function assertNotBooleanPass(value, message) {
+  assertNotBoolean(value, message);
+  return value;
+}
+function isBigInt(value) {
+  return typeof value == "bigint";
+}
+function isNotBigInt(value) {
+  return !isBigInt(value);
+}
+function assertBigInt(value, message = "Expected value to be bigint.") {
+  assert(isBigInt(value), message);
+}
+function assertNotBigInt(value, message = "Expected value to not be bigint.") {
+  assert(isNotBigInt(value), message);
+}
+function assertBigIntPass(value, message) {
+  assertBigInt(value, message);
+  return value;
+}
+function assertNotBigIntPass(value, message) {
+  assertNotBigInt(value, message);
+  return value;
+}
+function isFunction(value) {
+  return typeof value == "function";
+}
+function isNotFunction(value) {
+  return !isFunction(value);
+}
+function assertFunction(value, message = "Expected value to be function.") {
+  assert(isFunction(value), message);
+}
+function assertNotFunction(value, message = "Expected value to not be function.") {
+  assert(isNotFunction(value), message);
+}
+function assertFunctionPass(value, message) {
+  assertFunction(value, message);
+  return value;
+}
+function assertNotFunctionPass(value, message) {
+  assertNotFunction(value, message);
+  return value;
+}
+function isSymbol(value) {
+  return typeof value == "symbol";
+}
+function isNotSymbol(value) {
+  return !isSymbol(value);
+}
+function assertSymbol(value, message = "Expected value to be symbol.") {
+  assert(isSymbol(value), message);
+}
+function assertNotSymbol(value, message = "Expected value to not be symbol.") {
+  assert(isNotSymbol(value), message);
+}
+function assertSymbolPass(value, message) {
+  assertSymbol(value, message);
+  return value;
+}
+function assertNotSymbolPass(value, message) {
+  assertNotSymbol(value, message);
+  return value;
+}
+function isObject(value) {
+  return value?.constructor == Object;
+}
+function isNotObject(value) {
+  return !isObject(value);
+}
+function assertObject(value, message = "Expected value to be object.") {
+  assert(isObject(value), message);
+}
+function assertNotObject(value, message = "Expected value to not be object.") {
+  assert(isNotObject(value), message);
+}
+function assertObjectPass(value, message) {
+  assertObject(value, message);
+  return value;
+}
+function assertNotObjectPass(value, message) {
+  assertNotObject(value, message);
+  return value;
+}
+function isPrimitive(value) {
+  const type = typeof value;
+  return type == "string" || type == "number" || type == "boolean" || type == "bigint" || type == "symbol" || value === null || value === void 0;
+}
+function isNotPrimitive(value) {
+  return !isPrimitive(value);
+}
+function assertPrimitive(value, message = "Expected value to be primitive.") {
+  assert(isPrimitive(value), message);
+}
+function assertNotPrimitive(value, message = "Expected value to not be primitive.") {
+  assert(isNotPrimitive(value), message);
+}
+function assertPrimitivePass(value, message) {
+  assertPrimitive(value, message);
+  return value;
+}
+function assertNotPrimitivePass(value, message) {
+  assertNotPrimitive(value, message);
+  return value;
+}
+function isJsonPrimitive(value) {
+  const type = typeof value;
+  return type == "string" || type == "number" || type == "boolean" || value === null;
+}
+function isNotJsonPrimitive(value) {
+  return !isJsonPrimitive(value);
+}
+function assertJsonPrimitive(value, message = "Expected value to be json-primitive.") {
+  assert(isJsonPrimitive(value), message);
+}
+function assertNotJsonPrimitive(value, message = "Expected value to not be json-primitive.") {
+  assert(isNotJsonPrimitive(value), message);
+}
+function assertJsonPrimitivePass(value, message) {
+  assertJsonPrimitive(value, message);
+  return value;
+}
+function assertNotJsonPrimitivePass(value, message) {
+  assertNotJsonPrimitive(value, message);
+  return value;
+}
+function isDate(value) {
+  return value instanceof Date;
+}
+function isNotDate(value) {
+  return !isDate(value);
+}
+function assertDate(value, message = "Expected value to be Date.") {
+  assert(isDate(value), message);
+}
+function assertNotDate(value, message = "Expected value to not be Date.") {
+  assert(isNotDate(value), message);
+}
+function assertDatePass(value, message) {
+  assertDate(value, message);
+  return value;
+}
+function assertNotDatePass(value, message) {
+  assertNotDate(value, message);
+  return value;
+}
+function isValidDate(value) {
+  return isDate(value) && !Number.isNaN(value.getTime());
+}
+function isNotValidDate(value) {
+  return !isValidDate(value);
+}
+function assertValidDate(value, message = "Expected value to be a valid Date.") {
+  assert(isValidDate(value), message);
+}
+function assertNotValidDate(value, message = "Expected value to not be a valid Date.") {
+  assert(isNotValidDate(value), message);
+}
+function assertValidDatePass(value, message) {
+  assertValidDate(value, message);
+  return value;
+}
+function assertNotValidDatePass(value, message) {
+  assertNotValidDate(value, message);
+  return value;
+}
+function isRegExp(value) {
+  return value instanceof RegExp;
+}
+function isNotRegExp(value) {
+  return !isRegExp(value);
+}
+function assertRegExp(value, message = "Expected value to be RegExp.") {
+  assert(isRegExp(value), message);
+}
+function assertNotRegExp(value, message = "Expected value to not be RegExp.") {
+  assert(isNotRegExp(value), message);
+}
+function assertRegExpPass(value, message) {
+  assertRegExp(value, message);
+  return value;
+}
+function assertNotRegExpPass(value, message) {
+  assertNotRegExp(value, message);
+  return value;
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isNotArray(value) {
+  return !isArray(value);
+}
+function assertArray(value, message = "Expected value to be Array.") {
+  assert(isArray(value), message);
+}
+function assertNotArray(value, message = "Expected value to not be Array.") {
+  assert(isNotArray(value), message);
+}
+function assertArrayPass(value, message) {
+  assertArray(value, message);
+  return value;
+}
+function assertNotArrayPass(value, message) {
+  assertNotArray(value, message);
+  return value;
+}
+function isWritableArray(value) {
+  return isArray(value);
+}
+function isNotWritableArray(value) {
+  return isNotArray(value);
+}
+function assertWritableArray(value, message = "Expected value to be Array.") {
+  assertArray(value, message);
+}
+function assertNotWritableArray(value, message = "Expected value to not be Array.") {
+  assertNotArray(value, message);
+}
+function assertWritableArrayPass(value, message) {
+  return assertArrayPass(value, message);
+}
+function assertNotWritableArrayPass(value, message) {
+  return assertNotArrayPass(value, message);
+}
+function isBlob(value) {
+  return import_supports.supportsBlob && value instanceof Blob;
+}
+function isNotBlob(value) {
+  return !isBlob(value);
+}
+function assertBlob(value, message = "Expected value to be Blob.") {
+  assert(isBlob(value), message);
+}
+function assertNotBlob(value, message = "Expected value to not be Blob.") {
+  assert(isNotBlob(value), message);
+}
+function assertBlobPass(value, message) {
+  assertBlob(value, message);
+  return value;
+}
+function assertNotBlobPass(value, message) {
+  assertNotBlob(value, message);
+  return value;
+}
+function isBinaryData(value) {
+  return isArrayBuffer(value) || isArrayBufferView(value);
+}
+function isNotBinaryData(value) {
+  return !isBinaryData(value);
+}
+function assertBinaryData(value, message = "Expected value to be BinaryData.") {
+  assert(isBinaryData(value), message);
+}
+function assertNotBinaryData(value, message = "Expected value to not be BinaryData.") {
+  assert(isNotBinaryData(value), message);
+}
+function assertBinaryDataPass(value, message) {
+  assertBinaryData(value, message);
+  return value;
+}
+function assertNotBinaryDataPass(value, message) {
+  assertNotBinaryData(value, message);
+  return value;
+}
+function isArrayBuffer(value) {
+  return value instanceof ArrayBuffer;
+}
+function isNotArrayBuffer(value) {
+  return !isArrayBuffer(value);
+}
+function assertArrayBuffer(value, message = "Expected value to be ArrayBuffer.") {
+  assert(isArrayBuffer(value), message);
+}
+function assertNotArrayBuffer(value, message = "Expected value to not be ArrayBuffer.") {
+  assert(isNotArrayBuffer(value), message);
+}
+function assertArrayBufferPass(value, message) {
+  assertArrayBuffer(value, message);
+  return value;
+}
+function assertNotArrayBufferPass(value, message) {
+  assertNotArrayBuffer(value, message);
+  return value;
+}
+function isArrayBufferView(value) {
+  return ArrayBuffer.isView(value);
+}
+function isNotArrayBufferView(value) {
+  return !isArrayBufferView(value);
+}
+function assertArrayBufferView(value, message = "Expected value to be ArrayBufferView.") {
+  assert(isArrayBufferView(value), message);
+}
+function assertNotArrayBufferView(value, message = "Expected value to not be ArrayBufferView.") {
+  assert(isNotArrayBufferView(value), message);
+}
+function assertArrayBufferViewPass(value, message) {
+  assertArrayBufferView(value, message);
+  return value;
+}
+function assertNotArrayBufferViewPass(value, message) {
+  assertNotArrayBufferView(value, message);
+  return value;
+}
+function isTypedArray(value) {
+  return ArrayBuffer.isView(value) && isNotDataView(value);
+}
+function isNotTypedArray(value) {
+  return !isTypedArray(value);
+}
+function assertTypedArray(value, message = "Expected value to be TypedArray.") {
+  assert(isTypedArray(value), message);
+}
+function assertNotTypedArray(value, message = "Expected value to not be TypedArray.") {
+  assert(isNotTypedArray(value), message);
+}
+function assertTypedArrayPass(value, message) {
+  assertTypedArray(value, message);
+  return value;
+}
+function assertNotTypedArrayPass(value, message) {
+  assertNotTypedArray(value, message);
+  return value;
+}
+function isInt8Array(value) {
+  return value instanceof Int8Array;
+}
+function isNotInt8Array(value) {
+  return !isInt8Array(value);
+}
+function assertInt8Array(value, message = "Expected value to be Int8Array.") {
+  assert(isInt8Array(value), message);
+}
+function assertNotInt8Array(value, message = "Expected value to not be Int8Array.") {
+  assert(isNotInt8Array(value), message);
+}
+function assertInt8ArrayPass(value, message) {
+  assertInt8Array(value, message);
+  return value;
+}
+function assertNotInt8ArrayPass(value, message) {
+  assertNotInt8Array(value, message);
+  return value;
+}
+function isUint8Array(value) {
+  return value instanceof Uint8Array;
+}
+function isNotUint8Array(value) {
+  return !isUint8Array(value);
+}
+function assertUint8Array(value, message = "Expected value to be Uint8Array.") {
+  assert(isUint8Array(value), message);
+}
+function assertNotUint8Array(value, message = "Expected value to not be Uint8Array.") {
+  assert(isNotUint8Array(value), message);
+}
+function assertUint8ArrayPass(value, message) {
+  assertUint8Array(value, message);
+  return value;
+}
+function assertNotUint8ArrayPass(value, message) {
+  assertNotUint8Array(value, message);
+  return value;
+}
+function isUint8ClampedArray(value) {
+  return value instanceof Uint8ClampedArray;
+}
+function isNotUint8ClampedArray(value) {
+  return !isUint8ClampedArray(value);
+}
+function assertUint8ClampedArray(value, message = "Expected value to be Uint8ClampedArray.") {
+  assert(isUint8ClampedArray(value), message);
+}
+function assertNotUint8ClampedArray(value, message = "Expected value to not be Uint8ClampedArray.") {
+  assert(isNotUint8ClampedArray(value), message);
+}
+function assertUint8ClampedArrayPass(value, message) {
+  assertUint8ClampedArray(value, message);
+  return value;
+}
+function assertNotUint8ClampedArrayPass(value, message) {
+  assertNotUint8ClampedArray(value, message);
+  return value;
+}
+function isInt16Array(value) {
+  return value instanceof Int16Array;
+}
+function isNotInt16Array(value) {
+  return !isInt16Array(value);
+}
+function assertInt16Array(value, message = "Expected value to be Int16Array.") {
+  assert(isInt16Array(value), message);
+}
+function assertNotInt16Array(value, message = "Expected value to not be Int16Array.") {
+  assert(isNotInt16Array(value), message);
+}
+function assertInt16ArrayPass(value, message) {
+  assertInt16Array(value, message);
+  return value;
+}
+function assertNotInt16ArrayPass(value, message) {
+  assertNotInt16Array(value, message);
+  return value;
+}
+function isUint16Array(value) {
+  return value instanceof Uint16Array;
+}
+function isNotUint16Array(value) {
+  return !isUint16Array(value);
+}
+function assertUint16Array(value, message = "Expected value to be Uint16Array.") {
+  assert(isUint16Array(value), message);
+}
+function assertNotUint16Array(value, message = "Expected value to not be Uint16Array.") {
+  assert(isNotUint16Array(value), message);
+}
+function assertUint16ArrayPass(value, message) {
+  assertUint16Array(value, message);
+  return value;
+}
+function assertNotUint16ArrayPass(value, message) {
+  assertNotUint16Array(value, message);
+  return value;
+}
+function isInt32Array(value) {
+  return value instanceof Int32Array;
+}
+function isNotInt32Array(value) {
+  return !isInt32Array(value);
+}
+function assertInt32Array(value, message = "Expected value to be Int32Array.") {
+  assert(isInt32Array(value), message);
+}
+function assertNotInt32Array(value, message = "Expected value to not be Int32Array.") {
+  assert(isNotInt32Array(value), message);
+}
+function assertInt32ArrayPass(value, message) {
+  assertInt32Array(value, message);
+  return value;
+}
+function assertNotInt32ArrayPass(value, message) {
+  assertNotInt32Array(value, message);
+  return value;
+}
+function isUint32Array(value) {
+  return value instanceof Uint32Array;
+}
+function isNotUint32Array(value) {
+  return !isUint32Array(value);
+}
+function assertUint32Array(value, message = "Expected value to be Uint32Array.") {
+  assert(isUint32Array(value), message);
+}
+function assertNotUint32Array(value, message = "Expected value to not be Uint32Array.") {
+  assert(isNotUint32Array(value), message);
+}
+function assertUint32ArrayPass(value, message) {
+  assertUint32Array(value, message);
+  return value;
+}
+function assertNotUint32ArrayPass(value, message) {
+  assertNotUint32Array(value, message);
+  return value;
+}
+function isFloat32Array(value) {
+  return value instanceof Float32Array;
+}
+function isNotFloat32Array(value) {
+  return !isFloat32Array(value);
+}
+function assertFloat32Array(value, message = "Expected value to be Float32Array.") {
+  assert(isFloat32Array(value), message);
+}
+function assertNotFloat32Array(value, message = "Expected value to not be Float32Array.") {
+  assert(isNotFloat32Array(value), message);
+}
+function assertFloat32ArrayPass(value, message) {
+  assertFloat32Array(value, message);
+  return value;
+}
+function assertNotFloat32ArrayPass(value, message) {
+  assertNotFloat32Array(value, message);
+  return value;
+}
+function isFloat64Array(value) {
+  return value instanceof Float64Array;
+}
+function isNotFloat64Array(value) {
+  return !isFloat64Array(value);
+}
+function assertFloat64Array(value, message = "Expected value to be Float64Array.") {
+  assert(isFloat64Array(value), message);
+}
+function assertNotFloat64Array(value, message = "Expected value to not be Float64Array.") {
+  assert(isNotFloat64Array(value), message);
+}
+function assertFloat64ArrayPass(value, message) {
+  assertFloat64Array(value, message);
+  return value;
+}
+function assertNotFloat64ArrayPass(value, message) {
+  assertNotFloat64Array(value, message);
+  return value;
+}
+function isBigInt64Array(value) {
+  return value instanceof BigInt64Array;
+}
+function isNotBigInt64Array(value) {
+  return !isBigInt64Array(value);
+}
+function assertBigInt64Array(value, message = "Expected value to be BigInt64Array.") {
+  assert(isBigInt64Array(value), message);
+}
+function assertNotBigInt64Array(value, message = "Expected value to not be BigInt64Array.") {
+  assert(isNotBigInt64Array(value), message);
+}
+function assertBigInt64ArrayPass(value, message) {
+  assertBigInt64Array(value, message);
+  return value;
+}
+function assertNotBigInt64ArrayPass(value, message) {
+  assertNotBigInt64Array(value, message);
+  return value;
+}
+function isBigUint64Array(value) {
+  return value instanceof BigUint64Array;
+}
+function isNotBigUint64Array(value) {
+  return !isBigUint64Array(value);
+}
+function assertBigUint64Array(value, message = "Expected value to be BigUint64Array.") {
+  assert(isBigUint64Array(value), message);
+}
+function assertNotBigUint64Array(value, message = "Expected value to not be BigUint64Array.") {
+  assert(isNotBigUint64Array(value), message);
+}
+function assertBigUint64ArrayPass(value, message) {
+  assertBigUint64Array(value, message);
+  return value;
+}
+function assertNotBigUint64ArrayPass(value, message) {
+  assertNotBigUint64Array(value, message);
+  return value;
+}
+function isDataView(value) {
+  return value instanceof DataView;
+}
+function isNotDataView(value) {
+  return !isDataView(value);
+}
+function assertDataView(value, message = "Expected value to be DataView.") {
+  assert(isDataView(value), message);
+}
+function assertNotDataView(value, message = "Expected value to not be DataView.") {
+  assert(isNotDataView(value), message);
+}
+function assertDataViewPass(value, message) {
+  assertDataView(value, message);
+  return value;
+}
+function assertNotDataViewPass(value, message) {
+  assertNotDataView(value, message);
+  return value;
+}
+function isSet(value) {
+  return value instanceof Set;
+}
+function isNotSet(value) {
+  return !isSet(value);
+}
+function assertSet(value, message = "Expected value to be Set.") {
+  assert(isSet(value), message);
+}
+function assertNotSet(value, message = "Expected value to not be Set.") {
+  assert(isNotSet(value), message);
+}
+function assertSetPass(value, message) {
+  assertSet(value, message);
+  return value;
+}
+function assertNotSetPass(value, message) {
+  assertNotSet(value, message);
+  return value;
+}
+function isMap(value) {
+  return value instanceof Map;
+}
+function isNotMap(value) {
+  return !isMap(value);
+}
+function assertMap(value, message = "Expected value to be Map.") {
+  assert(isMap(value), message);
+}
+function assertNotMap(value, message = "Expected value to not be Map.") {
+  assert(isNotMap(value), message);
+}
+function assertMapPass(value, message) {
+  assertMap(value, message);
+  return value;
+}
+function assertNotMapPass(value, message) {
+  assertNotMap(value, message);
+  return value;
+}
+function isPromise(value) {
+  return value instanceof Promise;
+}
+function isNotPromise(value) {
+  return !isPromise(value);
+}
+function assertPromise(value, message = "Expected value to be Promise.") {
+  assert(isPromise(value), message);
+}
+function assertNotPromise(value, message = "Expected value to not be Promise.") {
+  assert(isNotPromise(value), message);
+}
+function assertPromisePass(value, message) {
+  assertPromise(value, message);
+  return value;
+}
+function assertNotPromisePass(value, message) {
+  assertNotPromise(value, message);
+  return value;
+}
+function isReadableStream(value) {
+  return import_supports.supportsReadableStream && value instanceof ReadableStream;
+}
+function isNotReadableStream(value) {
+  return !isReadableStream(value);
+}
+function assertReadableStream(value, message = "Expected value to be ReadableStream.") {
+  assert(isReadableStream(value), message);
+}
+function assertNotReadableStream(value, message = "Expected value to not be ReadableStream.") {
+  assert(isNotReadableStream(value), message);
+}
+function assertReadableStreamPass(value, message) {
+  assertReadableStream(value, message);
+  return value;
+}
+function assertNotReadableStreamPass(value, message) {
+  assertNotReadableStream(value, message);
+  return value;
+}
+function isError(value) {
+  return value instanceof Error;
+}
+function isNotError(value) {
+  return !isError(value);
+}
+function assertError(value, message = "Expected value to be Error.") {
+  assert(isError(value), message);
+}
+function assertNotError(value, message = "Expected value to not be Error.") {
+  assert(isNotError(value), message);
+}
+function assertErrorPass(value, message) {
+  assertError(value, message);
+  return value;
+}
+function assertNotErrorPass(value, message) {
+  assertNotError(value, message);
+  return value;
+}