+
+## Usage
+
+```javascript
+var assert = require( '@stdlib/assert' );
+```
+
+#### assert
+
+Included in this namespace is a comprehensive suite of assertion utilities, such as utilities for testing for various data types and others for testing for JavaScript feature support.
+
+```javascript
+var o = assert;
+// returns {...}
+```
+
+To validate the built-in JavaScript data types, the namespace includes the following assertion utilities:
+
+
+
+
+
+- [`isArray( value )`][@stdlib/assert/is-array]: test if a value is an array.
+- [`isBoolean( value )`][@stdlib/assert/is-boolean]: test if a value is a boolean.
+- [`isDateObject( value )`][@stdlib/assert/is-date-object]: test if a value is a Date object.
+- [`isFunction( value )`][@stdlib/assert/is-function]: test if a value is a function.
+- [`isnan( value )`][@stdlib/assert/is-nan]: test if a value is NaN.
+- [`isNull( value )`][@stdlib/assert/is-null]: test if a value is null.
+- [`isNumber( value )`][@stdlib/assert/is-number]: test if a value is a number.
+- [`isObject( value )`][@stdlib/assert/is-object]: test if a value is an object.
+- [`isRegExp( value )`][@stdlib/assert/is-regexp]: test if a value is a regular expression.
+- [`isString( value )`][@stdlib/assert/is-string]: test if a value is a string.
+- [`isSymbol( value )`][@stdlib/assert/is-symbol]: test if a value is a symbol.
+- [`isUndefined( value )`][@stdlib/assert/is-undefined]: test if a value is undefined.
+
+
+
+
+
+For primitive types having corresponding object wrappers, assertion utilities provide `isObject` and `isPrimitive` methods to test for either objects or primitives, respectively.
+
+
+
+```javascript
+var isBoolean = require( '@stdlib/assert/is-boolean' );
+
+var bool = isBoolean.isObject( new Boolean( false ) );
+// returns true
+
+bool = isBoolean.isObject( false );
+// returns false
+
+bool = isBoolean.isPrimitive( false );
+// returns true
+```
+
+Many of the assertion utilities have corresponding packages that test whether array elements are of the given data type:
+
+
+
+
+
+- [`isArrayArray( value )`][@stdlib/assert/is-array-array]: test if a value is an array of arrays.
+- [`isBooleanArray( value )`][@stdlib/assert/is-boolean-array]: test if a value is an array-like object of booleans.
+- [`isFunctionArray( value )`][@stdlib/assert/is-function-array]: test if a value is an array-like object containing only functions.
+- [`isNaNArray( value )`][@stdlib/assert/is-nan-array]: test if a value is an array-like object containing only NaN values.
+- [`isNullArray( value )`][@stdlib/assert/is-null-array]: test if a value is an array-like object containing only null values.
+- [`isNumberArray( value )`][@stdlib/assert/is-number-array]: test if a value is an array-like object of numbers.
+- [`isObjectArray( value )`][@stdlib/assert/is-object-array]: test if a value is an array-like object containing only objects.
+- [`isStringArray( value )`][@stdlib/assert/is-string-array]: test if a value is an array of strings.
+- [`isSymbolArray( value )`][@stdlib/assert/is-symbol-array]: test if a value is an array-like object containing only symbols.
+
+
+
+
+
+Where applicable, similar to the assertion utilities for built-in data types, array assertion utilities provides methods for testing for an array of primitives or objects.
+
+
+
+```javascript
+var isStringArray = require( '@stdlib/assert/is-string-array' );
+
+var bool = isStringArray( [ 'hello', 'world' ] );
+// returns true
+
+bool = isStringArray.primitives( [ 'hello', 'world' ] );
+// returns true
+
+bool = isStringArray.objects( [ 'hello', 'world' ] );
+// returns false
+
+bool = isStringArray.objects( [ new String( 'hello' ), new String( 'world' ) ] );
+// returns true
+```
+
+The namespace also contains utilities to test for numbers within a certain range or for numbers satisfying a particular "type":
+
+
+
+
+
+- [`isCubeNumber( value )`][@stdlib/assert/is-cube-number]: test if a value is a cube number.
+- [`isIntegerArray( value )`][@stdlib/assert/is-integer-array]: test if a value is an array-like object containing only integers.
+- [`isInteger( value )`][@stdlib/assert/is-integer]: test if a value is a number having an integer value.
+- [`isNegativeIntegerArray( value )`][@stdlib/assert/is-negative-integer-array]: test if a value is an array-like object containing only negative integers.
+- [`isNegativeInteger( value )`][@stdlib/assert/is-negative-integer]: test if a value is a number having a negative integer value.
+- [`isNegativeNumberArray( value )`][@stdlib/assert/is-negative-number-array]: test if a value is an array-like object containing only negative numbers.
+- [`isNegativeNumber( value )`][@stdlib/assert/is-negative-number]: test if a value is a number having a negative value.
+- [`isNonNegativeIntegerArray( value )`][@stdlib/assert/is-nonnegative-integer-array]: test if a value is an array-like object containing only nonnegative integers.
+- [`isNonNegativeInteger( value )`][@stdlib/assert/is-nonnegative-integer]: test if a value is a number having a nonnegative integer value.
+- [`isNonNegativeNumberArray( value )`][@stdlib/assert/is-nonnegative-number-array]: test if a value is an array-like object containing only nonnegative numbers.
+- [`isNonNegativeNumber( value )`][@stdlib/assert/is-nonnegative-number]: test if a value is a number having a nonnegative value.
+- [`isNonPositiveIntegerArray( value )`][@stdlib/assert/is-nonpositive-integer-array]: test if a value is an array-like object containing only nonpositive integers.
+- [`isNonPositiveInteger( value )`][@stdlib/assert/is-nonpositive-integer]: test if a value is a number having a nonpositive integer value.
+- [`isNonPositiveNumberArray( value )`][@stdlib/assert/is-nonpositive-number-array]: test if a value is an array-like object containing only nonpositive numbers.
+- [`isNonPositiveNumber( value )`][@stdlib/assert/is-nonpositive-number]: test if a value is a number having a nonpositive value.
+- [`isPositiveIntegerArray( value )`][@stdlib/assert/is-positive-integer-array]: test if a value is an array-like object containing only positive integers.
+- [`isPositiveInteger( value )`][@stdlib/assert/is-positive-integer]: test if a value is a number having a positive integer value.
+- [`isPositiveNumberArray( value )`][@stdlib/assert/is-positive-number-array]: test if a value is an array-like object containing only positive numbers.
+- [`isPositiveNumber( value )`][@stdlib/assert/is-positive-number]: test if a value is a number having a positive value.
+- [`isSafeIntegerArray( value )`][@stdlib/assert/is-safe-integer-array]: test if a value is an array-like object containing only safe integers.
+- [`isSafeInteger( value )`][@stdlib/assert/is-safe-integer]: test if a value is a number having a safe integer value.
+- [`isSquareNumber( value )`][@stdlib/assert/is-square-number]: test if a value is a square number.
+- [`isSquareTriangularNumber( value )`][@stdlib/assert/is-square-triangular-number]: test if a value is a square triangular number.
+- [`isTriangularNumber( value )`][@stdlib/assert/is-triangular-number]: test if a value is a triangular number.
+
+
+
+
+
+The namespace provides various utilities for validating typed arrays:
+
+
+
+
+
+- [`isFloat32Array( value )`][@stdlib/assert/is-float32array]: test if a value is a Float32Array.
+- [`isFloat64Array( value )`][@stdlib/assert/is-float64array]: test if a value is a Float64Array.
+- [`isInt16Array( value )`][@stdlib/assert/is-int16array]: test if a value is an Int16Array.
+- [`isInt32Array( value )`][@stdlib/assert/is-int32array]: test if a value is an Int32Array.
+- [`isInt8Array( value )`][@stdlib/assert/is-int8array]: test if a value is an Int8Array.
+- [`isUint16Array( value )`][@stdlib/assert/is-uint16array]: test if a value is a Uint16Array.
+- [`isUint32Array( value )`][@stdlib/assert/is-uint32array]: test if a value is a Uint32Array.
+- [`isUint8Array( value )`][@stdlib/assert/is-uint8array]: test if a value is a Uint8Array.
+- [`isUint8ClampedArray( value )`][@stdlib/assert/is-uint8clampedarray]: test if a value is a Uint8ClampedArray.
+
+
+
+
+
+The namespace includes utilities for validating `ndarray`s (n-dimensional arrays).
+
+
+
+
+
+- [`isCentrosymmetricMatrix( value )`][@stdlib/assert/is-centrosymmetric-matrix]: test if a value is a centrosymmetric matrix.
+- [`isFloat32MatrixLike( value )`][@stdlib/assert/is-float32matrix-like]: test if a value is a 2-dimensional ndarray-like object containing single-precision floating-point numbers.
+- [`isFloat32ndarrayLike( value )`][@stdlib/assert/is-float32ndarray-like]: test if a value is an ndarray-like object containing single-precision floating-point numbers.
+- [`isFloat32VectorLike( value )`][@stdlib/assert/is-float32vector-like]: test if a value is a 1-dimensional ndarray-like object containing single-precision floating-point numbers.
+- [`isFloat64MatrixLike( value )`][@stdlib/assert/is-float64matrix-like]: test if a value is a 2-dimensional ndarray-like object containing double-precision floating-point numbers.
+- [`isFloat64ndarrayLike( value )`][@stdlib/assert/is-float64ndarray-like]: test if a value is an ndarray-like object containing double-precision floating-point numbers.
+- [`isFloat64VectorLike( value )`][@stdlib/assert/is-float64vector-like]: test if a value is a 1-dimensional ndarray-like object containing double-precision floating-point numbers.
+- [`isMatrixLike( value )`][@stdlib/assert/is-matrix-like]: test if a value is 2-dimensional ndarray-like object.
+- [`isndarrayLike( value )`][@stdlib/assert/is-ndarray-like]: test if a value is ndarray-like.
+- [`isNonSymmetricMatrix( value )`][@stdlib/assert/is-nonsymmetric-matrix]: test if a value is a non-symmetric matrix.
+- [`isPersymmetricMatrix( value )`][@stdlib/assert/is-persymmetric-matrix]: test if a value is a persymmetric matrix.
+- [`isSkewCentrosymmetricMatrix( value )`][@stdlib/assert/is-skew-centrosymmetric-matrix]: test if a value is a skew-centrosymmetric matrix.
+- [`isSkewPersymmetricMatrix( value )`][@stdlib/assert/is-skew-persymmetric-matrix]: test if a value is a skew-persymmetric matrix.
+- [`isSkewSymmetricMatrix( value )`][@stdlib/assert/is-skew-symmetric-matrix]: test if a value is a skew-symmetric matrix.
+- [`isSquareMatrix( value )`][@stdlib/assert/is-square-matrix]: test if a value is a 2-dimensional ndarray-like object having equal dimensions.
+- [`isSymmetricMatrix( value )`][@stdlib/assert/is-symmetric-matrix]: test if a value is a symmetric matrix.
+- [`isVectorLike( value )`][@stdlib/assert/is-vector-like]: test if a value is a 1-dimensional ndarray-like object.
+
+
+
+
+
+The namespace includes utilities for validating complex numbers and arrays of complex numbers:
+
+
+
+
+
+- [`isComplexLike( value )`][@stdlib/assert/is-complex-like]: test if a value is a complex number-like object.
+- [`isComplexTypedArrayLike( value )`][@stdlib/assert/is-complex-typed-array-like]: test if a value is complex-typed-array-like.
+- [`isComplexTypedArray( value )`][@stdlib/assert/is-complex-typed-array]: test if a value is a complex typed array.
+- [`isComplex( value )`][@stdlib/assert/is-complex]: test if a value is a 64-bit or 128-bit complex number.
+- [`isComplex128( value )`][@stdlib/assert/is-complex128]: test if a value is a 128-bit complex number.
+- [`isComplex128Array( value )`][@stdlib/assert/is-complex128array]: test if a value is a Complex128Array.
+- [`isComplex64( value )`][@stdlib/assert/is-complex64]: test if a value is a 64-bit complex number.
+- [`isComplex64Array( value )`][@stdlib/assert/is-complex64array]: test if a value is a Complex64Array.
+
+
+
+
+
+The namespace includes utilities for validating other special arrays or buffers:
+
+
+
+
+
+- [`isArrayLength( value )`][@stdlib/assert/is-array-length]: test if a value is a valid array length.
+- [`isArrayLikeObject( value )`][@stdlib/assert/is-array-like-object]: test if a value is an array-like object.
+- [`isArrayLike( value )`][@stdlib/assert/is-array-like]: test if a value is array-like.
+- [`isArrayBuffer( value )`][@stdlib/assert/is-arraybuffer]: test if a value is an ArrayBuffer.
+- [`isBetweenArray( value, a, b[, left, right] )`][@stdlib/assert/is-between-array]: test if a value is an array-like object where every element is between two values.
+- [`isCircularArray( value )`][@stdlib/assert/is-circular-array]: test if a value is an array containing a circular reference.
+- [`isEmptyArray( value )`][@stdlib/assert/is-empty-array]: test if a value is an empty array.
+- [`isFalsyArray( value )`][@stdlib/assert/is-falsy-array]: test if a value is an array-like object containing only falsy values.
+- [`isFiniteArray( value )`][@stdlib/assert/is-finite-array]: test if a value is an array-like object containing only finite numbers.
+- [`isNumericArray( value )`][@stdlib/assert/is-numeric-array]: test if a value is a numeric array.
+- [`isPlainObjectArray( value )`][@stdlib/assert/is-plain-object-array]: test if a value is an array-like object containing only plain objects.
+- [`isProbabilityArray( value )`][@stdlib/assert/is-probability-array]: test if a value is an array-like object containing only probabilities.
+- [`isSharedArrayBuffer( value )`][@stdlib/assert/is-sharedarraybuffer]: test if a value is a SharedArrayBuffer.
+- [`isTruthyArray( value )`][@stdlib/assert/is-truthy-array]: test if a value is an array-like object containing only truthy values.
+- [`isTypedArrayLength( value )`][@stdlib/assert/is-typed-array-length]: test if a value is a valid typed array length.
+- [`isTypedArrayLike( value )`][@stdlib/assert/is-typed-array-like]: test if a value is typed-array-like.
+- [`isTypedArray( value )`][@stdlib/assert/is-typed-array]: test if a value is a typed array.
+- [`isUnityProbabilityArray( value )`][@stdlib/assert/is-unity-probability-array]: test if a value is an array of probabilities that sum to one.
+
+
+
+
+
+To test for error objects, the namespace includes the following utilities:
+
+
+
+
+
+- [`isError( value )`][@stdlib/assert/is-error]: test if a value is an Error object.
+- [`isEvalError( value )`][@stdlib/assert/is-eval-error]: test if a value is an EvalError object.
+- [`isRangeError( value )`][@stdlib/assert/is-range-error]: test if a value is a RangeError object.
+- [`isReferenceError( value )`][@stdlib/assert/is-reference-error]: test if a value is a ReferenceError object.
+- [`isSyntaxError( value )`][@stdlib/assert/is-syntax-error]: test if a value is a SyntaxError object.
+- [`isTypeError( value )`][@stdlib/assert/is-type-error]: test if a value is a TypeError object.
+- [`isURIError( value )`][@stdlib/assert/is-uri-error]: test if a value is a URIError object.
+
+
+
+
+
+The namespace exposes the following constants concerning the current running process:
+
+
+
+
+
+- [`IS_BROWSER`][@stdlib/assert/is-browser]: check if the runtime is a web browser.
+- [`IS_DARWIN`][@stdlib/assert/is-darwin]: boolean indicating if the current process is running on Darwin.
+- [`IS_ELECTRON_MAIN`][@stdlib/assert/is-electron-main]: check if the runtime is the main Electron process.
+- [`IS_ELECTRON_RENDERER`][@stdlib/assert/is-electron-renderer]: check if the runtime is the Electron renderer process.
+- [`IS_ELECTRON`][@stdlib/assert/is-electron]: check if the runtime is Electron.
+- [`IS_LITTLE_ENDIAN`][@stdlib/assert/is-little-endian]: check if an environment is little endian.
+- [`IS_NODE`][@stdlib/assert/is-node]: check if the runtime is Node.js.
+- [`IS_WEB_WORKER`][@stdlib/assert/is-web-worker]: check if the runtime is a web worker.
+- [`IS_WINDOWS`][@stdlib/assert/is-windows]: boolean indicating if the current process is running on Windows.
+
+
+
+
+
+To test whether a runtime environment supports certain features, the namespace includes the following utilities:
+
+
+
+
+
+- [`hasArrayBufferSupport()`][@stdlib/assert/has-arraybuffer-support]: detect native `ArrayBuffer` support.
+- [`hasAsyncAwaitSupport()`][@stdlib/assert/has-async-await-support]: detect native `async`/`await` support.
+- [`hasAsyncIteratorSymbolSupport()`][@stdlib/assert/has-async-iterator-symbol-support]: detect native `Symbol.asyncIterator` support.
+- [`hasClassSupport()`][@stdlib/assert/has-class-support]: detect native `class` support.
+- [`hasDefinePropertiesSupport()`][@stdlib/assert/has-define-properties-support]: detect `Object.defineProperties` support.
+- [`hasDefinePropertySupport()`][@stdlib/assert/has-define-property-support]: detect `Object.defineProperty` support.
+- [`hasFloat32ArraySupport()`][@stdlib/assert/has-float32array-support]: detect native `Float32Array` support.
+- [`hasFloat64ArraySupport()`][@stdlib/assert/has-float64array-support]: detect native `Float64Array` support.
+- [`hasFunctionNameSupport()`][@stdlib/assert/has-function-name-support]: detect native function `name` support.
+- [`hasGeneratorSupport()`][@stdlib/assert/has-generator-support]: detect native `generator function` support.
+- [`hasGlobalThisSupport()`][@stdlib/assert/has-globalthis-support]: detect `globalThis` support.
+- [`hasInt16ArraySupport()`][@stdlib/assert/has-int16array-support]: detect native `Int16Array` support.
+- [`hasInt32ArraySupport()`][@stdlib/assert/has-int32array-support]: detect native `Int32Array` support.
+- [`hasInt8ArraySupport()`][@stdlib/assert/has-int8array-support]: detect native `Int8Array` support.
+- [`hasIteratorSymbolSupport()`][@stdlib/assert/has-iterator-symbol-support]: detect native `Symbol.iterator` support.
+- [`hasMapSupport()`][@stdlib/assert/has-map-support]: detect native `Map` support.
+- [`hasNodeBufferSupport()`][@stdlib/assert/has-node-buffer-support]: detect native `Buffer` support.
+- [`hasProxySupport()`][@stdlib/assert/has-proxy-support]: detect native `Proxy` support.
+- [`hasSetSupport()`][@stdlib/assert/has-set-support]: detect native `Set` support.
+- [`hasSharedArrayBufferSupport()`][@stdlib/assert/has-sharedarraybuffer-support]: detect native `SharedArrayBuffer` support.
+- [`hasSymbolSupport()`][@stdlib/assert/has-symbol-support]: detect native `Symbol` support.
+- [`hasToStringTagSupport()`][@stdlib/assert/has-tostringtag-support]: detect native `Symbol.toStringTag` support.
+- [`hasUint16ArraySupport()`][@stdlib/assert/has-uint16array-support]: detect native `Uint16Array` support.
+- [`hasUint32ArraySupport()`][@stdlib/assert/has-uint32array-support]: detect native `Uint32Array` support.
+- [`hasUint8ArraySupport()`][@stdlib/assert/has-uint8array-support]: detect native `Uint8Array` support.
+- [`hasUint8ClampedArraySupport()`][@stdlib/assert/has-uint8clampedarray-support]: detect native `Uint8ClampedArray` support.
+- [`hasWebAssemblySupport()`][@stdlib/assert/has-wasm-support]: detect native WebAssembly support.
+- [`hasWeakMapSupport()`][@stdlib/assert/has-weakmap-support]: detect native `WeakMap` support.
+- [`hasWeakSetSupport()`][@stdlib/assert/has-weakset-support]: detect native `WeakSet` support.
+
+
+
+
+
+The remaining namespace utilities are as follows:
+
+
+
+
+
+- [`contains( val, searchValue[, position] )`][@stdlib/assert/contains]: test if an array-like value contains a search value.
+- [`deepEqual( a, b )`][@stdlib/assert/deep-equal]: test for deep equality between two values.
+- [`deepHasOwnProp( value, path[, options] )`][@stdlib/assert/deep-has-own-property]: test whether an object contains a nested key path.
+- [`deepHasProp( value, path[, options] )`][@stdlib/assert/deep-has-property]: test whether an object contains a nested key path, either own or inherited.
+- [`hasOwnProp( value, property )`][@stdlib/assert/has-own-property]: test if an object has a specified property.
+- [`hasProp( value, property )`][@stdlib/assert/has-property]: test if an object has a specified property, either own or inherited.
+- [`hasUTF16SurrogatePairAt( string, position )`][@stdlib/assert/has-utf16-surrogate-pair-at]: test if a position in a string marks the start of a UTF-16 surrogate pair.
+- [`instanceOf( value, constructor )`][@stdlib/assert/instance-of]: test whether a value has in its prototype chain a specified constructor as a prototype property.
+- [`isAbsolutePath( value )`][@stdlib/assert/is-absolute-path]: test if a value is an absolute path.
+- [`isAccessorPropertyIn( value, property )`][@stdlib/assert/is-accessor-property-in]: test if an object's own or inherited property has an accessor descriptor.
+- [`isAccessorProperty( value, property )`][@stdlib/assert/is-accessor-property]: test if an object's own property has an accessor descriptor.
+- [`isAlphagram( value )`][@stdlib/assert/is-alphagram]: test if a value is an alphagram.
+- [`isAlphaNumeric( value )`][@stdlib/assert/is-alphanumeric]: test whether a string contains only alphanumeric characters.
+- [`isAnagram( str, value )`][@stdlib/assert/is-anagram]: test if a value is an anagram.
+- [`isArguments( value )`][@stdlib/assert/is-arguments]: test if a value is an arguments object.
+- [`isASCII( value )`][@stdlib/assert/is-ascii]: test whether a character belongs to the ASCII character set and whether this is true for all characters in a provided string.
+- [`isBetween( value, a, b[, left, right] )`][@stdlib/assert/is-between]: test if a value is between two values.
+- [`IS_BIG_ENDIAN`][@stdlib/assert/is-big-endian]: check if an environment is big endian.
+- [`isBinaryString( value )`][@stdlib/assert/is-binary-string]: test if a value is a binary string.
+- [`isBoxedPrimitive( value )`][@stdlib/assert/is-boxed-primitive]: test if a value is a JavaScript boxed primitive.
+- [`isBuffer( value )`][@stdlib/assert/is-buffer]: test if a value is a Buffer object.
+- [`isCapitalized( value )`][@stdlib/assert/is-capitalized]: test if a value is a string having an uppercase first character.
+- [`isCircular( value )`][@stdlib/assert/is-circular]: test if a value is a plain object containing a circular reference.
+- [`isCircular( value )`][@stdlib/assert/is-circular]: test if an object-like value contains a circular reference.
+- [`isCollection( value )`][@stdlib/assert/is-collection]: test if a value is a collection.
+- [`isComposite( value )`][@stdlib/assert/is-composite]: test if a value is a composite number.
+- [`isConfigurablePropertyIn( value, property )`][@stdlib/assert/is-configurable-property-in]: test if an object's own or inherited property is configurable.
+- [`isConfigurableProperty( value, property )`][@stdlib/assert/is-configurable-property]: test if an object's own property is configurable.
+- [`isDataPropertyIn( value, property )`][@stdlib/assert/is-data-property-in]: test if an object's own or inherited property has a data descriptor.
+- [`isDataProperty( value, property )`][@stdlib/assert/is-data-property]: test if an object's own property has a data descriptor.
+- [`isDigitString( value )`][@stdlib/assert/is-digit-string]: test whether a string contains only numeric digits.
+- [`isEmailAddress( value )`][@stdlib/assert/is-email-address]: test if a value is an email address.
+- [`isEmptyObject( value )`][@stdlib/assert/is-empty-object]: test if a value is an empty object.
+- [`isEmptyString( value )`][@stdlib/assert/is-empty-string]: test if a value is an empty string.
+- [`isEnumerablePropertyIn( value, property )`][@stdlib/assert/is-enumerable-property-in]: test if an object's own or inherited property is enumerable.
+- [`isEnumerableProperty( value, property )`][@stdlib/assert/is-enumerable-property]: test if an object's own property is enumerable.
+- [`isEven( value )`][@stdlib/assert/is-even]: test if a value is an even number.
+- [`isFalsy( value )`][@stdlib/assert/is-falsy]: test if a value is falsy.
+- [`isFinite( value )`][@stdlib/assert/is-finite]: test if a value is a finite number.
+- [`isGeneratorObjectLike( value )`][@stdlib/assert/is-generator-object-like]: test if a value is `generator` object-like.
+- [`isGeneratorObject( value )`][@stdlib/assert/is-generator-object]: test if a value is a `generator` object.
+- [`isgzipBuffer( value )`][@stdlib/assert/is-gzip-buffer]: test if a value is a gzip buffer.
+- [`isHexString( value )`][@stdlib/assert/is-hex-string]: test whether a string contains only hexadecimal digits.
+- [`isInfinite( value )`][@stdlib/assert/is-infinite]: test if a value is an infinite number.
+- [`isInheritedProperty( value, property )`][@stdlib/assert/is-inherited-property]: test if an object has an inherited property.
+- [`isIterableLike( value )`][@stdlib/assert/is-iterable-like]: test if a value is `iterable`-like.
+- [`isIteratorLike( value )`][@stdlib/assert/is-iterator-like]: test if a value is `iterator`-like.
+- [`isJSON( value )`][@stdlib/assert/is-json]: test if a value is a parseable JSON string.
+- [`isLeapYear( [value] )`][@stdlib/assert/is-leap-year]: test if a value corresponds to a leap year in the Gregorian calendar.
+- [`isLowercase( value )`][@stdlib/assert/is-lowercase]: test if a value is a lowercase string.
+- [`isMethodIn( value, property )`][@stdlib/assert/is-method-in]: test if an object has a specified method name, either own or inherited.
+- [`isMethod( value, property )`][@stdlib/assert/is-method]: test if an object has a specified method name.
+- [`isNamedTypedTupleLike( value )`][@stdlib/assert/is-named-typed-tuple-like]: test if a value is named typed tuple-like.
+- [`isNativeFunction( value )`][@stdlib/assert/is-native-function]: test if a value is a native function.
+- [`isNegativeZero( value )`][@stdlib/assert/is-negative-zero]: test if a value is a number equal to negative zero.
+- [`isNodeBuiltin( value )`][@stdlib/assert/is-node-builtin]: test whether a string matches a Node.js built-in module name.
+- [`isNodeDuplexStreamLike( value )`][@stdlib/assert/is-node-duplex-stream-like]: test if a value is Node duplex stream-like.
+- [`isNodeReadableStreamLike( value )`][@stdlib/assert/is-node-readable-stream-like]: test if a value is Node readable stream-like.
+- [`isNodeREPL()`][@stdlib/assert/is-node-repl]: check if running in a Node.js REPL environment.
+- [`isNodeStreamLike( value )`][@stdlib/assert/is-node-stream-like]: test if a value is Node stream-like.
+- [`isNodeTransformStreamLike( value )`][@stdlib/assert/is-node-transform-stream-like]: test if a value is Node transform stream-like.
+- [`isNodeWritableStreamLike( value )`][@stdlib/assert/is-node-writable-stream-like]: test if a value is Node writable stream-like.
+- [`isNonConfigurablePropertyIn( value, property )`][@stdlib/assert/is-nonconfigurable-property-in]: test if an object's own or inherited property is non-configurable.
+- [`isNonConfigurableProperty( value, property )`][@stdlib/assert/is-nonconfigurable-property]: test if an object's own property is non-configurable.
+- [`isNonEnumerablePropertyIn( value, property )`][@stdlib/assert/is-nonenumerable-property-in]: test if an object's own or inherited property is non-enumerable.
+- [`isNonEnumerableProperty( value, property )`][@stdlib/assert/is-nonenumerable-property]: test if an object's own property is non-enumerable.
+- [`isObjectLike( value )`][@stdlib/assert/is-object-like]: test if a value is object-like.
+- [`isOdd( value )`][@stdlib/assert/is-odd]: test if a value is an odd number.
+- [`isPlainObject( value )`][@stdlib/assert/is-plain-object]: test if a value is a plain object.
+- [`isPositiveZero( value )`][@stdlib/assert/is-positive-zero]: test if a value is a number equal to positive zero.
+- [`isPrime( value )`][@stdlib/assert/is-prime]: test if a value is a prime number.
+- [`isPrimitive( value )`][@stdlib/assert/is-primitive]: test if a value is a JavaScript primitive.
+- [`isPRNGLike( value )`][@stdlib/assert/is-prng-like]: test if a value is PRNG-like.
+- [`isProbability( value )`][@stdlib/assert/is-probability]: test if a value is a probability.
+- [`isPrototypeOf( obj, prototype )`][@stdlib/assert/is-prototype-of]: test if an object's prototype chain contains a provided prototype.
+- [`isReadOnlyPropertyIn( value, property )`][@stdlib/assert/is-read-only-property-in]: test if an object's own or inherited property is read-only.
+- [`isReadOnlyProperty( value, property )`][@stdlib/assert/is-read-only-property]: test if an object's own property is read-only.
+- [`isReadWritePropertyIn( value, property )`][@stdlib/assert/is-read-write-property-in]: test if an object's own or inherited property is readable and writable.
+- [`isReadWriteProperty( value, property )`][@stdlib/assert/is-read-write-property]: test if an object's own property is readable and writable.
+- [`isReadablePropertyIn( value, property )`][@stdlib/assert/is-readable-property-in]: test if an object's own or inherited property is readable.
+- [`isReadableProperty( value, property )`][@stdlib/assert/is-readable-property]: test if an object's own property is readable.
+- [`isRegExpString( value )`][@stdlib/assert/is-regexp-string]: test if a value is a regular expression string.
+- [`isRelativePath( value )`][@stdlib/assert/is-relative-path]: test if a value is a relative path.
+- [`isSameValueZero( a, b )`][@stdlib/assert/is-same-value-zero]: test if two arguments are the same value.
+- [`isSameValue( a, b )`][@stdlib/assert/is-same-value]: test if two arguments are the same value.
+- [`isStrictEqual( a, b )`][@stdlib/assert/is-strict-equal]: test if two arguments are strictly equal.
+- [`isTruthy( value )`][@stdlib/assert/is-truthy]: test if a value is truthy.
+- [`isUNCPath( value )`][@stdlib/assert/is-unc-path]: test if a value is a UNC path.
+- [`isUndefinedOrNull( value )`][@stdlib/assert/is-undefined-or-null]: test if a value is undefined or null.
+- [`isUppercase( value )`][@stdlib/assert/is-uppercase]: test if a value is an uppercase string.
+- [`isURI( value )`][@stdlib/assert/is-uri]: test if a value is a URI.
+- [`isWhitespace( value )`][@stdlib/assert/is-whitespace]: test whether a string contains only white space characters.
+- [`isWritablePropertyIn( value, property )`][@stdlib/assert/is-writable-property-in]: test if an object's own or inherited property is writable.
+- [`isWritableProperty( value, property )`][@stdlib/assert/is-writable-property]: test if an object's own property is writable.
+- [`isWriteOnlyPropertyIn( value, property )`][@stdlib/assert/is-write-only-property-in]: test if an object's own or inherited property is write-only.
+- [`isWriteOnlyProperty( value, property )`][@stdlib/assert/is-write-only-property]: test if an object's own property is write-only.
+
+
+
+
+
+
+
+
+
+