time-to-botec/js/node_modules/@stdlib/assert/lib/index.js

/**
* @license Apache-2.0
*
* Copyright (c) 2018 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*    http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

'use strict';

/*
* When adding modules to the namespace, ensure that they are added in alphabetical order according to module name.
*/

// MODULES //

var setReadOnly = require( '@stdlib/utils/define-read-only-property' );


// MAIN //

/**
* Top-level namespace.
*
* @namespace ns
*/
var ns = {};

/**
* @name contains
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/contains}
*/
setReadOnly( ns, 'contains', require( './../contains' ) );

/**
* @name deepEqual
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/deep-equal}
*/
setReadOnly( ns, 'deepEqual', require( './../deep-equal' ) );

/**
* @name deepHasOwnProp
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/deep-has-own-property}
*/
setReadOnly( ns, 'deepHasOwnProp', require( './../deep-has-own-property' ) );

/**
* @name deepHasProp
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/deep-has-property}
*/
setReadOnly( ns, 'deepHasProp', require( './../deep-has-property' ) );

/**
* @name hasArrayBufferSupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-arraybuffer-support}
*/
setReadOnly( ns, 'hasArrayBufferSupport', require( './../has-arraybuffer-support' ) );

/**
* @name hasArrowFunctionSupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-arrow-function-support}
*/
setReadOnly( ns, 'hasArrowFunctionSupport', require( './../has-arrow-function-support' ) );

/**
* @name hasAsyncAwaitSupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-async-await-support}
*/
setReadOnly( ns, 'hasAsyncAwaitSupport', require( './../has-async-await-support' ) );

/**
* @name hasAsyncIteratorSymbolSupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-async-iterator-symbol-support}
*/
setReadOnly( ns, 'hasAsyncIteratorSymbolSupport', require( './../has-async-iterator-symbol-support' ) );

/**
* @name hasBigIntSupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-bigint-support}
*/
setReadOnly( ns, 'hasBigIntSupport', require( './../has-bigint-support' ) );

/**
* @name hasBigInt64ArraySupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-bigint64array-support}
*/
setReadOnly( ns, 'hasBigInt64ArraySupport', require( './../has-bigint64array-support' ) );

/**
* @name hasBigUint64ArraySupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-biguint64array-support}
*/
setReadOnly( ns, 'hasBigUint64ArraySupport', require( './../has-biguint64array-support' ) );

/**
* @name hasClassSupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-class-support}
*/
setReadOnly( ns, 'hasClassSupport', require( './../has-class-support' ) );

/**
* @name hasDataViewSupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-dataview-support}
*/
setReadOnly( ns, 'hasDataViewSupport', require( './../has-dataview-support' ) );

/**
* @name hasDefinePropertiesSupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-define-properties-support}
*/
setReadOnly( ns, 'hasDefinePropertiesSupport', require( './../has-define-properties-support' ) );

/**
* @name hasDefinePropertySupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-define-property-support}
*/
setReadOnly( ns, 'hasDefinePropertySupport', require( './../has-define-property-support' ) );

/**
* @name hasFloat32ArraySupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-float32array-support}
*/
setReadOnly( ns, 'hasFloat32ArraySupport', require( './../has-float32array-support' ) );

/**
* @name hasFloat64ArraySupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-float64array-support}
*/
setReadOnly( ns, 'hasFloat64ArraySupport', require( './../has-float64array-support' ) );

/**
* @name hasFunctionNameSupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-function-name-support}
*/
setReadOnly( ns, 'hasFunctionNameSupport', require( './../has-function-name-support' ) );

/**
* @name hasGeneratorSupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-generator-support}
*/
setReadOnly( ns, 'hasGeneratorSupport', require( './../has-generator-support' ) );

/**
* @name hasGlobalThisSupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-globalthis-support}
*/
setReadOnly( ns, 'hasGlobalThisSupport', require( './../has-globalthis-support' ) );

/**
* @name hasInt8ArraySupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-int8array-support}
*/
setReadOnly( ns, 'hasInt8ArraySupport', require( './../has-int8array-support' ) );

/**
* @name hasInt16ArraySupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-int16array-support}
*/
setReadOnly( ns, 'hasInt16ArraySupport', require( './../has-int16array-support' ) );

/**
* @name hasInt32ArraySupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-int32array-support}
*/
setReadOnly( ns, 'hasInt32ArraySupport', require( './../has-int32array-support' ) );

/**
* @name hasIteratorSymbolSupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-iterator-symbol-support}
*/
setReadOnly( ns, 'hasIteratorSymbolSupport', require( './../has-iterator-symbol-support' ) );

/**
* @name hasMapSupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-map-support}
*/
setReadOnly( ns, 'hasMapSupport', require( './../has-map-support' ) );

/**
* @name hasNodeBufferSupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-node-buffer-support}
*/
setReadOnly( ns, 'hasNodeBufferSupport', require( './../has-node-buffer-support' ) );

/**
* @name hasOwnProp
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-own-property}
*/
setReadOnly( ns, 'hasOwnProp', require( './../has-own-property' ) );

/**
* @name hasProp
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-property}
*/
setReadOnly( ns, 'hasProp', require( './../has-property' ) );

/**
* @name hasProxySupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-proxy-support}
*/
setReadOnly( ns, 'hasProxySupport', require( './../has-proxy-support' ) );

