@tstdl/base 0.85.13 → 0.86.0-beta1

package/utils/type-guards.js

@@ -1,1076 +1,253 @@
-"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 !isUndefined(value);
-}
-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 !isNull(value);
-}
-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;
-}
+/* 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; }