/**
* @name hasSetSupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-set-support}
*/
setReadOnly( ns, 'hasSetSupport', require( './../has-set-support' ) );

/**
* @name hasSharedArrayBufferSupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-sharedarraybuffer-support}
*/
setReadOnly( ns, 'hasSharedArrayBufferSupport', require( './../has-sharedarraybuffer-support' ) );

/**
* @name hasSymbolSupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-symbol-support}
*/
setReadOnly( ns, 'hasSymbolSupport', require( './../has-symbol-support' ) );

/**
* @name hasToStringTagSupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-tostringtag-support}
*/
setReadOnly( ns, 'hasToStringTagSupport', require( './../has-tostringtag-support' ) );

/**
* @name hasUint8ArraySupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-uint8array-support}
*/
setReadOnly( ns, 'hasUint8ArraySupport', require( './../has-uint8array-support' ) );

/**
* @name hasUint8ClampedArraySupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-uint8clampedarray-support}
*/
setReadOnly( ns, 'hasUint8ClampedArraySupport', require( './../has-uint8clampedarray-support' ) );

/**
* @name hasUint16ArraySupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-uint16array-support}
*/
setReadOnly( ns, 'hasUint16ArraySupport', require( './../has-uint16array-support' ) );

/**
* @name hasUint32ArraySupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-uint32array-support}
*/
setReadOnly( ns, 'hasUint32ArraySupport', require( './../has-uint32array-support' ) );

/**
* @name hasUTF16SurrogatePairAt
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-utf16-surrogate-pair-at}
*/
setReadOnly( ns, 'hasUTF16SurrogatePairAt', require( './../has-utf16-surrogate-pair-at' ) );

/**
* @name hasWebAssemblySupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-wasm-support}
*/
setReadOnly( ns, 'hasWebAssemblySupport', require( './../has-wasm-support' ) );

/**
* @name hasWeakMapSupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-weakmap-support}
*/
setReadOnly( ns, 'hasWeakMapSupport', require( './../has-weakmap-support' ) );

/**
* @name hasWeakSetSupport
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/has-weakset-support}
*/
setReadOnly( ns, 'hasWeakSetSupport', require( './../has-weakset-support' ) );

/**
* @name instanceOf
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/instance-of}
*/
setReadOnly( ns, 'instanceOf', require( './../instance-of' ) );

/**
* @name isAbsolutePath
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-absolute-path}
*/
setReadOnly( ns, 'isAbsolutePath', require( './../is-absolute-path' ) );

/**
* @name isAccessorProperty
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-accessor-property}
*/
setReadOnly( ns, 'isAccessorProperty', require( './../is-accessor-property' ) );

/**
* @name isAccessorPropertyIn
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-accessor-property-in}
*/
setReadOnly( ns, 'isAccessorPropertyIn', require( './../is-accessor-property-in' ) );

/**
* @name isAlphagram
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-alphagram}
*/
setReadOnly( ns, 'isAlphagram', require( './../is-alphagram' ) );

/**
* @name isAlphaNumeric
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-alphanumeric}
*/
setReadOnly( ns, 'isAlphaNumeric', require( './../is-alphanumeric' ) );

/**
* @name isAnagram
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-anagram}
*/
setReadOnly( ns, 'isAnagram', require( './../is-anagram' ) );

/**
* @name isArguments
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-arguments}
*/
setReadOnly( ns, 'isArguments', require( './../is-arguments' ) );

/**
* @name isArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-array}
*/
setReadOnly( ns, 'isArray', require( './../is-array' ) );

/**
* @name isArrayArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-array-array}
*/
setReadOnly( ns, 'isArrayArray', require( './../is-array-array' ) );

/**
* @name isArrayLength
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-array-length}
*/
setReadOnly( ns, 'isArrayLength', require( './../is-array-length' ) );

/**
* @name isArrayLike
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-array-like}
*/
setReadOnly( ns, 'isArrayLike', require( './../is-array-like' ) );

/**
* @name isArrayLikeObject
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-array-like-object}
*/
setReadOnly( ns, 'isArrayLikeObject', require( './../is-array-like-object' ) );

/**
* @name isArrayBuffer
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-arraybuffer}
*/
setReadOnly( ns, 'isArrayBuffer', require( './../is-arraybuffer' ) );

/**
* @name isArrayBufferView
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-arraybuffer-view}
*/
setReadOnly( ns, 'isArrayBufferView', require( './../is-arraybuffer-view' ) );

/**
* @name isArrowFunction
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-arrow-function}
*/
setReadOnly( ns, 'isArrowFunction', require( './../is-arrow-function' ) );

/**
* @name isASCII
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-ascii}
*/
setReadOnly( ns, 'isASCII', require( './../is-ascii' ) );

/**
* @name isBetween
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-between}
*/
setReadOnly( ns, 'isBetween', require( './../is-between' ) );

/**
* @name isBetweenArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-between-array}
*/
setReadOnly( ns, 'isBetweenArray', require( './../is-between-array' ) );

/**
* @name IS_BIG_ENDIAN
* @memberof ns
* @readonly
* @type {boolean}
* @see {@link module:@stdlib/assert/is-big-endian}
*/
setReadOnly( ns, 'IS_BIG_ENDIAN', require( './../is-big-endian' ) );

/**
* @name isBigInt
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-bigint}
*/
setReadOnly( ns, 'isBigInt', require( './../is-bigint' ) );

/**
* @name isBigInt64Array
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-bigint64array}
*/
setReadOnly( ns, 'isBigInt64Array', require( './../is-bigint64array' ) );

/**
* @name isBigUint64Array
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-biguint64array}
*/
setReadOnly( ns, 'isBigUint64Array', require( './../is-biguint64array' ) );

/**
* @name isBinaryString
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-binary-string}
*/
setReadOnly( ns, 'isBinaryString', require( './../is-binary-string' ) );

/**
* @name isBoolean
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-boolean}
*/
setReadOnly( ns, 'isBoolean', require( './../is-boolean' ) );

/**
* @name isBooleanArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-boolean-array}
*/
setReadOnly( ns, 'isBooleanArray', require( './../is-boolean-array' ) );

/**
* @name isBoxedPrimitive
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-boxed-primitive}
*/
setReadOnly( ns, 'isBoxedPrimitive', require( './../is-boxed-primitive' ) );

/**
* @name IS_BROWSER
* @memberof ns
* @readonly
* @type {boolean}
* @see {@link module:@stdlib/assert/is-browser}
*/
setReadOnly( ns, 'IS_BROWSER', require( './../is-browser' ) );

/**
* @name isBuffer
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-buffer}
*/
setReadOnly( ns, 'isBuffer', require( './../is-buffer' ) );

/**
* @name isCapitalized
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-capitalized}
*/
setReadOnly( ns, 'isCapitalized', require( './../is-capitalized' ) );

/**
* @name isCentrosymmetricMatrix
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-centrosymmetric-matrix}
*/
setReadOnly( ns, 'isCentrosymmetricMatrix', require( './../is-centrosymmetric-matrix' ) );

/**
* @name isCircular
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-circular}
*/
setReadOnly( ns, 'isCircular', require( './../is-circular' ) );

/**
* @name isCircularArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-circular-array}
*/
setReadOnly( ns, 'isCircularArray', require( './../is-circular-array' ) );

/**
* @name isCircularPlainObject
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-circular-plain-object}
*/
setReadOnly( ns, 'isCircularPlainObject', require( './../is-circular-plain-object' ) );

/**
* @name isClass
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-class}
*/
setReadOnly( ns, 'isClass', require( './../is-class' ) );

/**
* @name isCollection
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-collection}
*/
setReadOnly( ns, 'isCollection', require( './../is-collection' ) );

/**
* @name isComplex
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-complex}
*/
setReadOnly( ns, 'isComplex', require( './../is-complex' ) );

/**
* @name isComplexLike
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-complex-like}
*/
setReadOnly( ns, 'isComplexLike', require( './../is-complex-like' ) );

/**
* @name isComplexTypedArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-complex-typed-array}
*/
setReadOnly( ns, 'isComplexTypedArray', require( './../is-complex-typed-array' ) );

/**
* @name isComplexTypedArrayLike
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-complex-typed-array-like}
*/
setReadOnly( ns, 'isComplexTypedArrayLike', require( './../is-complex-typed-array-like' ) );

/**
* @name isComplex64
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-complex64}
*/
setReadOnly( ns, 'isComplex64', require( './../is-complex64' ) );

/**
* @name isComplex64Array
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-complex64array}
*/
setReadOnly( ns, 'isComplex64Array', require( './../is-complex64array' ) );

/**
* @name isComplex128
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-complex128}
*/
setReadOnly( ns, 'isComplex128', require( './../is-complex128' ) );

/**
* @name isComplex128Array
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-complex128array}
*/
setReadOnly( ns, 'isComplex128Array', require( './../is-complex128array' ) );

/**
* @name isComposite
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-composite}
*/
setReadOnly( ns, 'isComposite', require( './../is-composite' ) );

/**
* @name isConfigurableProperty
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-configurable-property}
*/
setReadOnly( ns, 'isConfigurableProperty', require( './../is-configurable-property' ) );

/**
* @name isConfigurablePropertyIn
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-configurable-property-in}
*/
setReadOnly( ns, 'isConfigurablePropertyIn', require( './../is-configurable-property-in' ) );

/**
* @name isCubeNumber
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-cube-number}
*/
setReadOnly( ns, 'isCubeNumber', require( './../is-cube-number' ) );

/**
* @name IS_DARWIN
* @memberof ns
* @readonly
* @type {boolean}
* @see {@link module:@stdlib/assert/is-darwin}
*/
setReadOnly( ns, 'IS_DARWIN', require( './../is-darwin' ) );

/**
* @name isDataProperty
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-data-property}
*/
setReadOnly( ns, 'isDataProperty', require( './../is-data-property' ) );

/**
* @name isDataPropertyIn
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-data-property-in}
*/
setReadOnly( ns, 'isDataPropertyIn', require( './../is-data-property-in' ) );

/**
* @name isDataView
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-dataview}
*/
setReadOnly( ns, 'isDataView', require( './../is-dataview' ) );

/**
* @name isDateObject
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-date-object}
*/
setReadOnly( ns, 'isDateObject', require( './../is-date-object' ) );

/**
* @name isDigitString
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-digit-string}
*/
setReadOnly( ns, 'isDigitString', require( './../is-digit-string' ) );

/**
* @name IS_DOCKER
* @memberof ns
* @readonly
* @type {boolean}
* @see {@link module:@stdlib/assert/is-docker}
*/
setReadOnly( ns, 'IS_DOCKER', require( './../is-docker' ) );

/**
* @name IS_ELECTRON
* @memberof ns
* @readonly
* @type {boolean}
* @see {@link module:@stdlib/assert/is-electron}
*/
setReadOnly( ns, 'IS_ELECTRON', require( './../is-electron' ) );

/**
* @name IS_ELECTRON_MAIN
* @memberof ns
* @readonly
* @type {boolean}
* @see {@link module:@stdlib/assert/is-electron-main}
*/
setReadOnly( ns, 'IS_ELECTRON_MAIN', require( './../is-electron-main' ) );

/**
* @name IS_ELECTRON_RENDERER
* @memberof ns
* @readonly
* @type {boolean}
* @see {@link module:@stdlib/assert/is-electron-renderer}
*/
setReadOnly( ns, 'IS_ELECTRON_RENDERER', require( './../is-electron-renderer' ) );

/**
* @name isEmailAddress
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-email-address}
*/
setReadOnly( ns, 'isEmailAddress', require( './../is-email-address' ) );

/**
* @name isEmptyArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-empty-array}
*/
setReadOnly( ns, 'isEmptyArray', require( './../is-empty-array' ) );

/**
* @name isEmptyObject
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-empty-object}
*/
setReadOnly( ns, 'isEmptyObject', require( './../is-empty-object' ) );

/**
* @name isEmptyString
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-empty-string}
*/
setReadOnly( ns, 'isEmptyString', require( './../is-empty-string' ) );

/**
* @name isEnumerableProperty
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-enumerable-property}
*/
setReadOnly( ns, 'isEnumerableProperty', require( './../is-enumerable-property' ) );

/**
* @name isEnumerablePropertyIn
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-enumerable-property-in}
*/
setReadOnly( ns, 'isEnumerablePropertyIn', require( './../is-enumerable-property-in' ) );

/**
* @name isError
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-error}
*/
setReadOnly( ns, 'isError', require( './../is-error' ) );

/**
* @name isEvalError
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-eval-error}
*/
setReadOnly( ns, 'isEvalError', require( './../is-eval-error' ) );

/**
* @name isEven
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-even}
*/
setReadOnly( ns, 'isEven', require( './../is-even' ) );

/**
* @name isFalsy
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-falsy}
*/
setReadOnly( ns, 'isFalsy', require( './../is-falsy' ) );

/**
* @name isFalsyArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-falsy-array}
*/
setReadOnly( ns, 'isFalsyArray', require( './../is-falsy-array' ) );

/**
* @name isFinite
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-finite}
*/
setReadOnly( ns, 'isFinite', require( './../is-finite' ) );

/**
* @name isFiniteArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-finite-array}
*/
setReadOnly( ns, 'isFiniteArray', require( './../is-finite-array' ) );

/**
* @name isFloat32Array
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-float32array}
*/
setReadOnly( ns, 'isFloat32Array', require( './../is-float32array' ) );

/**
* @name isFloat32MatrixLike
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-float32matrix-like}
*/
setReadOnly( ns, 'isFloat32MatrixLike', require( './../is-float32matrix-like' ) );

/**
* @name isFloat32ndarrayLike
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-float32ndarray-like}
*/
setReadOnly( ns, 'isFloat32ndarrayLike', require( './../is-float32ndarray-like' ) );

/**
* @name isFloat32VectorLike
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-float32vector-like}
*/
setReadOnly( ns, 'isFloat32VectorLike', require( './../is-float32vector-like' ) );

/**
* @name isFloat64Array
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-float64array}
*/
setReadOnly( ns, 'isFloat64Array', require( './../is-float64array' ) );

/**
* @name isFloat64MatrixLike
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-float64matrix-like}
*/
setReadOnly( ns, 'isFloat64MatrixLike', require( './../is-float64matrix-like' ) );

/**
* @name isFloat64ndarrayLike
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-float64ndarray-like}
*/
setReadOnly( ns, 'isFloat64ndarrayLike', require( './../is-float64ndarray-like' ) );

/**
* @name isFloat64VectorLike
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-float64vector-like}
*/
setReadOnly( ns, 'isFloat64VectorLike', require( './../is-float64vector-like' ) );

/**
* @name isFunction
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-function}
*/
setReadOnly( ns, 'isFunction', require( './../is-function' ) );

/**
* @name isFunctionArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-function-array}
*/
setReadOnly( ns, 'isFunctionArray', require( './../is-function-array' ) );

/**
* @name isGeneratorObject
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-generator-object}
*/
setReadOnly( ns, 'isGeneratorObject', require( './../is-generator-object' ) );

/**
* @name isGeneratorObjectLike
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-generator-object-like}
*/
setReadOnly( ns, 'isGeneratorObjectLike', require( './../is-generator-object-like' ) );

/**
* @name isgzipBuffer
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-gzip-buffer}
*/
setReadOnly( ns, 'isgzipBuffer', require( './../is-gzip-buffer' ) );

/**
* @name isHexString
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-hex-string}
*/
setReadOnly( ns, 'isHexString', require( './../is-hex-string' ) );

/**
* @name isInfinite
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-infinite}
*/
setReadOnly( ns, 'isInfinite', require( './../is-infinite' ) );

/**
* @name isInheritedProperty
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-inherited-property}
*/
setReadOnly( ns, 'isInheritedProperty', require( './../is-inherited-property' ) );

/**
* @name isInt8Array
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-int8array}
*/
setReadOnly( ns, 'isInt8Array', require( './../is-int8array' ) );

/**
* @name isInt16Array
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-int16array}
*/
setReadOnly( ns, 'isInt16Array', require( './../is-int16array' ) );

/**
* @name isInt32Array
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-int32array}
*/
setReadOnly( ns, 'isInt32Array', require( './../is-int32array' ) );

/**
* @name isInteger
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-integer}
*/
setReadOnly( ns, 'isInteger', require( './../is-integer' ) );

/**
* @name isIntegerArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-integer-array}
*/
setReadOnly( ns, 'isIntegerArray', require( './../is-integer-array' ) );

/**
* @name isIterableLike
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-iterable-like}
*/
setReadOnly( ns, 'isIterableLike', require( './../is-iterable-like' ) );

/**
* @name isIteratorLike
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-iterator-like}
*/
setReadOnly( ns, 'isIteratorLike', require( './../is-iterator-like' ) );

/**
* @name isJSON
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-json}
*/
setReadOnly( ns, 'isJSON', require( './../is-json' ) );

/**
* @name isLeapYear
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-leap-year}
*/
setReadOnly( ns, 'isLeapYear', require( './../is-leap-year' ) );

/**
* @name IS_LITTLE_ENDIAN
* @memberof ns
* @readonly
* @type {boolean}
* @see {@link module:@stdlib/assert/is-little-endian}
*/
setReadOnly( ns, 'IS_LITTLE_ENDIAN', require( './../is-little-endian' ) );

/**
* @name isLowercase
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-lowercase}
*/
setReadOnly( ns, 'isLowercase', require( './../is-lowercase' ) );

/**
* @name isMatrixLike
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-matrix-like}
*/
setReadOnly( ns, 'isMatrixLike', require( './../is-matrix-like' ) );

/**
* @name isMethod
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-method}
*/
setReadOnly( ns, 'isMethod', require( './../is-method' ) );

/**
* @name isMethodIn
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-method-in}
*/
setReadOnly( ns, 'isMethodIn', require( './../is-method-in' ) );

/**
* @name IS_MOBILE
* @memberof ns
* @readonly
* @type {boolean}
* @see {@link module:@stdlib/assert/is-mobile}
*/
setReadOnly( ns, 'IS_MOBILE', require( './../is-mobile' ) );

/**
* @name isNamedTypedTupleLike
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-named-typed-tuple-like}
*/
setReadOnly( ns, 'isNamedTypedTupleLike', require( './../is-named-typed-tuple-like' ) );

/**
* @name isnan
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-nan}
*/
setReadOnly( ns, 'isnan', require( './../is-nan' ) );

/**
* @name isNaNArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-nan-array}
*/
setReadOnly( ns, 'isNaNArray', require( './../is-nan-array' ) );

/**
* @name isNativeFunction
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-native-function}
*/
setReadOnly( ns, 'isNativeFunction', require( './../is-native-function' ) );

/**
* @name isndarrayLike
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-ndarray-like}
*/
setReadOnly( ns, 'isndarrayLike', require( './../is-ndarray-like' ) );

/**
* @name isNegativeInteger
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-negative-integer}
*/
setReadOnly( ns, 'isNegativeInteger', require( './../is-negative-integer' ) );

/**
* @name isNegativeIntegerArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-negative-integer-array}
*/
setReadOnly( ns, 'isNegativeIntegerArray', require( './../is-negative-integer-array' ) );

/**
* @name isNegativeNumber
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-negative-number}
*/
setReadOnly( ns, 'isNegativeNumber', require( './../is-negative-number' ) );

/**
* @name isNegativeNumberArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-negative-number-array}
*/
setReadOnly( ns, 'isNegativeNumberArray', require( './../is-negative-number-array' ) );

/**
* @name isNegativeZero
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-negative-zero}
*/
setReadOnly( ns, 'isNegativeZero', require( './../is-negative-zero' ) );

/**
* @name IS_NODE
* @memberof ns
* @readonly
* @type {boolean}
* @see {@link module:@stdlib/assert/is-node}
*/
setReadOnly( ns, 'IS_NODE', require( './../is-node' ) );

/**
* @name isNodeBuiltin
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-node-builtin}
*/
setReadOnly( ns, 'isNodeBuiltin', require( './../is-node-builtin' ) );

/**
* @name isNodeDuplexStreamLike
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-node-duplex-stream-like}
*/
setReadOnly( ns, 'isNodeDuplexStreamLike', require( './../is-node-duplex-stream-like' ) );

/**
* @name isNodeReadableStreamLike
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-node-readable-stream-like}
*/
setReadOnly( ns, 'isNodeReadableStreamLike', require( './../is-node-readable-stream-like' ) );

/**
* @name isNodeREPL
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-node-repl}
*/
setReadOnly( ns, 'isNodeREPL', require( './../is-node-repl' ) );

/**
* @name isNodeStreamLike
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-node-stream-like}
*/
setReadOnly( ns, 'isNodeStreamLike', require( './../is-node-stream-like' ) );

/**
* @name isNodeTransformStreamLike
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-node-transform-stream-like}
*/
setReadOnly( ns, 'isNodeTransformStreamLike', require( './../is-node-transform-stream-like' ) );

/**
* @name isNodeWritableStreamLike
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-node-writable-stream-like}
*/
setReadOnly( ns, 'isNodeWritableStreamLike', require( './../is-node-writable-stream-like' ) );

/**
* @name isNonConfigurableProperty
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-nonconfigurable-property}
*/
setReadOnly( ns, 'isNonConfigurableProperty', require( './../is-nonconfigurable-property' ) );

/**
* @name isNonConfigurablePropertyIn
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-nonconfigurable-property-in}
*/
setReadOnly( ns, 'isNonConfigurablePropertyIn', require( './../is-nonconfigurable-property-in' ) );

/**
* @name isNonEnumerableProperty
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-nonenumerable-property}
*/
setReadOnly( ns, 'isNonEnumerableProperty', require( './../is-nonenumerable-property' ) );

/**
* @name isNonEnumerablePropertyIn
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-nonenumerable-property-in}
*/
setReadOnly( ns, 'isNonEnumerablePropertyIn', require( './../is-nonenumerable-property-in' ) );

/**
* @name isNonNegativeInteger
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-nonnegative-integer}
*/
setReadOnly( ns, 'isNonNegativeInteger', require( './../is-nonnegative-integer' ) );

/**
* @name isNonNegativeIntegerArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-nonnegative-integer-array}
*/
setReadOnly( ns, 'isNonNegativeIntegerArray', require( './../is-nonnegative-integer-array' ) );

/**
* @name isNonNegativeNumber
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-nonnegative-number}
*/
setReadOnly( ns, 'isNonNegativeNumber', require( './../is-nonnegative-number' ) );

/**
* @name isNonNegativeNumberArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-nonnegative-number-array}
*/
setReadOnly( ns, 'isNonNegativeNumberArray', require( './../is-nonnegative-number-array' ) );

/**
* @name isNonPositiveInteger
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-nonpositive-integer}
*/
setReadOnly( ns, 'isNonPositiveInteger', require( './../is-nonpositive-integer' ) );

/**
* @name isNonPositiveIntegerArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-nonpositive-integer-array}
*/
setReadOnly( ns, 'isNonPositiveIntegerArray', require( './../is-nonpositive-integer-array' ) );

/**
* @name isNonPositiveNumber
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-nonpositive-number}
*/
setReadOnly( ns, 'isNonPositiveNumber', require( './../is-nonpositive-number' ) );

/**
* @name isNonPositiveNumberArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-nonpositive-number-array}
*/
setReadOnly( ns, 'isNonPositiveNumberArray', require( './../is-nonpositive-number-array' ) );

/**
* @name isNonSymmetricMatrix
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-nonsymmetric-matrix}
*/
setReadOnly( ns, 'isNonSymmetricMatrix', require( './../is-nonsymmetric-matrix' ) );

/**
* @name isNull
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-null}
*/
setReadOnly( ns, 'isNull', require( './../is-null' ) );

/**
* @name isNullArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-null-array}
*/
setReadOnly( ns, 'isNullArray', require( './../is-null-array' ) );

/**
* @name isNumber
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-number}
*/
setReadOnly( ns, 'isNumber', require( './../is-number' ) );

/**
* @name isNumberArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-number-array}
*/
setReadOnly( ns, 'isNumberArray', require( './../is-number-array' ) );

/**
* @name isNumericArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-numeric-array}
*/
setReadOnly( ns, 'isNumericArray', require( './../is-numeric-array' ) );

/**
* @name isObject
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-object}
*/
setReadOnly( ns, 'isObject', require( './../is-object' ) );

/**
* @name isObjectArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-object-array}
*/
setReadOnly( ns, 'isObjectArray', require( './../is-object-array' ) );

/**
* @name isObjectLike
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-object-like}
*/
setReadOnly( ns, 'isObjectLike', require( './../is-object-like' ) );

/**
* @name isOdd
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-odd}
*/
setReadOnly( ns, 'isOdd', require( './../is-odd' ) );

/**
* @name isPersymmetricMatrix
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-persymmetric-matrix}
*/
setReadOnly( ns, 'isPersymmetricMatrix', require( './../is-persymmetric-matrix' ) );

/**
* @name isPlainObject
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-plain-object}
*/
setReadOnly( ns, 'isPlainObject', require( './../is-plain-object' ) );

/**
* @name isPlainObjectArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-plain-object-array}
*/
setReadOnly( ns, 'isPlainObjectArray', require( './../is-plain-object-array' ) );

/**
* @name isPositiveInteger
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-positive-integer}
*/
setReadOnly( ns, 'isPositiveInteger', require( './../is-positive-integer' ) );

/**
* @name isPositiveIntegerArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-positive-integer-array}
*/
setReadOnly( ns, 'isPositiveIntegerArray', require( './../is-positive-integer-array' ) );

/**
* @name isPositiveNumber
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-positive-number}
*/
setReadOnly( ns, 'isPositiveNumber', require( './../is-positive-number' ) );

/**
* @name isPositiveNumberArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-positive-number-array}
*/
setReadOnly( ns, 'isPositiveNumberArray', require( './../is-positive-number-array' ) );

/**
* @name isPositiveZero
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-positive-zero}
*/
setReadOnly( ns, 'isPositiveZero', require( './../is-positive-zero' ) );

/**
* @name isPrime
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-prime}
*/
setReadOnly( ns, 'isPrime', require( './../is-prime' ) );

/**
* @name isPrimitive
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-primitive}
*/
setReadOnly( ns, 'isPrimitive', require( './../is-primitive' ) );

/**
* @name isPrimitiveArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-primitive-array}
*/
setReadOnly( ns, 'isPrimitiveArray', require( './../is-primitive-array' ) );

/**
* @name isPRNGLike
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-prng-like}
*/
setReadOnly( ns, 'isPRNGLike', require( './../is-prng-like' ) );

/**
* @name isProbability
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-probability}
*/
setReadOnly( ns, 'isProbability', require( './../is-probability' ) );

/**
* @name isProbabilityArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-probability-array}
*/
setReadOnly( ns, 'isProbabilityArray', require( './../is-probability-array' ) );

/**
* @name isPrototypeOf
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-prototype-of}
*/
setReadOnly( ns, 'isPrototypeOf', require( './../is-prototype-of' ) );

/**
* @name isRangeError
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-range-error}
*/
setReadOnly( ns, 'isRangeError', require( './../is-range-error' ) );

/**
* @name isReadOnlyProperty
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-read-only-property}
*/
setReadOnly( ns, 'isReadOnlyProperty', require( './../is-read-only-property' ) );

/**
* @name isReadOnlyPropertyIn
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-read-only-property-in}
*/
setReadOnly( ns, 'isReadOnlyPropertyIn', require( './../is-read-only-property-in' ) );

/**
* @name isReadWriteProperty
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-read-write-property}
*/
setReadOnly( ns, 'isReadWriteProperty', require( './../is-read-write-property' ) );

/**
* @name isReadWritePropertyIn
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-read-write-property-in}
*/
setReadOnly( ns, 'isReadWritePropertyIn', require( './../is-read-write-property-in' ) );

/**
* @name isReadableProperty
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-readable-property}
*/
setReadOnly( ns, 'isReadableProperty', require( './../is-readable-property' ) );

/**
* @name isReadablePropertyIn
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-readable-property-in}
*/
setReadOnly( ns, 'isReadablePropertyIn', require( './../is-readable-property-in' ) );

/**
* @name isReferenceError
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-reference-error}
*/
setReadOnly( ns, 'isReferenceError', require( './../is-reference-error' ) );

/**
* @name isRegExp
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-regexp}
*/
setReadOnly( ns, 'isRegExp', require( './../is-regexp' ) );

/**
* @name isRegExpString
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-regexp-string}
*/
setReadOnly( ns, 'isRegExpString', require( './../is-regexp-string' ) );

/**
* @name isRelativePath
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-relative-path}
*/
setReadOnly( ns, 'isRelativePath', require( './../is-relative-path' ) );

/**
* @name isSafeInteger
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-safe-integer}
*/
setReadOnly( ns, 'isSafeInteger', require( './../is-safe-integer' ) );

/**
* @name isSafeIntegerArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-safe-integer-array}
*/
setReadOnly( ns, 'isSafeIntegerArray', require( './../is-safe-integer-array' ) );

/**
* @name isSameValue
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-same-value}
*/
setReadOnly( ns, 'isSameValue', require( './../is-same-value' ) );

/**
* @name isSameValueZero
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-same-value-zero}
*/
setReadOnly( ns, 'isSameValueZero', require( './../is-same-value-zero' ) );

/**
* @name isSharedArrayBuffer
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-sharedarraybuffer}
*/
setReadOnly( ns, 'isSharedArrayBuffer', require( './../is-sharedarraybuffer' ) );

/**
* @name isSkewCentrosymmetricMatrix
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-skew-centrosymmetric-matrix}
*/
setReadOnly( ns, 'isSkewCentrosymmetricMatrix', require( './../is-skew-centrosymmetric-matrix' ) );

/**
* @name isSkewPersymmetricMatrix
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-skew-persymmetric-matrix}
*/
setReadOnly( ns, 'isSkewPersymmetricMatrix', require( './../is-skew-persymmetric-matrix' ) );

/**
* @name isSkewSymmetricMatrix
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-skew-symmetric-matrix}
*/
setReadOnly( ns, 'isSkewSymmetricMatrix', require( './../is-skew-symmetric-matrix' ) );

/**
* @name isSquareMatrix
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-square-matrix}
*/
setReadOnly( ns, 'isSquareMatrix', require( './../is-square-matrix' ) );

/**
* @name isSquareNumber
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-square-number}
*/
setReadOnly( ns, 'isSquareNumber', require( './../is-square-number' ) );

/**
* @name isSquareTriangularNumber
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-square-triangular-number}
*/
setReadOnly( ns, 'isSquareTriangularNumber', require( './../is-square-triangular-number' ) );

/**
* @name isStrictEqual
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-strict-equal}
*/
setReadOnly( ns, 'isStrictEqual', require( './../is-strict-equal' ) );

/**
* @name isString
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-string}
*/
setReadOnly( ns, 'isString', require( './../is-string' ) );

/**
* @name isStringArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-string-array}
*/
setReadOnly( ns, 'isStringArray', require( './../is-string-array' ) );

/**
* @name isSymbol
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-symbol}
*/
setReadOnly( ns, 'isSymbol', require( './../is-symbol' ) );

/**
* @name isSymbolArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-symbol-array}
*/
setReadOnly( ns, 'isSymbolArray', require( './../is-symbol-array' ) );

/**
* @name isSymmetricMatrix
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-symmetric-matrix}
*/
setReadOnly( ns, 'isSymmetricMatrix', require( './../is-symmetric-matrix' ) );

/**
* @name isSyntaxError
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-syntax-error}
*/
setReadOnly( ns, 'isSyntaxError', require( './../is-syntax-error' ) );

/**
* @name IS_TOUCH_DEVICE
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-touch-device}
*/
setReadOnly( ns, 'IS_TOUCH_DEVICE', require( './../is-touch-device' ) );

/**
* @name isTriangularNumber
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-triangular-number}
*/
setReadOnly( ns, 'isTriangularNumber', require( './../is-triangular-number' ) );

/**
* @name isTruthy
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-truthy}
*/
setReadOnly( ns, 'isTruthy', require( './../is-truthy' ) );

/**
* @name isTruthyArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-truthy-array}
*/
setReadOnly( ns, 'isTruthyArray', require( './../is-truthy-array' ) );

/**
* @name isTypeError
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-type-error}
*/
setReadOnly( ns, 'isTypeError', require( './../is-type-error' ) );

/**
* @name isTypedArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-typed-array}
*/
setReadOnly( ns, 'isTypedArray', require( './../is-typed-array' ) );

/**
* @name isTypedArrayLength
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-typed-array-length}
*/
setReadOnly( ns, 'isTypedArrayLength', require( './../is-typed-array-length' ) );

/**
* @name isTypedArrayLike
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-typed-array-like}
*/
setReadOnly( ns, 'isTypedArrayLike', require( './../is-typed-array-like' ) );

/**
* @name isUint8Array
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-uint8array}
*/
setReadOnly( ns, 'isUint8Array', require( './../is-uint8array' ) );

/**
* @name isUint8ClampedArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-uint8clampedarray}
*/
setReadOnly( ns, 'isUint8ClampedArray', require( './../is-uint8clampedarray' ) );

/**
* @name isUint16Array
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-uint16array}
*/
setReadOnly( ns, 'isUint16Array', require( './../is-uint16array' ) );

/**
* @name isUint32Array
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-uint32array}
*/
setReadOnly( ns, 'isUint32Array', require( './../is-uint32array' ) );

/**
* @name isUNCPath
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-unc-path}
*/
setReadOnly( ns, 'isUNCPath', require( './../is-unc-path' ) );

/**
* @name isUndefined
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-undefined}
*/
setReadOnly( ns, 'isUndefined', require( './../is-undefined' ) );

/**
* @name isUndefinedOrNull
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-undefined-or-null}
*/
setReadOnly( ns, 'isUndefinedOrNull', require( './../is-undefined-or-null' ) );

/**
* @name isUnityProbabilityArray
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-unity-probability-array}
*/
setReadOnly( ns, 'isUnityProbabilityArray', require( './../is-unity-probability-array' ) );

/**
* @name isUppercase
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-uppercase}
*/
setReadOnly( ns, 'isUppercase', require( './../is-uppercase' ) );

/**
* @name isURI
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-uri}
*/
setReadOnly( ns, 'isURI', require( './../is-uri' ) );

/**
* @name isURIError
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-uri-error}
*/
setReadOnly( ns, 'isURIError', require( './../is-uri-error' ) );

/**
* @name isVectorLike
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-vector-like}
*/
setReadOnly( ns, 'isVectorLike', require( './../is-vector-like' ) );

/**
* @name IS_WEB_WORKER
* @memberof ns
* @readonly
* @type {boolean}
* @see {@link module:@stdlib/assert/is-web-worker}
*/
setReadOnly( ns, 'IS_WEB_WORKER', require( './../is-web-worker' ) );

/**
* @name isWhitespace
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-whitespace}
*/
setReadOnly( ns, 'isWhitespace', require( './../is-whitespace' ) );

/**
* @name IS_WINDOWS
* @memberof ns
* @readonly
* @type {boolean}
* @see {@link module:@stdlib/assert/is-windows}
*/
setReadOnly( ns, 'IS_WINDOWS', require( './../is-windows' ) );

/**
* @name isWritableProperty
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-writable-property}
*/
setReadOnly( ns, 'isWritableProperty', require( './../is-writable-property' ) );

/**
* @name isWritablePropertyIn
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-writable-property-in}
*/
setReadOnly( ns, 'isWritablePropertyIn', require( './../is-writable-property-in' ) );

/**
* @name isWriteOnlyProperty
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-write-only-property}
*/
setReadOnly( ns, 'isWriteOnlyProperty', require( './../is-write-only-property' ) );

/**
* @name isWriteOnlyPropertyIn
* @memberof ns
* @readonly
* @type {Function}
* @see {@link module:@stdlib/assert/is-write-only-property-in}
*/
setReadOnly( ns, 'isWriteOnlyPropertyIn', require( './../is-write-only-property-in' ) );


// EXPORTS //

module.exports = ns;